TypeDAL 4.9.1__tar.gz → 4.9.2__tar.gz

{typedal-4.9.1 → typedal-4.9.2}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!--next-version-placeholder-->
 
+## v4.9.2 (2026-07-02)
+
+### Fix
+
+* **query-builder:** Normalize field rnames in select options ([`5fe46d9`](https://github.com/trialandsuccess/TypeDAL/commit/5fe46d9b4acd3081ff6e87cf7f9a45b8f4aa876b))
+
 ## v4.9.1 (2026-07-02)
 
 ### Fix

{typedal-4.9.1 → typedal-4.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.9.1
+Version: 4.9.2
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues
@@ -43,6 +43,7 @@ Requires-Dist: ewok; extra == 'dev'
 Requires-Dist: hatch; extra == 'dev'
 Requires-Dist: mkdocs; extra == 'dev'
 Requires-Dist: mkdocs-dracula-theme; extra == 'dev'
+Requires-Dist: psycopg2-binary; extra == 'dev'
 Requires-Dist: pydantic<3; extra == 'dev'
 Requires-Dist: pyright<1.1.400; extra == 'dev'
 Requires-Dist: pytest-typing; extra == 'dev'

{typedal-4.9.1 → typedal-4.9.2}/pyproject.toml

@@ -97,6 +97,7 @@ dev = [
     "contextlib-chdir",
     "testcontainers",
     "pydantic < 3",
+    "psycopg2-binary",
     # depends on ->
     "requests<2.32",
     # mypy:

{typedal-4.9.1 → typedal-4.9.2}/src/typedal/__about__.py

@@ -5,4 +5,4 @@ This file contains the Version info for this package.
 # SPDX-FileCopyrightText: 2023-present Robin van der Noord <robinvandernoord@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "4.9.1"
+__version__ = "4.9.2"

{typedal-4.9.1 → typedal-4.9.2}/src/typedal/fields.py

@@ -268,6 +268,20 @@ class TypedField[T_Value](Expression):  # pragma: no cover
         return t.cast(Expression, self._field.lower())
 
 
+def rname(field: TypedField[t.Any] | Field) -> str:
+    """
+    Return the full rname (table and field).
+    """
+
+    table = field._table
+    inner_field = field._field if isinstance(field, TypedField) else field
+
+    if not (table and inner_field):
+        raise ValueError("missing table or inner field on this 'field'")
+
+    return "%s.%s" % (table._rname, inner_field._rname)
+
+
 def is_typed_field(cls: t.Any) -> t.TypeGuard["TypedField[t.Any]"]:
     """
     Is `cls` an instance or subclass of TypedField?

{typedal-4.9.1 → typedal-4.9.2}/src/typedal/query_builder.py

@@ -152,7 +152,22 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
         """
         Return a clone of this builder with permission overrides merged in.
         """
-        return self._extend(permissions=t.cast(Permissions, permissions))
+        return self._extend(permissions=permissions)
+
+    def _normalize_select_option(
+        self, value: str | Field | Expression | bool | t.Iterable[str | Field]
+    ) -> str | bool | list[str]:
+        # currently only used for 'distinct' since orderby, ... are patched by pydal itself in select()
+        if isinstance(value, bool):
+            return value
+
+        if isinstance(value, (list, tuple, set)):
+            return list(self._normalize_select_option(val) for val in value)
+
+        if rname := getattr(value, "_rname", None):
+            return str(rname)
+
+        return str(value)
 
     def select(self, *fields: t.Any, **options: t.Unpack[SelectKwargs]) -> "QueryBuilder[T_MetaInstance]":
         """
@@ -179,6 +194,11 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
             left: othertable.on(query) - do a LEFT JOIN. Using TypeDAL relationships with .join() is recommended!
             cache: cache the query result to speed up repeated queries; e.g. (cache=(cache.ram, 3600), cacheable=True)
         """
+
+        for key in ("distinct",):
+            if options.get(key):
+                options[key] = self._normalize_select_option(options[key])
+
         return self._extend(select_args=list(fields), select_kwargs=options)
 
     def orderby(self, *fields: OrderBy) -> "QueryBuilder[T_MetaInstance]":
@@ -272,7 +292,10 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
         return self._extend(overwrite_query=new_query)
 
     def _parse_relationships(
-        self, fields: t.Iterable[str | t.Type[TypedTable]], method: JOIN_OPTIONS = None, **update: t.Any
+        self,
+        fields: t.Iterable[str | t.Type[TypedTable]],
+        method: JOIN_OPTIONS = None,
+        **update: t.Any,
     ) -> dict[str, Relationship[t.Any]]:
         """
         Parse relationship fields into a dict of base relationships with nested relationships.
@@ -766,7 +789,11 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
         return joins
 
     def _build_inner_joins_recursive(
-        self, relation: Relationship[t.Any], parent_table: t.Type[_TypedTable], key: str, parent_key: str = ""
+        self,
+        relation: Relationship[t.Any],
+        parent_table: t.Type[_TypedTable],
+        key: str,
+        parent_key: str = "",
     ) -> list[t.Any]:
         """Recursively build inner joins for a relationship and its nested relationships."""
         db = self._get_db()
@@ -876,13 +903,21 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
             # todo: add additional test, deduplicate
             nested_key = f"{parent_key}.{nested_name}" if parent_key else f"{key}.{nested_name}"
             select_args = self._process_relationship_for_left_join(
-                nested, nested_name, select_args, left_joins, other, nested_key
+                nested,
+                nested_name,
+                select_args,
+                left_joins,
+                other,
+                nested_key,
             )
 
         return select_args
 
     def _ensure_relationship_fields(
-        self, select_args: list[t.Any], other: t.Type[TypedTable], select_fields: str
+        self,
+        select_args: list[t.Any],
+        other: t.Type[TypedTable],
+        select_fields: str,
     ) -> list[t.Any]:
         """Ensure required fields from relationship table are selected."""
         if f"{other}." not in select_fields:
@@ -895,7 +930,10 @@ class QueryBuilder[T_MetaInstance: _TypedTable]:
         return select_args
 
     def _update_select_args_with_alias(
-        self, select_args: list[t.Any], pre_alias: str, other: t.Type[TypedTable]
+        self,
+        select_args: list[t.Any],
+        pre_alias: str,
+        other: t.Type[TypedTable],
     ) -> list[t.Any]:
         """Update select_args to use aliased table names."""
         post_alias = str(other).split(" AS ")[-1]

{typedal-4.9.1 → typedal-4.9.2}/src/typedal/types.py

@@ -71,7 +71,7 @@ def merge_permissions(*permission_sets: Permissions | None) -> Permissions:
 
         for key in permission_types:
             if key in permission_set:
-                merged[key] = merged[key] and bool(permission_set[key])
+                merged[key] = merged[key] and bool(permission_set[key])  # type: ignore
 
     return t.cast(Permissions, merged)
 
@@ -188,6 +188,8 @@ class Reference(_Reference):
 class Field(_Field):
     """Pydal Field object. Make mypy happy."""
 
+    _rname: str
+
 
 class Rows(_Rows):
     """Pydal Rows object. Make mypy happy."""
@@ -283,7 +285,7 @@ class SelectKwargs(t.TypedDict, total=False):
     groupby: "GroupBy | t.Iterable[GroupBy] | None"
     having: "Having | None"
     limitby: t.Optional[tuple[int, int]]
-    distinct: bool | Field | Expression | str
+    distinct: bool | Field | Expression | str | t.Iterable[str]
     orderby_on_limitby: bool
     cacheable: bool
     cache: "CacheTuple"

typedal-4.9.2/tests/conftest.py

@@ -0,0 +1,30 @@
+import tempfile
+
+import pytest
+from testcontainers.postgres import PostgresContainer
+
+from src.typedal import TypeDAL
+
+postgres = PostgresContainer(
+    dbname="postgres",
+    username="someuser",
+    password="somepass",
+)
+
+
+@pytest.fixture(scope="module", autouse=True)
+def psql(request):
+    postgres.ports = {
+        5432: 9631,  # as set in valid.env
+    }
+
+    request.addfinalizer(postgres.stop)
+    postgres.start()
+
+
+@pytest.fixture
+def dal_psql(psql):
+    conn_str = postgres.get_connection_url()
+    uri = "postgres://" + conn_str.split("://")[-1]
+    with tempfile.TemporaryDirectory() as d:
+        yield TypeDAL(uri, attempts=1, migrate=True, enable_typedal_caching=False, folder=d)

{typedal-4.9.1 → typedal-4.9.2}/tests/test_config.py

@@ -9,7 +9,6 @@ from pathlib import Path
 
 import pytest
 from contextlib_chdir import chdir
-from testcontainers.postgres import PostgresContainer
 
 from src.typedal import TypeDAL, TypedField, TypedTable
 from src.typedal.config import (
@@ -20,22 +19,6 @@ from src.typedal.config import (
 )
 from src.typedal.fields import PointField, TimestampField, UUIDField
 
-postgres = PostgresContainer(
-    dbname="postgres",
-    username="someuser",
-    password="somepass",
-)
-
-
-@pytest.fixture(scope="module", autouse=True)
-def psql(request):
-    postgres.ports = {
-        5432: 9631,  # as set in valid.env
-    }
-
-    request.addfinalizer(postgres.stop)
-    postgres.start()
-
 
 @pytest.fixture
 def at_temp_dir():

{typedal-4.9.1 → typedal-4.9.2}/tests/test_query_builder.py

@@ -1,8 +1,9 @@
 import pytest
-from pydal.objects import Query
+from pydal.objects import Field, Query
 
 from src.typedal import TypeDAL, TypedField, TypedTable, relationship
 from typedal import QueryBuilder
+from typedal.fields import rname
 
 db = TypeDAL("sqlite:memory")
 
@@ -559,6 +560,48 @@ def test_orderby():
     )
 
 
+def test_select_kwargs_use_rname_psql(dal_psql: TypeDAL):
+    db = dal_psql
+
+    @db.define(rname="some_table")
+    class Sometable(TypedTable):
+        name = TypedField(str, rname="some_name")
+
+    Sometable.insert(name="B")
+    Sometable.insert(name="A")
+    Sometable.insert(name="A")
+    db.commit()
+
+    # default orderby/distinct
+
+    orderby_sql = Sometable.select(orderby=Sometable.name).to_sql().lower()
+
+    assert "sometable.name" not in orderby_sql
+    assert "some_table.some_name" in orderby_sql
+
+    distinct_sql1 = Sometable.select(Sometable.name, distinct=Sometable.name).to_sql().lower()
+    distinct_sql2 = Sometable.select(Sometable.name, distinct=(Sometable.name, Sometable.id)).to_sql().lower()
+    distinct_sql3 = Sometable.select(Sometable.name, distinct=("name", "id")).to_sql().lower()
+
+    for sql in (distinct_sql1, distinct_sql2, distinct_sql3):
+        assert "sometable.name" not in sql
+        assert "some_table.some_name" in sql
+
+    builder = Sometable.select(orderby=Sometable.name)
+    existing_orderby: Field = builder.select_kwargs.get("orderby")
+
+    existing_orderby_name = rname(existing_orderby)
+    sometable_name = rname(Sometable.name)
+    sometable_name_pydal = rname(db.sometable.name)
+
+    with pytest.raises(ValueError):
+        rname(TypedField(str, rname="some_name"))
+
+    for sql in (existing_orderby_name, sometable_name, sometable_name_pydal):
+        assert "sometable.name" not in sql
+        assert "some_table.some_name" in sql
+
+
 def test_execute():
     _setup_data()