Method add_many

src/query/insert.rs:173–238

Add many Models to Self

(mut self, models: I)

    /// Add many Models to Self
    pub fn add_many<M, I>(mut self, models: I) -> Self
    where
        M: IntoActiveModel<A>,
        I: IntoIterator<Item = M>,
    {
        let mut columns: Vec<_> = <A::Entity as EntityTrait>::Column::iter()
            .map(|_| None)
            .collect();
        let mut null_value: Vec<Option<Value>> =
            std::iter::repeat(None).take(columns.len()).collect();
        let mut all_values: Vec<Vec<SimpleExpr>> = Vec::new();

        for model in models.into_iter() {
            let mut am: A = model.into_active_model();
            self.primary_key =
                if !<<A::Entity as EntityTrait>::PrimaryKey as PrimaryKeyTrait>::auto_increment() {
                    am.get_primary_key_value()
                } else {
                    None
                };
            let mut values = Vec::with_capacity(columns.len());
            for (idx, col) in <A::Entity as EntityTrait>::Column::iter().enumerate() {
                let av = am.take(col);
                match av {
                    ActiveValue::Set(value) | ActiveValue::Unchanged(value) => {
                        columns[idx] = Some(col); // mark the column as used
                        null_value[idx] = Some(value.as_null()); // store the null value with the correct type
                        values.push(col.save_as(Expr::val(value))); // same as add() above
                    }
                    ActiveValue::NotSet => {
                        values.push(SimpleExpr::Keyword(Keyword::Null)); // indicate a missing value
                    }
                }
            }
            all_values.push(values);
        }

        if !all_values.is_empty() {
            // filter only used column
            self.query.columns(columns.iter().cloned().flatten());

            // flag used column
            self.columns = columns.iter().map(Option::is_some).collect();
        }

        for values in all_values {
            // since we've aligned the column set, this never panics
            self.query
                .values_panic(values.into_iter().enumerate().filter_map(|(i, v)| {
                    if columns[i].is_some() {
                        // only if the column is used
                        if !matches!(v, SimpleExpr::Keyword(Keyword::Null)) {
                            // use the value expression
                            Some(v)
                        } else {
                            // use null as standin, which must be Some
                            null_value[i].clone().map(SimpleExpr::Value)
                        }