rust-ef 1.8.0

Rust Entity Framework - An EFCore-inspired ORM for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

//! Cascade save: drain children from principal HasMany navigations, FK fixup
//! after principal PK backfill, and M2M join-row insertion via direct SQL.
//!
//! See `cascade-save-plan.md` for the full design. Key types:
//! - [`DrainedChild`]: a child entity extracted from a principal's HasMany,
//!   with parent linkage metadata.
//! - [`FixupLink`]: records the parent→child association for post-INSERT FK
//!   fixup (one-to-many) or join-row insertion (M2M).

use crate::metadata::{NavigationKind, NavigationMeta};
use crate::relations::DeleteBehavior;
use std::any::{Any, TypeId};

/// A child entity drained from a principal's HasMany navigation, with the
/// metadata needed to fixup its FK after the principal's PK is backfilled.
pub struct DrainedChild {
    /// The principal entity's TypeId (e.g. `Blog`).
    pub parent_type_id: TypeId,
    /// Index of the principal entry in its DbSet (for PK lookup after INSERT).
    pub parent_entry_idx: usize,
    /// The drained child entity, type-erased.
    pub child: Box<dyn Any + Send + Sync>,
    /// The child entity's TypeId (e.g. `Post`).
    pub child_type_id: TypeId,
    /// The FK target type for `set_foreign_key` (the principal type).
    pub fk_target_type_id: TypeId,
    /// M2M only: the join table name. `None` for one-to-many.
    pub through_table: Option<String>,
    /// M2M only: FK column on the join table pointing to the principal.
    pub through_parent_fk_col: Option<String>,
    /// M2M only: FK column on the join table pointing to the child.
    pub through_child_fk_col: Option<String>,
}

/// Records a parent→child association for post-INSERT FK fixup.
///
/// For one-to-many: after the principal is inserted and its PK backfilled,
/// each child's FK field is set to the principal's PK via `set_foreign_key`.
///
/// For M2M: after both principal and child are inserted and their PKs
/// backfilled, a join-table row is inserted via direct SQL.
pub struct FixupLink {
    pub parent_type_id: TypeId,
    pub parent_entry_idx: usize,
    pub child_type_id: TypeId,
    pub child_entry_indices: Vec<usize>,
    pub fk_target_type_id: TypeId,
    /// M2M only: the join table name. `None` for one-to-many.
    pub through_table: Option<String>,
    pub through_parent_fk_col: Option<String>,
    pub through_child_fk_col: Option<String>,
}

/// Generates a batched `INSERT INTO through_table (parent_col, child_col)
/// VALUES (?, ?), (?, ?), ...` statement for M2M join rows.
pub fn m2m_insert_sql(table: &str, parent_col: &str, child_col: &str, row_count: usize) -> String {
    let placeholders: Vec<String> = (0..row_count).map(|_| "(?, ?)".to_string()).collect();
    format!(
        "INSERT INTO {} ({}, {}) VALUES {}",
        table,
        parent_col,
        child_col,
        placeholders.join(", ")
    )
}

// ---------------------------------------------------------------------------
// Cascade delete types
// ---------------------------------------------------------------------------

/// The action to take for untracked dependents when a principal is deleted.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CascadeDeleteAction {
    /// `DELETE FROM child_table WHERE fk = ?`
    Delete,
    /// `UPDATE child_table SET fk = NULL WHERE fk = ?`
    SetNull,
}

/// A directive to delete or nullify untracked dependents of a Deleted
/// principal. Generated during the cascade delete drain loop and executed
/// as direct SQL at the start of the DELETE phase, before PK-based deletes.
pub struct CascadeDeleteDirective {
    /// The table to act on (child table for HasMany, join table for M2M).
    pub table: String,
    /// The FK column to filter on.
    pub fk_column: String,
    /// The principal's PK value.
    pub principal_pk: i64,
    /// The action to perform.
    pub action: CascadeDeleteAction,
}

// ---------------------------------------------------------------------------
// Delete behavior resolution
// ---------------------------------------------------------------------------

/// Resolves the effective `DeleteBehavior` for a navigation, applying
/// EFCore-style defaults when `delete_behavior` is `None`:
/// - ManyToMany → Cascade (join rows are always pruned)
/// - required FK (non-nullable type, e.g. `i32`) → Cascade
/// - optional FK (nullable type, e.g. `Option<i32>`) → Restrict
pub fn resolve_delete_behavior(nav: &NavigationMeta) -> DeleteBehavior {
    if let Some(b) = nav.delete_behavior {
        return b;
    }
    if nav.kind == NavigationKind::ManyToMany {
        return DeleteBehavior::Cascade;
    }
    if let Some(meta_fn) = nav.related_entity_meta {
        let child_meta = meta_fn();
        if let Some(fk_prop) = child_meta.properties.iter().find(|p| p.is_foreign_key) {
            let is_nullable = fk_prop.type_name.contains("Option");
            return if is_nullable {
                DeleteBehavior::Restrict
            } else {
                DeleteBehavior::Cascade
            };
        }
    }
    DeleteBehavior::Cascade
}