t-sql 3.2.0__tar.gz → 4.1.0__tar.gz

{t_sql-3.2.0 → t_sql-4.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 3.2.0
+Version: 4.1.0
 Summary: Safe SQL. SQL queries for python t-strings (PEP 750)
 Project-URL: Homepage, https://github.com/nhumrich/t-sql
 License-File: LICENSE
@@ -257,12 +257,47 @@ query = (Posts.select()
 
 ## Query Features
 
+### Selecting All Columns from a Table
+
+Use `Table.ALL` to select all columns from a specific table:
+
 ```python
+# Select all columns from posts
+query = Posts.select(Posts.ALL)
+# ('SELECT posts.* FROM posts', [])
+
+# Select all columns from posts + specific columns from joined tables
+query = (Posts.select(Posts.ALL, Users.username, Users.email)
+         .join(Users, Posts.user_id == Users.id))
+# ('SELECT posts.*, users.username, users.email FROM posts INNER JOIN users ON ...', [])
+
+# Select all columns from multiple tables
+query = Posts.select(Posts.ALL, Users.ALL).join(Users, Posts.user_id == Users.id)
+# ('SELECT posts.*, users.* FROM posts INNER JOIN users ON ...', [])
+```
+
+This is particularly useful when joining tables where you want all columns from one table but only specific columns from others.
+
+### NULL Checks and Other Operators
+
+```python
+# NULL checks
+query = Users.select().where(Users.email.is_null())
+query = Users.select().where(Users.email.is_not_null())
+
 # IN clause
 query = Users.select().where(Users.id.in_([1, 2, 3]))
+query = Users.select().where(Users.id.not_in([1, 2, 3]))
 
 # LIKE clause
 query = Users.select().where(Users.username.like('%john%'))
+query = Users.select().where(Users.username.not_like('%john%'))
+query = Users.select().where(Users.username.ilike('%JOHN%'))  # case-insensitive
+query = Users.select().where(Users.username.not_ilike('%JOHN%'))
+
+# BETWEEN clause
+query = Users.select().where(Users.age.between(18, 65))
+query = Users.select().where(Users.age.not_between(18, 65))
 
 # ORDER BY
 query = Posts.select().order_by(Posts.id)  # defaults to ASC
@@ -460,7 +495,7 @@ uv add t-sql --optional sqlalchemy
 **1. Simple Column annotations** (for query builder only):
 
 ```python
-from tsql import Table, Column
+from tsql.query_builder import Table, Column
 
 class Users(Table):
     id: Column
@@ -468,38 +503,29 @@ class Users(Table):
     age: Column
 ```
 
-**2. SQLAlchemy Column objects** (for alembic integration):
+**2. SQLAlchemy with SAColumn wrapper** (recommended for type checkers):
 
 ```python
-from sqlalchemy import MetaData, Column, String, Integer, ForeignKey
-from tsql.query_builder import Table
+from sqlalchemy import MetaData, Integer, String
+from tsql.query_builder import Table, SAColumn
 
 metadata = MetaData()
 
 class Users(Table, metadata=metadata):
-    id = Column(String, primary_key=True)
-    email = Column(String(255), unique=True, nullable=False)
-    name = Column(String(100))
-    age = Column(Integer)
+    id = SAColumn(Integer, primary_key=True)
+    email = SAColumn(String(255), unique=True, nullable=False)
+    name = SAColumn(String(100))
+    age = SAColumn(Integer)
 
 # Use for alembic
 target_metadata = metadata
 
-# Use for queries (works identically!)
+# Use for queries
 query = Users.select().where(Users.age > 18)
 ```
 
-You can mix both approaches:
+The `SAColumn` wrapper tells type checkers it returns a tsql `Column`, while at runtime it creates a SQLAlchemy `Column`. This gives you proper IDE completions for methods like `.is_null()`, `.like()`, etc.
 
-```python
-from sqlalchemy import Column, String, DateTime
-from sqlalchemy.sql.functions import now
-
-class Events(Table, metadata=metadata):
-    id = Column(String, primary_key=True)
-    topic: Column  # Simple annotation - becomes nullable String column
-    created_at = Column(DateTime, server_default=now())
-```
 
 ## Schema Support
 

{t_sql-3.2.0 → t_sql-4.1.0}/README.md

@@ -247,12 +247,47 @@ query = (Posts.select()
 
 ## Query Features
 
+### Selecting All Columns from a Table
+
+Use `Table.ALL` to select all columns from a specific table:
+
 ```python
+# Select all columns from posts
+query = Posts.select(Posts.ALL)
+# ('SELECT posts.* FROM posts', [])
+
+# Select all columns from posts + specific columns from joined tables
+query = (Posts.select(Posts.ALL, Users.username, Users.email)
+         .join(Users, Posts.user_id == Users.id))
+# ('SELECT posts.*, users.username, users.email FROM posts INNER JOIN users ON ...', [])
+
+# Select all columns from multiple tables
+query = Posts.select(Posts.ALL, Users.ALL).join(Users, Posts.user_id == Users.id)
+# ('SELECT posts.*, users.* FROM posts INNER JOIN users ON ...', [])
+```
+
+This is particularly useful when joining tables where you want all columns from one table but only specific columns from others.
+
+### NULL Checks and Other Operators
+
+```python
+# NULL checks
+query = Users.select().where(Users.email.is_null())
+query = Users.select().where(Users.email.is_not_null())
+
 # IN clause
 query = Users.select().where(Users.id.in_([1, 2, 3]))
+query = Users.select().where(Users.id.not_in([1, 2, 3]))
 
 # LIKE clause
 query = Users.select().where(Users.username.like('%john%'))
+query = Users.select().where(Users.username.not_like('%john%'))
+query = Users.select().where(Users.username.ilike('%JOHN%'))  # case-insensitive
+query = Users.select().where(Users.username.not_ilike('%JOHN%'))
+
+# BETWEEN clause
+query = Users.select().where(Users.age.between(18, 65))
+query = Users.select().where(Users.age.not_between(18, 65))
 
 # ORDER BY
 query = Posts.select().order_by(Posts.id)  # defaults to ASC
@@ -450,7 +485,7 @@ uv add t-sql --optional sqlalchemy
 **1. Simple Column annotations** (for query builder only):
 
 ```python
-from tsql import Table, Column
+from tsql.query_builder import Table, Column
 
 class Users(Table):
     id: Column
@@ -458,38 +493,29 @@ class Users(Table):
     age: Column
 ```
 
-**2. SQLAlchemy Column objects** (for alembic integration):
+**2. SQLAlchemy with SAColumn wrapper** (recommended for type checkers):
 
 ```python
-from sqlalchemy import MetaData, Column, String, Integer, ForeignKey
-from tsql.query_builder import Table
+from sqlalchemy import MetaData, Integer, String
+from tsql.query_builder import Table, SAColumn
 
 metadata = MetaData()
 
 class Users(Table, metadata=metadata):
-    id = Column(String, primary_key=True)
-    email = Column(String(255), unique=True, nullable=False)
-    name = Column(String(100))
-    age = Column(Integer)
+    id = SAColumn(Integer, primary_key=True)
+    email = SAColumn(String(255), unique=True, nullable=False)
+    name = SAColumn(String(100))
+    age = SAColumn(Integer)
 
 # Use for alembic
 target_metadata = metadata
 
-# Use for queries (works identically!)
+# Use for queries
 query = Users.select().where(Users.age > 18)
 ```
 
-You can mix both approaches:
+The `SAColumn` wrapper tells type checkers it returns a tsql `Column`, while at runtime it creates a SQLAlchemy `Column`. This gives you proper IDE completions for methods like `.is_null()`, `.like()`, etc.
 
-```python
-from sqlalchemy import Column, String, DateTime
-from sqlalchemy.sql.functions import now
-
-class Events(Table, metadata=metadata):
-    id = Column(String, primary_key=True)
-    topic: Column  # Simple annotation - becomes nullable String column
-    created_at = Column(DateTime, server_default=now())
-```
 
 ## Schema Support
 

{t_sql-3.2.0 → t_sql-4.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "3.2.0"
+version = "4.1.0"
 description = "Safe SQL. SQL queries for python t-strings (PEP 750)"
 readme = "README.md"
 requires-python = ">=3.14"
@@ -23,9 +23,12 @@ dev = [
     "anyio>=4.9.0",
     "asyncpg>=0.30.0",
     "cryptography>=46.0.2",
+    "mypy>=1.18.2",
+    "pyright>=1.1.406",
     "pytest>=8.3.5",
     "pytest-asyncio>=0.24.0",
     "sqlalchemy>=2.0.0",
+    "ty>=0.0.1a23",
 ]
 
 [tool.hatch.build.targets.wheel]

{t_sql-3.2.0 → t_sql-4.1.0}/tests/test_query_builder.py

@@ -838,23 +838,81 @@ def test_tstring_with_params_in_select():
     assert params == [' - ', 5]
 
 
-def test_column_is_null_property():
-    """Test is_null property"""
-    condition = Users.email.is_null
+def test_select_table_all():
+    """Test selecting all columns from a table using Table.ALL"""
+    query = Posts.select(Posts.ALL)
+    sql, params = query.render()
+
+    assert 'SELECT posts.*' in sql
+    assert 'FROM posts' in sql
+    assert params == []
+
+
+def test_select_table_all_with_other_columns():
+    """Test mixing Table.ALL with specific columns from another table"""
+    query = Posts.select(Posts.ALL, Users.username, Users.email)
+    sql, params = query.render()
+
+    assert 'SELECT posts.*, users.username, users.email' in sql
+    assert 'FROM posts' in sql
+    assert params == []
+
+
+def test_select_multiple_table_alls():
+    """Test selecting all columns from multiple tables"""
+    query = Posts.select(Posts.ALL, Users.ALL)
+    sql, params = query.render()
+
+    assert 'SELECT posts.*, users.*' in sql
+    assert 'FROM posts' in sql
+    assert params == []
+
+
+def test_select_table_all_with_join():
+    """Test Table.ALL in a real-world join scenario"""
+    query = (Posts.select(Posts.ALL, Users.username)
+             .join(Users, Posts.user_id == Users.id)
+             .where(Posts.id > 100))
+    sql, params = query.render()
+
+    assert 'SELECT posts.*, users.username' in sql
+    assert 'FROM posts' in sql
+    assert 'INNER JOIN users ON posts.user_id = users.id' in sql
+    assert 'WHERE posts.id > ?' in sql
+    assert params == [100]
+
+
+def test_select_table_all_with_schema():
+    """Test that Table.ALL works with schema-qualified tables"""
+    class Accounts(Table, table_name='accounts', schema='other'):
+        id: Column
+        name: Column
+
+    query = Accounts.select(Accounts.ALL)
+    sql, params = query.render()
+
+    assert 'SELECT other.accounts.*' in sql
+    assert 'FROM other.accounts' in sql
+    assert params == []
+
+
+def test_column_is_null_method():
+    """Test is_null method"""
+    condition = Users.email.is_null()
     assert condition.operator == 'IS'
     assert condition.right is None
 
 
-def test_column_is_not_null_property():
-    """Test is_not_null property"""
-    condition = Users.email.is_not_null
+def test_column_is_not_null_method():
+    """Test is_not_null method"""
+    condition = Users.email.is_not_null()
     assert condition.operator == 'IS NOT'
     assert condition.right is None
 
 
 def test_where_with_is_null():
     """Test WHERE with is_null"""
-    query = Users.select().where(Users.email.is_null)
+    query = Users.select().where(Users.email.is_null())
     sql, params = query.render()
 
     assert 'WHERE users.email IS NULL' in sql
@@ -863,7 +921,7 @@ def test_where_with_is_null():
 
 def test_where_with_is_not_null():
     """Test WHERE with is_not_null"""
-    query = Users.select().where(Users.email.is_not_null)
+    query = Users.select().where(Users.email.is_not_null())
     sql, params = query.render()
 
     assert 'WHERE users.email IS NOT NULL' in sql
@@ -1002,7 +1060,7 @@ def test_complex_query_with_new_operators():
     """Test complex query using multiple new operators"""
     query = (Users.select()
              .where(Users.id.between(1, 100))
-             .where(Users.email.is_not_null)
+             .where(Users.email.is_not_null())
              .where(Users.id.not_in([5, 10, 15]))
              .where(Users.username.ilike('%test%')))
     sql, params = query.render()

{t_sql-3.2.0 → t_sql-4.1.0}/tests/test_sqlalchemy_integration.py

@@ -229,6 +229,38 @@ def test_mixing_query_builder_with_tsql():
     assert params == [18, 'john', 'john', 25]
 
 
+def test_sa_column_annotations_are_correct_type():
+    """Test that SA Column assignments get correct type annotations for IDE autocomplete"""
+    from tsql.query_builder import Column as TsqlColumn
+
+    metadata = MetaData()
+
+    class MyTable(Table, table_name='mytable', metadata=metadata):
+        my_column = Column(TIMESTAMP())
+        another = Column(Integer())
+        text_field = Column(String(100))
+
+    # Verify that __annotations__ has been updated to reflect tsql.Column
+    assert 'my_column' in MyTable.__annotations__
+    assert 'another' in MyTable.__annotations__
+    assert 'text_field' in MyTable.__annotations__
+
+    assert MyTable.__annotations__['my_column'] == TsqlColumn
+    assert MyTable.__annotations__['another'] == TsqlColumn
+    assert MyTable.__annotations__['text_field'] == TsqlColumn
+
+    # Verify that the columns actually work as tsql.Column objects
+    col = MyTable.my_column
+    assert isinstance(col, TsqlColumn)
+    assert hasattr(col, 'is_null')
+    assert hasattr(col, 'asc')
+    assert hasattr(col, 'desc')
+
+    # Verify is_null works
+    condition = col.is_null()
+    assert condition.operator == 'IS'
+    assert condition.right is None
+
 def gen_id(prefix):
     """Dummy function for test"""
     return f"{prefix}_123"

{t_sql-3.2.0 → t_sql-4.1.0}/tsql/query_builder.py

@@ -38,10 +38,9 @@ class OrderByClause:
 class Column:
     """Represents a bound column (table + column name) for building queries"""
 
-    def __init__(self, table_name: str = None, column_name: str = None, python_type: type = None, alias: str = None, schema: str = None):
+    def __init__(self, table_name: str | None = None, column_name: str | None = None, alias: str | None = None, schema: str | None = None):
         self.table_name = table_name
         self.column_name = column_name
-        self.python_type = python_type
         self.alias = alias
         self.schema = schema
 
@@ -71,7 +70,7 @@ class Column:
         Example:
             users.select(users.first_name.as_('first'), users.last_name.as_('last'))
         """
-        return Column(self.table_name, self.column_name, self.python_type, alias, self.schema)
+        return Column(self.table_name, self.column_name, alias, self.schema)
 
     def __eq__(self, other) -> 'Condition':
         if other is None:
@@ -149,12 +148,10 @@ class Column:
         """
         return Condition(self, 'NOT BETWEEN', (start, end))
 
-    @property
     def is_null(self) -> 'Condition':
         """Create an IS NULL condition"""
         return Condition(self, 'IS', None)
 
-    @property
     def is_not_null(self) -> 'Condition':
         """Create an IS NOT NULL condition"""
         return Condition(self, 'IS NOT', None)
@@ -197,13 +194,22 @@ class Table:
         class Users(Table, table_name='user_accounts'):
             id: Column
 
-    For SQLAlchemy integration, use SQLAlchemy Column objects:
+    For SQLAlchemy integration, use the SAColumn wrapper for type checker compatibility:
 
-        from sqlalchemy import Column, Integer, String
+        from sqlalchemy import Integer, String
+        from tsql.query_builder import Table, SAColumn
 
         class Users(Table, metadata=metadata, schema='public'):
-            id = Column(Integer, primary_key=True)
-            name = Column(String(100))
+            id = SAColumn(Integer, primary_key=True)
+            name = SAColumn(String(100))
+
+    Alternative: Use explicit type annotations with SQLAlchemy Column:
+
+        from sqlalchemy import Column as SACol
+
+        class Users(Table, metadata=metadata):
+            id: Column = SACol(Integer, primary_key=True)
+            name: Column = SACol(String(100))
     """
     table_name: ClassVar[str]
     schema: ClassVar[Optional[str]] = None
@@ -270,8 +276,12 @@ class Table:
                     sa_col.name = field_name
                     sa_columns.append(sa_col)
 
-                # Create query builder ColumnDescriptor
-                setattr(cls, field_name, ColumnDescriptor(field_name, field_type))
+                # Create query builder Column directly
+                setattr(cls, field_name, Column(cls.table_name, field_name, schema=schema))
+                # Update annotation to reflect the Column type
+                if not hasattr(cls, '__annotations__'):
+                    cls.__annotations__ = {}
+                cls.__annotations__[field_name] = Column
                 continue
 
             # Check if it's a Column instance (for column_name remapping)
@@ -282,8 +292,12 @@ class Table:
                     # 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 query builder Column directly with the DB column name
+                setattr(cls, field_name, Column(cls.table_name, db_column_name, schema=schema))
+                # Update annotation to reflect the Column type
+                if not hasattr(cls, '__annotations__'):
+                    cls.__annotations__ = {}
+                cls.__annotations__[field_name] = Column
 
                 # Create SQLAlchemy column if metadata provided
                 if metadata is not None and HAS_SQLALCHEMY:
@@ -293,8 +307,12 @@ class Table:
 
             # Check if it's an Ellipsis (...) declaration
             if field_value is ...:
-                # Create query builder ColumnDescriptor
-                setattr(cls, field_name, ColumnDescriptor(field_name, None))
+                # Create query builder Column directly
+                setattr(cls, field_name, Column(cls.table_name, field_name, schema=schema))
+                # Update annotation to reflect the Column type
+                if not hasattr(cls, '__annotations__'):
+                    cls.__annotations__ = {}
+                cls.__annotations__[field_name] = Column
                 continue
 
             # Otherwise, handle type annotations
@@ -302,8 +320,12 @@ class Table:
                 # No type annotation, Ellipsis, or SA Column - skip
                 continue
 
-            # Create query builder ColumnDescriptor for type-annotated fields
-            setattr(cls, field_name, ColumnDescriptor(field_name, field_type))
+            # Create query builder Column directly for type-annotated fields
+            setattr(cls, field_name, Column(cls.table_name, field_name, schema=schema))
+            # Update annotation to reflect the Column type
+            if not hasattr(cls, '__annotations__'):
+                cls.__annotations__ = {}
+            cls.__annotations__[field_name] = Column
 
             # Create SQLAlchemy column if metadata provided
             if metadata is not None and HAS_SQLALCHEMY:
@@ -314,6 +336,9 @@ class Table:
         if metadata is not None and HAS_SQLALCHEMY:
             cls._sa_table = SATable(cls.table_name, metadata, *sa_columns, schema=schema)
 
+        # Add the ALL column for wildcard column selection
+        cls.ALL = Column(cls.table_name, '*', schema=schema)
+
     @classmethod
     def select(cls, *columns: Union['Column', Template]) -> 'SelectQueryBuilder':
         """Start building a SELECT query"""
@@ -364,23 +389,6 @@ class Table:
         return DeleteBuilder(cls)
 
 
-class ColumnDescriptor:
-    """Descriptor that creates Column objects when accessed on Table classes or instances"""
-
-    def __init__(self, column_name: str, python_type: type = None):
-        self.column_name = column_name
-        self.python_type = python_type
-
-    def __set_name__(self, owner, name):
-        self.column_name = name
-
-    def __get__(self, obj, objtype=None) -> Column:
-        if objtype is None:
-            objtype = type(obj)
-        schema = getattr(objtype, 'schema', None)
-        return Column(objtype.table_name, self.column_name, self.python_type, schema=schema)
-
-
 class Condition:
     """Represents a WHERE clause condition"""
 
@@ -1058,3 +1066,32 @@ if HAS_SQLALCHEMY:
         datetime: DateTime,
         float: Float,
     }
+
+
+# Helper function for type checker compatibility with SQLAlchemy columns
+def SAColumn(*args: Any, **kwargs: Any) -> Column:  # noqa: N802
+    """Wrapper for SQLAlchemy Column that satisfies type checkers.
+
+    This function returns a SQLAlchemy Column at runtime but tells type checkers
+    it returns a tsql Column. This allows you to use SQLAlchemy columns without
+    explicit type annotations while still getting proper IDE completions.
+
+    Usage:
+        from tsql.query_builder import Table, SAColumn
+        from sqlalchemy import Integer, String
+
+        class Users(Table):
+            id = SAColumn(Integer, primary_key=True)  # Type checker sees: tsql Column
+            name = SAColumn(String(100))
+
+    Note: This shadows the SQLAlchemy Column import. Import SA Column explicitly if needed:
+        from sqlalchemy import Column as SA_Column
+
+    Alternative: Use explicit type annotations:
+        from sqlalchemy import Column as SACol
+        id: Column = SACol(Integer, primary_key=True)
+    """
+    if not HAS_SQLALCHEMY:
+        raise ImportError("SQLAlchemy is not installed. Cannot use SAColumn() helper.")
+    from sqlalchemy import Column as SA_Column
+    return SA_Column(*args, **kwargs)  # type: ignore[return-value]