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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 4.4.1
+Version: 4.5.0
 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.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "4.4.1"
+version = "4.5.0"
 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.5.0}/tests/test_type_processor.py

@@ -258,3 +258,65 @@ 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"}'
+        }
+    ]
+
+    results = query.map_results(rows)
+
+    # Check aliased column was decrypted
+    assert results[0]["social"] == "123-45-6789"
+    assert results[0].social == "123-45-6789"  # Test attribute access
+    # Check joined table column was deserialized
+    assert results[0]["metadata_col"] == {"key": "value"}
+    assert results[0].metadata_col == {"key": "value"}  # Test attribute access
+
+    # 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"}'
+        }
+    ]
+
+    results_star = query_star.map_results(rows_star)
+
+    # Both processors should be applied
+    assert results_star[0]["ssn"] == "987-65-4321"
+    assert results_star[0].ssn == "987-65-4321"  # Test attribute access
+    assert results_star[0]["metadata_col"] == {"foo": "bar"}
+    assert results_star[0].metadata_col == {"foo": "bar"}  # Test attribute access

{t_sql-4.4.1 → t_sql-4.5.0}/tsql/__init__.py

@@ -362,6 +362,7 @@ def delete(table: str, id: str | int) -> TSQL:
 
 from tsql.query_builder import UnsafeQueryError
 from tsql.type_processor import TypeProcessor
+from tsql.row import Row
 
 __all__ = [
     'TSQL',
@@ -375,5 +376,6 @@ __all__ = [
     'set_style',
     'UnsafeQueryError',
     'TypeProcessor',
+    'Row',
 ]
 

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

@@ -4,6 +4,7 @@ from datetime import datetime
 from abc import ABC, abstractmethod
 
 from tsql import TSQL, t_join
+from tsql.row import Row
 
 
 class UnsafeQueryError(Exception):
@@ -559,41 +560,58 @@ class QueryBuilder(ABC):
         """
         return self.to_tsql().render(style)
 
-    def map_results(self, rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def map_results(self, rows: List[Dict[str, Any]]) -> List[Row]:
         """Transform database rows with type processors applied.
 
         This method applies process_result_value from type processors to convert
         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.
+        Returns Row objects (dict subclass with attribute access) for consistent
+        API regardless of input type (dict, asyncpg Record, etc.).
 
         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
+            List of Row objects with transformed values
 
         Example:
             query = User.select().where(User.id == 1)
             rows = await conn.fetch(*query.render())
-            transformed_rows = query.map_results(rows)  # ssn decrypted, metadata deserialized
+            results = query.map_results(rows)
+            print(results[0].name)  # Attribute access
+            print(results[0]['name'])  # Dict access
         """
         if not hasattr(self, 'base_table'):
             raise AttributeError("map_results requires a base_table attribute")
 
+        # Build a map of result_column_name -> processor
+        processors = {}
+
+        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)
+
+            for table in tables:
+                processors.update(table._type_processors)
+
+        # Convert to Row objects and apply processors
         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
-
-            # Apply type processors in place
+            row_dict = Row(row)  # Converts dict/Record to Row
             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 col_name in processors:
+                    row_dict[col_name] = processors[col_name].process_result_value(row_dict[col_name])
             results.append(row_dict)
 
         return results

t_sql-4.5.0/tsql/row.py

@@ -0,0 +1,39 @@
+"""Row object - dict with attribute access support."""
+
+
+class Row(dict):
+    """A dict subclass that supports attribute-style access.
+
+    Provides a nicer API for accessing row data while maintaining
+    full dict compatibility.
+
+    Example:
+        row = Row({'id': 1, 'name': 'Alice'})
+        print(row.id)        # 1 (attribute access)
+        print(row['name'])   # Alice (dict access)
+        row.age = 30         # Set via attribute
+        print(row['age'])    # 30
+    """
+
+    def __getattr__(self, key: str):
+        """Allow attribute-style access to dict keys."""
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(f"Row has no attribute {key!r}") from None
+
+    def __setattr__(self, key: str, value):
+        """Allow attribute-style setting of dict keys."""
+        self[key] = value
+
+    def __delattr__(self, key: str):
+        """Allow attribute-style deletion of dict keys."""
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"Row has no attribute {key!r}") from None
+
+    def __repr__(self) -> str:
+        """Nice repr for debugging."""
+        items = ', '.join(f'{k}={v!r}' for k, v in self.items())
+        return f"Row({items})"