plain.postgres 0.113.0__tar.gz → 0.113.2__tar.gz

{plain_postgres-0.113.0 → plain_postgres-0.113.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.113.0
+Version: 0.113.2
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause

{plain_postgres-0.113.0 → plain_postgres-0.113.2}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,26 @@
 # plain-postgres changelog
 
+## [0.113.2](https://github.com/dropseed/plain/releases/plain-postgres@0.113.2) (2026-08-10)
+
+### What's changed
+
+- Fixed a `NameError` on any expression-based ordering — `Model.query.order_by(F("name"))`, `order_by(Lower("name"))`, or `Options(ordering=[Lower("name")])`. `SQLCompiler` cast ordering items to `BaseExpression`, which was imported only under `TYPE_CHECKING`; `cast()`'s first argument is an ordinary expression and is evaluated at runtime, so the branch raised instead of compiling. `BaseExpression` moves into the existing runtime import from `plain.postgres.expressions`. ([3429735be0](https://github.com/dropseed/plain/commit/3429735be0))
+- `QuerySet.order_by()` and `Query.add_ordering()` now accept `str | ResolvableExpression` instead of `str` / `str | BaseExpression`. That's the protocol both layers actually test with `isinstance()`, and the one `F()` satisfies (`F` extends `Combinable`, not `BaseExpression`) — so no type-checked caller could reach the expression branch at all before. ([3429735be0](https://github.com/dropseed/plain/commit/3429735be0))
+
+### Upgrade instructions
+
+- No changes required.
+
+## [0.113.1](https://github.com/dropseed/plain/releases/plain-postgres@0.113.1) (2026-08-07)
+
+### What's changed
+
+- Internal: `Meta` field sorting tolerates a field whose `name` hasn't been set yet, keeping the sort key type-correct under ty 0.0.65. No behavior change. ([a798c13c92](https://github.com/dropseed/plain/commit/a798c13c92))
+
+### Upgrade instructions
+
+- No changes required.
+
 ## [0.113.0](https://github.com/dropseed/plain/releases/plain-postgres@0.113.0) (2026-08-02)
 
 ### What's changed
@@ -18,7 +39,9 @@
 - Replace `QuerySet.extra()` calls: `extra(select=...)` becomes `annotate(name=RawSQL("...", []))`, `extra(where=...)` becomes `filter()` with expressions or `RawSQL`, and `extra(order_by=...)` becomes `order_by()` on an annotation.
 - Replace `FilteredRelation` annotations with filtered subqueries or `Q` conditions, and `QuerySet.alias()` with `annotate()`.
 - Replace `Q(a) ^ Q(b)` / `qs1 ^ qs2` with explicit AND/OR logic: `(Q(a) | Q(b)) & ~(Q(a) & Q(b))`.
-- If `plain migrations create` now refuses a field it previously accepted, follow the error's remedy: declare `required=False, default=""` (or `default=b""` / an appropriate literal) so existing rows get a value, or add it with `allow_null=True` plus a backfill data migration.(https://github.com/dropseed/plain/releases/plain-postgres@0.112.0) (2026-07-21)
+- If `plain migrations create` now refuses a field it previously accepted, follow the error's remedy: declare `required=False, default=""` (or `default=b""` / an appropriate literal) so existing rows get a value, or add it with `allow_null=True` plus a backfill data migration.
+
+## [0.112.0](https://github.com/dropseed/plain/releases/plain-postgres@0.112.0) (2026-07-21)
 
 ### What's changed
 

{plain_postgres-0.113.0 → plain_postgres-0.113.2}/plain/postgres/meta.py

@@ -130,8 +130,8 @@ class Meta:
                     field.contribute_to_class(model, attr_name)
 
         # Sort fields: primary key first, then alphabetically by name
-        instance.local_fields.sort(key=lambda f: (not f.primary_key, f.name))
-        instance.local_many_to_many.sort(key=lambda f: f.name)
+        instance.local_fields.sort(key=lambda f: (not f.primary_key, f.name or ""))
+        instance.local_many_to_many.sort(key=lambda f: f.name or "")
 
         return instance
 

{plain_postgres-0.113.0 → plain_postgres-0.113.2}/plain/postgres/query.py

@@ -1262,7 +1262,7 @@ class QuerySet[T: "Model"]:
 
         return clone
 
-    def order_by(self, *field_names: str) -> Self:
+    def order_by(self, *field_names: str | ResolvableExpression) -> Self:
         """Return a new QuerySet instance with the ordering changed."""
         if self.sql_query.is_sliced:
             raise TypeError("Cannot reorder a query once a slice has been taken.")

{plain_postgres-0.113.0 → plain_postgres-0.113.2}/plain/postgres/sql/compiler.py

@@ -22,6 +22,7 @@ from plain.postgres.dialect import (
 )
 from plain.postgres.exceptions import EmptyResultSet, FieldError, FullResultSet
 from plain.postgres.expressions import (
+    BaseExpression,
     F,
     OrderBy,
     Ref,
@@ -49,7 +50,6 @@ from plain.utils.regex_helper import _lazy_re_compile
 
 if TYPE_CHECKING:
     from plain.postgres.connection import DatabaseConnection
-    from plain.postgres.expressions import BaseExpression
     from plain.postgres.sql.query import AggregateQuery, InsertQuery
 
 # Type aliases for SQL compilation results

{plain_postgres-0.113.0 → plain_postgres-0.113.2}/plain/postgres/sql/query.py

@@ -2035,7 +2035,7 @@ class Query(BaseExpression):
                     )
                 )
 
-    def add_ordering(self, *ordering: str | BaseExpression) -> None:
+    def add_ordering(self, *ordering: str | ResolvableExpression) -> None:
         """
         Add items from the 'ordering' sequence to the query's "order by"
         clause. These items are either field names (not column names) --

{plain_postgres-0.113.0 → plain_postgres-0.113.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.postgres"
-version = "0.113.0"
+version = "0.113.2"
 description = "Model your data and store it in a database."
 authors = [{ name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev" }]
 readme = "README.md"

plain_postgres-0.113.2/tests/public/test_order_by_expressions.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from app.examples.models.iteration import IterationExample
+
+from plain.postgres.expressions import F
+from plain.postgres.functions import Lower
+
+
+def test_order_by_f_expression(db):
+    """`order_by()` accepts expressions, not just field-name strings."""
+    IterationExample.query.create(name="beta", tag="b")
+    IterationExample.query.create(name="alpha", tag="a")
+
+    names = list(
+        IterationExample.query.order_by(F("name")).values_list("name", flat=True)
+    )
+
+    assert names == ["alpha", "beta"]
+
+
+def test_order_by_function_expression(db):
+    """Database functions work as ordering expressions."""
+    IterationExample.query.create(name="Beta", tag="b")
+    IterationExample.query.create(name="alpha", tag="a")
+
+    names = list(
+        IterationExample.query.order_by(Lower("name")).values_list("name", flat=True)
+    )
+
+    assert names == ["alpha", "Beta"]