Creating condition in loop & rust compiler move issue

[rsurkin]

Hi, I'm little bit new in Rust and Sea query,

I want to create an condition in loop, because I want to manipulate with some if statesment, and my code will be more convenient for reading

use sea_query::{Iden, PostgresQueryBuilder, Query, Expr, LogicalChainOper, Condition, Cond};
use sea_query_binder::SqlxBinder;
use serde::{Deserialize, Serialize};
use sqlx::{Error, FromRow, PgPool};

#[derive(Iden)]
pub enum MyTable {
    Table,
    Id,
    Version,
}

struct ValidatorParam {
    id: String,
    version: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
struct MyTableData {
    pub id: String,
    pub version: String,
}

pub async  fn query_db (pool: PgPool) -> Result<Option<MyTableData>, Error> {
    let mut select =  Query::select()
        .columns([
            MyTable::Id,
            MyTable::Version,
        ])
        .from(MyTable::Table)
        .to_owned();

    let params = vec![
        ValidatorParam{
            id: "1".to_string(),
            version: "1".to_string(),
        },
        ValidatorParam{
            id: "2".to_string(),
            version: "2".to_string(),
        },
    ];
    
    let mut where_condition = Condition::any();
    for ValidatorParam { id, version } in &params {
        // here I got an error Value used after being moved
        where_condition.add( // <---- here
            Cond::all()
                .add(Expr::col(MyTable::Id).eq(id))
                .add(Expr::col(MyTable::Version).eq(id))
        );
    }

    // select.cond_where(where_condition);

    let (sql, values) = select
        .build_sqlx(PostgresQueryBuilder);
    
    sqlx::query_as_with::<_, MyTableData, _>(&sql, values)
        .fetch_optional(&pool)
        .await
}

I'm little bit strugling with this, I could avoid this issue by using inside loop

select.and_or_where(
                LogicalChainOper::And(
                ... 

But I disslike, how my code, is looks. may be some bug inside Condtion, since, conditions vector is not explicitly declared as reference type.

P.S. AI sux

[Expurple]

Hi. Can you paste the full error message? This would help to identify exactly:

• which variable is being used twice
• what type it has
• where exactly is it being moved

If I were to guess, it looks like where_condition.add( consumes (moves) the condition (self) and returns the updated condition back, rather than modifies the condition by reference (&mut self). You need to assign the updated condition back to the variable: where_condition = where_condition.add(. Your original code would be OK if that method accepted &mut self.

Perhaps, AI could guide you too, if you pasted your full function and the full error message into the prompt

[rsurkin]

updated code in topic,
target variable is where_condition

and I don't have any idea, where it moved, since it's declared as mutable refernce,
it's used twice, due for loop,

I'm await behaviour like

fn main() {
    let mut numbers = Vec::new();  // mutable empty vector
    for i in 1..=10 {
        numbers.push(i);  // push each i into the vector
    }
    println!("The vector is: {:?}", numbers);
}

[rsurkin]

thanks, u are right, tricky,

differences between

ConditionalStatement::and_or_where that it returns -> &mut Self -> &mut Self

and Condition::add returns -> Self

may be it will be good thing to update library to api like ConditionalStatement

[Expurple]

differences between [..] that it returns

The more important difference here is in the parameter type (&mut self -> vs self ->), rather than the return type (-> &mut Self vs -> Self).

and I don't have any idea, where it moved

where_condition.add( moves where_condition, because add declares the first parameter as self. It means that the condition is moved into the method by value, when the method is called.

since it's declared as mutable refernce

No. let mut where_condition is a mutable variable, but it's not a mutable reference. It's not a reference, because it's type (Condition) is not a reference type (&something).

A mutable reference would be:

• either let where_condition: &mut Condition (an immutable variable that always references the same location that can't be changed, but the value at that location can be mutated)
• or let mut where_condition: &mut Condition (a mutable variable that could reference different locations at different times and can mutate the values at these locations).

[rsurkin]

// changes to make code working 
    let mut where_condition = Condition::any();
    for ValidatorParam { id, version } in &params  {
  
        where_condition = where_condition.add(
            Cond::all()
                .add(Expr::col(MyTable::Id).eq(id))
                .add(Expr::col(MyTable::Version).eq(id))
        );
    }

    select.cond_where(where_condition);