t-sql 4.4.1__tar.gz → 4.4.2__tar.gz

{t_sql-4.4.1 → t_sql-4.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 4.4.1
+Version: 4.4.2
 Summary: Safe SQL. SQL queries for python t-strings (PEP 750)
 Project-URL: Homepage, https://github.com/nhumrich/t-sql
 License-File: LICENSE

{t_sql-4.4.1 → t_sql-4.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "4.4.1"
+version = "4.4.2"
 description = "Safe SQL. SQL queries for python t-strings (PEP 750)"
 readme = "README.md"
 requires-python = ">=3.14"

{t_sql-4.4.1 → t_sql-4.4.2}/tests/test_type_processor.py

@@ -258,3 +258,61 @@ def test_type_processor_not_applied_to_column_comparisons():
     # No parameters should be generated (column-to-column comparison)
     assert len(params) == 0
     assert "user.ssn = user.backup_ssn" in sql
+
+
+@pytest.mark.skipif(not HAS_SQLALCHEMY, reason="SQLAlchemy not installed")
+def test_map_results_with_joins_and_aliases():
+    """Test that map_results handles JOINs and column aliases correctly"""
+    metadata = MetaData()
+
+    class User(Table, metadata=metadata):
+        id = SAColumn(Integer, primary_key=True)
+        name = SAColumn(String(100))
+        ssn = SAColumn(String(255), type_processor=EncryptedString(key="secret123"))
+
+    class Profile(Table, metadata=metadata):
+        id = SAColumn(Integer, primary_key=True)
+        user_id = SAColumn(Integer)
+        metadata_col = SAColumn(String(255), type_processor=JSONType())
+
+    # Test with explicit columns including alias
+    query = (
+        User.select(User.id, User.name, User.ssn.as_('social'), Profile.metadata_col)
+        .join(Profile, on=User.id == Profile.user_id)
+    )
+
+    # Simulate database rows (using the format that EncryptedString produces)
+    rows = [
+        {
+            "id": 1,
+            "name": "Alice",
+            "social": "encrypted_123-45-6789_secret123",  # Aliased column
+            "metadata_col": '{"key": "value"}'
+        }
+    ]
+
+    query.map_results(rows)
+
+    # Check aliased column was decrypted
+    assert rows[0]["social"] == "123-45-6789"
+    # Check joined table column was deserialized
+    assert rows[0]["metadata_col"] == {"key": "value"}
+
+    # Test with SELECT * (should process all columns from all tables)
+    query_star = User.select().join(Profile, on=User.id == Profile.user_id)
+
+    rows_star = [
+        {
+            "id": 1,
+            "name": "Alice",
+            "ssn": "encrypted_987-65-4321_secret123",
+            "user_id": 1,
+            "metadata_col": '{"foo": "bar"}'
+        }
+    ]
+
+    query_star.map_results(rows_star)
+
+    # Both processors should be applied
+    assert rows_star[0]["ssn"] == "987-65-4321"
+    assert rows_star[0]["metadata_col"] == {"foo": "bar"}

{t_sql-4.4.1 → t_sql-4.4.2}/tsql/query_builder.py

@@ -566,37 +566,49 @@ class QueryBuilder(ABC):
         database values back to Python values (e.g., decrypt encrypted fields,
         deserialize JSON, etc.).
 
-        Preserves the original row object type when possible by updating values
-        in place rather than creating new dictionaries.
+        Modifies row objects in place to preserve driver-specific row types
+        (e.g., asyncpg Record objects).
 
         Args:
-            rows: List of dictionaries from database query results
+            rows: List of row objects from database query results
 
         Returns:
-            List of dictionaries with transformed values
+            The same list of rows with transformed values (mutated in place)
 
         Example:
             query = User.select().where(User.id == 1)
             rows = await conn.fetch(*query.render())
-            transformed_rows = query.map_results(rows)  # ssn decrypted, metadata deserialized
+            query.map_results(rows)  # ssn decrypted, metadata deserialized (in place)
         """
         if not hasattr(self, 'base_table'):
             raise AttributeError("map_results requires a base_table attribute")
 
-        results = []
-        for row in rows:
-            # Convert row to dict if it's not already (some drivers return Record objects)
-            row_dict = dict(row) if not isinstance(row, dict) else row
+        # Build a map of result_column_name -> processor
+        processors = {}
 
-            # Apply type processors in place
-            for col_name in list(row_dict.keys()):
-                if col_name in self.base_table._type_processors:
-                    processor = self.base_table._type_processors[col_name]
-                    row_dict[col_name] = processor.process_result_value(row_dict[col_name])
+        if hasattr(self, '_columns') and self._columns is not None:
+            # Explicit columns - we know exactly which ones and from which table
+            for col in self._columns:
+                if isinstance(col, Column) and col.type_processor:
+                    # The result key is the alias if present, otherwise column_name
+                    result_key = col.alias if col.alias else col.column_name
+                    processors[result_key] = col.type_processor
+        else:
+            # SELECT * - check all tables involved (base table + joins)
+            tables = [self.base_table]
+            if hasattr(self, '_joins'):
+                tables.extend(join.table for join in self._joins)
 
-            results.append(row_dict)
+            for table in tables:
+                processors.update(table._type_processors)
+
+        # Apply processors to rows in place
+        for row in rows:
+            for col_name in list(row.keys()):
+                if col_name in processors:
+                    row[col_name] = processors[col_name].process_result_value(row[col_name])
 
-        return results
+        return rows
 
 
 class InsertBuilder(QueryBuilder):