t-sql 2.1.1__tar.gz → 2.1.3__tar.gz

{t_sql-2.1.1 → t_sql-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 2.1.1
+Version: 2.1.3
 Summary: Safe SQL. SQL queries for python t-strings (PEP 750)
 Project-URL: Homepage, https://github.com/nhumrich/t-sql
 License-File: LICENSE
@@ -515,17 +515,47 @@ class Users(Table, table_name='user_accounts', schema='public'):
     name: Column
 ```
 
-# Note on Usage
+# Rendering Queries
 
-This library should ideally be used in middleware or library code right before making a query. It can enforce the use of t-strings and prevent raw strings:
+All query types (t-strings, TSQL objects, and QueryBuilder objects) can be rendered using `tsql.render()`:
 
 ```python
-from string.templatelib import Template
 import tsql
+from tsql.query_builder import Table, Column
+
+class Users(Table):
+    id: Column
+    name: Column
+
+# All of these work with tsql.render():
+sql, params = tsql.render(t"SELECT * FROM users WHERE id = {user_id}")
+sql, params = tsql.render(Users.select().where(Users.id == user_id))
+sql, params = tsql.render(tsql.select('users', user_id))
+
+# Or call .render() directly on TSQL/QueryBuilder objects:
+query = Users.select().where(Users.age > 18)
+sql, params = query.render()
+```
+
+# Type Safety & Preventing SQL Injection
+
+This library should ideally be used in middleware or library code to enforce safe query construction. Use the `TSQLQuery` type to prevent raw strings:
 
-def execute_sql_query(query):
-    if not isinstance(query, Template):
-        raise TypeError('Cannot make a query without using t-strings')
+```python
+from tsql import TSQLQuery, render
+
+def execute_sql_query(query: TSQLQuery):
+    """Only accepts safe, parameterized queries"""
+    sql, params = render(query)
+    return sql_engine.execute(sql, params)
 
-    return sql_engine.execute(*tsql.render(query))
+# Type checker allows these:
+execute_sql_query(t"SELECT * FROM users WHERE id = {user_id}")  # ✓
+execute_sql_query(Users.select())  # ✓
+execute_sql_query(tsql.select('users'))  # ✓
+
+# Type checker rejects raw strings:
+execute_sql_query("SELECT * FROM users")  # ✗ Type error!
 ```
+
+The `TSQLQuery` type is a union of `TSQL`, `Template` (t-strings), and `QueryBuilder`, ensuring all queries are safe from SQL injection.

{t_sql-2.1.1 → t_sql-2.1.3}/README.md

@@ -505,17 +505,47 @@ class Users(Table, table_name='user_accounts', schema='public'):
     name: Column
 ```
 
-# Note on Usage
+# Rendering Queries
 
-This library should ideally be used in middleware or library code right before making a query. It can enforce the use of t-strings and prevent raw strings:
+All query types (t-strings, TSQL objects, and QueryBuilder objects) can be rendered using `tsql.render()`:
 
 ```python
-from string.templatelib import Template
 import tsql
+from tsql.query_builder import Table, Column
+
+class Users(Table):
+    id: Column
+    name: Column
+
+# All of these work with tsql.render():
+sql, params = tsql.render(t"SELECT * FROM users WHERE id = {user_id}")
+sql, params = tsql.render(Users.select().where(Users.id == user_id))
+sql, params = tsql.render(tsql.select('users', user_id))
+
+# Or call .render() directly on TSQL/QueryBuilder objects:
+query = Users.select().where(Users.age > 18)
+sql, params = query.render()
+```
+
+# Type Safety & Preventing SQL Injection
+
+This library should ideally be used in middleware or library code to enforce safe query construction. Use the `TSQLQuery` type to prevent raw strings:
 
-def execute_sql_query(query):
-    if not isinstance(query, Template):
-        raise TypeError('Cannot make a query without using t-strings')
+```python
+from tsql import TSQLQuery, render
+
+def execute_sql_query(query: TSQLQuery):
+    """Only accepts safe, parameterized queries"""
+    sql, params = render(query)
+    return sql_engine.execute(sql, params)
 
-    return sql_engine.execute(*tsql.render(query))
+# Type checker allows these:
+execute_sql_query(t"SELECT * FROM users WHERE id = {user_id}")  # ✓
+execute_sql_query(Users.select())  # ✓
+execute_sql_query(tsql.select('users'))  # ✓
+
+# Type checker rejects raw strings:
+execute_sql_query("SELECT * FROM users")  # ✗ Type error!
 ```
+
+The `TSQLQuery` type is a union of `TSQL`, `Template` (t-strings), and `QueryBuilder`, ensuring all queries are safe from SQL injection.

{t_sql-2.1.1 → t_sql-2.1.3}/pyproject.toml

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

{t_sql-2.1.1 → t_sql-2.1.3}/tests/test_query_builder.py

@@ -31,6 +31,29 @@ def test_table_creation():
     assert Users.username.column_name == 'username'
 
 
+def test_column_name_remapping():
+    """Test that Column(column_name=...) allows remapping Python attribute to DB column name"""
+    class MyTable(Table, table_name='my_table'):
+        id: Column
+        system_var: Column = Column(column_name='systemvar')
+
+    # Verify that the Python attribute name is 'system_var'
+    assert isinstance(MyTable.system_var, Column)
+    assert MyTable.system_var.table_name == 'my_table'
+
+    # But the DB column name is 'systemvar'
+    assert MyTable.system_var.column_name == 'systemvar'
+
+    # Verify it works in queries
+    query = MyTable.select(MyTable.system_var).where(MyTable.system_var == 'test')
+    sql, params = query.render()
+
+    # The SQL should use 'systemvar', not 'system_var'
+    assert 'my_table.systemvar' in sql
+    assert 'system_var' not in sql
+    assert params == ['test']
+
+
 def test_column_equality():
     """Test Column equality operator"""
     condition = Users.id == 5
@@ -256,7 +279,7 @@ def test_column_to_column_comparison():
 
 
 def test_to_tsql_returns_tsql_object():
-    """Test that QueryBuilder.to_tsql() returns a TSQL object"""
+    """Test that SelectQueryBuilder.to_tsql() returns a TSQL object"""
     query = Users.select(Users.id).where(Users.id > 5)
     tsql_obj = query.to_tsql()
 
@@ -913,7 +936,7 @@ def test_where_with_not_ilike():
 
 
 def test_in_with_subquery():
-    """Test IN with a subquery (QueryBuilder)"""
+    """Test IN with a subquery (SelectQueryBuilder)"""
     subquery = Users.select(Users.id).where(Users.username.like('%admin%'))
     query = Posts.select().where(Posts.user_id.in_(subquery))
     sql, params = query.render()
@@ -924,7 +947,7 @@ def test_in_with_subquery():
 
 
 def test_not_in_with_subquery():
-    """Test NOT IN with a subquery (QueryBuilder)"""
+    """Test NOT IN with a subquery (SelectQueryBuilder)"""
     subquery = Users.select(Users.id).where(Users.username.like('%banned%'))
     query = Posts.select().where(Posts.user_id.not_in(subquery))
     sql, params = query.render()

{t_sql-2.1.1 → t_sql-2.1.3}/tsql/__init__.py

@@ -1,10 +1,13 @@
 import re
 import string
-from typing import NamedTuple, Tuple, Any, List, Dict, Iterable
+from typing import NamedTuple, Tuple, Any, List, Dict, Iterable, Union, TYPE_CHECKING
 from string.templatelib import Template, Interpolation
 
 from tsql.styles import ParamStyle, QMARK
 
+if TYPE_CHECKING:
+    from tsql.query_builder import QueryBuilder
+
 default_style = QMARK
 
 def set_style(style: type[ParamStyle]):
@@ -213,7 +216,57 @@ def as_set(value_dict: dict[str, Any]):
     return tsql_obj
 
 
-def render(query: Template|TSQL, style=None) -> RenderedQuery:
+# Type alias for safe, parameterized queries
+TSQLQuery = Union[TSQL, Template, 'QueryBuilder']
+"""Type alias representing safe, parameterized SQL queries.
+
+This type includes all valid ways to construct safe queries in tsql:
+- TSQL: Rendered t-string queries
+- Template: Raw t-string templates (PEP 750)
+- QueryBuilder: Type-safe query builder objects
+
+Use this type to ensure functions only accept safe, parameterized queries
+and never raw strings that could be vulnerable to SQL injection.
+
+Examples:
+    Accept any safe query type::
+
+        def execute_query(query: TSQLQuery) -> None:
+            sql, params = render(query)
+            cursor.execute(sql, params)
+
+    Type checking prevents unsafe usage::
+
+        execute_query(t"SELECT * FROM users WHERE id = {user_id}")  # OK
+        execute_query(select("users"))  # OK
+        execute_query(User.select().where(User.id == 1))  # OK
+        execute_query("SELECT * FROM users")  # Type error!
+"""
+
+
+def render(query: TSQLQuery, style=None) -> RenderedQuery:
+    """Render a safe query to SQL and parameters.
+
+    Args:
+        query: A TSQLQuery (TSQL, Template, or QueryBuilder)
+        style: Optional parameter style (defaults to global default_style)
+
+    Returns:
+        RenderedQuery with sql string and parameter values
+
+    Raises:
+        TypeError: If query is a raw string (use t-strings instead)
+    """
+    # Handle QueryBuilder (duck typing to avoid circular import)
+    if hasattr(query, 'build') and callable(query.build):
+        query = query.build()
+
+    if isinstance(query, str):
+        raise TypeError(
+            "Cannot render raw strings - they are vulnerable to SQL injection. "
+            "Use t-strings instead: t'SELECT * FROM users WHERE id = {user_id}'"
+        )
+
     if not isinstance(query, TSQL):
         query = TSQL(query)
 
@@ -305,6 +358,7 @@ def delete(table: str, id: str | int) -> TSQL:
 
 __all__ = [
     'TSQL',
+    'TSQLQuery',
     'render',
     't_join',
     'select',

{t_sql-2.1.1 → t_sql-2.1.3}/tsql/query_builder.py

@@ -1,6 +1,7 @@
 from typing import Any, List, Optional, Union, ClassVar
 from string.templatelib import Template
 from datetime import datetime
+from abc import ABC, abstractmethod
 
 from tsql import TSQL, t_join
 
@@ -18,7 +19,7 @@ except ImportError:
 class Column:
     """Represents a bound column (table + column name) for building queries"""
 
-    def __init__(self, table_name: str, column_name: str, python_type: type = None, alias: str = None, schema: str = None):
+    def __init__(self, table_name: str = None, column_name: str = None, python_type: type = None, alias: str = None, schema: str = None):
         self.table_name = table_name
         self.column_name = column_name
         self.python_type = python_type
@@ -75,21 +76,21 @@ class Column:
     def __ge__(self, other) -> 'Condition':
         return Condition(self, '>=', other)
 
-    def in_(self, values: Union[list, tuple, 'Column', Template, 'QueryBuilder']) -> 'Condition':
+    def in_(self, values: Union[list, tuple, 'Column', Template, 'SelectQueryBuilder']) -> 'Condition':
         """Create an IN condition
 
         Args:
-            values: List/tuple of values, a Column, a Template (t-string), or a QueryBuilder for subqueries
+            values: List/tuple of values, a Column, a Template (t-string), or a SelectQueryBuilder for subqueries
         """
         if isinstance(values, (list, tuple)):
             return Condition(self, 'IN', tuple(values))
         return Condition(self, 'IN', values)
 
-    def not_in(self, values: Union[list, tuple, 'Column', Template, 'QueryBuilder']) -> 'Condition':
+    def not_in(self, values: Union[list, tuple, 'Column', Template, 'SelectQueryBuilder']) -> 'Condition':
         """Create a NOT IN condition
 
         Args:
-            values: List/tuple of values, a Column, a Template (t-string), or a QueryBuilder for subqueries
+            values: List/tuple of values, a Column, a Template (t-string), or a SelectQueryBuilder for subqueries
         """
         if isinstance(values, (list, tuple)):
             return Condition(self, 'NOT IN', tuple(values))
@@ -186,7 +187,7 @@ class Table:
                 'value': getattr(cls, field_name, None)
             }
 
-        # Then, check for Ellipsis (...) assignments and SA Columns
+        # Then, check for Ellipsis (...) assignments, SA Columns, and Column instances
         for field_name in dir(cls):
             if field_name.startswith('_'):
                 continue
@@ -206,6 +207,13 @@ class Table:
                         'type': None,
                         'value': field_value
                     }
+            # Check for Column instances (for column_name remapping)
+            elif isinstance(field_value, Column):
+                if field_name not in all_fields:
+                    all_fields[field_name] = {
+                        'type': None,
+                        'value': field_value
+                    }
 
         # Process all fields
         for field_name, field_info in all_fields.items():
@@ -225,6 +233,23 @@ class Table:
                 setattr(cls, field_name, ColumnDescriptor(field_name, field_type))
                 continue
 
+            # Check if it's a Column instance (for column_name remapping)
+            if isinstance(field_value, Column):
+                # Extract the column_name from the Column instance
+                db_column_name = field_value.column_name
+                if db_column_name is None:
+                    # No column_name specified, use field_name
+                    db_column_name = field_name
+
+                # Create query builder ColumnDescriptor with the DB column name
+                setattr(cls, field_name, ColumnDescriptor(db_column_name, field_type))
+
+                # Create SQLAlchemy column if metadata provided
+                if metadata is not None and HAS_SQLALCHEMY:
+                    sa_type = PYTHON_TO_SA.get(field_type, String)()
+                    sa_columns.append(SAColumn(db_column_name, sa_type))
+                continue
+
             # Check if it's an Ellipsis (...) declaration
             if field_value is ...:
                 # Create query builder ColumnDescriptor
@@ -249,9 +274,9 @@ class Table:
             cls._sa_table = SATable(cls.table_name, metadata, *sa_columns, schema=schema)
 
     @classmethod
-    def select(cls, *columns: Union['Column', Template]) -> 'QueryBuilder':
+    def select(cls, *columns: Union['Column', Template]) -> 'SelectQueryBuilder':
         """Start building a SELECT query"""
-        builder = QueryBuilder(cls)
+        builder = SelectQueryBuilder(cls)
         if columns:
             builder.select(*columns)
         return builder
@@ -390,7 +415,31 @@ class Join:
         return t'{join_type:unsafe} JOIN {table_name:literal} ON {condition_tsql}'
 
 
-class InsertBuilder:
+class QueryBuilder(ABC):
+    """Abstract base class for all query builders.
+
+    All query builders (SELECT, INSERT, UPDATE, DELETE) implement this interface,
+    allowing middleware and query handlers to accept any builder type.
+    """
+
+    @abstractmethod
+    def to_tsql(self) -> TSQL:
+        """Build and return a TSQL object representing the query."""
+        ...
+
+    def render(self, style=None) -> tuple[str, list]:
+        """Convenience method to render the query directly.
+
+        Args:
+            style: Optional parameter style (e.g., QMARK, NUMERIC, etc.)
+
+        Returns:
+            Tuple of (sql_string, parameters)
+        """
+        return self.to_tsql().render(style)
+
+
+class InsertBuilder(QueryBuilder):
     """Fluent interface for building INSERT queries"""
 
     def __init__(self, base_table: 'Table', values: dict[str, Any]):
@@ -572,7 +621,7 @@ class InsertBuilder:
             return f"InsertBuilder(<error rendering: {e}>)"
 
 
-class UpdateBuilder:
+class UpdateBuilder(QueryBuilder):
     """Fluent interface for building UPDATE queries"""
 
     def __init__(self, base_table: 'Table', values: dict[str, Any]):
@@ -663,7 +712,7 @@ class UpdateBuilder:
             return f"UpdateBuilder(<error rendering: {e}>)"
 
 
-class DeleteBuilder:
+class DeleteBuilder(QueryBuilder):
     """Fluent interface for building DELETE queries"""
 
     def __init__(self, base_table: 'Table'):
@@ -731,8 +780,8 @@ class DeleteBuilder:
             return f"DeleteBuilder(<error rendering: {e}>)"
 
 
-class QueryBuilder:
-    """Fluent interface for building SQL queries"""
+class SelectQueryBuilder(QueryBuilder):
+    """Fluent interface for building SQL SELECT queries"""
 
     def __init__(self, base_table: 'Table'):
         self.base_table = base_table
@@ -745,7 +794,7 @@ class QueryBuilder:
         self._limit_value: Optional[int] = None
         self._offset_value: Optional[int] = None
 
-    def select(self, *columns: Union[Column, Template]) -> 'QueryBuilder':
+    def select(self, *columns: Union[Column, Template]) -> 'SelectQueryBuilder':
         """Specify columns to select
 
         Args:
@@ -764,7 +813,7 @@ class QueryBuilder:
         self._columns = list(columns) if columns else None
         return self
 
-    def where(self, condition: Union[Condition, Template]) -> 'QueryBuilder':
+    def where(self, condition: Union[Condition, Template]) -> 'SelectQueryBuilder':
         """Add a WHERE condition (multiple calls are ANDed together)
 
         Accepts either Condition objects from query builder or raw t-string Templates
@@ -772,20 +821,20 @@ class QueryBuilder:
         self._conditions.append(condition)
         return self
 
-    def join(self, table: 'Table', on: Condition, join_type: str = 'INNER') -> 'QueryBuilder':
+    def join(self, table: 'Table', on: Condition, join_type: str = 'INNER') -> 'SelectQueryBuilder':
         """Add a JOIN clause"""
         self._joins.append(Join(table, on, join_type))
         return self
 
-    def left_join(self, table: 'Table', on: Condition) -> 'QueryBuilder':
+    def left_join(self, table: 'Table', on: Condition) -> 'SelectQueryBuilder':
         """Add a LEFT JOIN clause"""
         return self.join(table, on, 'LEFT')
 
-    def right_join(self, table: 'Table', on: Condition) -> 'QueryBuilder':
+    def right_join(self, table: 'Table', on: Condition) -> 'SelectQueryBuilder':
         """Add a RIGHT JOIN clause"""
         return self.join(table, on, 'RIGHT')
 
-    def order_by(self, *columns: Union[Column, tuple[Column, str]]) -> 'QueryBuilder':
+    def order_by(self, *columns: Union[Column, tuple[Column, str]]) -> 'SelectQueryBuilder':
         """Add ORDER BY clause. Pass (column, 'DESC') for descending"""
         for col in columns:
             if isinstance(col, tuple):
@@ -794,12 +843,12 @@ class QueryBuilder:
                 self._order_by_columns.append((col, 'ASC'))
         return self
 
-    def group_by(self, *columns: Column) -> 'QueryBuilder':
+    def group_by(self, *columns: Column) -> 'SelectQueryBuilder':
         """Add GROUP BY clause"""
         self._group_by_columns.extend(columns)
         return self
 
-    def having(self, condition: Union[Condition, Template]) -> 'QueryBuilder':
+    def having(self, condition: Union[Condition, Template]) -> 'SelectQueryBuilder':
         """Add HAVING condition (multiple calls are ANDed together)
 
         Accepts either Condition objects from query builder or raw t-string Templates
@@ -807,12 +856,12 @@ class QueryBuilder:
         self._having_conditions.append(condition)
         return self
 
-    def limit(self, n: int) -> 'QueryBuilder':
+    def limit(self, n: int) -> 'SelectQueryBuilder':
         """Add LIMIT clause"""
         self._limit_value = n
         return self
 
-    def offset(self, n: int) -> 'QueryBuilder':
+    def offset(self, n: int) -> 'SelectQueryBuilder':
         """Add OFFSET clause"""
         self._offset_value = n
         return self
@@ -894,10 +943,10 @@ class QueryBuilder:
         try:
             query, params = self.to_tsql().render()
             if params:
-                return f"QueryBuilder(\n  SQL: {query}\n  Params: {params}\n)"
-            return f"QueryBuilder({query})"
+                return f"SelectQueryBuilder(\n  SQL: {query}\n  Params: {params}\n)"
+            return f"SelectQueryBuilder({query})"
         except Exception as e:
-            return f"QueryBuilder(<error rendering: {e}>)"
+            return f"SelectQueryBuilder(<error rendering: {e}>)"
 
 
 # Python type to SQLAlchemy type mapping (for simple type annotations)

t_sql-2.1.1/.idea/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

t_sql-2.1.1/.idea/inspectionProfiles/Project_Default.xml

@@ -1,24 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
-    <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="ourVersions">
-        <value>
-          <list size="3">
-            <item index="0" class="java.lang.String" itemvalue="3.11" />
-            <item index="1" class="java.lang.String" itemvalue="3.12" />
-            <item index="2" class="java.lang.String" itemvalue="3.13" />
-          </list>
-        </value>
-      </option>
-    </inspection_tool>
-    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="ignoredIdentifiers">
-        <list>
-          <option value="base64.binascii" />
-        </list>
-      </option>
-    </inspection_tool>
-  </profile>
-</component>

t_sql-2.1.1/.idea/inspectionProfiles/profiles_settings.xml

@@ -1,6 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <settings>
-    <option name="USE_PROJECT_PROFILE" value="false" />
-    <version value="1.0" />
-  </settings>
-</component>

t_sql-2.1.1/.idea/misc.xml

@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Black">
-    <option name="sdkName" value="uv (tsql)" />
-  </component>
-  <component name="KubernetesApiPersistence">{}</component>
-  <component name="KubernetesApiProvider"><![CDATA[{
-  "isMigrated": true
-}]]></component>
-  <component name="ProjectRootManager" version="2" project-jdk-name="uv (tsql)" project-jdk-type="Python SDK" />
-</project>

t_sql-2.1.1/.idea/tsql.iml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module version="4">
-  <component name="PyDocumentationSettings">
-    <option name="format" value="PLAIN" />
-    <option name="myDocStringFormat" value="Plain" />
-  </component>
-  <component name="TestRunnerService">
-    <option name="PROJECT_TEST_RUNNER" value="py.test" />
-  </component>
-</module>

t_sql-2.1.1/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

t_sql-2.1.1/.idea/workspace.xml

@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AutoImportSettings">
-    <option name="autoReloadType" value="SELECTIVE" />
-  </component>
-  <component name="ChangeListManager">
-    <list default="true" id="059146b3-62bd-4ad4-890d-4356cf237b89" name="Changes" comment="">
-      <change beforePath="$PROJECT_DIR$/README.md" beforeDir="false" afterPath="$PROJECT_DIR$/README.md" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/tests/test_mysql_integration.py" beforeDir="false" afterPath="$PROJECT_DIR$/tests/test_mysql_integration.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/tests/test_query_builder.py" beforeDir="false" afterPath="$PROJECT_DIR$/tests/test_query_builder.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/tests/test_sqlalchemy_integration.py" beforeDir="false" afterPath="$PROJECT_DIR$/tests/test_sqlalchemy_integration.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/tests/test_sqlite_integration.py" beforeDir="false" afterPath="$PROJECT_DIR$/tests/test_sqlite_integration.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/tsql/__init__.py" beforeDir="false" afterPath="$PROJECT_DIR$/tsql/__init__.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/tsql/query_builder.py" beforeDir="false" afterPath="$PROJECT_DIR$/tsql/query_builder.py" afterDir="false" />
-    </list>
-    <option name="SHOW_DIALOG" value="false" />
-    <option name="HIGHLIGHT_CONFLICTS" value="true" />
-    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
-    <option name="LAST_RESOLUTION" value="IGNORE" />
-  </component>
-  <component name="Git.Settings">
-    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
-  </component>
-  <component name="GitHubPullRequestSearchHistory">{
-  &quot;lastFilter&quot;: {
-    &quot;state&quot;: &quot;OPEN&quot;,
-    &quot;assignee&quot;: &quot;nhumrich&quot;
-  }
-}</component>
-  <component name="GithubPullRequestsUISettings">{
-  &quot;selectedUrlAndAccountId&quot;: {
-    &quot;url&quot;: &quot;git@github.com:nhumrich/tsql.git&quot;,
-    &quot;accountId&quot;: &quot;f308fc0d-c429-47fb-8e52-74bdc95408d8&quot;
-  }
-}</component>
-  <component name="ProjectColorInfo">{
-  &quot;associatedIndex&quot;: 2
-}</component>
-  <component name="ProjectId" id="33DagtaPqCq8RWQhigWGQcgOtLh" />
-  <component name="ProjectViewState">
-    <option name="compactDirectories" value="true" />
-    <option name="hideEmptyMiddlePackages" value="true" />
-    <option name="showLibraryContents" value="true" />
-  </component>
-  <component name="PropertiesComponent">{
-  &quot;keyToString&quot;: {
-    &quot;ModuleVcsDetector.initialDetectionPerformed&quot;: &quot;true&quot;,
-    &quot;Python tests.pytest in test_sqlalchemy_integration.py.executor&quot;: &quot;Debug&quot;,
-    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.TerminalTabsStorage.copyFrom.TerminalArrangementManager.252&quot;: &quot;true&quot;,
-    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
-    &quot;git-widget-placeholder&quot;: &quot;main&quot;,
-    &quot;junie.onboarding.icon.badge.shown&quot;: &quot;true&quot;,
-    &quot;last_opened_file_path&quot;: &quot;/home/nhumrich/personal/tsql&quot;,
-    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
-    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
-    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
-    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
-    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
-    &quot;to.speed.mode.migration.done&quot;: &quot;true&quot;,
-    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
-  }
-}</component>
-  <component name="RunManager">
-    <configuration name="pytest in test_sqlalchemy_integration.py" type="tests" factoryName="py.test" temporary="true" nameIsGenerated="true">
-      <module name="tsql" />
-      <option name="ENV_FILES" value="" />
-      <option name="INTERPRETER_OPTIONS" value="" />
-      <option name="PARENT_ENVS" value="true" />
-      <option name="SDK_HOME" value="" />
-      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
-      <option name="IS_MODULE_SDK" value="true" />
-      <option name="ADD_CONTENT_ROOTS" value="true" />
-      <option name="ADD_SOURCE_ROOTS" value="true" />
-      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
-      <option name="_new_keywords" value="&quot;&quot;" />
-      <option name="_new_parameters" value="&quot;&quot;" />
-      <option name="_new_additionalArguments" value="&quot;&quot;" />
-      <option name="_new_target" value="&quot;$PROJECT_DIR$/tests/test_sqlalchemy_integration.py&quot;" />
-      <option name="_new_targetType" value="&quot;PATH&quot;" />
-      <method v="2" />
-    </configuration>
-    <recent_temporary>
-      <list>
-        <item itemvalue="Python tests.pytest in test_sqlalchemy_integration.py" />
-      </list>
-    </recent_temporary>
-  </component>
-  <component name="SharedIndexes">
-    <attachedChunks>
-      <set>
-        <option value="bundled-js-predefined-d6986cc7102b-3aa1da707db6-JavaScript-PY-252.26830.99" />
-        <option value="bundled-python-sdk-164cda30dcd9-0af03a5fa574-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-252.26830.99" />
-      </set>
-    </attachedChunks>
-  </component>
-  <component name="TaskManager">
-    <task active="true" id="Default" summary="Default task">
-      <changelist id="059146b3-62bd-4ad4-890d-4356cf237b89" name="Changes" comment="" />
-      <created>1758854212149</created>
-      <option name="number" value="Default" />
-      <option name="presentableId" value="Default" />
-      <updated>1758854212149</updated>
-    </task>
-    <servers />
-  </component>
-  <component name="TypeScriptGeneratedFilesManager">
-    <option name="version" value="3" />
-  </component>
-  <component name="Vcs.Log.Tabs.Properties">
-    <option name="TAB_STATES">
-      <map>
-        <entry key="MAIN">
-          <value>
-            <State />
-          </value>
-        </entry>
-      </map>
-    </option>
-  </component>
-  <component name="com.intellij.coverage.CoverageDataManagerImpl">
-    <SUITE FILE_PATH="coverage/tsql$pytest_in_test_sqlalchemy_integration_py.coverage" NAME="pytest in test_sqlalchemy_integration.py Coverage Results" MODIFIED="1760138305802" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-  </component>
-</project>