ydb 0.13.1

Crate contains generated low-level grpc code from YDB API protobuf, used as base for ydb crate
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use std::time::Duration;
use tokio::time::timeout;
use ydb::{ydb_params, ydb_struct, ClientBuilder, Query, Value, YdbError, YdbResult};

#[tokio::main]
async fn main() -> YdbResult<()> {
    let client = ClientBuilder::new_from_connection_string("grpc://localhost:2136?database=local")?
        .client()?;

    if let Ok(res) = timeout(Duration::from_secs(3), client.wait()).await {
        res?
    } else {
        return Err(YdbError::from("Connection timeout"));
    };

    let table_client = client.table_client();
    let table_name = "test";

    let _ = table_client
        .retry_execute_scheme_query(format!("DROP TABLE {table_name}"))
        .await; // ignore drop error

    // create table
    table_client
        .retry_execute_scheme_query(format!(
            "CREATE TABLE {table_name} (id Int64 NOT NULL, val Utf8, PRIMARY KEY(id))"
        ))
        .await?;

    // Create vec of structs, there values will insert to table
    let rows = vec![
        ydb_struct!(
            "id" => 1_i64,
            "val" => Value::Text("test1".into()),
        ),
        ydb_struct!(
            "id" => 2_i64,
            "val" => Value::Text("test2".into()),
        ),
        ydb_struct!(
            "id" => 3_i64,
            "val" => Value::Text("test3".into())),
    ];

    // example value will use only for type description
    let example = ydb_struct!(
        "id" => 1_i64,
        "val" => "test",
    );

    let list = Value::list_from(example, rows)?;

    let query = Query::new(
        "DECLARE $list AS List<Struct<
id: Int64,
val: Utf8,
>>;

UPSERT INTO test
SELECT * FROM AS_TABLE($list)
",
    )
    .with_params(ydb_params!("$list" => list));

    table_client
        .retry_transaction(|t| async {
            let mut t = t;
            t.query(query.clone()).await?;
            t.commit().await?;
            Ok(())
        })
        .await?;

    let keys = vec![
        ydb_struct!("id" => 1i64),
        ydb_struct!("id" => 3i64),
        ydb_struct!("id" => 42i64),
    ];

    let result_set = table_client
        .retry_read_rows(format!("/local/{table_name}"), keys, None)
        .await?;

    let mut rows = result_set.rows();

    let row_to_val = |mut row: ydb::Row| -> YdbResult<(i64, String)> {
        let id: Option<i64> = row.remove_field_by_name("id")?.try_into()?;
        let val: Option<String> = row.remove_field_by_name("val")?.try_into()?;

        Ok((id.unwrap(), val.unwrap()))
    };

    assert_eq!(
        row_to_val(rows.next().unwrap()).unwrap(),
        (1i64, "test1".to_string())
    );

    assert_eq!(
        row_to_val(rows.next().unwrap()).unwrap(),
        (3i64, "test3".to_string())
    );

    assert!(rows.next().is_none());

    println!("OK");

    Ok(())
}