Does agdb support nested queries?

[Raj2032]

Does agdb support nested queries, for example:

struct Person
{
    name: Name,
    age: u32,
}
struct Name
{
    first: String,
    last: String,
}

fn main()
{
    let name = Person{Name: {first: "john", last: "Doe"}, age: 69};
}

where I want to query the person's first and last name?

[michaelvlach]

Hi, yes, this is possible in three ways. I would recommend the first but the others are worth considering as well:

1. Flattened nested struct:

#[derive(DbType)]
struct Name {
    first: String,
    last: String,
}

#[derive(DbElement)]
struct Person {
    #[agdb(flatten)]
    name: Name,
    age: u64,
}

This will create an element with keys: first, last, age. If you want the Name's field to be renamed then do:

#[derive(DbType)]
struct Name {
    #[agdb(rename = "first_name")]
    first: String,
    #[agdb(rename = "last_name")]
    last: String,
}

Then when searching you use those fields as normal, e.g.

QueryBuilder::select().element::<Person>() .search().from(1).where_().key("last_name").value("Doe").query();

2. Name as derived binary value:

#[derive(Clone, DbValue, DbSerialize)]
struct Name {
    first: String,
    last: String,
}

#[derive(DbElement)]
struct Person {
    name: Name,
    age: u64,
}

This will create a single value by serializing the Name into the binary representation. The search might still work bu the binary representations is <len><first><len><last> in bytes, not UTF-8 and the matching might be surprising in some cases. Nevertheless still possible:

QueryBuilder::select().element::<Person>() .search().from(1).where_().key("name").value(Comparison::Contains("Doe".as_bytes().into())).query();

3. Custom serialization of name:

The issue with the binary value is that it might not be as nice for non-ASCII names or interact well with conditions such as StartsWith (because it starts with the length value). You could manually implement the From/TryFrom for DbValue, e.g.

impl From<Name> for DbValue {
        fn from(name: Name) -> Self {
            format!("{} {}", name2.first, name2.last).into()
        }
    }

    impl TryFrom<DbValue> for Name {
        type Error = DbError;

        fn try_from(value: DbValue) -> Result<Self, Self::Error> {
            let value_str = value.string()?;
            let parts: Vec<&str> = value_str.split_whitespace().collect();
            if parts.len() != 2 {
                return Err(DbError::serialization(
                    agdb::DbErrorType::NotEnoughData,
                    "Invalid format for Name. Expected 'first last'.",
                ));
            }
            Ok(Name {
                first: parts[0].to_string(),
                last: parts[1].to_string(),
            })
        }
    }

This will create a single field "name" and in it will be concatenated "first last". That will allow you to search with Comparison::contains (or StartsWith, EndsWith) e.g.

QueryBuilder::select().element::<Person>() .search().from(1).where_().key("name").value(Comparison::Contains("Doe".into())).query();

[Raj2032]

Hi mate thanks for your help.

It seems like option 2 is the best for my usecase but a couple of questions:

1. Based on what you have provided, it looks like it might search for both first name and last name for the name "Doe"?
2. It looks kinda like a non-native way of doing nested queries am I correct?

[michaelvlach]

I would really recommend option 1 as that is the most straightforward. You would then choose one or both of first_name / last_name to search in. The concatenated variant is only really useful if you want to search for any substring of the concatenated string (first or last name) but even then that would typically by case insensitive which is not natively supported.

I will hazard a guess that you actually want to store Person with distinct first name and last name but also want to full string case insensitive search for the "name". That would in fact best be modelled using an extra field, e.g. name_search where you would concatenate first and last name case insensitive and then search with Comparison::Contains() against that.

[Raj2032]

Hi @michaelvlach thanks for your response. I will keep this in mind and will very likely stick with option 1. Just one last thing I was wondering if you had something similar to how native_db does it? If not all good I will keep in mind what you have suggested.