Add multi conditions and sort select (#2)

* Add multi conditions and sort select

* Update library information

Author: wu-clan

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlalchemy-crud-plus"
-description = "Asynchronous CRUD Operation based on SQLAlChemy2 Model"
+description = "Asynchronous CRUD operation based on SQLAlchemy2 model"
 dynamic = [
     "version",
 ]
@@ -11,10 +11,21 @@ dependencies = [
     "sqlalchemy>=2.0.0",
     "pydantic>=2.0",
 ]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
 requires-python = ">=3.10"
 readme = "README.md"
 license = { text = "MIT" }
 
+[project.urls]
+homepage = "https://github.com/fastapi-practices/sqlalchemy-crud-plus"
+repository = "https://github.com/fastapi-practices/sqlalchemy-crud-plus"
+
 [tool.pdm.dev-dependencies]
 lint = [
     "ruff>=0.4.0",

sqlalchemy_crud_plus/crud.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-from typing import Any, Generic, Sequence, Type, TypeVar
+from typing import Any, Generic, Literal, Sequence, Type, TypeVar
 
 from pydantic import BaseModel
-from sqlalchemy import Row, RowMapping, select
+from sqlalchemy import Row, RowMapping, and_, asc, desc, or_, select
 from sqlalchemy import delete as sa_delete
 from sqlalchemy import update as sa_update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from sqlalchemy_crud_plus.errors import ModelColumnError
+from sqlalchemy_crud_plus.errors import ModelColumnError, SelectExpressionError
 
 _Model = TypeVar('_Model')
 _CreateSchema = TypeVar('_CreateSchema', bound=BaseModel)
@@ -59,7 +59,34 @@ async def select_model_by_column(self, session: AsyncSession, column: str, colum
             query = await session.execute(select(self.model).where(model_column == column_value))  # type: ignore
             return query.scalars().first()
         else:
-            raise ModelColumnError('Model column not found')
+            raise ModelColumnError(f'Model column {column} is not found')
+
+    async def select_model_by_columns(
+        self, session: AsyncSession, expression: Literal['and', 'or'] = 'and', **conditions
+    ) -> _Model | None:
+        """
+        Query by columns
+
+        :param session:
+        :param expression:
+        :param conditions: Query conditions, format：column1=value1, column2=value2
+        :return:
+        """
+        where_list = []
+        for column, value in conditions.items():
+            if hasattr(self.model, column):
+                model_column = getattr(self.model, column)
+                where_list.append(model_column == value)
+            else:
+                raise ModelColumnError(f'Model column {column} is not found')
+        match expression:
+            case 'and':
+                query = await session.execute(select(self.model).where(and_(*where_list)))
+            case 'or':
+                query = await session.execute(select(self.model).where(or_(*where_list)))
+            case _:
+                raise SelectExpressionError(f'select expression {expression} is not supported')
+        return query.scalars().first()
 
     async def select_models(self, session: AsyncSession) -> Sequence[Row | RowMapping | Any] | None:
         """
@@ -71,6 +98,41 @@ async def select_models(self, session: AsyncSession) -> Sequence[Row | RowMappin
         query = await session.execute(select(self.model))
         return query.scalars().all()
 
+    async def select_models_order(
+        self,
+        session: AsyncSession,
+        *columns,
+        model_sort: Literal['skip', 'asc', 'desc'] = 'skip',
+    ) -> Sequence[Row | RowMapping | Any] | None:
+        """
+        Query all rows asc or desc
+
+        :param session:
+        :param columns:
+        :param model_sort:
+        :return:
+        """
+        if model_sort != 'skip':
+            if len(columns) != 1:
+                raise SelectExpressionError('ACS and DESC only allow you to specify one column for sorting')
+        sort_list = []
+        for column in columns:
+            if hasattr(self.model, column):
+                model_column = getattr(self.model, column)
+                sort_list.append(model_column)
+            else:
+                raise ModelColumnError(f'Model column {column} is not found')
+        match model_sort:
+            case 'skip':
+                query = await session.execute(select(self.model).order_by(*sort_list))
+            case 'asc':
+                query = await session.execute(select(self.model).order_by(asc(*sort_list)))
+            case 'desc':
+                query = await session.execute(select(self.model).order_by(desc(*sort_list)))
+            case _:
+                raise SelectExpressionError(f'select sort expression {model_sort} is not supported')
+        return query.scalars().all()
+
     async def update_model(self, session: AsyncSession, pk: int, obj: _UpdateSchema | dict[str, Any], **kwargs) -> int:
         """
         Update an instance of a model

sqlalchemy_crud_plus/errors.py

@@ -15,3 +15,10 @@ class ModelColumnError(SQLAlchemyCRUDPlusException):
 
     def __init__(self, msg: str) -> None:
         super().__init__(msg)
+
+
+class SelectExpressionError(SQLAlchemyCRUDPlusException):
+    """Error raised when a select expression is invalid."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(msg)

tests/test_crud.py

@@ -54,6 +54,18 @@ async def test_select_model_by_column():
             assert result.name == f'test_name_{i}'
 
 
+@pytest.mark.asyncio
+async def test_select_model_by_columns():
+    await create_test_model()
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        for i in range(1, 10):
+            result = await crud.select_model_by_columns(session, id=f'{i}', name=f'test_name_{i}')
+            assert result.name == f'test_name_{i}'
+            result = await crud.select_model_by_columns(session, 'or', id=f'{i}', name='null')
+            assert result.name == f'test_name_{i}'
+
+
 @pytest.mark.asyncio
 async def test_select_models():
     await create_test_model()
@@ -63,6 +75,19 @@ async def test_select_models():
         assert len(result) == 9
 
 
+@pytest.mark.asyncio
+async def test_select_models_order():
+    await create_test_model()
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_models_order(session, 'id', 'name')
+        assert result[0].id == 1
+        result = await crud.select_models_order(session, 'id', model_sort='asc')
+        assert result[0].id == 1
+        result = await crud.select_models_order(session, 'id', model_sort='desc')
+        assert result[0].id == 9
+
+
 @pytest.mark.asyncio
 async def test_update_model():
     await create_test_model()