select

Selects all records in a table, or a specific record, from the database.

Method Syntax

db.select(resource)

Arguments

Argument	Description
`resource`	The table name or a record ID to select.

Example usage

// Select all records from a table
let people: Vec<Person> = db.select("person").await?;
// Select a specific record from a table
let person: Option<Person> = db.select(("person",
    "h5wxrf2ewk8xjxosxtyc")).await?;

The type on the left decides what each record is converted into. To accept records of any shape without a struct, use Value, which keeps every SurrealDB type, or serde_json::Value, which turns record IDs into strings. The page on flexible typing shows these and other ways to work without a struct.

use surrealdb::types::Value;

let people: Vec<Value> = db.select("person").await?;

Example usage: Retrieve unique id of a record

use surrealdb::Surreal;
use surrealdb::engine::remote::ws::Ws;
use surrealdb::opt::auth::Root;
use surrealdb::types::{RecordId, SurrealValue};

#[derive(Debug, SurrealValue)]
struct Person {
    id: RecordId,
    name: String,
    age: u8,
}

#[tokio::main]
async fn main() -> surrealdb::Result<()> {
    // Connect to the database
    let db = Surreal::new::<Ws>("localhost:8000").await?;

    // Sign in
    db.signin(Root {
        username: "root".to_string(),
        password: "secret".to_string(),
    })
    .await?;

    // Select namespace and database to use
    db.use_ns("main").use_db("main").await?;

    // Create a person
    db.query("CREATE person:john SET name = 'John Doe', age = 25")
        .await?
        .check()?;

    // Query that person
    let john: Option<Person> = db.select(("person", "john")).await?;
    dbg!(john);

    Ok(())
}

Example usage: collect records into a map keyed by ID

RecordId implements Hash and Eq, so the records that .select() returns can be collected into a HashMap keyed by their IDs:

use std::collections::HashMap;
use surrealdb::types::RecordId;

let people: Vec<Person> = db.select("person").await?;
let by_id: HashMap<RecordId, Person> = people
    .into_iter()
    .map(|person| (person.id.clone(), person))
    .collect();

let john = by_id.get(&RecordId::new("person", "john"));

To key the map by the record key alone, use person.id.key.clone(), a RecordIdKey, in place of the whole ID.

Restrict records with `.range()`

When selecting all records in a table (not a single record id), you can restrict results to a record-id range by chaining .range(...). The argument implements Into<RecordIdKeyRange>: strings and tuples such as "a"..="z" or (Bound::Included(x), Bound::Excluded(y)) express inclusive or exclusive bounds on the table’s record keys.

use surrealdb::{
    engine::any::connect,
    opt::Resource,
    types::{ToSql, Value},
};

#[tokio::main]
async fn main() {
    let db = connect("memory").await.unwrap();
    db.use_ns("ns").use_db("db").await.unwrap();

    db.query("CREATE person:alucard, person:plato, person:vlad")
        .await
        .unwrap();

    let res = db
        .select::<Value>(Resource::from("person"))
        .range("n"..="z")
        .await
        .unwrap()
        .to_sql();
    println!("{res:?}");
}

Translated query

This function will run the following query in the database:

SELECT * FROM $resource;