ferrum-orm 0.1.15__tar.gz → 0.1.17__tar.gz

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/Cargo.lock

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

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/Cargo.toml

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

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/PKG-INFO

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

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/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.15 → ferrum_orm-0.1.17}/pyproject.toml

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

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/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.15"
+__version__ = "0.1.17"
 __all__ = [
     "Aggregate",
     "CreateExtension",

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/python/ferrum/drivers/postgres.py

@@ -159,6 +159,7 @@ class AsyncpgDriver:
         self._statement_timeout_ms = statement_timeout_ms
         self._max_lifetime = max_lifetime
         self._pool: Any = None
+        self._extra_codecs: list[dict[str, Any]] = []
 
     async def open(self) -> None:
         try:
@@ -177,9 +178,12 @@ class AsyncpgDriver:
             pool_kwargs["max_inactive_connection_lifetime"] = self._max_lifetime
 
         statement_timeout_ms = self._statement_timeout_ms
+        extra_codecs = self._extra_codecs
 
         async def _init_conn(conn: Any) -> None:
             await _register_json_codecs(conn)
+            for codec in extra_codecs:
+                await conn.set_type_codec(**codec)
             if statement_timeout_ms is not None:
                 await conn.execute(f"SET statement_timeout = {statement_timeout_ms}")
 
@@ -193,6 +197,39 @@ class AsyncpgDriver:
                 f"{type(exc).__name__} [FERR-E101]"
             ) from None
 
+    async def add_type_codec(
+        self,
+        type_name: str,
+        *,
+        schema: str,
+        encoder: Any,
+        decoder: Any,
+        format: str = "text",
+    ) -> None:
+        """Register an asyncpg type codec on every connection in the pool.
+
+        asyncpg exposes ``set_type_codec`` on a connection, not on a pool, so
+        registering directly against one acquired connection only covers that
+        connection — every other pooled connection keeps the default codec and
+        the same query succeeds or fails depending on which one it lands on.
+        Recording the codec here applies it from the pool ``init`` hook, and
+        expiring the pool forces already-initialized connections to be replaced
+        so the registration is uniform.
+        """
+        if any(c["typename"] == type_name and c["schema"] == schema for c in self._extra_codecs):
+            return
+        self._extra_codecs.append(
+            {
+                "typename": type_name,
+                "schema": schema,
+                "encoder": encoder,
+                "decoder": decoder,
+                "format": format,
+            }
+        )
+        if self._pool is not None:
+            await self._pool.expire_connections()
+
     async def close(self) -> None:
         if self._pool is not None:
             await self._pool.close()

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/python/ferrum/ext/pgvector.py

@@ -61,40 +61,43 @@ async def register_vector_codecs(
 ) -> None:
     """Ensure the ``vector`` extension exists and register asyncpg codecs.
 
+    The codec is installed pool-wide (every current and future connection), so
+    ``vector`` columns decode to ``list[float]`` no matter which pooled
+    connection serves a query.
+
+    Writing a vector does not require this call: Ferrum binds vector values as
+    pgvector text literals, which asyncpg accepts without a codec.
+
     Idempotent: safe to call multiple times and from concurrent startup paths.
-    ``DuplicateObjectError`` from the extension-creation step and codec
-    re-registration on an already-configured pool are both handled gracefully.
+    ``DuplicateObjectError`` from the extension-creation step and repeat
+    registration of the same codec are both handled gracefully.
 
     Args:
         conn: An open Ferrum ``Connection``.
-        timeout: Statement timeout (seconds) for the ``CREATE EXTENSION`` DDL.
+        timeout: Timeout (seconds) for the ``CREATE EXTENSION`` DDL.
             Defaults to 5 s.  Set to ``0`` to disable the timeout guard.
 
     Raises:
-        FerrumConfigError: If the connection is not a PostgreSQL connection or
-            the pool is not open.
+        FerrumConfigError: If the connection is not a PostgreSQL connection, the
+            pool is not open, or the driver is not the asyncpg driver.
     """
     if conn.dialect != "postgres":
         raise FerrumConfigError(
             "pgvector integration requires a PostgreSQL connection. [FERR-C001]"
         )
-    driver = conn._require_driver()
+    driver = conn._driver
     pool = getattr(driver, "_pool", None)
-    # TimedQueryExecutor wraps the real driver; fall back to its _inner attribute.
-    if pool is None:
-        inner = getattr(driver, "_inner", None)
-        pool = getattr(inner, "_pool", None) if inner is not None else None
-    if pool is None:
+    if driver is None or pool is None:
         raise FerrumConfigError("PostgreSQL pool is not open. [FERR-C001]")
 
     # CREATE EXTENSION — idempotent via IF NOT EXISTS; the DuplicateObjectError
     # guard covers rare race conditions where two concurrent startup paths both
     # attempt the DDL at the same moment.
     try:
-        create_sql = "CREATE EXTENSION IF NOT EXISTS vector"
-        if timeout > 0:
-            create_sql = f"SET LOCAL statement_timeout = {int(timeout * 1000)}; {create_sql}"
-        await pool.execute("CREATE EXTENSION IF NOT EXISTS vector")
+        await pool.execute(
+            "CREATE EXTENSION IF NOT EXISTS vector",
+            timeout=timeout if timeout > 0 else None,
+        )
     except Exception as exc:
         # asyncpg raises DuplicateObjectError (SQLSTATE 42710) if another
         # concurrent caller committed the extension between our IF NOT EXISTS
@@ -103,37 +106,21 @@ async def register_vector_codecs(
         if "DuplicateObject" not in exc_name:
             raise
 
-    # Codec registration — asyncpg raises InvalidStateError if the same custom
-    # type is registered twice on the same pool.  Treat it as idempotent.
-    try:
-        set_pool_codec = getattr(pool, "set_type_codec", None)
-        if set_pool_codec is not None:
-            await set_pool_codec(
-                "vector",
-                schema="public",
-                encoder=_encode_vector,
-                decoder=_decode_vector,
-                format="text",
-            )
-        else:
-            # asyncpg exposes codecs on Connection, not Pool. Ferrum's normal
-            # vector query path casts bound text to ``vector`` and projects the
-            # vector column out, so registering the currently acquired
-            # connection is sufficient for callers that explicitly hydrate a
-            # vector immediately after startup without making pool startup fail.
-            async with pool.acquire() as raw_conn:
-                await raw_conn.set_type_codec(
-                    "vector",
-                    schema="public",
-                    encoder=_encode_vector,
-                    decoder=_decode_vector,
-                    format="text",
-                )
-    except Exception as exc:
-        exc_name = type(exc).__name__
-        if exc_name not in ("InvalidStateError", "AlreadyInitializedError"):
-            # Re-raise unknown errors; swallow the known re-registration ones.
-            raise
+    # Registering through the driver applies the codec from the pool's ``init``
+    # hook, so every connection — including ones the pool opens later — decodes
+    # ``vector`` columns to ``list[float]``. Registering against a single
+    # acquired connection instead made vector reads depend on which pooled
+    # connection served the query.
+    add_codec = getattr(driver, "add_type_codec", None)
+    if add_codec is None:
+        raise FerrumConfigError("pgvector integration requires the asyncpg driver. [FERR-C001]")
+    await add_codec(
+        "vector",
+        schema="public",
+        encoder=_encode_vector,
+        decoder=_decode_vector,
+        format="text",
+    )
 
 
 async def vector_search(

{ferrum_orm-0.1.15 → ferrum_orm-0.1.17}/python/ferrum/queryset.py

@@ -215,8 +215,16 @@ def _encode_bind_value(value: object) -> dict[str, object]:
 
 def _prepare_field_value(field: Any, value: object) -> object:  # noqa: ANN401
     """Normalize a Python value for the field's database representation."""
-    if value is not None and field.field_type == "json":
+    if value is None:
+        return value
+    if field.field_type == "json":
         return json.dumps(value, default=str, separators=(",", ":"))
+    if field.field_type == "vector" and isinstance(value, (list, tuple)):
+        # asyncpg has no built-in codec for the pgvector ``vector`` type and
+        # falls back to text, so a bound ``list[float]`` raises DataError
+        # ("expected str, got list"). Bind the pgvector text literal instead —
+        # the same encoding ``nearest_to()`` uses on the read path.
+        return _encode_vector_literal([float(v) for v in cast(list[Any], value)])
     return value