Enhance the relationship code

Author: wu-clan

sqlalchemy_crud_plus/crud.py

@@ -131,13 +131,15 @@ async def count(
         self,
         session: AsyncSession,
         *whereclause: ColumnExpressionArgument[bool],
+        join_conditions: JoinConditionsConfig | None = None,
         **kwargs,
     ) -> int:
         """
         Count records that match specified filters.
 
-        :param session: The SQLAlchemy async session
-        :param whereclause: Additional WHERE clauses to apply to the query
+        :param session: SQLAlchemy async session
+        :param whereclause: Additional WHERE clauses
+        :param join_conditions: JOIN conditions for relationships
         :param kwargs: Filter expressions using field__operator=value syntax
         :return:
         """
@@ -150,6 +152,9 @@ async def count(
         if filters:
             stmt = stmt.where(*filters)
 
+        if join_conditions:
+            stmt = apply_join_conditions(self.model, stmt, join_conditions)
+
         query = await session.execute(stmt)
         total_count = query.scalar()
         return total_count if total_count is not None else 0
@@ -158,13 +163,15 @@ async def exists(
         self,
         session: AsyncSession,
         *whereclause: ColumnExpressionArgument[bool],
+        join_conditions: JoinConditionsConfig | None = None,
         **kwargs,
     ) -> bool:
         """
         Check whether records that match the specified filters exist.
 
-        :param session: The SQLAlchemy async session
-        :param whereclause: Additional WHERE clauses to apply to the query
+        :param session: SQLAlchemy async session
+        :param whereclause: Additional WHERE clauses
+        :param join_conditions: JOIN conditions for relationships
         :param kwargs: Filter expressions using field__operator=value syntax
         :return:
         """
@@ -174,6 +181,10 @@ async def exists(
             filters.extend(parse_filters(self.model, **kwargs))
 
         stmt = select(self.model).where(*filters).limit(1)
+
+        if join_conditions:
+            stmt = apply_join_conditions(self.model, stmt, join_conditions)
+
         query = await session.execute(stmt)
         return query.scalars().first() is not None
 
@@ -241,44 +252,60 @@ async def select_model_by_column(
         :param kwargs: Filter expressions using field__operator=value syntax
         :return:
         """
-        filters = list(whereclause)
-
-        if kwargs:
-            filters.extend(parse_filters(self.model, **kwargs))
-
-        stmt = select(self.model).where(*filters)
-
-        if options:
-            stmt = stmt.options(*options)
-
-        if join_conditions:
-            stmt = apply_join_conditions(self.model, stmt, join_conditions)
-
-        if load_strategies:
-            rel_options = build_load_strategies(self.model, load_strategies)
-            if rel_options:
-                stmt = stmt.options(*rel_options)
+        stmt = await self.select(
+            *whereclause,
+            options=options,
+            load_strategies=load_strategies,
+            join_conditions=join_conditions,
+            **kwargs
+        )
 
         query = await session.execute(stmt)
         return query.scalars().first()
 
-    async def select(self, *whereclause: ColumnExpressionArgument[bool], **kwargs) -> Select:
+    async def select(
+        self,
+        *whereclause: ColumnExpressionArgument[bool],
+        options: QueryOptions | None = None,
+        load_strategies: LoadStrategiesConfig | None = None,
+        join_conditions: JoinConditionsConfig | None = None,
+        **kwargs
+    ) -> Select:
         """
         Construct the SQLAlchemy selection.
 
         :param whereclause: WHERE clauses to apply to the query
+        :param options: SQLAlchemy loading options
+        :param load_strategies: Relationship loading strategies
+        :param join_conditions: JOIN conditions for relationships
         :param kwargs: Query expressions
         :return:
         """
-        filters = parse_filters(self.model, **kwargs) + list(whereclause)
+        filters =  list(whereclause)
+        filters.extend(parse_filters(self.model, **kwargs))
         stmt = select(self.model).where(*filters)
+
+        if join_conditions:
+            stmt = apply_join_conditions(self.model, stmt, join_conditions)
+
+        if options:
+            stmt = stmt.options(*options)
+
+        if load_strategies:
+            rel_options = build_load_strategies(self.model, load_strategies)
+            if rel_options:
+                stmt = stmt.options(*rel_options)
+
         return stmt
 
     async def select_order(
         self,
         sort_columns: SortColumns,
         sort_orders: SortOrders = None,
         *whereclause: ColumnExpressionArgument[bool],
+        options: QueryOptions | None = None,
+        load_strategies: LoadStrategiesConfig | None = None,
+        join_conditions: JoinConditionsConfig | None = None,
         **kwargs: Any,
     ) -> Select:
         """
@@ -287,10 +314,19 @@ async def select_order(
         :param sort_columns: Column names to sort by
         :param sort_orders: Sort orders ('asc' or 'desc')
         :param whereclause: WHERE clauses to apply to the query
+        :param options: SQLAlchemy loading options
+        :param load_strategies: Relationship loading strategies
+        :param join_conditions: JOIN conditions for relationships
         :param kwargs: Query expressions
         :return:
         """
-        stmt = await self.select(*whereclause, **kwargs)
+        stmt = await self.select(
+            *whereclause,
+            options=options,
+            load_strategies=load_strategies,
+            join_conditions=join_conditions,
+            **kwargs
+        )
         sorted_stmt = apply_sorting(self.model, stmt, sort_columns, sort_orders)
         return sorted_stmt
 
@@ -306,7 +342,7 @@ async def select_models(
         **kwargs: Any,
     ) -> Sequence[Model]:
         """
-         Query all rows that match the specified filters with optional relationship loading and joins.
+        Query all rows that match the specified filters with optional relationship loading and joins.
 
         :param session: SQLAlchemy async session
         :param whereclause: Additional WHERE clauses
@@ -318,18 +354,13 @@ async def select_models(
         :param kwargs: Filter expressions using field__operator=value syntax
         :return:
         """
-        stmt = await self.select(*whereclause, **kwargs)
-
-        if options:
-            stmt = stmt.options(*options)
-
-        if join_conditions:
-            stmt = apply_join_conditions(self.model, stmt, join_conditions)
-
-        if load_strategies:
-            rel_options = build_load_strategies(self.model, load_strategies)
-            if rel_options:
-                stmt = stmt.options(*rel_options)
+        stmt = await self.select(
+            *whereclause,
+            options=options,
+            load_strategies=load_strategies,
+            join_conditions=join_conditions,
+            **kwargs
+        )
 
         if limit is not None:
             stmt = stmt.limit(limit)
@@ -368,18 +399,15 @@ async def select_models_order(
         :param  kwargs: Filter expressions using field__operator=value syntax
         :return:
         """
-        stmt = await self.select_order(sort_columns, sort_orders, *whereclause, **kwargs)
-
-        if options:
-            stmt = stmt.options(*options)
-
-        if join_conditions:
-            stmt = apply_join_conditions(self.model, stmt, join_conditions)
-
-        if load_strategies:
-            rel_options = build_load_strategies(self.model, load_strategies)
-            if rel_options:
-                stmt = stmt.options(*rel_options)
+        stmt = await self.select_order(
+            sort_columns,
+            sort_orders,
+            *whereclause,
+            options=options,
+            load_strategies=load_strategies,
+            join_conditions=join_conditions,
+            **kwargs
+        )
 
         if limit is not None:
             stmt = stmt.limit(limit)

sqlalchemy_crud_plus/utils.py

@@ -374,6 +374,8 @@ def apply_join_conditions(model: type[Model], stmt: Select, join_conditions: Joi
                 elif join_type == 'inner':
                     stmt = stmt.join(rel_attr)
                 elif join_type == 'right':
+                    # RIGHT OUTER JOIN: SQLAlchemy doesn't directly support RIGHT JOIN
+                    # The standard approach is to reverse the table order and use LEFT JOIN For ORM relationships
                     stmt = stmt.join(rel_attr, isouter=True)
                 elif join_type == 'full':
                     stmt = stmt.join(rel_attr, full=True)

tests/test_options.py

@@ -1,3 +1,5 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 import pytest
 
 from sqlalchemy.ext.asyncio import AsyncSession

tests/test_relationship_select.py tests/test_relationships.pytests/test_relationship_select.py renamed to tests/test_relationships.py

@@ -199,3 +199,90 @@ async def test_many_to_many_role_users(
 
         assert role is not None
         assert len(role.users) > 0
+
+
+class TestCountWithRelationships:
+    """Test count method with relationship queries."""
+
+    @pytest.mark.asyncio
+    async def test_count_with_inner_join(
+        self, db_session: AsyncSession, rel_sample_data: dict, rel_user_crud: CRUDPlus[RelUser]
+    ):
+        """Test count with INNER JOIN."""
+        count = await rel_user_crud.count(
+            db_session,
+            join_conditions=['posts']
+        )
+
+        assert count > 0
+        total_users = await rel_user_crud.count(db_session)
+        assert count >= total_users
+
+    @pytest.mark.asyncio
+    async def test_count_with_left_join(
+        self, db_session: AsyncSession, rel_sample_data: dict, rel_user_crud: CRUDPlus[RelUser]
+    ):
+        """Test count with LEFT JOIN."""
+        count = await rel_user_crud.count(
+            db_session,
+            join_conditions={'posts': 'left'}
+        )
+
+        total_users = await rel_user_crud.count(db_session)
+        assert count >= total_users
+
+    @pytest.mark.asyncio
+    async def test_count_with_filters(
+        self, db_session: AsyncSession, rel_sample_data: dict, rel_user_crud: CRUDPlus[RelUser]
+    ):
+        """Test count with JOIN conditions and filters."""
+        users = rel_sample_data['users']
+
+        count = await rel_user_crud.count(
+            db_session,
+            join_conditions=['posts'],
+            name=users[0].name
+        )
+
+        assert count >= 0
+
+
+class TestExistsWithRelationships:
+    """Test exists method with relationship queries."""
+
+    @pytest.mark.asyncio
+    async def test_exists_with_inner_join(
+        self, db_session: AsyncSession, rel_sample_data: dict, rel_user_crud: CRUDPlus[RelUser]
+    ):
+        """Test exists with INNER JOIN."""
+        exists = await rel_user_crud.exists(
+            db_session,
+            join_conditions=['posts']
+        )
+
+        assert exists is True
+
+    @pytest.mark.asyncio
+    async def test_exists_with_left_join(
+        self, db_session: AsyncSession, rel_sample_data: dict, rel_post_crud: CRUDPlus[RelPost]
+    ):
+        """Test exists with LEFT JOIN."""
+        exists = await rel_post_crud.exists(
+            db_session,
+            join_conditions={'category': 'left'}
+        )
+
+        assert exists is True
+
+    @pytest.mark.asyncio
+    async def test_exists_false_case(
+        self, db_session: AsyncSession, rel_sample_data: dict, rel_user_crud: CRUDPlus[RelUser]
+    ):
+        """Test exists returns False when no records match."""
+        exists = await rel_user_crud.exists(
+            db_session,
+            join_conditions=['posts'],
+            name='nonexistent_user'
+        )
+
+        assert exists is False

tests/test_utils.py

@@ -237,6 +237,16 @@ def test_apply_join_conditions_dict(self):
         sql_str = str(new_stmt)
         assert 'JOIN' in sql_str.upper()
 
+    def test_apply_join_conditions_right_join_limitation(self):
+        """Test that RIGHT JOIN is treated as LEFT JOIN due to SQLAlchemy limitations."""
+        stmt = select(RelPost)
+        # RIGHT JOIN should work but behave like LEFT JOIN
+        new_stmt = apply_join_conditions(RelPost, stmt, {'author': 'right'})
+
+        sql_str = str(new_stmt)
+        assert 'JOIN' in sql_str.upper()
+        # Note: RIGHT JOIN is treated as LEFT JOIN in SQLAlchemy ORM
+
     def test_apply_join_conditions_invalid_relation(self):
         """Test applying JOIN conditions with invalid relationship."""
         stmt = select(RelPost)