How to accept any value from a SELECT statement (using Rust SDK)?

[szabgab]

Something along the line:

let res: Vec<surrealdb::sql::Value> = db.select("user").await?;`

This one gives me an error:

Failed to convert  ... to `T`: invalid value: map, expected map with a single key

serde_json has a Value type for this to be used when deserializng from JSON without defining a struct to accept the data.

Full example

use serde::{Deserialize, Serialize};
use surrealdb::engine::local::Mem;
use surrealdb::engine::local::Db;
use surrealdb::sql::Thing;
use surrealdb::Surreal;


#[derive(Debug, Serialize, Deserialize)]
struct Message {
    text: String,
}

#[derive(Debug, Deserialize)]
struct Record {
    #[allow(dead_code)]
    id: Thing,
}

#[tokio::main]
async fn main() -> surrealdb::Result<()> {
    let db = Surreal::new::<Mem>(()).await?;

    db.use_ns("demo").use_db("insert-select-in-memory").await?;

    create_a_new_message_with_random_id(&db, "Hello World").await?;
    create_a_new_message_with_random_id(&db, "Another message").await?;

    select_all_the_messages(&db).await?;
    select_everyting(&db).await?;

    Ok(())
}

async fn select_all_the_messages(db: &Surreal<Db>) -> surrealdb::Result<()> {
    let mut response = db.query("SELECT * from messages").await?;
    let messages: Vec<Message> = response.take(0)?;
    for message in &messages {
        println!("{}", message.text);
    }


    Ok(())
}


async fn select_everyting(db: &Surreal<Db>) -> surrealdb::Result<()> {

    let mut response = db.query("SELECT * from messages").await?;
    let messages: Vec<surrealdb::sql::Value> = response.take(0)?;
    for message in &messages {
        println!("{}", message);
    }


    Ok(())
}

async fn create_a_new_message_with_random_id(
    db: &Surreal<Db>,
    message: &str,
) -> surrealdb::Result<()> {
    let created: Vec<Record> = db
        .create("messages")
        .content(Message {
            text: message.to_owned(),
        })
        .await?;
    println!("{created:?}");

    Ok(())
}

Result:

[Record { id: Thing { tb: "messages", id: String("sm9m7hya3gwm5dtm3rfm") } }]
[Record { id: Thing { tb: "messages", id: String("zav6jt8mwc6ax7wnv3rf") } }]
Hello World
Another message
Error: Api(FromValue { value: Array(Array([Object(Object({"id": Thing(Thing { tb: "messages", id: String("sm9m7hya3gwm5dtm3rfm") }), "text": Strand(Strand("Hello World"))})), Object(Object({"id": Thing(Thing { tb: "messages", id: String("zav6jt8mwc6ax7wnv3rf") }), "text": Strand(Strand("Another message"))}))])), error: "invalid value: map, expected map with a single key" })

How could I make the select_everyting work without using the Message struct?

[rushmorem]

This

let res: Vec<surrealdb::sql::Value> = db.select("user").await?;

simply needs to be

let res = db.select(Resource::from("user")).await?;

In v1 res will be surrealdb::sql::Value, in v2 it will be surrealdb::Value (the sql module is undocumented in v2).

serde_json has a Value type for this to be used when deserializng from JSON without defining a struct to accept the data.

Yes, surrealdb::Value is similar to that.

You can do a similar thing for raw queries as well.

let value: Value = result.take(0)?;

so select_everything should look like this

async fn select_everyting(db: &Surreal<Db>) -> surrealdb::Result<()> {
    let mut response = db.query("SELECT * from messages").await?;
    let messages: Value = response.take(0)?;
    println!("{messages}");
    Ok(())
}