ActiveValue 与 ActiveModel

#[derive(Clone, Debug)]
pub enum ActiveValue<V>
where
    V: Into<Value>,
{
    Set(V),
    Unchanged(V),
    NotSet,
}

    pub fn set_ne(&mut self, value: V)
    where
        V: PartialEq,
    {
        match self {
            ActiveValue::Unchanged(current) if &value == current => {}
            _ => *self = ActiveValue::Set(value),
        }
    }

    pub fn reset(&mut self) {
        *self = match self.take() {
            Some(value) => ActiveValue::Set(value),
            None => ActiveValue::NotSet,
        };
    }

let mut a: ActiveValue<i32> = Unchanged(3);
a.set_ne(3);
println!("Unchanged(3).set_ne(3)  -> {a:?}");
// ... 其余每行同样的写法
let m = item::Model { id: 1, sku: "a1".into(), name: "apple".into(), qty: 3, note: None };
let mut am = m.clone().into_active_model();
println!("into_active_model       -> {am:?}");
println!("is_changed              -> {}", am.is_changed());
am.name.set_ne("apple".to_owned());
println!("after set_ne(same)      -> is_changed {}", am.is_changed());
am.name = Set("apple".to_owned());
println!("after Set(same)         -> is_changed {}", am.is_changed());
let am = m.into_active_model().reset_all();
println!("reset_all               -> {am:?}");
println!("Default                 -> {:?}", <item::ActiveModel as Default>::default());

Unchanged(3).set_ne(3)  -> Unchanged(3)
Unchanged(3).set_ne(4)  -> Set(4)
Set(3).set_ne(3)        -> Set(3)
NotSet.set_ne(3)        -> Set(3)
Unchanged(3).reset()    -> Set(3)
NotSet.reset()          -> NotSet
Set(3).take()           -> Some(3), left NotSet
Unchanged(3).into_value -> Some(Int(Some(3)))
Set(3) == Unchanged(3)  -> false
into_active_model       -> ActiveModel { id: Unchanged(1), sku: Unchanged("a1"), name: Unchanged("apple"), qty: Unchanged(3), note: Unchanged(None) }
is_changed              -> false
after set_ne(same)      -> is_changed false
after Set(same)         -> is_changed true
reset_all               -> ActiveModel { id: Set(1), sku: Set("a1"), name: Set("apple"), qty: Set(3), note: Set(None) }
Default                 -> ActiveModel { id: NotSet, sku: NotSet, name: NotSet, qty: NotSet, note: NotSet }

            fn get(&self, c: <Self::Entity as sea_orm::EntityTrait>::Column) -> sea_orm::ActiveValue<sea_orm::Value> {
                match c {
                    #(<Self::Entity as sea_orm::EntityTrait>::Column::#names => self.#fields.clone().into_wrapped_value(),)*
                    _ => sea_orm::ActiveValue::NotSet,
                }
            }
            // ...
            fn try_set(&mut self, c: <Self::Entity as sea_orm::EntityTrait>::Column, v: sea_orm::Value) -> Result<(), sea_orm::DbErr> {
                match c {
                    #(<Self::Entity as sea_orm::EntityTrait>::Column::#names => self.#fields = sea_orm::ActiveValue::Set(sea_orm::sea_query::ValueType::try_from(v).map_err(|e| sea_orm::DbErr::Type(e.to_string()))?),)*
                    _ => return Err(sea_orm::DbErr::Type(format!("ActiveModel does not have this field: {:?}", sea_orm::ColumnTrait::as_column_ref(&c)))),
                }
                Ok(())
            }

get(Qty)                -> Unchanged(Int(Some(3)))
set(Qty, 4)             -> Set(4)
try_set(Qty, "x")       -> Err(Type("Value type mismatch"))
not_set(Note)           -> NotSet

error[E0034]: multiple applicable items in scope
  --> src/bin/av_states.rs:44:66
   |
44 |   println!("Default                 -> {:?}", item::ActiveModel::default());
   |                                                                  ^^^^^^^ multiple `default` found
   |
   = note: candidate #1 is defined in an impl of the trait `ActiveModelTrait` for the type `ActiveModel`
   = note: candidate #2 is defined in an impl of the trait `std::default::Default` for the type `ActiveModel`

        let dummy_am = Self::default_values();
        let len = <<Self::Entity as EntityTrait>::Column>::iter().len();
        // Mark down which attribute exists in the JSON object
        let mut json_keys = Vec::with_capacity(len);
        let mut merged = serde_json::Map::with_capacity(len);

        for col in <<Self::Entity as EntityTrait>::Column>::iter() {
            let key = col.json_key();
            let has_key = input.contains_key(key);
            json_keys.push((col, has_key));
            match dummy_am.get(col) {
                ActiveValue::Unchanged(value) | ActiveValue::Set(value) => {
                    merged.insert(key.to_owned(), sea_query::sea_value_to_json_value(&value));
                }
                _ => {}
            }
        }

        merged.append(&mut input);
        // ...
        let model: <Self::Entity as EntityTrait>::Model =
            serde_json::from_value(json_value).map_err(json_err)?;
        let mut am = model.into_active_model();

        // Transform attribute that exists in JSON object into ActiveValue::Set, otherwise ActiveValue::NotSet
        for (col, json_key_exists) in json_keys {
            match (json_key_exists, am.get(col)) {
                (true, ActiveValue::Set(value) | ActiveValue::Unchanged(value)) => {
                    am.set(col, value);
                }
                _ => {
                    am.not_set(col);
                }
            }
        }

for j in [
  json!({"name": "pear"}),
  json!({"id": 9, "sku": "p9", "name": "pear", "qty": 1, "note": null}),
  json!({"note": null}),
  json!({"qty": null}),
  json!({"qty": "many"}),
  json!(["not", "an", "object"]),
] {
  match item::ActiveModel::from_json(j.clone()) {
    Ok(am) => println!("from_json {j} -> {am:?}"),
    Err(e) => println!("from_json {j} -> Err {e:?} / {e}"),
  }
}

from_json {"name":"pear"} -> ActiveModel { id: NotSet, sku: NotSet, name: Set("pear"), qty: NotSet, note: NotSet }
from_json {"id":9,"name":"pear","note":null,"qty":1,"sku":"p9"} -> ActiveModel { id: Set(9), sku: Set("p9"), name: Set("pear"), qty: Set(1), note: Set(None) }
from_json {"note":null} -> ActiveModel { id: NotSet, sku: NotSet, name: NotSet, qty: NotSet, note: Set(None) }
from_json {"qty":null} -> Err Json("invalid type: null, expected i32") / Json Error: invalid type: null, expected i32
from_json {"qty":"many"} -> Err Json("invalid type: string \"many\", expected i32") / Json Error: invalid type: string "many", expected i32
from_json ["not","an","object"] -> Err Json("invalid type: expected JSON object for item") / Json Error: invalid type: expected JSON object for item

puzzle: Set("apple"), is_changed true