plain.postgres 0.89.2__tar.gz → 0.90.0__tar.gz

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.postgres
-Version: 0.89.2
+Version: 0.90.0
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-Expression: BSD-3-Clause
@@ -154,8 +154,8 @@ class PublishedQuerySet(postgres.QuerySet["Article"]):
 
 @postgres.register_model
 class Article(postgres.Model):
-    title: str = types.CharField(max_length=200)
-    status: str = types.CharField(max_length=20)
+    title: str = types.TextField(max_length=200)
+    status: str = types.TextField(max_length=20)
 
     query = PublishedQuerySet()
 
@@ -552,7 +552,7 @@ from plain.postgres import types
 
 class Product(postgres.Model):
     # Text fields
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     description: str = types.TextField()
 
     # Numeric fields
@@ -569,8 +569,7 @@ class Product(postgres.Model):
 
 **Text fields:**
 
-- [`CharField`](./fields/__init__.py#CharField) - String with max length
-- [`TextField`](./fields/__init__.py#TextField) - Unlimited text
+- [`TextField`](./fields/__init__.py#TextField) - Text (with optional max length)
 - [`EmailField`](./fields/__init__.py#EmailField) - Email address (validated)
 - [`URLField`](./fields/__init__.py#URLField) - URL (validated)
 
@@ -659,7 +658,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Integration(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     api_key: str = types.EncryptedTextField(max_length=200)
     credentials: dict = types.EncryptedJSONField(required=False, allow_null=True)
 ```
@@ -694,7 +693,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField("Author", on_delete=postgres.CASCADE)
     tags = types.ManyToManyField("Tag")
 ```
@@ -709,13 +708,13 @@ from plain.postgres import types
 
 @postgres.register_model
 class Author(postgres.Model):
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     # Explicit reverse accessor for all books by this author
     books = types.ReverseForeignKey(to="Book", field="author")
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField(Author, on_delete=postgres.CASCADE)
 
 # Usage
@@ -732,13 +731,13 @@ For many-to-many relationships:
 ```python
 @postgres.register_model
 class Feature(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     # Explicit reverse accessor for all cars with this feature
     cars = types.ReverseManyToMany(to="Car", field="features")
 
 @postgres.register_model
 class Car(postgres.Model):
-    model: str = types.CharField(max_length=100)
+    model: str = types.TextField(max_length=100)
     features = types.ManyToManyField(Feature)
 
 # Usage
@@ -805,7 +804,7 @@ You can optimize queries and ensure data integrity with indexes and constraints:
 ```python
 class User(postgres.Model):
     email: str = types.EmailField()
-    username: str = types.CharField(max_length=150)
+    username: str = types.TextField(max_length=150)
     age: int = types.IntegerField()
 
     model_options = postgres.Options(
@@ -829,12 +828,12 @@ Add indexes for columns that appear in `.filter()`, `.order_by()`, or `.exclude(
 ```python
 # Bad — full table scan on every filtered query
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
 # Good — indexed for common queries
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
     model_options = postgres.Options(
@@ -876,10 +875,10 @@ Use `default=""` instead of `allow_null=True` to avoid two representations of "e
 
 ```python
 # Bad — NULL and "" both mean "empty"
-nickname: str = types.CharField(max_length=50, allow_null=True)
+nickname: str = types.TextField(max_length=50, allow_null=True)
 
 # Good — single empty representation
-nickname: str = types.CharField(max_length=50, default="")
+nickname: str = types.TextField(max_length=50, default="")
 ```
 
 ## Forms
@@ -1041,10 +1040,6 @@ See [`default_settings.py`](./default_settings.py) for more details.
 
 Add the field to your model class, then run `plain makemigrations` to create a migration. If the field is required (no default value and not nullable), you'll be prompted to provide a default value for existing rows.
 
-#### What's the difference between `CharField` and `TextField`?
-
-`CharField` requires a `max_length` and is typically used for short strings like names or emails. `TextField` has no length limit and is used for longer content like descriptions or body text.
-
 #### How do I create a unique constraint on multiple fields?
 
 Use `UniqueConstraint` in your model's `model_options`:

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/plain/postgres/CHANGELOG.md

@@ -1,5 +1,22 @@
 # plain-postgres changelog
 
+## [0.90.0](https://github.com/dropseed/plain/releases/plain-postgres@0.90.0) (2026-03-28)
+
+### What's changed
+
+- **Removed `CharField`** — use `TextField` for all string fields. PostgreSQL treats `varchar` and `text` identically (same storage, same performance), so the distinction was unnecessary. `TextField` now accepts an optional `max_length` for Python-side validation via `MaxLengthValidator`, without affecting the database column type. ([5062ee4dd1fd](https://github.com/dropseed/plain/commit/5062ee4dd1fd))
+- **`EmailField` and `URLField` now extend `TextField`** instead of `CharField`. Their default `max_length` values (254 and 200 respectively) have been removed — pass `max_length` explicitly if you need validation. ([5062ee4dd1fd](https://github.com/dropseed/plain/commit/5062ee4dd1fd))
+- **Simplified field class internals** — removed the `get_internal_type()` method and 6 lookup dicts from `dialect.py`. Each field class now declares its SQL type directly via `db_type_sql` class attribute. String-based type comparisons replaced with `isinstance()` checks throughout. ([3ffdebe22250](https://github.com/dropseed/plain/commit/3ffdebe22250))
+- **Added `postgres converge` command** — detects and fixes safe schema mismatches between models and the database. Currently handles `character varying` → `text` conversions. ([fe8cf3995e95](https://github.com/dropseed/plain/commit/fe8cf3995e95))
+
+### Upgrade instructions
+
+- Replace `CharField` with `TextField` in model code (e.g. `types.CharField(max_length=100)` → `types.TextField(max_length=100)`)
+- Replace `CharField` with `TextField` in migration files (e.g. `postgres.CharField(max_length=255)` → `postgres.TextField(max_length=255)`)
+- If you subclass `CharField`, change the parent class to `TextField`
+- `EmailField` no longer defaults `max_length=254` and `URLField` no longer defaults `max_length=200` — remove these from migration files if present (e.g. `postgres.EmailField(max_length=254)` → `postgres.EmailField()`)
+- Run `plain postgres converge` to convert existing `character varying` columns to `text` (in development and production). The conversion is instant and safe — PostgreSQL treats them identically. Use `--yes` to skip confirmation in CI/deploy scripts.
+
 ## [0.89.2](https://github.com/dropseed/plain/releases/plain-postgres@0.89.2) (2026-03-27)
 
 ### What's changed

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/plain/postgres/README.md

@@ -142,8 +142,8 @@ class PublishedQuerySet(postgres.QuerySet["Article"]):
 
 @postgres.register_model
 class Article(postgres.Model):
-    title: str = types.CharField(max_length=200)
-    status: str = types.CharField(max_length=20)
+    title: str = types.TextField(max_length=200)
+    status: str = types.TextField(max_length=20)
 
     query = PublishedQuerySet()
 
@@ -540,7 +540,7 @@ from plain.postgres import types
 
 class Product(postgres.Model):
     # Text fields
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     description: str = types.TextField()
 
     # Numeric fields
@@ -557,8 +557,7 @@ class Product(postgres.Model):
 
 **Text fields:**
 
-- [`CharField`](./fields/__init__.py#CharField) - String with max length
-- [`TextField`](./fields/__init__.py#TextField) - Unlimited text
+- [`TextField`](./fields/__init__.py#TextField) - Text (with optional max length)
 - [`EmailField`](./fields/__init__.py#EmailField) - Email address (validated)
 - [`URLField`](./fields/__init__.py#URLField) - URL (validated)
 
@@ -647,7 +646,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Integration(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     api_key: str = types.EncryptedTextField(max_length=200)
     credentials: dict = types.EncryptedJSONField(required=False, allow_null=True)
 ```
@@ -682,7 +681,7 @@ from plain.postgres import types
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField("Author", on_delete=postgres.CASCADE)
     tags = types.ManyToManyField("Tag")
 ```
@@ -697,13 +696,13 @@ from plain.postgres import types
 
 @postgres.register_model
 class Author(postgres.Model):
-    name: str = types.CharField(max_length=200)
+    name: str = types.TextField(max_length=200)
     # Explicit reverse accessor for all books by this author
     books = types.ReverseForeignKey(to="Book", field="author")
 
 @postgres.register_model
 class Book(postgres.Model):
-    title: str = types.CharField(max_length=200)
+    title: str = types.TextField(max_length=200)
     author: Author = types.ForeignKeyField(Author, on_delete=postgres.CASCADE)
 
 # Usage
@@ -720,13 +719,13 @@ For many-to-many relationships:
 ```python
 @postgres.register_model
 class Feature(postgres.Model):
-    name: str = types.CharField(max_length=100)
+    name: str = types.TextField(max_length=100)
     # Explicit reverse accessor for all cars with this feature
     cars = types.ReverseManyToMany(to="Car", field="features")
 
 @postgres.register_model
 class Car(postgres.Model):
-    model: str = types.CharField(max_length=100)
+    model: str = types.TextField(max_length=100)
     features = types.ManyToManyField(Feature)
 
 # Usage
@@ -793,7 +792,7 @@ You can optimize queries and ensure data integrity with indexes and constraints:
 ```python
 class User(postgres.Model):
     email: str = types.EmailField()
-    username: str = types.CharField(max_length=150)
+    username: str = types.TextField(max_length=150)
     age: int = types.IntegerField()
 
     model_options = postgres.Options(
@@ -817,12 +816,12 @@ Add indexes for columns that appear in `.filter()`, `.order_by()`, or `.exclude(
 ```python
 # Bad — full table scan on every filtered query
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
 # Good — indexed for common queries
 class Order(postgres.Model):
-    status: str = types.CharField(max_length=20)
+    status: str = types.TextField(max_length=20)
     created_at: datetime = types.DateTimeField()
 
     model_options = postgres.Options(
@@ -864,10 +863,10 @@ Use `default=""` instead of `allow_null=True` to avoid two representations of "e
 
 ```python
 # Bad — NULL and "" both mean "empty"
-nickname: str = types.CharField(max_length=50, allow_null=True)
+nickname: str = types.TextField(max_length=50, allow_null=True)
 
 # Good — single empty representation
-nickname: str = types.CharField(max_length=50, default="")
+nickname: str = types.TextField(max_length=50, default="")
 ```
 
 ## Forms
@@ -1029,10 +1028,6 @@ See [`default_settings.py`](./default_settings.py) for more details.
 
 Add the field to your model class, then run `plain makemigrations` to create a migration. If the field is required (no default value and not nullable), you'll be prompted to provide a default value for existing rows.
 
-#### What's the difference between `CharField` and `TextField`?
-
-`CharField` requires a `max_length` and is typically used for short strings like names or emails. `TextField` has no length limit and is used for longer content like descriptions or body text.
-
 #### How do I create a unique constraint on multiple fields?
 
 Use `UniqueConstraint` in your model's `model_options`:

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/plain/postgres/__init__.py

@@ -13,7 +13,6 @@ from .fields import (
     BigIntegerField,
     BinaryField,
     BooleanField,
-    CharField,
     DateField,
     DateTimeField,
     DecimalField,
@@ -63,7 +62,6 @@ __all__ = [
     "BigIntegerField",
     "BinaryField",
     "BooleanField",
-    "CharField",
     "DateField",
     "DateTimeField",
     "DecimalField",

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/plain/postgres/agents/.claude/rules/plain-postgres.md

@@ -12,7 +12,7 @@ Import fields via `from plain.postgres import types` and annotate with Python ty
 ```python
 from plain.postgres import types
 
-name: str = types.CharField(max_length=100)
+name: str = types.TextField(max_length=100)
 car: Car = types.ForeignKeyField("Car", on_delete=postgres.CASCADE)
 ```
 

plain_postgres-0.90.0/plain/postgres/cli/converge.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import click
+
+from ..db import get_connection
+from ..dialect import quote_name
+from ..introspection import check_model
+from ..registry import models_registry
+
+
+@click.command()
+@click.option(
+    "--yes",
+    "-y",
+    is_flag=True,
+    help="Skip confirmation prompt.",
+)
+def converge(yes: bool) -> None:
+    """Fix safe schema mismatches between models and the database.
+
+    Detects column type mismatches that can be fixed without data loss
+    (e.g. character varying → text) and applies ALTER COLUMN TYPE statements.
+    """
+    conn = get_connection()
+    fixes: list[tuple[str, str, str, str]] = []  # (table, column, actual, expected)
+
+    with conn.cursor() as cursor:
+        for model in models_registry.get_models():
+            result = check_model(conn, cursor, model)
+            table = result["table"]
+            for col in result["columns"]:
+                for issue in col["issues"]:
+                    if issue["kind"] == "type_mismatch":
+                        expected = issue["detail"].split("expected ")[1].split(",")[0]
+                        actual = issue["detail"].split("actual ")[1]
+                        if _is_safe_type_fix(actual, expected):
+                            fixes.append((table, col["name"], actual, expected))
+
+    if not fixes:
+        click.secho("Schema is converged — nothing to fix.", fg="green")
+        return
+
+    click.secho(
+        f"{len(fixes)} column{'s' if len(fixes) != 1 else ''} to fix:\n", bold=True
+    )
+    for table, column, actual, expected in fixes:
+        click.echo(f"  {table}.{column}: ", nl=False)
+        click.secho(actual, fg="red", nl=False)
+        click.echo(" → ", nl=False)
+        click.secho(expected, fg="green")
+
+    click.echo()
+
+    if not yes:
+        if not click.confirm("Apply these changes?"):
+            return
+
+    click.echo()
+
+    with conn.cursor() as cursor:
+        for table, column, actual, expected in fixes:
+            sql = f"ALTER TABLE {quote_name(table)} ALTER COLUMN {quote_name(column)} TYPE {expected}"
+            click.echo(f"  {sql}")
+            cursor.execute(sql)
+
+    conn.commit()
+
+    click.echo()
+    click.secho(
+        f"Fixed {len(fixes)} column{'s' if len(fixes) != 1 else ''}.", fg="green"
+    )
+
+
+def _is_safe_type_fix(actual: str, expected: str) -> bool:
+    """Return True if converting actual → expected is safe (no data loss, no rewrite)."""
+    # character varying(N) → text is always safe in PostgreSQL.
+    # They use the same storage format; the ALTER is metadata-only.
+    if actual.startswith("character varying") and expected == "text":
+        return True
+    return False

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/plain/postgres/cli/core.py

@@ -13,6 +13,7 @@ from plain.cli import register_cli
 from ..backups.cli import cli as backups_cli
 from ..db import get_connection
 from ..dialect import quote_name
+from .converge import converge
 from .diagnose import diagnose
 from .schema import schema
 
@@ -24,6 +25,7 @@ def cli() -> None:
 
 
 cli.add_command(backups_cli)
+cli.add_command(converge)
 cli.add_command(diagnose)
 cli.add_command(schema)
 

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/plain/postgres/connection.py

@@ -29,6 +29,7 @@ from plain.exceptions import ImproperlyConfigured
 from plain.logs import get_framework_logger
 from plain.postgres import utils
 from plain.postgres.dialect import MAX_NAME_LENGTH, quote_name
+from plain.postgres.fields import GenericIPAddressField, TimeField, UUIDField
 from plain.postgres.indexes import Index
 from plain.postgres.schema import DatabaseSchemaEditor
 from plain.postgres.transaction import TransactionManagementError
@@ -841,12 +842,7 @@ class DatabaseConnection:
         to that type. The resulting string should contain a '%s' placeholder
         for the expression being cast.
         """
-        internal_type = output_field.get_internal_type()
-        if internal_type in (
-            "GenericIPAddressField",
-            "TimeField",
-            "UUIDField",
-        ):
+        if isinstance(output_field, GenericIPAddressField | TimeField | UUIDField):
             # PostgreSQL will resolve a union as type 'text' if input types are
             # 'unknown'.
             # https://www.postgresql.org/docs/current/typeconv-union-case.html

{plain_postgres-0.89.2 → plain_postgres-0.90.0}/plain/postgres/dialect.py

@@ -14,7 +14,6 @@ from functools import lru_cache, partial
 from typing import TYPE_CHECKING, Any
 
 import psycopg
-from psycopg.types import numeric
 from psycopg.types.json import Jsonb
 
 from plain.postgres.constants import OnConflict
@@ -25,26 +24,6 @@ from plain.utils.regex_helper import _lazy_re_compile
 if TYPE_CHECKING:
     from plain.postgres.fields import Field
 
-
-# Integer field safe ranges by internal_type.
-INTEGER_FIELD_RANGES: dict[str, tuple[int, int]] = {
-    "SmallIntegerField": (-32768, 32767),
-    "IntegerField": (-2147483648, 2147483647),
-    "BigIntegerField": (-9223372036854775808, 9223372036854775807),
-    "PositiveBigIntegerField": (0, 9223372036854775807),
-    "PositiveSmallIntegerField": (0, 32767),
-    "PositiveIntegerField": (0, 2147483647),
-    "PrimaryKeyField": (-9223372036854775808, 9223372036854775807),
-}
-
-# Mapping of Field.get_internal_type() to the data type for Cast().
-CAST_DATA_TYPES: dict[str, str] = {
-    "PrimaryKeyField": "bigint",
-}
-
-# CharField data type when max_length isn't provided.
-CAST_CHAR_FIELD_WITHOUT_MAX_LENGTH: str | None = "character varying"
-
 # Start and end points for window expressions.
 PRECEDING: str = "PRECEDING"
 FOLLOWING: str = "FOLLOWING"
@@ -68,16 +47,6 @@ EXPLAIN_OPTIONS = frozenset(
 )
 SUPPORTED_EXPLAIN_FORMATS: set[str] = {"JSON", "TEXT", "XML", "YAML"}
 
-# PostgreSQL integer type mapping for psycopg.
-INTEGERFIELD_TYPE_MAP = {
-    "SmallIntegerField": numeric.Int2,
-    "IntegerField": numeric.Int4,
-    "BigIntegerField": numeric.Int8,
-    "PositiveSmallIntegerField": numeric.Int2,
-    "PositiveIntegerField": numeric.Int4,
-    "PositiveBigIntegerField": numeric.Int8,
-}
-
 # Maximum length of an identifier (63 by default in PostgreSQL).
 MAX_NAME_LENGTH: int = 63
 
@@ -91,52 +60,6 @@ DEFERRABLE_SQL: str = " DEFERRABLE INITIALLY DEFERRED"
 _EXTRACT_FORMAT_RE = _lazy_re_compile(r"[A-Z_]+")
 
 
-# ##### Data type mappings (from constants.py) #####
-
-
-def _get_varchar_column(data: dict[str, Any]) -> str:
-    if data["max_length"] is None:
-        return "character varying"
-    return "character varying({max_length})".format(**data)
-
-
-# Maps Field objects to their associated PostgreSQL column types.
-# Column-type strings can contain format strings interpolated against Field.__dict__.
-DATA_TYPES: dict[str, Any] = {
-    "PrimaryKeyField": "bigint",
-    "BinaryField": "bytea",
-    "BooleanField": "boolean",
-    "CharField": _get_varchar_column,
-    "DateField": "date",
-    "DateTimeField": "timestamp with time zone",
-    "DecimalField": "numeric(%(max_digits)s,%(decimal_places)s)",
-    "DurationField": "interval",
-    "FloatField": "double precision",
-    "IntegerField": "integer",
-    "BigIntegerField": "bigint",
-    "GenericIPAddressField": "inet",
-    "JSONField": "jsonb",
-    "PositiveBigIntegerField": "bigint",
-    "PositiveIntegerField": "integer",
-    "PositiveSmallIntegerField": "smallint",
-    "SmallIntegerField": "smallint",
-    "TextField": "text",
-    "TimeField": "time without time zone",
-    "UUIDField": "uuid",
-}
-
-# Check constraints for fields that need them.
-DATA_TYPE_CHECK_CONSTRAINTS: dict[str, str] = {
-    "PositiveBigIntegerField": '"%(column)s" >= 0',
-    "PositiveIntegerField": '"%(column)s" >= 0',
-    "PositiveSmallIntegerField": '"%(column)s" >= 0',
-}
-
-# Suffix applied to column definitions (e.g., for identity columns).
-DATA_TYPES_SUFFIX: dict[str, str] = {
-    "PrimaryKeyField": "GENERATED BY DEFAULT AS IDENTITY",
-}
-
 # SQL operators for lookups.
 OPERATORS: dict[str, str] = {
     "exact": "= %s",
@@ -375,19 +298,21 @@ def limit_offset_sql(low_mark: int | None, high_mark: int | None) -> str:
     )
 
 
-def lookup_cast(lookup_type: str, internal_type: str | None = None) -> str:
+def lookup_cast(lookup_type: str, field: Field | None = None) -> str:
     """
     Return the string to use in a query when performing lookups
     ("contains", "like", etc.). It should contain a '%s' placeholder for
     the column being searched against.
     """
+    from plain.postgres.fields import (
+        EmailField,
+        GenericIPAddressField,
+        TextField,
+    )
+
     lookup = "%s"
 
-    if lookup_type == "isnull" and internal_type in (
-        "CharField",
-        "EmailField",
-        "TextField",
-    ):
+    if lookup_type == "isnull" and isinstance(field, EmailField | TextField):
         return "%s::text"
 
     # Cast text lookups to text to allow things like filter(x__contains=4)
@@ -402,7 +327,7 @@ def lookup_cast(lookup_type: str, internal_type: str | None = None) -> str:
         "regex",
         "iregex",
     ):
-        if internal_type == "GenericIPAddressField":
+        if isinstance(field, GenericIPAddressField):
             lookup = "HOST(%s)"
         else:
             lookup = "%s::text"
@@ -448,16 +373,6 @@ def prep_for_like_query(x: str) -> str:
     return str(x).replace("\\", "\\\\").replace("%", r"\%").replace("_", r"\_")
 
 
-def adapt_integerfield_value(
-    value: int | Any | None, internal_type: str
-) -> int | Any | None:
-    from plain.postgres.expressions import ResolvableExpression
-
-    if value is None or isinstance(value, ResolvableExpression):
-        return value
-    return INTEGERFIELD_TYPE_MAP[internal_type](value)
-
-
 def adapt_ipaddressfield_value(
     value: str | None,
 ) -> ipaddress.IPv4Address | ipaddress.IPv6Address | None:
@@ -531,14 +446,17 @@ def combine_expression(connector: str, sub_expressions: list[str]) -> str:
 
 
 def subtract_temporals(
-    internal_type: str,
+    field: Field,
     lhs: tuple[str, list[Any] | tuple[Any, ...]],
     rhs: tuple[str, list[Any] | tuple[Any, ...]],
 ) -> tuple[str, tuple[Any, ...]]:
+    from plain.postgres.fields import DateField, DateTimeField
+
     lhs_sql, lhs_params = lhs
     rhs_sql, rhs_params = rhs
     params = (*lhs_params, *rhs_params)
-    if internal_type == "DateField":
+    # DateField (but not DateTimeField) needs interval conversion
+    if isinstance(field, DateField) and not isinstance(field, DateTimeField):
         return f"(interval '1 day' * ({lhs_sql} - {rhs_sql}))", params
     # Use native temporal subtraction
     return f"({lhs_sql} - {rhs_sql})", params