feat: Enhance query handling with IN operator support and related tests

- Updated `CrudRepositoryImplementationService` to support IN operations in query filtering, including validation for parameter types and handling of empty lists.
- Modified `_Query` class to include `field_operations` for mapping field names to their respective operations.
- Enhanced `_MetodQueryBuilder` to parse method names with IN operations and generate appropriate query structures.
- Added comprehensive unit tests for IN operator functionality, including cases for single fields, multiple fields with AND/OR conditions, and error handling for invalid types and empty lists.
- Updated existing tests to reflect changes in query structure and ensure correct SQL statement generation.

Author: William-W-Chen

py_spring_model/py_spring_model_rest/service/curd_repository_implementation_service/crud_repository_implementation_service.py

@@ -133,10 +133,34 @@ def _get_sql_statement(
         parsed_query: _Query,
         params: dict[str, Any],
     ) -> SelectOfScalar[PySpringModelT]:
-        filter_condition_stack: list[ColumnElement[bool]] = [
-            getattr(model_type, field) == params[field]
-            for field in parsed_query.required_fields
-        ]
+        filter_condition_stack: list[ColumnElement[bool]] = []
+        
+        for field in parsed_query.required_fields:
+            column = getattr(model_type, field)
+            param_value = params[field]
+            
+            # Check if this field has a specific operation
+            if field in parsed_query.field_operations:
+                operation = parsed_query.field_operations[field]
+                if operation == "in":
+                    # Handle IN operation
+                    if not isinstance(param_value, (list, tuple, set)):
+                        raise ValueError(f"Parameter for IN operation must be a collection (list, tuple, or set), got {type(param_value)}")
+                    
+                    # Handle empty list case - return no results
+                    if len(param_value) == 0:
+                        # Create a condition that's always false
+                        filter_condition_stack.append(column == None)
+                        continue
+                    
+                    filter_condition_stack.append(column.in_(param_value))
+                else:
+                    # Default to equality for unknown operations
+                    filter_condition_stack.append(column == param_value)
+            else:
+                # Default equality operation
+                filter_condition_stack.append(column == param_value)
+        
         for notation in parsed_query.notations:
             right_condition = filter_condition_stack.pop(0)
             left_condition = filter_condition_stack.pop(0)

py_spring_model/py_spring_model_rest/service/curd_repository_implementation_service/method_query_builder.py

@@ -1,4 +1,5 @@
 import re
+from typing import Dict, Any
 
 from pydantic import BaseModel
 
@@ -9,12 +10,14 @@ class _Query(BaseModel):
     - `conditions`: A list of string conditions that will be used to filter the query.
     - `is_one_result`: A boolean indicating whether the query should return a single result or a list of results.
     - `required_fields`: A list of string field names that should be included in the query result.
+    - `field_operations`: A dictionary mapping field names to their operations (e.g., "in" for IN operator).
     """
 
     raw_query_list: list[str]
     is_one_result: bool
     notations: list[str]
     required_fields: list[str]
+    field_operations: Dict[str, str] = {}
 
 
 class _MetodQueryBuilder:
@@ -36,6 +39,7 @@ def parse_query(self) -> _Query:
         Example:
             - 'find_by_name_and_age' -> Query(raw_query_list=['name', '_and_', 'age'], is_one_result=True, required_fields=['name', 'age'])
             - 'find_all_by_name_or_age' -> Query(raw_query_list=['name', '_or_', 'age'], is_one_result=False, required_fields=['name', 'age'])
+            - 'find_by_status_in' -> Query(raw_query_list=['status'], is_one_result=True, required_fields=['status'], field_operations={'status': 'in'})
         """
         is_one = False
         pattern = ""   
@@ -53,7 +57,6 @@ def parse_query(self) -> _Query:
         if len(pattern) == 0:
             raise ValueError(f"Method name must start with 'get_by', 'find_by', 'find_all_by', or 'get_all_by': {self.method_name}")
 
-
         match = re.match(pattern, self.method_name)
         if not match:
             raise ValueError(f"Invalid method name: {self.method_name}")
@@ -62,13 +65,26 @@ def parse_query(self) -> _Query:
         # Split fields by '_and_' or '_or_' and keep logical operators
         raw_query_list = re.split(r"(_and_|_or_)", raw_query)
 
+        # Extract required fields and detect operations
+        required_fields = []
+        field_operations = {}
+        
+        for field in raw_query_list:
+            if field not in ["_and_", "_or_"]:
+                # Check for IN operation
+                if field.endswith("_in"):
+                    base_field = field[:-3]  # Remove "_in" suffix
+                    required_fields.append(base_field)
+                    field_operations[base_field] = "in"
+                else:
+                    required_fields.append(field)
+
         return _Query(
             raw_query_list=raw_query_list,
             is_one_result=is_one,
-            required_fields=[
-                field for field in raw_query_list if field not in ["_and_", "_or_"]
-            ],
+            required_fields=required_fields,
             notations=[
                 notation for notation in raw_query_list if notation in ["_and_", "_or_"]
             ],
+            field_operations=field_operations,
         )

tests/test_crud_repository_implementation_service.py

@@ -15,12 +15,17 @@ class User(PySpringModel, table=True):
     id: int = Field(default=None, primary_key=True)
     name: str
     email: str
+    status: str = Field(default="active")
+    category: str = Field(default="general")
 
 class UserView(BaseModel):
     name: str
 
 class UserRepository(CrudRepository[int,User]):
     def find_by_name(self, name: str) -> User: ...
+    def find_all_by_status_in(self, status: list[str]) -> list[User]: ...
+    def find_all_by_id_in_and_name(self, id: list[int], name: str) -> list[User]: ...
+    def find_all_by_status_in_or_category_in(self, status: list[str], category: list[str]) -> list[User]: ...
     @Query("SELECT * FROM user WHERE name = {name}")
     def query_uery_by_name(self, name: str) -> User: ...
 
@@ -53,17 +58,17 @@ def implementation_service(self) -> CrudRepositoryImplementationService:
     def test_query_single_annotation(self, implementation_service: CrudRepositoryImplementationService):
         parsed_query = _MetodQueryBuilder("find_by_name").parse_query()
         statement = implementation_service._get_sql_statement(User, parsed_query, {"name": "John Doe"})
-        assert str(statement).replace("\n", "") == 'SELECT "user".id, "user".name, "user".email FROM "user" WHERE "user".name = :name_1'
+        assert str(statement).replace("\n", "") == 'SELECT "user".id, "user".name, "user".email, "user".status, "user".category FROM "user" WHERE "user".name = :name_1'
 
     def test_query_and_annotation(self, implementation_service: CrudRepositoryImplementationService):
         parsed_query = _MetodQueryBuilder("find_by_name_and_email").parse_query()
         statement = implementation_service._get_sql_statement(User, parsed_query, {"name": "John Doe", "email": "john@example.com"})
-        assert str(statement).replace("\n", "") == 'SELECT "user".id, "user".name, "user".email FROM "user" WHERE "user".email = :email_1 AND "user".name = :name_1'
+        assert str(statement).replace("\n", "") == 'SELECT "user".id, "user".name, "user".email, "user".status, "user".category FROM "user" WHERE "user".email = :email_1 AND "user".name = :name_1'
 
     def test_query_or_annotation(self, implementation_service: CrudRepositoryImplementationService):
         parsed_query = _MetodQueryBuilder("find_by_name_or_email").parse_query()
         statement = implementation_service._get_sql_statement(User, parsed_query, {"name": "John Doe", "email": "john@example.com"})
-        assert str(statement).replace("\n", "") == 'SELECT "user".id, "user".name, "user".email FROM "user" WHERE "user".email = :email_1 OR "user".name = :name_1'
+        assert str(statement).replace("\n", "") == 'SELECT "user".id, "user".name, "user".email, "user".status, "user".category FROM "user" WHERE "user".email = :email_1 OR "user".name = :name_1'
 
     def test_did_implement_query(self, user_repository: UserRepository, implementation_service: CrudRepositoryImplementationService):
         user = User(name="John Doe", email="john@example.com")
@@ -103,9 +108,68 @@ def test_query_user_view_by_name_invalid_argument_type(self, user_repository: Us
         with pytest.raises(ValueError, match=".*"):
             user_repository.query_user_view_by_name(name=None)  # `name` should not be None # type: ignore
 
+    def test_in_operator_single_field(self, implementation_service: CrudRepositoryImplementationService):
+        parsed_query = _MetodQueryBuilder("find_by_status_in").parse_query()
+        statement = implementation_service._get_sql_statement(User, parsed_query, {"status": ["active", "pending"]})
+        assert "IN" in str(statement).upper()
+        assert "status" in str(statement).lower()
+
+    def test_in_operator_with_and(self, implementation_service: CrudRepositoryImplementationService):
+        parsed_query = _MetodQueryBuilder("find_by_id_in_and_name").parse_query()
+        statement = implementation_service._get_sql_statement(User, parsed_query, {"id": [1, 2, 3], "name": "John"})
+        assert "IN" in str(statement).upper()
+        assert "AND" in str(statement).upper()
+
+    def test_in_operator_with_or(self, implementation_service: CrudRepositoryImplementationService):
+        parsed_query = _MetodQueryBuilder("find_by_status_in_or_category_in").parse_query()
+        statement = implementation_service._get_sql_statement(User, parsed_query, {"status": ["active"], "category": ["premium"]})
+        assert "IN" in str(statement).upper()
+        assert "OR" in str(statement).upper()
+
+    def test_in_operator_empty_list(self, implementation_service: CrudRepositoryImplementationService):
+        parsed_query = _MetodQueryBuilder("find_by_status_in").parse_query()
+        statement = implementation_service._get_sql_statement(User, parsed_query, {"status": []})
+        # Empty list should result in a condition that's always false
+        assert "IS NULL" in str(statement) or "= NULL" in str(statement)
+
+    def test_in_operator_invalid_type(self, implementation_service: CrudRepositoryImplementationService):
+        parsed_query = _MetodQueryBuilder("find_by_status_in").parse_query()
+        with pytest.raises(ValueError, match="Parameter for IN operation must be a collection"):
+            implementation_service._get_sql_statement(User, parsed_query, {"status": "not_a_list"})
+
+    def test_in_operator_implementation(self, user_repository: UserRepository, implementation_service: CrudRepositoryImplementationService):
+        # Create test users
+        user1 = User(name="John", email="john@example.com", status="active", category="premium")
+        user2 = User(name="Jane", email="jane@example.com", status="pending", category="premium")
+        user3 = User(name="Bob", email="bob@example.com", status="active", category="basic")
 
+        user_repository.save(user1)
+        user_repository.save(user2)
+        user_repository.save(user3)
 
-    
-
-
+        # Implement the query
+        implementation_service._implemenmt_query(user_repository.__class__)
+        
+        # Test IN operator
+        active_users = user_repository.find_all_by_status_in(status=["active"])
+        assert len(active_users) == 2
+        assert all(user.status == "active" for user in active_users)
+        
+        # Test IN with AND
+        premium_active_users = user_repository.find_all_by_id_in_and_name(id=[user1.id, user2.id], name="John")
+        assert len(premium_active_users) == 1
+        assert premium_active_users[0].name == "John"
+        
+        # Test IN with OR
+        active_or_premium = user_repository.find_all_by_status_in_or_category_in(status=["active"], category=["premium"])
+        assert len(active_or_premium) == 3  # All users are either active or premium
 
+    def test_in_operator_empty_list_returns_no_results(self, user_repository: UserRepository, implementation_service: CrudRepositoryImplementationService):
+        user = User(name="John", email="john@example.com", status="active")
+        user_repository.save(user)
+        
+        implementation_service._implemenmt_query(user_repository.__class__)
+        
+        # Empty list should return no results
+        results = user_repository.find_all_by_status_in(status=[])
+        assert len(results) == 0

tests/test_method_query_builder.py

@@ -5,35 +5,71 @@
 
 class TestMetodQueryBuilder:
     @pytest.mark.parametrize(
-        "method_name, expected_raw_query_list, expected_is_one_result, expected_required_fields, expected_notations",
+        "method_name, expected_raw_query_list, expected_is_one_result, expected_required_fields, expected_notations, expected_field_operations",
         [
             (
                 "get_by_name_and_age",
                 ["name", "_and_", "age"],
                 True,
                 ["name", "age"],
                 ["_and_"],
+                {},
             ),
             (
                 "find_by_name_or_age",
                 ["name", "_or_", "age"],
                 True,
                 ["name", "age"],
                 ["_or_"],
+                {},
             ),
             (
                 "find_all_by_name_and_age",
                 ["name", "_and_", "age"],
                 False,
                 ["name", "age"],
                 ["_and_"],
+                {},
             ),
             (
                 "get_all_by_city_or_country",
                 ["city", "_or_", "country"],
                 False,
                 ["city", "country"],
                 ["_or_"],
+                {},
+            ),
+            (
+                "find_by_status_in",
+                ["status_in"],
+                True,
+                ["status"],
+                [],
+                {"status": "in"},
+            ),
+            (
+                "find_all_by_id_in",
+                ["id_in"],
+                False,
+                ["id"],
+                [],
+                {"id": "in"},
+            ),
+            (
+                "find_by_status_in_and_name",
+                ["status_in", "_and_", "name"],
+                True,
+                ["status", "name"],
+                ["_and_"],
+                {"status": "in"},
+            ),
+            (
+                "find_by_status_in_or_category_in",
+                ["status_in", "_or_", "category_in"],
+                True,
+                ["status", "category"],
+                ["_or_"],
+                {"status": "in", "category": "in"},
             ),
         ],
     )
@@ -44,6 +80,7 @@ def test_parse_query(
         expected_is_one_result,
         expected_required_fields,
         expected_notations,
+        expected_field_operations,
     ):
         builder = _MetodQueryBuilder(method_name)
         query = builder.parse_query()
@@ -53,6 +90,7 @@ def test_parse_query(
         assert query.is_one_result == expected_is_one_result
         assert query.required_fields == expected_required_fields
         assert query.notations == expected_notations
+        assert query.field_operations == expected_field_operations
 
     def test_invalid_method_name(self):
         invalid_method_name = "invalid_method_name"