ferrum-orm 0.1.14__tar.gz → 0.1.16__tar.gz

{ferrum_orm-0.1.14 → ferrum_orm-0.1.16}/Cargo.lock

@@ -223,7 +223,7 @@ checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "ferrum-core"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "criterion",
  "proptest",
@@ -234,7 +234,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-migrate"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "ferrum-core",
  "serde",
@@ -243,7 +243,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-pyo3"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "ferrum-core",
  "ferrum-sql",
@@ -255,7 +255,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-sql"
-version = "0.1.14"
+version = "0.1.16"
 dependencies = [
  "criterion",
  "ferrum-core",

{ferrum_orm-0.1.14 → ferrum_orm-0.1.16}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/ferrum-core", "crates/ferrum-sql", "crates/ferrum-pyo3"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.14"
+version = "0.1.16"
 edition = "2021"
 authors = ["Ferrum Contributors"]
 license = "Apache-2.0"

{ferrum_orm-0.1.14 → ferrum_orm-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferrum-orm
-Version: 0.1.14
+Version: 0.1.16
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers

{ferrum_orm-0.1.14 → ferrum_orm-0.1.16}/crates/ferrum-sql/src/emit.rs

@@ -1219,6 +1219,11 @@ fn filter_clause(
 /// `UPDATE … FROM (VALUES …)` requires explicit casts so `PostgreSQL` can infer
 /// the correct column types when the VALUES clause contains multiple rows.
 /// The cast is appended to the placeholder, e.g. `$1::bigint`, `$2::text`.
+///
+/// The cast must be assignment-compatible with the DDL column type, and for PK
+/// columns it must match exactly: the join predicate `t.pk = v.pk` resolves an
+/// operator rather than an assignment cast, so a `uuid` column compared against
+/// a `text` VALUES column fails with `UndefinedFunction` (42883).
 fn postgres_value_cast(
     field_type: ferrum_core::ir::metadata::FieldType,
     placeholder: &str,
@@ -1226,8 +1231,11 @@ fn postgres_value_cast(
     use ferrum_core::ir::metadata::FieldType;
     let cast = match field_type {
         FieldType::Int | FieldType::BigInt => "bigint",
-        FieldType::Float | FieldType::Decimal => "double precision",
-        FieldType::Text | FieldType::Uuid | FieldType::TsVector | FieldType::Enum => "text",
+        FieldType::Float => "double precision",
+        FieldType::Decimal => "numeric",
+        FieldType::Text | FieldType::Enum => "text",
+        FieldType::Uuid => "uuid",
+        FieldType::TsVector => "tsvector",
         FieldType::Bool => "boolean",
         FieldType::Datetime => "timestamptz",
         FieldType::Date => "date",
@@ -1235,7 +1243,8 @@ fn postgres_value_cast(
         FieldType::Json => "jsonb",
         FieldType::Bytes => "bytea",
         FieldType::Vector => "vector",
-        FieldType::ArrayText | FieldType::ArrayUuid => "text[]",
+        FieldType::ArrayText => "text[]",
+        FieldType::ArrayUuid => "uuid[]",
         FieldType::ArrayInt => "bigint[]",
         FieldType::ArrayFloat => "double precision[]",
     };
@@ -2112,6 +2121,79 @@ mod tests {
         assert!(matches!(err, CompileError::MalformedIr { .. }));
     }
 
+    /// Every VALUES placeholder must carry the cast of its DDL column type.
+    /// A `uuid` PK cast to `text` made `t.id = v.id` resolve `uuid = text`,
+    /// which `PostgreSQL` rejects with `UndefinedFunction` (42883); `uuid[]` and
+    /// `tsvector` columns failed the SET assignment for the same reason.
+    #[test]
+    fn bulk_update_casts_match_column_types() {
+        let field = |name: &str, field_type: FieldType| FieldMeta {
+            name: name.into(),
+            column_name: name.into(),
+            field_type,
+            allowed_operators: vec!["eq".into()],
+            nullable: true,
+            vector_dimensions: None,
+            fts_config: None,
+            fts_source_columns: None,
+        };
+        let meta = ModelMetadata {
+            model_name: "Ticket".into(),
+            table_name: "tickets".into(),
+            fields: vec![
+                field("id", FieldType::Uuid),
+                field("tags", FieldType::ArrayUuid),
+                field("search", FieldType::TsVector),
+                field("amount", FieldType::Decimal),
+            ],
+            pk_index: 0,
+            pk_fields: vec![0],
+            full_text_indexes: vec![],
+        };
+        let field_ref = |name: &str, index: usize| FieldRef {
+            name: name.into(),
+            index,
+        };
+        let ir = QuerySetIR {
+            version: IR_VERSION,
+            model_name: "Ticket".into(),
+            operation: Operation::BulkUpdate {
+                pk_fields: vec![field_ref("id", 0)],
+                fields: vec![
+                    field_ref("tags", 1),
+                    field_ref("search", 2),
+                    field_ref("amount", 3),
+                ],
+                rows: vec![ferrum_core::ir::BulkUpdateRow {
+                    pk_values: vec![BindValue::Text(
+                        "00000000-0000-0000-0000-000000000001".into(),
+                    )],
+                    values: vec![
+                        BindValue::TextArray(vec![]),
+                        BindValue::Text("lexeme".into()),
+                        BindValue::Text("1.005".into()),
+                    ],
+                }],
+            },
+            filters: vec![],
+            order_by: vec![],
+            limit: None,
+            offset: None,
+            vector_order_by: None,
+            text_rank_by: None,
+            predicate: None,
+            distinct: false,
+            exists: false,
+            joins: vec![],
+            aggregation: None,
+        };
+        let q = emit_bulk_update(Dialect::Postgres, &meta, &ir).unwrap();
+        assert!(q.sql_text.contains("$1::uuid,"), "{}", q.sql_text);
+        assert!(q.sql_text.contains("$2::uuid[]"), "{}", q.sql_text);
+        assert!(q.sql_text.contains("$3::tsvector"), "{}", q.sql_text);
+        assert!(q.sql_text.contains("$4::numeric"), "{}", q.sql_text);
+    }
+
     // ── MessagePack wire-format round-trip ───────────────────────────────────
 
     /// IR + metadata `MessagePack`-encoded (NAMED) decode back into the same serde

{ferrum_orm-0.1.14 → ferrum_orm-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ferrum-orm"
-version = "0.1.14"
+version = "0.1.16"
 description = "Next-generation async ORM for Python with a Rust-powered core"
 license = { text = "Apache-2.0" }
 readme = "README.md"

{ferrum_orm-0.1.14 → ferrum_orm-0.1.16}/python/ferrum/__init__.py

@@ -6,7 +6,7 @@ Import paths are stable API; internal module paths are not.
 
 from __future__ import annotations
 
-__version__ = "0.1.14"
+__version__ = "0.1.16"
 __all__ = [
     "Aggregate",
     "CreateExtension",

{ferrum_orm-0.1.14 → ferrum_orm-0.1.16}/python/ferrum/drivers/postgres.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import contextlib
+import json
 from collections.abc import AsyncGenerator
 from typing import Any
 
@@ -11,6 +12,41 @@ from ferrum.drivers.streaming import AsyncpgChunkStream
 from ferrum.errors import FerrumConfigError, FerrumConnectionError, map_db_error
 
 
+def _encode_json_param(value: Any) -> str:
+    """Encode a Python value for asyncpg ``json`` / ``jsonb`` text codecs.
+
+    Ferrum's bind path already ``json.dumps`` JSON fields to text before the
+    driver (with SQL ``::jsonb`` casts). Accept pre-serialized strings so a
+    codec encoder never double-encodes those binds if a future path sends the
+    parameter as a native json/jsonb OID.
+    """
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, default=str, separators=(",", ":"))
+
+
+def _decode_json_param(value: str) -> Any:
+    """Decode asyncpg ``json`` / ``jsonb`` text into native Python objects."""
+    return json.loads(value)
+
+
+async def _register_json_codecs(conn: Any) -> None:
+    """Make JSONB/JSON columns hydrate as ``dict`` / ``list``, not ``str``.
+
+    asyncpg's default is to return ``json``/``jsonb`` as text. Without this,
+    ``model_construct`` leaves JSON fields as strings and Pydantic consumers
+    that expect ``dict`` fail at the agent/MCP boundary.
+    """
+    for type_name in ("jsonb", "json"):
+        await conn.set_type_codec(
+            type_name,
+            schema="pg_catalog",
+            encoder=_encode_json_param,
+            decoder=_decode_json_param,
+            format="text",
+        )
+
+
 class _BoundConnection:
     """Execution surface pinned to a single raw connection inside a transaction.
 
@@ -139,13 +175,15 @@ class AsyncpgDriver:
         }
         if self._max_lifetime is not None:
             pool_kwargs["max_inactive_connection_lifetime"] = self._max_lifetime
-        if self._statement_timeout_ms is not None:
-            timeout_ms = self._statement_timeout_ms
 
-            async def _init_conn(conn: Any) -> None:
-                await conn.execute(f"SET statement_timeout = {timeout_ms}")
+        statement_timeout_ms = self._statement_timeout_ms
+
+        async def _init_conn(conn: Any) -> None:
+            await _register_json_codecs(conn)
+            if statement_timeout_ms is not None:
+                await conn.execute(f"SET statement_timeout = {statement_timeout_ms}")
 
-            pool_kwargs["init"] = _init_conn
+        pool_kwargs["init"] = _init_conn
         try:
             self._pool = await asyncpg.create_pool(self._dsn, **pool_kwargs)
         except Exception as exc: