python-general-be-lib 0.9.1__tar.gz → 0.10.0__tar.gz

{python_general_be_lib-0.9.1 → python_general_be_lib-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-general-be-lib
-Version: 0.9.1
+Version: 0.10.0
 Summary: General purpose backend library — SQLAlchemy CRUD/Geometry repositories, FastAPI exceptions, Pydantic base models, logger utilities.
 Author-email: Andrea Di Placido <a.diplacido@arpes.it>, "Arpes S.r.l." <it.admin@arpes.it>
 License: MIT

python_general_be_lib-0.10.0/general/context.py

@@ -0,0 +1,31 @@
+"""Context of the operation in progress.
+
+Values the library **reads** and the consumer sets, kept in ``ContextVar`` objects rather
+than in globals: the value is per task, so concurrent requests served by the same process
+do not overwrite each other.
+
+The module imports nothing from the library and nothing from SQLAlchemy, so a middleware
+can set the context without paying for the data access layer.
+"""
+
+__all__ = ["current_user"]
+
+from contextvars import ContextVar
+from typing import Optional
+
+current_user: ContextVar[Optional[str]] = ContextVar("current_user", default=None)
+"""Identifier of the user the current operation is attributed to.
+
+Read by ``AuditMixin`` to fill ``create_uid``/``write_uid``. Setting it is up to the
+consumer, typically in the authentication middleware::
+
+    from general.context import current_user
+
+    @app.middleware("http")
+    async def track_user(request, call_next):
+        current_user.set(request.state.user_id)
+        return await call_next(request)
+
+Left unset it holds ``None``, which is what ends up in the columns for the operations
+having no user behind them: scheduled jobs, migrations, a console session.
+"""

{python_general_be_lib-0.9.1 → python_general_be_lib-0.10.0}/general/exception/__init__.py

@@ -2,9 +2,11 @@
 
 They all extend ``ExceptionInterface``, which in turn extends
 ``fastapi.HTTPException``: raised inside an endpoint they are automatically
-serialized into the response with their own status code. The mapping applied by
-``CrudRepository._handle_exception`` to the SQLAlchemy errors is documented in
-``crud_exceptions``.
+serialized into the response with their own status code.
+
+``raise_http_exception`` is the mapping the data access layers apply to the SQLAlchemy
+errors, shared by ``CrudRepository`` and ``CrudMetadata`` so that the same error gets the
+same status on both.
 """
 
 from .access_exceptions import *
@@ -12,6 +14,7 @@ from .crud_exceptions import *
 from .exception_interface import *
 
 __all__ = [
+    "raise_http_exception",
     "ExceptionInterface",
     "BadRequestException",
     "EntityNotFoundException",

{python_general_be_lib-0.9.1 → python_general_be_lib-0.10.0}/general/exception/crud_exceptions.py

@@ -1,12 +1,14 @@
 """HTTP exceptions for the persistence operations.
 
-These are the exceptions ``CrudRepository._handle_exception`` maps the SQLAlchemy
-errors onto: ``OperationalError`` to ``ServiceUnavailableException`` (503),
-``NoResultFound`` to ``EntityNotFoundException`` (404), ``DataError`` and
-``IntegrityError`` to ``BadRequestException`` (400).
+These are the exceptions the data access layers map the SQLAlchemy errors onto:
+``OperationalError`` to ``ServiceUnavailableException`` (503), ``NoResultFound`` to
+``EntityNotFoundException`` (404), ``DataError`` and ``IntegrityError`` to
+``BadRequestException`` (400). The mapping itself lives in ``raise_http_exception``, so
+that ``CrudRepository`` and ``CrudMetadata`` share one table instead of two copies.
 """
 
 __all__ = [
+    "raise_http_exception",
     "BadRequestException",
     "EntityNotFoundException",
     "ServiceUnavailableException",
@@ -15,6 +17,8 @@ __all__ = [
     "InternalServerException",
 ]
 
+from sqlalchemy.exc import DataError, IntegrityError, NoResultFound, OperationalError
+
 from .exception_interface import ExceptionInterface
 
 
@@ -87,3 +91,32 @@ class InternalServerException(ExceptionInterface):
     """
     status_code = 500
     default_message = "Impossibile gestire la richiesta al momento"
+
+
+def raise_http_exception(e: Exception):
+    """Re-raise a SQLAlchemy error as the matching HTTP exception.
+
+    Translates the error families the data access layers can attribute to a specific
+    HTTP status: anything else is re-raised unchanged, because guessing a status for an
+    unknown error hides the cause. In particular a ``ProgrammingError`` — a malformed
+    statement or a missing relation — stays as it is and surfaces as a 500, which is the
+    honest answer for a defect that is not the client's fault.
+
+    Args:
+        e (Exception): Caught exception.
+
+    Raises:
+        ServiceUnavailableException: On ``OperationalError``, database unreachable.
+        EntityNotFoundException: On ``NoResultFound``.
+        BadRequestException: On ``DataError`` or ``IntegrityError``.
+        Exception: The original exception, for every other type.
+    """
+    match e:
+        case OperationalError():
+            raise ServiceUnavailableException()
+        case NoResultFound():
+            raise EntityNotFoundException()
+        case DataError() | IntegrityError():
+            raise BadRequestException()
+        case _:
+            raise e

{python_general_be_lib-0.9.1 → python_general_be_lib-0.10.0}/general/interface/base/declarative_base.py

@@ -132,10 +132,23 @@ def _attributes_names(entity: type) -> tuple[str, ...]:
 
 
 def retrieve_mapper_entity(entity_name: str):
-    """Look up a subclass of ``Base`` by class name.
+    """Look up a mapped class by class name.
 
-    Iterates over ``Base.__subclasses__()``, so it only finds the **direct** subclasses
-    of ``Base`` and not the ones nested in further inheritance levels.
+    Scans ``Base.registry.mappers``, which holds every mapped class of the registry
+    regardless of how deep in the inheritance it sits: an entity behind an abstract
+    intermediate base, or one in single table inheritance, is found as well. Iterating
+    ``Base.__subclasses__()`` instead — as this did — only reaches the **direct**
+    subclasses, and left those two invisible.
+
+    Reading the collection does **not** trigger ``configure_mappers()``, so the lookup
+    stays usable while the entities referenced by name in a ``relationship`` are still
+    being imported.
+
+    The class name is not unique within a registry: two entities declared in different
+    packages can share it, and since the collection of mappers is a ``frozenset`` the one
+    returned would then depend on the iteration order. Reaching every level of the
+    inheritance made the case more likely, not less — before, the classes nested deeper
+    were invisible. A duplicate name is a project-level problem this function cannot solve.
 
     Args:
         entity_name (str): Name of the ORM class to look for, such as ``"User"``.
@@ -143,23 +156,33 @@ def retrieve_mapper_entity(entity_name: str):
     Returns:
         Type[Base] | None: The matching ORM class, or ``None`` when not found.
     """
-    for mapper in Base.__subclasses__():
-        if mapper.__name__ == entity_name:
-            return mapper
+    for mapper in Base.registry.mappers:
+        if mapper.class_.__name__ == entity_name:
+            return mapper.class_
+    return None
 
 
 def retrieve_mapper_from_table(table_name: str):
-    """Look up a subclass of ``Base`` by table name.
+    """Look up a mapped class by table name.
 
-    Iterates over ``Base.__subclasses__()``, so it only finds the **direct** subclasses
-    of ``Base`` and not the ones nested in further inheritance levels.
+    Scans ``Base.registry.mappers`` like ``retrieve_mapper_entity``, and returns the
+    **root of the hierarchy** for the table. The distinction matters under single table
+    inheritance, where several classes share one table and would all match: the root is
+    the deterministic answer, and the collection of mappers is a ``frozenset``, so
+    returning the first match found would depend on the iteration order.
+
+    Only mapped classes are in the registry, so an abstract intermediate base is excluded
+    by construction. Scanning ``Base.__subclasses__()`` instead — as this did — reached
+    those bases, and since they declare no ``__tablename__`` a single ``__abstract__``
+    class in the project raised ``AttributeError`` on **every** lookup.
 
     Args:
         table_name (str): Name of the table in the database, such as ``"users"``.
 
     Returns:
-        Type[Base] | None: The matching ORM class, or ``None`` when not found.
+        Type[Base] | None: The class the table is mapped on, or ``None`` when not found.
     """
-    for mapper in Base.__subclasses__():
-        if mapper.__tablename__ == table_name:
-            return mapper
+    for mapper in Base.registry.mappers:
+        if mapper.local_table is not None and mapper.local_table.name == table_name:
+            return mapper.base_mapper.class_
+    return None

{python_general_be_lib-0.9.1 → python_general_be_lib-0.10.0}/general/interface/metadata/crud_metadata.py

@@ -4,10 +4,14 @@ import logging
 from typing import Optional, Any, Type, Iterable, Sequence
 
 from pydantic import BaseModel
-from sqlalchemy import MetaData, Engine, Column, Table, inspect, Connection, select, RowMapping, CursorResult, not_, ARRAY, type_coerce
+from sqlalchemy import MetaData, Engine, Column, Table, inspect, Connection, select, RowMapping, CursorResult
 from sqlalchemy.exc import NoSuchTableError
+from sqlalchemy.sql.functions import count
 
-from ...exception.crud_exceptions import HasNoAttributeException, InternalServerException
+from ...exception.crud_exceptions import HasNoAttributeException, InternalServerException, raise_http_exception
+from ...interface.repository.handler.base_handler import BaseHandler
+from ...interface.repository.handler.statement_manager import StatementManager
+from ...paginator_dto import PaginatorResponseModel, parse_pagination
 
 
 class CrudMetadata:
@@ -20,12 +24,13 @@ class CrudMetadata:
     (``keep_open=True``) the raw results are returned with no commit and no close,
     otherwise the connection is opened, committed and closed internally.
 
-    Three things set it apart from ``CrudRepository``: it does not use the handler
-    pipeline, the filters going straight through ``_eq_where``, so there is no support
-    for JSON, ILIKE, intervals or aliases; the SQLAlchemy exceptions are logged and
-    re-raised as they are instead of being mapped onto HTTP exceptions; and the
-    serialization happens through ``parsing_model(**row)`` on the row mappings rather
-    than through ``model_validate`` on ORM entities.
+    The filters go through the same handler pipeline as ``CrudRepository``, built per
+    table from the columns of the reflected ``Table``: the ``BaseHandler`` alone by
+    default, plus whatever ``register_handlers`` adds for that table. The SQLAlchemy
+    exceptions are mapped onto HTTP exceptions with the same table, through
+    ``raise_http_exception``. What still sets this layer apart is the serialization, which
+    happens through ``parsing_model(**row)`` on the row mappings rather than through
+    ``model_validate`` on ORM entities.
 
     Attributes:
         schema (str | None): Name of the default schema of the tables.
@@ -33,8 +38,10 @@ class CrudMetadata:
         engine (Engine): SQLAlchemy Engine instance connected to the database.
         engine_inspection (Inspector): Inspector used for the introspections, such as
             the presence of a table.
+        statement_managers (dict[str, StatementManager]): Handler pipeline per table
+            name, built on first use and replaced by ``register_handlers``.
     """
-    __slots__ = "schema", "metadata", "engine", "engine_inspection"
+    __slots__ = "schema", "metadata", "engine", "engine_inspection", "statement_managers"
 
     @property
     def open_connection(self):
@@ -60,6 +67,7 @@ class CrudMetadata:
         self.metadata = MetaData(schema_name) if schema_name else MetaData()
         self.engine = engine
         self.engine_inspection = inspect(self.engine)
+        self.statement_managers = {}
         if reflect:
             self.metadata.reflect(bind=self.engine, schema=schema_name)
 
@@ -68,6 +76,13 @@ class CrudMetadata:
     def _handle_exception(self, connection: Connection, e: Exception, to_raise: bool = True):
         """Close the connection, log the error and re-raise it when required.
 
+        The mapping is the same one ``CrudRepository`` applies, through the shared
+        ``raise_http_exception``: an ``OperationalError`` becomes a 503, a
+        ``NoResultFound`` a 404, a ``DataError`` or an ``IntegrityError`` a 400, and any
+        other error is re-raised unchanged. Until this layer re-raised every SQLAlchemy
+        error as it was, so a constraint violation on a reflected table reached the client
+        as an unhandled 500 instead of the 400 the ORM layer returns for the same error.
+
         Args:
             connection (Connection): Connection to close.
             e (Exception): Caught exception.
@@ -75,12 +90,15 @@ class CrudMetadata:
                 Default: ``True``.
 
         Raises:
-            Exception: The original exception, when ``to_raise=True``.
+            ServiceUnavailableException: On ``OperationalError``, database unreachable.
+            EntityNotFoundException: On ``NoResultFound``.
+            BadRequestException: On ``DataError`` or ``IntegrityError``.
+            Exception: The original exception, for every other type.
         """
         connection.close()
         logging.error(e)
         if to_raise:
-            raise e
+            raise_http_exception(e)
 
     def commit(self, connection: Connection):
         """Commit the connection, handling the possible exceptions.
@@ -96,6 +114,50 @@ class CrudMetadata:
         except Exception as e:
             self._handle_exception(connection, e)
 
+    def register_handlers(self, from_table: str, handlers: list[BaseHandler]) -> StatementManager:
+        """Configure the specialized handlers for one table.
+
+        Without registration the pipeline of a table holds the ``BaseHandler`` alone,
+        which covers equality, ``IN`` and the ``ARRAY`` operators — the whole filtering
+        this layer used to support. Registering ``ILikeHandler``, ``JsonHandler``,
+        ``IntervalHandler`` or ``OrHandler`` extends it exactly as on ``CrudRepository``:
+        the handler interface works on the column collection of a reflected ``Table``
+        with no adaptation, JSON columns included, since reflection resolves a JSONB
+        column to ``python_type == dict``.
+
+        The registration is per table and per instance, and replaces any previous one.
+
+        Args:
+            from_table (str): Name of the table the handlers apply to.
+            handlers (list[BaseHandler]): Handlers to run before the base one, in order.
+
+        Returns:
+            StatementManager: The pipeline just registered.
+
+        Raises:
+            HasNoAttributeException: If the table does not exist.
+        """
+        table = self._get_table(name=from_table)
+        manager = StatementManager(handlers=handlers, base_handler=BaseHandler(table.c))
+        self.statement_managers[table.name] = manager
+        return manager
+
+    def _statement_manager(self, table: Table) -> StatementManager:
+        """Return the pipeline of a table, building a base-only one on first use.
+
+        Args:
+            table (Table): Table to get the pipeline for.
+
+        Returns:
+            StatementManager: Registered pipeline, or one holding only the
+                ``BaseHandler`` built from the columns of the table.
+        """
+        manager = self.statement_managers.get(table.name)
+        if manager is None:
+            manager = StatementManager(base_handler=BaseHandler(table.c))
+            self.statement_managers[table.name] = manager
+        return manager
+
     def has_columns(self, *columns: str, table: Table) -> bool:
         """Check that every given name is a column of the table.
 
@@ -189,7 +251,8 @@ class CrudMetadata:
         table.drop(self.engine)
         self.metadata.remove(table=table)
 
-    def find(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, parsing_model: Type[BaseModel] = None, **kwhere):
+    def find(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, parsing_model: Type[BaseModel] = None,
+             orders_by: dict[str, bool] = None, **kwhere):
         """Find the rows of the table matching the given criteria.
 
         Args:
@@ -210,10 +273,10 @@ class CrudMetadata:
         keep_open = False if connection is None else True
         connection = self.open_connection if connection is None else connection
         table = self.get_table(name=from_table)
-        result = self._find(table=table, connection=connection, where=where, columns=columns, limit=limit, **kwhere)
+        result = self._find(table=table, connection=connection, where=where, columns=columns, limit=limit, orders_by=orders_by, **kwhere)
         return self._return(connection=connection, result=result, keep_open=keep_open, commit=False, parsing_model=parsing_model)
 
-    def _find(self, table: Table, connection: Connection, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, **kwhere):
+    def _find(self, table: Table, connection: Connection, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, orders_by: dict[str, bool] = None, **kwhere):
         """Build and execute the SELECT statement with filters and limit.
 
         Args:
@@ -230,8 +293,10 @@ class CrudMetadata:
         """
         if where is None:
             where = kwhere if kwhere else {}
+        manager = self._statement_manager(table)
         stmt = self._select(table=table, columns=columns)
-        stmt = stmt.where(*[self._eq_where(table.c[column], condition) for column, condition in where.items()])
+        stmt = self._add_orders_by_condition(stmt, table, orders_by)
+        stmt = manager.prepare_statement(stmt=stmt, **where)
         stmt = self._add_limit_offset_condition(stmt, limit)
         return self.execute(connection=connection, stmt=stmt, mapping=True)
 
@@ -281,7 +346,7 @@ class CrudMetadata:
         """
         if values:
             stmt = table.insert().values(values)
-            stmt = stmt if not returning else stmt.returning()
+            stmt = stmt if not returning else stmt.returning(*table.c)
             return self.execute(connection=connection, stmt=stmt, mapping=True)
         else:
             return []
@@ -325,9 +390,9 @@ class CrudMetadata:
         if where is None:
             where = {}
         stmt = table.update()
-        stmt = stmt.where(*[self._eq_where(table.c[column], condition) for column, condition in where.items()])
+        stmt = self._statement_manager(table).prepare_statement(stmt=stmt, **where)
         stmt = stmt.values(**kwargs)
-        stmt = stmt if not returning else stmt.returning()
+        stmt = stmt if not returning else stmt.returning(*table.c)
         return self.execute(connection=connection, stmt=stmt, mapping=True)
 
     def delete(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, **kwhere):
@@ -371,7 +436,7 @@ class CrudMetadata:
         if where is None:
             where = kwhere if kwhere else {}
         stmt = table.delete()
-        stmt = stmt.where(*[self._eq_where(table.c[column], condition) for column, condition in where.items()])
+        stmt = self._statement_manager(table).prepare_statement(stmt=stmt, **where)
         return self.execute(connection=connection, stmt=stmt).rowcount
 
     # --------------
@@ -379,6 +444,10 @@ class CrudMetadata:
     def execute(self, connection: Connection, stmt, mapping: bool = False):
         """Execute a statement on the connection, handling the exceptions.
 
+        A statement returning no rows — a DML without ``RETURNING`` — yields an empty list
+        when ``mapping=True`` instead of raising: reading its rows would fail **after** the
+        write has already happened, so a retry would duplicate it.
+
         Args:
             connection (Connection): Connection to execute the statement on.
             stmt: SQLAlchemy Core statement to execute.
@@ -399,7 +468,9 @@ class CrudMetadata:
             self._handle_exception(connection, e)
         else:
             if mapping:
-                result = result.mappings().all()
+                # ``returns_rows`` è falso su un DML senza RETURNING: leggerne le righe
+                # solleverebbe ``ResourceClosedError`` **dopo** che la scrittura è avvenuta
+                result = result.mappings().all() if result.returns_rows else []
             return result
 
     def _get_table(self, name: str):
@@ -454,6 +525,174 @@ class CrudMetadata:
         """
         return self.engine_inspection.has_table(name, self.schema)
 
+    def count(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, **kwhere) -> int:
+        """Count the rows matching the given criteria.
+
+        Args:
+            from_table (str): Name of the table to count on.
+            connection (Connection, optional): External connection. When ``None``, one is
+                opened and closed at the end.
+            where (dict[str, Any], optional): Filters as a dictionary. Takes precedence
+                over ``**kwhere``.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            int: Number of matching rows.
+
+        Raises:
+            HasNoAttributeException: If the table does not exist.
+        """
+        keep_open = connection is not None
+        connection = self.open_connection if connection is None else connection
+        table = self.get_table(name=from_table)
+        total = self._count(table=table, connection=connection, where=where, **kwhere)
+        if not keep_open:
+            connection.close()
+        return total
+
+    def _count(self, table: Table, connection: Connection, where: dict[str, Any] = None, **kwhere) -> int:
+        """Run the ``COUNT`` with the filters applied.
+
+        The ``select_from`` is mandatory: ``select(count())`` alone compiles into a
+        ``SELECT count(*)`` with no FROM clause, which always returns 1.
+
+        Args:
+            table (Table): Table to count on.
+            connection (Connection): Connection to run the statement on.
+            where (dict[str, Any], optional): Filters. When ``None``, ``**kwhere`` is used.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            int: Number of matching rows.
+        """
+        if where is None:
+            where = kwhere if kwhere else {}
+        stmt = select(count()).select_from(table)
+        stmt = self._statement_manager(table).prepare_statement(stmt=stmt, **where)
+        return self.execute(connection=connection, stmt=stmt).scalar()
+
+    def paging_find(self, from_table: str, connection: Connection = None, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, page: int = 1,
+                    parsing_model: Type[BaseModel] = None, orders_by: dict[str, bool] = None, **kwhere) -> PaginatorResponseModel:
+        """Run a paginated search on a reflected table.
+
+        Mirrors ``CrudRepository.paging_find``, including the derived total: the data query
+        runs **first**, so that when the page itself tells how many rows there are the
+        ``COUNT`` is skipped entirely. The derived value is exact, not estimated.
+
+        Args:
+            from_table (str): Name of the table to search on.
+            connection (Connection, optional): External connection. When ``None``, one is
+                opened and closed at the end.
+            where (dict[str, Any], optional): Filters as a dictionary.
+            columns (list[str], optional): Columns to select.
+            limit (int): Number of rows per page. Default: 0, meaning no limit and
+                therefore a single page.
+            page (int): Requested page number, 1-based. Default: 1.
+            parsing_model (Type[BaseModel], optional): Model each row is serialized with.
+            orders_by (dict[str, bool], optional): Ordering, as ``{column: ascending}``,
+                with the clauses following the insertion order of the dictionary. When
+                omitted no ordering is applied, and without a total order two pages can
+                overlap.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            PaginatorResponseModel: Object carrying ``data``, ``tot_pages``, ``page``,
+                ``limit`` and the ordering.
+
+        Raises:
+            HasNoAttributeException: If the table or one of the columns does not exist.
+        """
+        keep_open = connection is not None
+        connection = self.open_connection if connection is None else connection
+        table = self.get_table(name=from_table)
+        paginated = self._paging_find(table=table, connection=connection, where=where, columns=columns, limit=limit, page=page, orders_by=orders_by, **kwhere)
+        if not keep_open:
+            if parsing_model is not None:
+                paginated.data = [parsing_model(**row) for row in paginated.data]
+            connection.close()
+        return paginated
+
+    def _paging_find(self, table: Table, connection: Connection, where: dict[str, Any] = None, columns: list[str] = None, limit: int = 0, page: int = 1,
+                     orders_by: dict[str, bool] = None, **kwhere) -> PaginatorResponseModel:
+        """Read the page and derive the total, running the ``COUNT`` only when needed.
+
+        Args:
+            table (Table): Table to search on.
+            connection (Connection): Connection to run the statements on.
+            where (dict[str, Any], optional): Filters. When ``None``, ``**kwhere`` is used.
+            columns (list[str], optional): Columns to select.
+            limit (int): Rows per page. 0 means no limit.
+            page (int): Page number, 1-based.
+            orders_by (dict[str, bool], optional): Ordering to apply.
+            **kwhere: Additional filters as keyword arguments.
+
+        Returns:
+            PaginatorResponseModel: Page and total, with the raw rows as ``data``.
+        """
+        if where is None:
+            where = kwhere if kwhere else {}
+        if orders_by is None:
+            orders_by = {}
+
+        manager = self._statement_manager(table)
+        stmt = self._select(table=table, columns=columns)
+        stmt = self._add_orders_by_condition(stmt, table, orders_by)
+        stmt = self._add_limit_offset_condition(stmt, limit, page)
+        # copia: ``conditions`` consuma le chiavi con ``pop`` e il ``where`` è del chiamante
+        conditions = manager.conditions(where=dict(where))
+        if conditions:
+            stmt = stmt.where(*conditions)
+        stmt = manager.options(stmt=stmt)
+
+        rows = self.execute(connection=connection, stmt=stmt, mapping=True)
+
+        read = len(rows)
+        if not limit or (read < limit and page == 1):
+            total = read
+        elif limit > read > 0 and page > 1:
+            total = (page - 1) * limit + read
+        else:
+            total = self._preconf_count(table=table, connection=connection, where=conditions)
+
+        return parse_pagination(limit=limit, page=page, orders_by=orders_by, count=total, data=rows)
+
+    def _preconf_count(self, table: Table, connection: Connection, where: Optional[list] = None) -> int:
+        """Count from already built WHERE conditions, reusing the ones of the page query.
+
+        Args:
+            table (Table): Table to count on.
+            connection (Connection): Connection to run the statement on.
+            where (list | None): Conditions as ``StatementManager.conditions`` returns
+                them. An empty list or ``None`` counts every row.
+
+        Returns:
+            int: Number of matching rows.
+        """
+        stmt = select(count()).select_from(table)
+        if where:
+            stmt = stmt.where(*where)
+        return self.execute(connection=connection, stmt=stmt).scalar()
+
+    def _add_orders_by_condition(self, stmt, table: Table, orders_by: dict[str, bool] = None):
+        """Add one ORDER BY clause per entry of ``orders_by``, in insertion order.
+
+        Args:
+            stmt: Statement to add the ordering to.
+            table (Table): Table the columns belong to.
+            orders_by (dict[str, bool], optional): ``{column: ascending}``. Nothing is
+                applied when empty or ``None``.
+
+        Returns:
+            Statement with the ORDER BY clauses applied.
+
+        Raises:
+            HasNoAttributeException: If one of the columns does not exist on the table.
+        """
+        manager = self._statement_manager(table)
+        for order_by, asc in (orders_by or {}).items():
+            stmt = manager.order_by_condition(stmt=stmt, order_by=order_by, asc=asc)
+        return stmt
+
     def _add_limit_offset_condition(self, stmt, limit: int, page: int = None):
         """Add the LIMIT and OFFSET clauses to the statement for pagination.
 
@@ -475,31 +714,3 @@ class CrudMetadata:
                 offset = (page - 1) * limit
                 stmt = stmt.offset(offset)
         return stmt
-
-    def _eq_where(self, col: Column, condition, neq: bool = False):
-        """Build the single WHERE condition for one column.
-
-        The logic matches ``BaseHandler._handle``: an ``ARRAY`` column compared to a list
-        yields an overlap (``&&``), compared to a scalar an ``= ANY``; a list yields an
-        ``IN`` and a scalar an equality.
-
-        Args:
-            col (Column): Column the condition applies to.
-            condition: Value or list of values to compare.
-            neq (bool): If ``True``, negate the condition with ``NOT``. Default: ``False``.
-
-        Returns:
-            ColumnElement: SQLAlchemy boolean expression.
-        """
-        is_array = isinstance(col.type, ARRAY)
-        if is_array and isinstance(condition, list):
-            eq_where = col.op("&&")(type_coerce(condition, col.type))
-        elif isinstance(condition, list):
-            eq_where = col.in_(condition)
-        elif is_array:
-            eq_where = condition == col.any_()
-        else:
-            eq_where = col == condition
-        if neq:
-            eq_where = not_(eq_where)
-        return eq_where

{python_general_be_lib-0.9.1 → python_general_be_lib-0.10.0}/general/interface/metadata/geom_metadata.py

@@ -101,8 +101,11 @@ class GeomMetadata(CrudMetadata):
         if intersection_area:
             stmt = stmt.add_columns(polygon_column.ST_Intersection(intersecting_geom).ST_Transform(3857).ST_Area().label("intersection_area"))
 
-        eq_where = [self._eq_where(table.c[column], condition) for column, condition in where.items()]
-        eq_where.extend([self._eq_where(table.c[column], condition, True) for column, condition in not_where.items()])
+        manager = self._statement_manager(table)
+        # ``conditions`` consuma le chiavi con ``pop``: il dizionario va copiato, altrimenti
+        # un chiamante che riusa i propri filtri li perde dopo la prima chiamata
+        eq_where = list(manager.conditions(where=dict(where)))
+        eq_where.extend(manager.conditions(neq=True, where=dict(not_where)))
 
         geom_condition = polygon_column.ST_Intersects(intersecting_geom)
 
@@ -174,7 +177,7 @@ class GeomMetadata(CrudMetadata):
             where = {}
 
         stmt = self._select(table, columns)
-        eq_where = [self._eq_where(table.c[column], condition) for column, condition in where.items()]
+        eq_where = list(self._statement_manager(table).conditions(where=dict(where)))
 
         geom_condition = self._geom_condition(geom=geom, geom_srid=geom_srid, polygon_column_srid=polygon_column_srid, buffer=tolerance)
         geom_condition = polygon_column.ST_Contains(geom_condition) if not contained else geom_condition.ST_Contains(polygon_column)