Attribute Macro insert_query 

#[insert_query]

Create an insert edgeDB query

Usage

    use edgedb_query::{ToEdgeQuery, EdgeQuery};
    use edgedb_query::queries::conflict::{UnlessConflictElse, Conflict};
    use edgedb_query_derive::{
            insert_query,
            select_query,
            query_result,
            edgedb_enum
    };

    #[insert_query(module ="users", table="User", result="UserResult")]
    pub struct InsertUser {
        #[field(param="first_name")]
        pub name: String,
        pub surname: Option<String>,
        pub age: i32,
        pub major: bool,
        pub vs: Vec<String>,
        #[field(scalar = "<users::Gender>")]
        pub gender: Sex,
        #[nested_query]
        pub wallet: Wallet,
        #[unless_conflict(on="username, surname")]
        pub find_user: UnlessConflictElse<FindUser>
    }

    #[edgedb_enum]
    pub enum Sex {
        #[value("male")]
        Male,
        #[value("female")]
        _Female,
    }

    #[insert_query(module = "users", table = "Wallet")]
    pub struct Wallet {
        pub money: i16,
    }

    #[select_query(module = "users", table = "User")]
    pub struct FindUser {
        #[filter(operator="Is")]
        #[field(column_name="name")]
        pub user_name: String
    }

    #[query_result]
    pub struct UserResult {
        pub id: uuid::Uuid,
        pub name: String,
    }

    async fn main() {
        let insert_user = InsertUser {
            name: "Joe".to_string(),
            surname: Some("Henri".to_string()),
            age: 35,
            major: true,
            vs: vec!["vs1".to_string()],
            gender: Sex::Male,
            wallet: Wallet {
                money: 0,
            },
            find_user: UnlessConflictElse {
                else_query: FindUser{
                    user_name: "Joe".to_string(),
                },
            }
        };

        let query  = insert_user.to_edge_query();

        let client = edgedb_tokio::create_client().await.unwrap();

        let user: UserResult = client
                    .query_single::<UserResult, _>(query.query.as_str(), &query.args.unwrap())
                    .await
                    .unwrap();

    }