Arc and Mutex for SQL Expression parameters

I have now converted OwnedExpression to use Expressive protocol and started to think about "LazyExpression".

It's not really an expression that's lazy - it is a parameter to the expression that is lazy.

So I ditched LazyExpression entirely, and instead implemented support for Arc and Arc

https://github.com/romaninsh/vantage/pull/61

Before, a parameter to Expression engine could be either a value or a nested expression.

Now, a parameter to Expression can also be Arc or Mutex holding a value or a nested expression.

In other words a query builder (which is mutable) can now be used inside another query. Of course we can still defer things too, which does give us a lot of flexibility:

Suppose you have a custom struct:

struct GreetingQuery { name: String, } 

a struct would generate a custom query with current name if it is part of a template:

impl From<&GreetingQuery> for OwnedExpression { fn from(greeting: &GreetingQuery) -> OwnedExpression { expr!("Hello {}", greeting.name.clone()) } } impl From<GreetingQuery> for IntoExpressive<OwnedExpression> { fn from(greeting: GreetingQuery) -> Self { IntoExpressive::nested(OwnedExpression::from(&greeting)) } } 

Lets construct our struct:

let greeting = Arc::new(Mutex::new(GreetingQuery { name: "world".to_string(), })); 

this can now be cloned and shared all throughout the app. Some expressions may rely on it:

let expr = expr!("select {}", &greeting); 

now every time expression is executed it will acquire a value from a mutex:

let result1 = db.execute(&expr).await; // select hello "world" { let mut guard = greeting.lock().unwrap(); guard.name = "vantage".to_string(); } let result2 = db.execute(&expr).await; // select helo "vantage"