Refactor code to enhance selection and operations (#9)

* WIP: refactoring enhancements

* Update delete method

* Fix query filter parse

* Update tests

* Update multiple_conditions to and

* fix parse filters method

* fix tests

* Add arithmetic filters

Author: wu-clan

Diff for: sqlalchemy_crud_plus/crud.py

@@ -1,184 +1,130 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-from typing import Any, Generic, Iterable, Literal, Sequence, Type, TypeVar
+from typing import Any, Generic, Iterable, Sequence, Type
 
-from pydantic import BaseModel
-from sqlalchemy import Row, RowMapping, and_, asc, desc, or_, select
+from sqlalchemy import Row, RowMapping, 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, SelectExpressionError
+from sqlalchemy_crud_plus.errors import MultipleResultsError
+from sqlalchemy_crud_plus.types import CreateSchema, Model, UpdateSchema
+from sqlalchemy_crud_plus.utils import apply_sorting, count, parse_filters
 
-_Model = TypeVar('_Model')
-_CreateSchema = TypeVar('_CreateSchema', bound=BaseModel)
-_UpdateSchema = TypeVar('_UpdateSchema', bound=BaseModel)
 
-
-class CRUDPlus(Generic[_Model]):
-    def __init__(self, model: Type[_Model]):
+class CRUDPlus(Generic[Model]):
+    def __init__(self, model: Type[Model]):
         self.model = model
 
-    async def create_model(self, session: AsyncSession, obj: _CreateSchema, commit: bool = False, **kwargs) -> _Model:
+    async def create_model(self, session: AsyncSession, obj: CreateSchema, commit: bool = False, **kwargs) -> Model:
         """
         Create a new instance of a model
 
-        :param session:
-        :param obj:
-        :param commit:
-        :param kwargs:
+        :param session: The SQLAlchemy async session.
+        :param obj: The Pydantic schema containing data to be saved.
+        :param commit: If `True`, commits the transaction immediately. Default is `False`.
+        :param kwargs: Additional model data not included in the pydantic schema.
         :return:
         """
-        if kwargs:
-            ins = self.model(**obj.model_dump(), **kwargs)
-        else:
+        if not kwargs:
             ins = self.model(**obj.model_dump())
+        else:
+            ins = self.model(**obj.model_dump(), **kwargs)
         session.add(ins)
         if commit:
             await session.commit()
         return ins
 
     async def create_models(
-        self, session: AsyncSession, obj: Iterable[_CreateSchema], commit: bool = False
-    ) -> list[_Model]:
+        self, session: AsyncSession, obj: Iterable[CreateSchema], commit: bool = False
+    ) -> list[Model]:
         """
         Create new instances of a model
 
-        :param session:
-        :param obj:
-        :param commit:
+        :param session: The SQLAlchemy async session.
+        :param obj: The Pydantic schema list containing data to be saved.
+        :param commit: If `True`, commits the transaction immediately. Default is `False`.
         :return:
         """
         ins_list = []
-        for i in obj:
-            ins_list.append(self.model(**i.model_dump()))
+        for ins in obj:
+            ins_list.append(self.model(**ins.model_dump()))
         session.add_all(ins_list)
         if commit:
             await session.commit()
         return ins_list
 
-    async def select_model_by_id(self, session: AsyncSession, pk: int) -> _Model | None:
+    async def select_model(self, session: AsyncSession, pk: int) -> Model | None:
         """
         Query by ID
 
-        :param session:
-        :param pk:
+        :param session: The SQLAlchemy async session.
+        :param pk: The database primary key value.
         :return:
         """
         stmt = select(self.model).where(self.model.id == pk)
         query = await session.execute(stmt)
         return query.scalars().first()
 
-    async def select_model_by_column(self, session: AsyncSession, column: str, column_value: Any) -> _Model | None:
+    async def select_model_by_column(self, session: AsyncSession, **kwargs) -> Model | None:
         """
         Query by column
 
-        :param session:
-        :param column:
-        :param column_value:
-        :return:
-        """
-        if hasattr(self.model, column):
-            model_column = getattr(self.model, column)
-            stmt = select(self.model).where(model_column == column_value)  # type: ignore
-            query = await session.execute(stmt)
-            return query.scalars().first()
-        else:
-            raise ModelColumnError(f'Column {column} is not found in {self.model}')
-
-    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
+        :param session: The SQLAlchemy async session.
+        :param kwargs: Query expressions.
         :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'Column {column} is not found in {self.model}')
-        match expression:
-            case 'and':
-                stmt = select(self.model).where(and_(*where_list))
-                query = await session.execute(stmt)
-            case 'or':
-                stmt = select(self.model).where(or_(*where_list))
-                query = await session.execute(stmt)
-            case _:
-                raise SelectExpressionError(
-                    f'Select expression {expression} is not supported, only supports `and`, `or`'
-                )
+        filters = await parse_filters(self.model, **kwargs)
+        stmt = select(self.model).where(*filters)
+        query = await session.execute(stmt)
         return query.scalars().first()
 
-    async def select_models(self, session: AsyncSession) -> Sequence[Row[Any] | RowMapping | Any]:
+    async def select_models(self, session: AsyncSession, **kwargs) -> Sequence[Row[Any] | RowMapping | Any]:
         """
         Query all rows
 
-        :param session:
+        :param session: The SQLAlchemy async session.
+        :param kwargs: Query expressions.
         :return:
         """
-        stmt = select(self.model)
+        filters = await parse_filters(self.model, **kwargs)
+        stmt = select(self.model).where(*filters)
         query = await session.execute(stmt)
         return query.scalars().all()
 
     async def select_models_order(
-        self,
-        session: AsyncSession,
-        *columns,
-        model_sort: Literal['asc', 'desc'] = 'desc',
+        self, session: AsyncSession, sort_columns: str | list[str], sort_orders: str | list[str] | None = None, **kwargs
     ) -> Sequence[Row | RowMapping | Any] | None:
         """
-        Query all rows asc or desc
+        Query all rows and sort by columns
 
-        :param session:
-        :param columns:
-        :param model_sort:
+        :param session: The SQLAlchemy async session.
+        :param sort_columns: more details see apply_sorting
+        :param sort_orders: more details see apply_sorting
         :return:
         """
-        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'Column {column} is not found in {self.model}')
-        match model_sort:
-            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, only supports `asc`, `desc`'
-                )
+        filters = await parse_filters(self.model, **kwargs)
+        stmt = select(self.model).where(*filters)
+        stmt_sort = await apply_sorting(self.model, stmt, sort_columns, sort_orders)
+        query = await session.execute(stmt_sort)
         return query.scalars().all()
 
     async def update_model(
-        self, session: AsyncSession, pk: int, obj: _UpdateSchema | dict[str, Any], commit: bool = False, **kwargs
+        self, session: AsyncSession, pk: int, obj: UpdateSchema | dict[str, Any], commit: bool = False
     ) -> int:
         """
-        Update an instance of model's primary key
+        Update an instance by model's primary key
 
-        :param session:
-        :param pk:
-        :param obj:
-        :param commit:
-        :param kwargs:
+        :param session: The SQLAlchemy async session.
+        :param pk: The database primary key value.
+        :param obj: A pydantic schema or dictionary containing the update data
+        :param commit: If `True`, commits the transaction immediately. Default is `False`.
         :return:
         """
         if isinstance(obj, dict):
             instance_data = obj
         else:
             instance_data = obj.model_dump(exclude_unset=True)
-        if kwargs:
-            instance_data.update(kwargs)
         stmt = sa_update(self.model).where(self.model.id == pk).values(**instance_data)
         result = await session.execute(stmt)
         if commit:
@@ -188,55 +134,80 @@ async def update_model(
     async def update_model_by_column(
         self,
         session: AsyncSession,
-        column: str,
-        column_value: Any,
-        obj: _UpdateSchema | dict[str, Any],
+        obj: UpdateSchema | dict[str, Any],
+        allow_multiple: bool = False,
         commit: bool = False,
         **kwargs,
     ) -> int:
         """
-        Update an instance of model column
+        Update an instance by model column
 
-        :param session:
-        :param column:
-        :param column_value:
-        :param obj:
-        :param commit:
-        :param kwargs:
+        :param session: The SQLAlchemy async session.
+        :param obj: A pydantic schema or dictionary containing the update data
+        :param allow_multiple: If `True`, allows updating multiple records that match the filters.
+        :param commit: If `True`, commits the transaction immediately. Default is `False`.
+        :param kwargs: Query expressions.
         :return:
         """
+        filters = await parse_filters(self.model, **kwargs)
+        total_count = await count(session, self.model, filters)
+        if not allow_multiple and total_count > 1:
+            raise MultipleResultsError(f'Only one record is expected to be update, found {total_count} records.')
         if isinstance(obj, dict):
             instance_data = obj
         else:
             instance_data = obj.model_dump(exclude_unset=True)
-        if kwargs:
-            instance_data.update(kwargs)
-        if hasattr(self.model, column):
-            model_column = getattr(self.model, column)
-        else:
-            raise ModelColumnError(f'Column {column} is not found in {self.model}')
-        stmt = sa_update(self.model).where(model_column == column_value).values(**instance_data)  # type: ignore
+        stmt = sa_update(self.model).where(*filters).values(**instance_data)  # type: ignore
         result = await session.execute(stmt)
         if commit:
             await session.commit()
         return result.rowcount  # type: ignore
 
-    async def delete_model(self, session: AsyncSession, pk: int, commit: bool = False, **kwargs) -> int:
+    async def delete_model(self, session: AsyncSession, pk: int, commit: bool = False) -> int:
         """
-        Delete an instance of a model
+        Delete an instance by model's primary key
 
-        :param session:
-        :param pk:
-        :param commit:
-        :param kwargs: for soft deletion only
+        :param session: The SQLAlchemy async session.
+        :param pk: The database primary key value.
+        :param commit: If `True`, commits the transaction immediately. Default is `False`.
         :return:
         """
-        if not kwargs:
-            stmt = sa_delete(self.model).where(self.model.id == pk)
-            result = await session.execute(stmt)
-        else:
-            stmt = sa_update(self.model).where(self.model.id == pk).values(**kwargs)
-            result = await session.execute(stmt)
+        stmt = sa_delete(self.model).where(self.model.id == pk)
+        result = await session.execute(stmt)
         if commit:
             await session.commit()
         return result.rowcount  # type: ignore
+
+    async def delete_model_by_column(
+        self,
+        session: AsyncSession,
+        allow_multiple: bool = False,
+        logical_deletion: bool = False,
+        deleted_flag_column: str = 'del_flag',
+        commit: bool = False,
+        **kwargs,
+    ) -> int:
+        """
+        Delete
+
+        :param session: The SQLAlchemy async session.
+        :param commit: If `True`, commits the transaction immediately. Default is `False`.
+        :param kwargs: Query expressions.
+        :param allow_multiple: If `True`, allows deleting multiple records that match the filters.
+        :param logical_deletion: If `True`, enable logical deletion instead of physical deletion
+        :param deleted_flag_column: Specify the flag column for logical deletion
+        :return:
+        """
+        filters = await parse_filters(self.model, **kwargs)
+        total_count = await count(session, self.model, filters)
+        if not allow_multiple and total_count > 1:
+            raise MultipleResultsError(f'Only one record is expected to be delete, found {total_count} records.')
+        if logical_deletion:
+            deleted_flag = {deleted_flag_column: True}
+            stmt = sa_update(self.model).where(*filters).values(**deleted_flag)
+        else:
+            stmt = sa_delete(self.model).where(*filters)
+        await session.execute(stmt)
+        if commit:
+            await session.commit()
+        return total_count

Diff for: sqlalchemy_crud_plus/errors.py

@@ -17,8 +17,22 @@ def __init__(self, msg: str) -> None:
         super().__init__(msg)
 
 
-class SelectExpressionError(SQLAlchemyCRUDPlusException):
+class SelectOperatorError(SQLAlchemyCRUDPlusException):
     """Error raised when a select expression is invalid."""
 
     def __init__(self, msg: str) -> None:
         super().__init__(msg)
+
+
+class ColumnSortError(SQLAlchemyCRUDPlusException):
+    """Error raised when a column sorting is invalid."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(msg)
+
+
+class MultipleResultsError(SQLAlchemyCRUDPlusException):
+    """Error raised when multiple results are invalid."""
+
+    def __init__(self, msg: str) -> None:
+        super().__init__(msg)

Diff for: sqlalchemy_crud_plus/types.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+Model = TypeVar('Model')
+
+CreateSchema = TypeVar('CreateSchema', bound=BaseModel)
+UpdateSchema = TypeVar('UpdateSchema', bound=BaseModel)

Diff for: sqlalchemy_crud_plus/utils.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import warnings
+
+from typing import Any, Callable, Type
+
+from sqlalchemy import ColumnElement, Select, and_, asc, desc, func, or_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm.util import AliasedClass
+
+from sqlalchemy_crud_plus.errors import ColumnSortError, ModelColumnError, SelectOperatorError
+from sqlalchemy_crud_plus.types import Model
+
+_SUPPORTED_FILTERS = {
+    # Comparison: https://docs.sqlalchemy.org/en/20/core/operators.html#comparison-operators
+    'gt': lambda column: column.__gt__,
+    'lt': lambda column: column.__lt__,
+    'ge': lambda column: column.__ge__,
+    'le': lambda column: column.__le__,
+    'eq': lambda column: column.__eq__,
+    'ne': lambda column: column.__ne__,
+    'between': lambda column: column.between,
+    # IN: https://docs.sqlalchemy.org/en/20/core/operators.html#in-comparisons
+    'in': lambda column: column.in_,
+    'not_in': lambda column: column.not_in,
+    # Identity: https://docs.sqlalchemy.org/en/20/core/operators.html#identity-comparisons
+    'is': lambda column: column.is_,
+    'is_not': lambda column: column.is_not,
+    'is_distinct_from': lambda column: column.is_distinct_from,
+    'is_not_distinct_from': lambda column: column.is_not_distinct_from,
+    # String: https://docs.sqlalchemy.org/en/20/core/operators.html#string-comparisons
+    'like': lambda column: column.like,
+    'not_like': lambda column: column.not_like,
+    'ilike': lambda column: column.ilike,
+    'not_ilike': lambda column: column.not_ilike,
+    # String Containment: https://docs.sqlalchemy.org/en/20/core/operators.html#string-containment
+    'startswith': lambda column: column.startswith,
+    'endswith': lambda column: column.endswith,
+    'contains': lambda column: column.contains,
+    # String matching: https://docs.sqlalchemy.org/en/20/core/operators.html#string-matching
+    'match': lambda column: column.match,
+    # String Alteration: https://docs.sqlalchemy.org/en/20/core/operators.html#string-alteration
+    'concat': lambda column: column.concat,
+    # Arithmetic: https://docs.sqlalchemy.org/en/20/core/operators.html#arithmetic-operators
+    'add': lambda column: column.__add__,
+    'radd': lambda column: column.__radd__,
+    'sub': lambda column: column.__sub__,
+    'rsub': lambda column: column.__rsub__,
+    'mul': lambda column: column.__mul__,
+    'rmul': lambda column: column.__rmul__,
+    'truediv': lambda column: column.__truediv__,
+    'rtruediv': lambda column: column.__rtruediv__,
+    'floordiv': lambda column: column.__floordiv__,
+    'rfloordiv': lambda column: column.__rfloordiv__,
+    'mod': lambda column: column.__mod__,
+    'rmod': lambda column: column.__rmod__,
+}
+
+
+async def get_sqlalchemy_filter(
+    operator: str, value: Any, allow_arithmetic: bool = True
+) -> Callable[[str], Callable] | None:
+    if operator in ['in', 'not_in', 'between']:
+        if not isinstance(value, (tuple, list, set)):
+            raise SelectOperatorError(f'The value of the <{operator}> filter must be tuple, list or set')
+
+    if (
+        operator
+        in ['add', 'radd', 'sub', 'rsub', 'mul', 'rmul', 'truediv', 'rtruediv', 'floordiv', 'rfloordiv', 'mod', 'rmod']
+        and not allow_arithmetic
+    ):
+        raise SelectOperatorError(f'Nested arithmetic operations are not allowed: {operator}')
+
+    sqlalchemy_filter = _SUPPORTED_FILTERS.get(operator)
+    if sqlalchemy_filter is None:
+        warnings.warn(
+            f'The operator <{operator}> is not yet supported, only {", ".join(_SUPPORTED_FILTERS.keys())}.',
+            SyntaxWarning,
+        )
+        return None
+
+    return sqlalchemy_filter
+
+
+async def get_column(model: Type[Model] | AliasedClass, field_name: str):
+    column = getattr(model, field_name, None)
+    if column is None:
+        raise ModelColumnError(f'Column {field_name} is not found in {model}')
+    return column
+
+
+async def parse_filters(model: Type[Model] | AliasedClass, **kwargs) -> list[ColumnElement]:
+    filters = []
+
+    for key, value in kwargs.items():
+        if '__' in key:
+            field_name, op = key.rsplit('__', 1)
+            column = await get_column(model, field_name)
+            if op == 'or':
+                or_filters = [
+                    sqlalchemy_filter(column)(or_value)
+                    for or_op, or_value in value.items()
+                    if (sqlalchemy_filter := await get_sqlalchemy_filter(or_op, or_value)) is not None
+                ]
+                filters.append(or_(*or_filters))
+            elif isinstance(value, dict) and {'value', 'condition'}.issubset(value):
+                advanced_value = value['value']
+                condition = value['condition']
+                sqlalchemy_filter = await get_sqlalchemy_filter(op, advanced_value)
+                if sqlalchemy_filter is not None:
+                    condition_filters = []
+                    for cond_op, cond_value in condition.items():
+                        condition_filter = await get_sqlalchemy_filter(cond_op, cond_value, allow_arithmetic=False)
+                        condition_filters.append(
+                            condition_filter(sqlalchemy_filter(column)(advanced_value))(cond_value)
+                            if cond_op != 'between'
+                            else condition_filter(sqlalchemy_filter(column)(advanced_value))(*cond_value)
+                        )
+                    filters.append(and_(*condition_filters))
+            else:
+                sqlalchemy_filter = await get_sqlalchemy_filter(op, value)
+                if sqlalchemy_filter is not None:
+                    filters.append(
+                        sqlalchemy_filter(column)(value) if op != 'between' else sqlalchemy_filter(column)(*value)
+                    )
+        else:
+            column = await get_column(model, key)
+            filters.append(column == value)
+
+    return filters
+
+
+async def apply_sorting(
+    model: Type[Model] | AliasedClass,
+    stmt: Select,
+    sort_columns: str | list[str],
+    sort_orders: str | list[str] | None = None,
+) -> Select:
+    """
+    Apply sorting to a SQLAlchemy query based on specified column names and sort orders.
+
+    :param model: The SQLAlchemy model.
+    :param stmt: The SQLAlchemy `Select` statement to which sorting will be applied.
+    :param sort_columns: A single column name or list of column names to sort the query results by.
+    Must be used in conjunction with sort_orders.
+    :param sort_orders: A single sort order ("asc" or "desc") or a list of sort orders, corresponding to each
+    column in sort_columns. If not specified, defaults to ascending order for all sort_columns.
+    :return:
+    """
+    if sort_orders and not sort_columns:
+        raise ValueError('Sort orders provided without corresponding sort columns.')
+
+    if sort_columns:
+        if not isinstance(sort_columns, list):
+            sort_columns = [sort_columns]
+
+        if sort_orders:
+            if not isinstance(sort_orders, list):
+                sort_orders = [sort_orders] * len(sort_columns)
+
+            if len(sort_columns) != len(sort_orders):
+                raise ColumnSortError('The length of sort_columns and sort_orders must match.')
+
+            for order in sort_orders:
+                if order not in ['asc', 'desc']:
+                    raise SelectOperatorError(
+                        f'Select sort operator {order} is not supported, only supports `asc`, `desc`'
+                    )
+
+        validated_sort_orders = ['asc'] * len(sort_columns) if not sort_orders else sort_orders
+
+        for idx, column_name in enumerate(sort_columns):
+            column = await get_column(model, column_name)
+            order = validated_sort_orders[idx]
+            stmt = stmt.order_by(asc(column) if order == 'asc' else desc(column))
+
+    return stmt
+
+
+async def count(
+    session: AsyncSession,
+    model: Type[Model] | AliasedClass,
+    filters: list[ColumnElement],
+) -> int:
+    """
+    Counts records that match specified filters.
+
+    :param session: The sqlalchemy session to use for the operation.
+    :param model: The SQLAlchemy model.
+    :param filters: Filters to apply for the count.
+    :return:
+    """
+    stmt = select(func.count()).select_from(model)
+    if filters:
+        stmt = stmt.where(*filters)
+    query = await session.execute(stmt)
+    total_count = query.scalar()
+    return total_count if total_count is not None else 0

Diff for: tests/conftest.py

@@ -1,18 +1,31 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+
 import pytest_asyncio
 
 from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
 
-from tests.model import Base
+from tests.model import Base, Ins
 
-async_engine = create_async_engine('sqlite+aiosqlite:///:memory:', future=True, pool_pre_ping=True)
-async_db_session = async_sessionmaker(async_engine, autoflush=False, expire_on_commit=False)
+_async_engine = create_async_engine('sqlite+aiosqlite:///:memory:', future=True)
+_async_session = async_sessionmaker(_async_engine, autoflush=False, expire_on_commit=False)
 
 
 @pytest_asyncio.fixture(scope='function', autouse=True)
 async def init_db():
-    async with async_engine.begin() as conn:
+    async with _async_engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
         yield
         await conn.run_sync(Base.metadata.drop_all)
+
+
+@pytest_asyncio.fixture
+async def async_db_session():
+    yield _async_session
+
+
+@pytest_asyncio.fixture
+async def create_test_model():
+    async with _async_session.begin() as session:
+        data = [Ins(name=f'name_{i}') for i in range(1, 10)]
+        session.add_all(data)

Diff for: tests/model.py

@@ -17,5 +17,6 @@ class Ins(Base):
 
     id: Mapped[int] = mapped_column(init=False, primary_key=True, index=True, autoincrement=True)
     name: Mapped[str] = mapped_column(String(64))
+    del_flag: Mapped[bool] = mapped_column(default=False)
     created_time: Mapped[datetime] = mapped_column(init=False, default_factory=datetime.now)
     updated_time: Mapped[datetime | None] = mapped_column(init=False, onupdate=datetime.now)

Diff for: tests/schema.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from pydantic import BaseModel
+
+
+class ModelTest(BaseModel):
+    name: str

Diff for: tests/test_create.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import pytest
+
+from sqlalchemy import select
+
+from sqlalchemy_crud_plus import CRUDPlus
+from tests.model import Ins
+from tests.schema import ModelTest
+
+
+@pytest.mark.asyncio
+async def test_create_model(async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        for i in range(1, 10):
+            data = ModelTest(name=f'name_{i}')
+            await crud.create_model(session, data)
+    async with async_db_session() as session:
+        for i in range(1, 10):
+            query = await session.scalar(select(Ins).where(Ins.id == i))
+            assert query.name == f'name_{i}'
+
+
+@pytest.mark.asyncio
+async def test_create_models(async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        data = []
+        for i in range(1, 10):
+            data.append(ModelTest(name=f'name_{i}'))
+        await crud.create_models(session, data)
+    async with async_db_session() as session:
+        for i in range(1, 10):
+            query = await session.scalar(select(Ins).where(Ins.id == i))
+            assert query.name == f'name_{i}'

Diff for: tests/test_crud.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import pytest
+
+from sqlalchemy_crud_plus import CRUDPlus
+from tests.model import Ins
+
+
+@pytest.mark.asyncio
+async def test_delete_model(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.delete_model(session, 1)
+        assert result == 1
+
+
+@pytest.mark.asyncio
+async def test_delete_model_by_column(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.delete_model_by_column(session, name='name_1')
+        assert result == 1
+
+
+@pytest.mark.asyncio
+async def test_delete_model_by_column_with_and(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.delete_model_by_column(session, id=1, name='name_1')
+        assert result == 1
+
+
+@pytest.mark.asyncio
+async def test_delete_model_by_column_logical(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.delete_model_by_column(session, logical_deletion=True, name='name_1')
+        assert result == 1
+
+
+@pytest.mark.asyncio
+async def test_delete_model_by_column_allow_multiple(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.delete_model_by_column(session, allow_multiple=True, name__startswith='name')
+        assert result == 9
+
+
+@pytest.mark.asyncio
+async def test_delete_model_by_column_logical_with_multiple(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.delete_model_by_column(
+            session, allow_multiple=True, logical_deletion=True, name__startswith='name'
+        )
+        assert result == 9

Diff for: tests/test_delete.py

@@ -0,0 +1,368 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import pytest
+
+from sqlalchemy_crud_plus import CRUDPlus
+from tests.model import Ins
+
+
+@pytest.mark.asyncio
+async def test_select_model(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        for i in range(1, 10):
+            result = await crud.select_model(session, i)
+            assert result.name == f'name_{i}'
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        for i in range(1, 10):
+            result = await crud.select_model_by_column(session, name=f'name_{i}')
+            assert result.name == f'name_{i}'
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_and(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        for i in range(1, 10):
+            result = await crud.select_model_by_column(session, id=i, name=f'name_{i}')
+            assert result.name == f'name_{i}'
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_gt(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__gt=1)
+        assert result.id == 2
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_lt(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__lt=1)
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_gte(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__ge=1)
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_lte(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__le=1)
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_eq(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__eq=1)
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_ne(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__ne=1)
+        assert result.id == 2
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_between(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__between=(0, 11))
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_is(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, del_flag__is=False)
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_is_not(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, del_flag__is_not=True)
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_is_distinct_from(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, del_flag__is_distinct_from=True)
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_is_not_distinct_from(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, del_flag__is_not_distinct_from=True)
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_like(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__like='name%')
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_not_like(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__not_like='name%')
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_ilike(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__ilike='NAME%')
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_not_ilike(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__not_ilike='NAME%')
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_startwith(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__startswith='name')
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_endwith(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__endswith='1')
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_contains(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__contains='name')
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+@pytest.mark.skip(reason='match not available in sqlite')
+async def test_select_model_by_column_with_match(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, name__match='name')
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_concat(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(
+            session, name__concat={'value': '_concat', 'condition': {'eq': 'name_1_concat'}}
+        )
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_add_string(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(
+            session, name__add={'value': '_add', 'condition': {'eq': 'name_1_add'}}
+        )
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_radd_string(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(
+            session, name__radd={'value': 'radd_', 'condition': {'eq': 'radd_name_1'}}
+        )
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_add_number(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__add={'value': 1, 'condition': {'eq': 2}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_radd_number(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__radd={'value': 1, 'condition': {'eq': 2}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_sub(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__sub={'value': 1, 'condition': {'eq': 0}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_rsub(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__rsub={'value': 2, 'condition': {'eq': 1}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_mul(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__mul={'value': 1, 'condition': {'eq': 1}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_rmul(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__rmul={'value': 1, 'condition': {'eq': 1}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_truediv(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__truediv={'value': 1, 'condition': {'eq': 1}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_rtruediv(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__rtruediv={'value': 1, 'condition': {'eq': 1}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_floordiv(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__floordiv={'value': 1, 'condition': {'eq': 1}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_rfloordiv(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__rfloordiv={'value': 1, 'condition': {'eq': 1}})
+        assert result is not None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_mod(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__mod={'value': 1, 'condition': {'eq': 0}})
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_rmod(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__rmod={'value': 1, 'condition': {'eq': 0}})
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_in(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__in=(1, 2, 3, 4, 5, 6, 7, 8, 9))
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_not_in(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__not_in=(1, 2, 3, 4, 5, 6, 7, 8, 9))
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_select_model_by_column_with_or(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_model_by_column(session, id__or={'le': 1, 'eq': 1})
+        assert result.id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_models(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_models(session)
+        assert len(result) == 9
+
+
+@pytest.mark.asyncio
+async def test_select_models_order_default_asc(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_models_order(session, ['id', 'name'])
+        assert result[0].id == 1
+
+
+@pytest.mark.asyncio
+async def test_select_models_order_desc(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_models_order(session, ['id', 'name'], ['desc', 'desc'])
+        assert result[0].id == 9
+
+
+@pytest.mark.asyncio
+async def test_select_models_order_asc_and_desc(create_test_model, async_db_session):
+    async with async_db_session() as session:
+        crud = CRUDPlus(Ins)
+        result = await crud.select_models_order(session, ['id', 'name'], ['asc', 'desc'])
+        assert result[0].id == 1

Diff for: tests/test_select.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+import pytest
+
+from sqlalchemy_crud_plus import CRUDPlus
+from tests.model import Ins
+from tests.schema import ModelTest
+
+
+@pytest.mark.asyncio
+async def test_update_model(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        data = ModelTest(name='name_update_1')
+        result = await crud.update_model(session, 1, data)
+        assert result == 1
+        result = await session.get(Ins, 1)
+        assert result.name == 'name_update_1'
+
+
+@pytest.mark.asyncio
+async def test_update_model_by_column(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        data = ModelTest(name='name_update_1')
+        result = await crud.update_model_by_column(session, data, name='name_1')
+        assert result == 1
+        result = await session.get(Ins, 1)
+        assert result.name == 'name_update_1'
+
+
+@pytest.mark.asyncio
+async def test_update_model_by_column_with_and(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        data = ModelTest(name='name_update_1')
+        result = await crud.update_model_by_column(session, data, id=1, name='name_1')
+        assert result == 1
+        result = await session.get(Ins, 1)
+        assert result.name == 'name_update_1'
+
+
+@pytest.mark.asyncio
+async def test_update_model_by_column_with_filter(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        data = ModelTest(name='name_update_1')
+        result = await crud.update_model_by_column(session, data, id__eq=1)
+        assert result == 1
+        result = await session.get(Ins, 1)
+        assert result.name == 'name_update_1'
+
+
+@pytest.mark.asyncio
+async def test_update_model_by_column_allow_multiple(create_test_model, async_db_session):
+    async with async_db_session.begin() as session:
+        crud = CRUDPlus(Ins)
+        data = ModelTest(name='name_update_1')
+        result = await crud.update_model_by_column(session, data, allow_multiple=True, name__startswith='name')
+        assert result == 9
+        result = await session.get(Ins, 1)
+        assert result.name == 'name_update_1'