ferrum-orm 0.1.9__tar.gz → 0.1.11__tar.gz

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/Cargo.lock

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

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/Cargo.toml

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

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/PKG-INFO

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

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/crates/ferrum-core/src/compile/mod.rs

@@ -18,7 +18,7 @@
 use crate::{
     error::CompileError,
     ir::{
-        metadata::FieldType, BindValue, ModelMetadata, Operation, Predicate, QuerySetIR,
+        metadata::FieldType, BindValue, JoinSpec, ModelMetadata, Operation, Predicate, QuerySetIR,
         SortDirection, IR_VERSION,
     },
 };
@@ -127,16 +127,18 @@ pub fn compile(metadata: &ModelMetadata, ir: &QuerySetIR) -> Result<CompiledQuer
         Operation::BulkDelete { pk_fields, ids } => validate_bulk_delete(metadata, pk_fields, ids)?,
     }
 
+    // Joins first so filter ``join_alias`` references can be checked against them.
+    validate_joins(metadata, ir)?;
+
     // Validate all field references in filters before touching SQL.
     for filter in &ir.filters {
-        validate_filter(metadata, filter)?;
+        validate_filter(metadata, filter, &ir.joins)?;
     }
 
     if let Some(predicate) = &ir.predicate {
-        validate_predicate(metadata, predicate)?;
+        validate_predicate(metadata, predicate, &ir.joins)?;
     }
 
-    validate_joins(metadata, ir)?;
     validate_order_by(metadata, ir)?;
     validate_vector_order_by(metadata, ir)?;
     validate_text_search(metadata, ir)?;
@@ -319,14 +321,15 @@ fn validate_vector_order_by(metadata: &ModelMetadata, ir: &QuerySetIR) -> Result
             operator: "nearest_to".into(),
         });
     }
-    // Accept both float_array (canonical vector type) and int_array (integer
-    // dims encoded by _encode_bind_value when the caller passes a list[int]).
+    // Prefer text (pgvector literal ``[f,f,...]`` + SQL ``::vector`` cast) so
+    // asyncpg does not bind ``list[float]`` as ``float[]`` (DataError). Still
+    // accept float_array / int_array for backwards-compatible IR producers.
     if !matches!(
         vector_order.value,
-        BindValue::FloatArray(_) | BindValue::IntArray(_)
+        BindValue::Text(_) | BindValue::FloatArray(_) | BindValue::IntArray(_)
     ) {
         return Err(CompileError::MalformedIr {
-            reason: "vector_order_by.value must be float_array or int_array".into(),
+            reason: "vector_order_by.value must be text, float_array, or int_array".into(),
         });
     }
     Ok(())
@@ -466,6 +469,11 @@ fn validate_predicate_fts(
         Predicate::Not { child } => validate_predicate_fts(metadata, child)?,
         Predicate::Filter { filter } => {
             if FTS_OPERATORS.contains(&filter.operator.as_str()) {
+                if filter.join_alias.is_some() {
+                    return Err(CompileError::MalformedIr {
+                        reason: "full-text operators are not supported on relation lookups".into(),
+                    });
+                }
                 validate_fts_filter(metadata, filter)?;
             }
         }
@@ -482,7 +490,36 @@ pub fn ir_has_where_clause(ir: &QuerySetIR) -> bool {
 fn validate_filter(
     metadata: &ModelMetadata,
     filter: &crate::ir::Filter,
+    joins: &[JoinSpec],
 ) -> Result<(), CompileError> {
+    if let Some(alias) = &filter.join_alias {
+        let join =
+            joins
+                .iter()
+                .find(|j| j.alias == *alias)
+                .ok_or_else(|| CompileError::MalformedIr {
+                    reason: format!("filter join_alias {alias:?} has no matching join"),
+                })?;
+        let remote = join
+            .remote_fields
+            .iter()
+            .find(|f| f.name == filter.field.name || f.index == filter.field.index)
+            .ok_or_else(|| CompileError::UnknownField {
+                model: metadata.model_name.clone(),
+                field: format!("{alias}__{}", filter.field.name),
+            })?;
+        if !remote.allowed_operators.is_empty()
+            && !remote.allowed_operators.contains(&filter.operator)
+        {
+            return Err(CompileError::UnsupportedOperator {
+                model: metadata.model_name.clone(),
+                field: format!("{alias}__{}", filter.field.name),
+                operator: filter.operator.clone(),
+            });
+        }
+        return Ok(());
+    }
+
     let field_meta =
         metadata
             .fields
@@ -502,15 +539,19 @@ fn validate_filter(
     Ok(())
 }
 
-fn validate_predicate(metadata: &ModelMetadata, predicate: &Predicate) -> Result<(), CompileError> {
+fn validate_predicate(
+    metadata: &ModelMetadata,
+    predicate: &Predicate,
+    joins: &[JoinSpec],
+) -> Result<(), CompileError> {
     match predicate {
         Predicate::And { children } | Predicate::Or { children } => {
             for child in children {
-                validate_predicate(metadata, child)?;
+                validate_predicate(metadata, child, joins)?;
             }
         }
-        Predicate::Not { child } => validate_predicate(metadata, child)?,
-        Predicate::Filter { filter } => validate_filter(metadata, filter)?,
+        Predicate::Not { child } => validate_predicate(metadata, child, joins)?,
+        Predicate::Filter { filter } => validate_filter(metadata, filter, joins)?,
     }
     Ok(())
 }
@@ -604,6 +645,7 @@ mod tests {
             },
             operator: "eq".into(),
             value: BindValue::Int(1),
+            join_alias: None,
         });
         let err = compile(&meta, &ir).unwrap_err();
         assert!(matches!(err, CompileError::UnknownField { .. }));
@@ -634,6 +676,7 @@ mod tests {
             },
             operator: "regex".into(), // not in allowed_operators
             value: BindValue::Int(1),
+            join_alias: None,
         });
         let err = compile(&meta, &ir).unwrap_err();
         assert!(matches!(err, CompileError::UnsupportedOperator { .. }));
@@ -679,6 +722,7 @@ mod tests {
             },
             operator: "match".into(),
             value: BindValue::Text("hello".into()),
+            join_alias: None,
         });
         let err = compile(&meta, &ir).unwrap_err();
         assert!(matches!(err, CompileError::UnsupportedOperator { .. }));
@@ -723,6 +767,7 @@ mod tests {
             },
             operator: "match_phrase".into(),
             value: BindValue::Text("hello world".into()),
+            join_alias: None,
         });
         ir.text_rank_by = Some(crate::ir::TextRankBy {
             field: FieldRef {
@@ -746,6 +791,7 @@ mod tests {
             },
             operator: "eq".into(),
             value: BindValue::Text("test@example.com".into()),
+            join_alias: None,
         });
         ir.order_by.push(OrderBy {
             field: FieldRef {

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/crates/ferrum-core/src/ir/mod.rs

@@ -67,9 +67,20 @@ pub struct QuerySetIR {
     pub joins: Vec<JoinSpec>,
 }
 
-/// JOIN metadata for ``select_related`` (`PostgreSQL` LEFT JOIN).
+/// JOIN kind for ``select_related`` (LEFT) vs relation-filter (INNER) joins.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum JoinKind {
+    /// ``LEFT JOIN`` — used by ``select_related()`` (preserve parent rows).
+    #[default]
+    Left,
+    /// ``INNER JOIN`` — used by relation-filter lookups (``team__slug=...``).
+    Inner,
+}
+
+/// JOIN metadata for ``select_related`` and relation-filter lookups.
 ///
-/// The emitter produces `LEFT JOIN <remote_table> AS <alias> ON <base_table>.<local_col> = <alias>.<remote_pk_column>`.
+/// The emitter produces `<JOIN KIND> <remote_table> AS <alias> ON <base_table>.<local_col> = <alias>.<remote_pk_column>`.
 /// All identifier fields are validated on the Python side before this struct is serialized into the IR.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct JoinSpec {
@@ -83,13 +94,25 @@ pub struct JoinSpec {
     pub remote_table: String,
     /// Remote table PK column name (from model metadata).
     pub remote_pk_column: String,
-    /// Columns to project from the remote table into `<alias>__<column>` aliases.
+    /// Columns available on the joined table (for SELECT projection and/or filter allowlisting).
     pub remote_fields: Vec<JoinFieldRef>,
+    /// ``left`` (default) or ``inner``.
+    #[serde(default)]
+    pub join_kind: JoinKind,
+    /// When ``true`` (default), project ``remote_fields`` into ``alias__col`` SELECT aliases.
+    /// Filter-only joins set this ``false`` so hydration is not polluted.
+    #[serde(default = "default_true")]
+    pub project_remote: bool,
+}
+
+fn default_true() -> bool {
+    true
 }
 
 /// A field reference into a joined (remote) model's metadata.
 ///
-/// Projected as `<alias>.<column> AS "<alias>__<column>"` in the SELECT list.
+/// When ``JoinSpec::project_remote`` is true, projected as
+/// `<alias>.<column> AS "<alias>__<column>"` in the SELECT list.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct JoinFieldRef {
     /// Index into the remote model's `ModelMetadata::fields`.
@@ -98,6 +121,9 @@ pub struct JoinFieldRef {
     pub name: String,
     /// Database column name of the remote field.
     pub column: String,
+    /// Operator allowlist copied from the remote field's ``FieldMeta`` (SQL-2).
+    #[serde(default)]
+    pub allowed_operators: Vec<String>,
 }
 
 /// The SQL operation this IR node represents.
@@ -149,10 +175,6 @@ pub enum Operation {
     },
 }
 
-fn default_true() -> bool {
-    true
-}
-
 /// One row payload for :variant:`Operation::BulkUpdate`.
 /// ``pk_values`` has one entry per PK field (single entry for single-PK models).
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -173,17 +195,26 @@ pub struct FieldRef {
 
 /// A filter predicate (one leaf of the WHERE clause).
 ///
-/// `operator` must be in `FieldMeta::allowed_operators` for `field`; the compiler
-/// rejects any string not in that allowlist before SQL is produced (SQL-1).
+/// `operator` must be in `FieldMeta::allowed_operators` for `field` (base model)
+/// or in the matching ``JoinFieldRef::allowed_operators`` when ``join_alias`` is
+/// set. The compiler rejects any string not in that allowlist before SQL is
+/// produced (SQL-1 / SQL-2).
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Filter {
     /// The model field being filtered.
+    ///
+    /// When ``join_alias`` is set, ``index``/``name`` refer to the **remote**
+    /// model's field (matched against ``JoinSpec::remote_fields``).
     pub field: FieldRef,
     /// Ferrum operator string, e.g. `"eq"`, `"gt"`, `"icontains"`, `"is_null"`.
-    /// Validated against `FieldMeta::allowed_operators` before SQL emission.
+    /// Validated against the field's operator allowlist before SQL emission.
     pub operator: String,
     /// Bound value for the filter — never interpolated into SQL text.
     pub value: BindValue,
+    /// When set, the filter targets a column on the JOIN with this alias
+    /// (Django-style ``relation__field`` lookups). ``None`` = base table.
+    #[serde(default)]
+    pub join_alias: Option<String>,
 }
 
 /// Composable boolean predicate tree (``Q`` objects on the Python side).

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/crates/ferrum-sql/benches/compile.rs

@@ -91,6 +91,7 @@ fn bench_select_ir() -> QuerySetIR {
                 },
                 operator: "eq".into(),
                 value: BindValue::Bool(true),
+                join_alias: None,
             },
             Filter {
                 field: FieldRef {
@@ -99,6 +100,7 @@ fn bench_select_ir() -> QuerySetIR {
                 },
                 operator: "icontains".into(),
                 value: BindValue::Text("example.com".into()),
+                join_alias: None,
             },
         ],
         order_by: vec![

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/crates/ferrum-sql/src/emit.rs

@@ -15,7 +15,10 @@ use crate::fts;
 use ferrum_core::{
     compile::CompiledQuery,
     error::CompileError,
-    ir::{BindValue, ModelMetadata, Predicate, QuerySetIR, SortDirection, VectorMetric},
+    ir::{
+        BindValue, Filter, JoinKind, JoinSpec, ModelMetadata, Predicate, QuerySetIR, SortDirection,
+        VectorMetric,
+    },
 };
 use std::fmt::Write as _;
 
@@ -59,6 +62,9 @@ pub fn emit_select(
     };
 
     for join in &ir.joins {
+        if !join.project_remote {
+            continue;
+        }
         let alias = dialect.quote_ident(&join.alias);
         for rf in &join.remote_fields {
             let col = dialect.quote_ident(&rf.column);
@@ -85,6 +91,7 @@ pub fn emit_select(
 
     if ir.exists {
         let mut inner = format!("SELECT 1 FROM {table}");
+        append_joins(dialect, metadata, ir, &table, &mut inner);
         if let Some(where_clause) = where_sql {
             write!(inner, " WHERE {where_clause}").expect("write to String is infallible");
         }
@@ -110,17 +117,7 @@ pub fn emit_select(
 
     let distinct_kw = if ir.distinct { "DISTINCT " } else { "" };
     let mut sql = format!("SELECT {distinct_kw}{fields} FROM {table}");
-    for join in &ir.joins {
-        let alias = dialect.quote_ident(&join.alias);
-        let remote_table = dialect.quote_ident(&join.remote_table);
-        let local_col = dialect.quote_ident(&metadata.fields[join.local_field.index].column_name);
-        let remote_pk = dialect.quote_ident(&join.remote_pk_column);
-        write!(
-            sql,
-            " LEFT JOIN {remote_table} AS {alias} ON {table}.{local_col} = {alias}.{remote_pk}"
-        )
-        .expect("write to String is infallible");
-    }
+    append_joins(dialect, metadata, ir, &table, &mut sql);
     if let Some(where_clause) = where_sql {
         write!(sql, " WHERE {where_clause}").expect("write to String is infallible");
     }
@@ -656,30 +653,12 @@ fn append_order_limit_offset(
     bound_params: &mut Vec<BindValue>,
     param_type_summary: &mut Vec<String>,
 ) -> Result<(), CompileError> {
-    if !ir.order_by.is_empty() {
-        let mut order_parts: Vec<String> = Vec::new();
-        for o in &ir.order_by {
-            let col = qualify_base_column(
-                dialect,
-                table,
-                &metadata.fields[o.field.index].column_name,
-                qualify_columns,
-            );
-            let dir = match o.direction {
-                SortDirection::Asc => "ASC",
-                SortDirection::Desc => "DESC",
-                SortDirection::Unknown => {
-                    return Err(CompileError::InvalidSortDirection {
-                        model: metadata.model_name.clone(),
-                        field: o.field.name.clone(),
-                        direction: "unknown".into(),
-                    })
-                }
-            };
-            order_parts.push(format!("{col} {dir}"));
-        }
-        write!(sql, " ORDER BY {}", order_parts.join(", ")).expect("write to String is infallible");
-    } else if let Some(vector_order) = &ir.vector_order_by {
+    // KNN / FTS ranking are primary ORDER BY keys; plain ``order_by()`` columns
+    // are secondary (tie-breakers). Previously an explicit ``order_by`` silently
+    // dropped ``vector_order_by`` / ``text_rank_by``.
+    let mut order_parts: Vec<String> = Vec::new();
+
+    if let Some(vector_order) = &ir.vector_order_by {
         let col = qualify_base_column(
             dialect,
             table,
@@ -688,7 +667,15 @@ fn append_order_limit_offset(
         );
         let op = vector_metric_to_sql(vector_order.metric);
         let placeholder = dialect.placeholder(bound_params.len() + 1);
-        write!(sql, " ORDER BY {col} {op} {placeholder}").expect("write to String is infallible");
+        // pgvector distance ops require a ``vector`` typed RHS. Binding a
+        // Python ``list[float]`` as ``float[]`` raises DataError; the IR carries
+        // a text literal ``'[f,f,...]'`` and we cast ``$N::vector`` on Postgres.
+        let rhs = if dialect == Dialect::Postgres {
+            format!("{placeholder}::vector")
+        } else {
+            placeholder
+        };
+        order_parts.push(format!("{col} {op} {rhs}"));
         param_type_summary.push(format!("{}:nearest_to", vector_order.field.name));
         bound_params.push(vector_order.value.clone());
     } else if let Some(text_rank) = &ir.text_rank_by {
@@ -710,11 +697,36 @@ fn append_order_limit_offset(
             table_name,
             bound_params.len() + 1,
         );
-        write!(sql, " ORDER BY {rank_sql}").expect("write to String is infallible");
+        order_parts.push(rank_sql);
         param_type_summary.push(format!("{}:text_rank", text_rank.field.name));
         bound_params.push(text_rank.query.clone());
     }
 
+    for o in &ir.order_by {
+        let col = qualify_base_column(
+            dialect,
+            table,
+            &metadata.fields[o.field.index].column_name,
+            qualify_columns,
+        );
+        let dir = match o.direction {
+            SortDirection::Asc => "ASC",
+            SortDirection::Desc => "DESC",
+            SortDirection::Unknown => {
+                return Err(CompileError::InvalidSortDirection {
+                    model: metadata.model_name.clone(),
+                    field: o.field.name.clone(),
+                    direction: "unknown".into(),
+                })
+            }
+        };
+        order_parts.push(format!("{col} {dir}"));
+    }
+
+    if !order_parts.is_empty() {
+        write!(sql, " ORDER BY {}", order_parts.join(", ")).expect("write to String is infallible");
+    }
+
     if dialect == Dialect::Mssql {
         // T-SQL pagination: OFFSET … ROWS [FETCH NEXT … ROWS ONLY]. The OFFSET/FETCH
         // clause requires an ORDER BY; inject a stable no-op order when none exists.
@@ -762,6 +774,67 @@ fn append_order_limit_offset(
 /// Returns `None` when there are no constraints (caller omits the `WHERE` keyword).
 /// All column references come from metadata allowlists; all values travel as
 /// bound parameters (SQL-1 + SQL-2).
+fn append_joins(
+    dialect: Dialect,
+    metadata: &ModelMetadata,
+    ir: &QuerySetIR,
+    table: &str,
+    sql: &mut String,
+) {
+    for join in &ir.joins {
+        let join_kw = match join.join_kind {
+            JoinKind::Left => "LEFT JOIN",
+            JoinKind::Inner => "INNER JOIN",
+        };
+        let alias = dialect.quote_ident(&join.alias);
+        let remote_table = dialect.quote_ident(&join.remote_table);
+        let local_col = dialect.quote_ident(&metadata.fields[join.local_field.index].column_name);
+        let remote_pk = dialect.quote_ident(&join.remote_pk_column);
+        write!(
+            sql,
+            " {join_kw} {remote_table} AS {alias} ON {table}.{local_col} = {alias}.{remote_pk}"
+        )
+        .expect("write to String is infallible");
+    }
+}
+
+fn resolve_filter_column(
+    dialect: Dialect,
+    metadata: &ModelMetadata,
+    filter: &Filter,
+    joins: &[JoinSpec],
+    table: &str,
+    qualify_columns: bool,
+) -> Result<String, CompileError> {
+    if let Some(alias) = &filter.join_alias {
+        let join =
+            joins
+                .iter()
+                .find(|j| j.alias == *alias)
+                .ok_or_else(|| CompileError::MalformedIr {
+                    reason: format!("filter join_alias {alias:?} has no matching join"),
+                })?;
+        let remote = join
+            .remote_fields
+            .iter()
+            .find(|f| f.name == filter.field.name || f.index == filter.field.index)
+            .ok_or_else(|| CompileError::UnknownField {
+                model: metadata.model_name.clone(),
+                field: format!("{alias}__{}", filter.field.name),
+            })?;
+        let alias_q = dialect.quote_ident(&join.alias);
+        let col_q = dialect.quote_ident(&remote.column);
+        Ok(format!("{alias_q}.{col_q}"))
+    } else {
+        Ok(qualify_base_column(
+            dialect,
+            table,
+            &metadata.fields[filter.field.index].column_name,
+            qualify_columns,
+        ))
+    }
+}
+
 fn build_where_sql(
     dialect: Dialect,
     metadata: &ModelMetadata,
@@ -774,12 +847,8 @@ fn build_where_sql(
     let mut parts: Vec<String> = Vec::new();
 
     for filter in &ir.filters {
-        let col = qualify_base_column(
-            dialect,
-            table,
-            &metadata.fields[filter.field.index].column_name,
-            qualify_columns,
-        );
+        let col =
+            resolve_filter_column(dialect, metadata, filter, &ir.joins, table, qualify_columns)?;
         let (clause, param) = filter_clause(
             dialect,
             metadata,
@@ -801,6 +870,7 @@ fn build_where_sql(
             dialect,
             metadata,
             predicate,
+            &ir.joins,
             table,
             qualify_columns,
             bound_params,
@@ -822,10 +892,12 @@ fn build_where_sql(
 /// `And`/`Or` wrap their children in parentheses to preserve grouping semantics
 /// regardless of SQL operator precedence. `Not` wraps its child in `NOT (…)`.
 /// Leaf `Filter` nodes delegate to `filter_clause`.
+#[allow(clippy::too_many_arguments)]
 fn emit_predicate(
     dialect: Dialect,
     metadata: &ModelMetadata,
     predicate: &Predicate,
+    joins: &[JoinSpec],
     table: &str,
     qualify_columns: bool,
     bound_params: &mut Vec<BindValue>,
@@ -840,6 +912,7 @@ fn emit_predicate(
                         dialect,
                         metadata,
                         child,
+                        joins,
                         table,
                         qualify_columns,
                         bound_params,
@@ -857,6 +930,7 @@ fn emit_predicate(
                         dialect,
                         metadata,
                         child,
+                        joins,
                         table,
                         qualify_columns,
                         bound_params,
@@ -872,6 +946,7 @@ fn emit_predicate(
                 dialect,
                 metadata,
                 child,
+                joins,
                 table,
                 qualify_columns,
                 bound_params,
@@ -879,12 +954,8 @@ fn emit_predicate(
             )?
         )),
         Predicate::Filter { filter } => {
-            let col = qualify_base_column(
-                dialect,
-                table,
-                &metadata.fields[filter.field.index].column_name,
-                qualify_columns,
-            );
+            let col =
+                resolve_filter_column(dialect, metadata, filter, joins, table, qualify_columns)?;
             let (clause, param) = filter_clause(
                 dialect,
                 metadata,
@@ -1105,6 +1176,7 @@ mod tests {
             },
             operator: "eq".into(),
             value: BindValue::Text("x@example.com".into()),
+            join_alias: None,
         });
         let q = emit_select(Dialect::Postgres, &meta, &ir).unwrap();
         // Bound value must NOT appear in SQL text (SQL-2).
@@ -1184,6 +1256,7 @@ mod tests {
             },
             operator: "icontains".into(), // not allowed for Int field
             value: BindValue::Int(42),
+            join_alias: None,
         });
         let err = emit_select(Dialect::Postgres, &meta, &ir).unwrap_err();
         assert!(matches!(err, CompileError::UnsupportedOperator { .. }));
@@ -1234,6 +1307,7 @@ mod tests {
             },
             operator: "eq".into(),
             value: BindValue::Text("user@example.com".into()),
+            join_alias: None,
         });
         ir.limit = Some(20);
 
@@ -1483,6 +1557,7 @@ mod tests {
                 },
                 operator: "eq".into(),
                 value: BindValue::Int(42),
+                join_alias: None,
             }],
         );
         let q = emit_update(Dialect::Postgres, &meta, &ir).unwrap();
@@ -1539,6 +1614,7 @@ mod tests {
             },
             operator: "eq".into(),
             value: BindValue::Int(7),
+            join_alias: None,
         }]);
         let q = emit_delete(Dialect::Postgres, &meta, &ir).unwrap();
         // Filter value must not appear in sql_text.
@@ -1577,6 +1653,7 @@ mod tests {
             },
             operator: "eq".into(),
             value: BindValue::Text("x@example.com".into()),
+            join_alias: None,
         });
         let q = emit_select(Dialect::Mssql, &meta, &ir).unwrap();
         assert!(q.sql_text.contains("[users]"), "bracket-quoted table");
@@ -1682,6 +1759,7 @@ mod tests {
                 },
                 operator: "eq".into(),
                 value: BindValue::Int(42),
+                join_alias: None,
             }],
         );
         let q = emit_update(Dialect::Mssql, &meta, &ir).unwrap();
@@ -1748,6 +1826,7 @@ mod tests {
             },
             operator: "eq".into(),
             value: BindValue::Text("a@example.com".into()),
+            join_alias: None,
         });
         ir.limit = Some(5);
 

{ferrum_orm-0.1.9 → ferrum_orm-0.1.11}/pyproject.toml

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