oracle_nosql_rust_sdk/
list_tables_request.rs

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
//
// Copyright (c) 2024, 2025 Oracle and/or its affiliates. All rights reserved.
//
// Licensed under the Universal Permissive License v 1.0 as shown at
//  https://oss.oracle.com/licenses/upl/
//
use crate::error::NoSQLError;
use crate::handle::Handle;
use crate::handle::SendOptions;
use crate::nson::*;
use crate::reader::Reader;
use crate::types::OpCode;
use crate::writer::Writer;
use std::result::Result;
use std::time::Duration;

/// Struct used for listing tables in the NoSQL Database.
#[derive(Default, Debug)]
pub struct ListTablesRequest {
    pub(crate) compartment_id: String,
    pub(crate) namespace: String,
    pub(crate) start_index: i32,
    pub(crate) limit: i32,
    pub(crate) timeout: Option<Duration>,
    // TODO: tags?
}

/// Struct representing the result of a [`ListTablesRequest`] operation.
#[derive(Default, Debug)]
pub struct ListTablesResult {
    pub table_names: Vec<String>,
    pub last_table_index: i32,
}

impl ListTablesRequest {
    pub fn new() -> ListTablesRequest {
        ListTablesRequest {
            ..Default::default()
        }
    }

    /// Specify the timeout value for the request.
    ///
    /// This is optional.
    /// If set, it must be greater than or equal to 1 millisecond, otherwise an
    /// IllegalArgument error will be returned.
    /// If not set, the default timeout value configured for the [`Handle`](crate::HandleBuilder::timeout()) is used.
    pub fn timeout(mut self, t: &Duration) -> Self {
        self.timeout = Some(t.clone());
        self
    }

    /// Cloud Service only: set the name or id of a compartment to be used for this operation.
    ///
    /// The compartment may be specified as either a name (or path for nested compartments) or as an id (OCID).
    /// A name (vs id) can only be used when authenticated using a specific user identity. It is not available if
    /// the associated handle authenticated as an Instance Principal (which can be done when calling the service from
    /// a compute instance in the Oracle Cloud Infrastructure: see [`HandleBuilder::cloud_auth_from_instance()`](crate::HandleBuilder::cloud_auth_from_instance()).)
    ///
    /// If no compartment is given, the root compartment of the tenancy will be used.
    pub fn compartment_id(mut self, compartment_id: &str) -> Self {
        self.compartment_id = compartment_id.to_string();
        self
    }

    pub fn namespace(mut self, namespace: &str) -> ListTablesRequest {
        self.namespace = namespace.to_string();
        self
    }

    pub fn limit(mut self, limit: i32) -> ListTablesRequest {
        self.limit = limit;
        self
    }

    pub fn start_index(mut self, start_index: i32) -> ListTablesRequest {
        self.start_index = start_index;
        self
    }

    pub async fn execute(&self, h: &Handle) -> Result<ListTablesResult, NoSQLError> {
        let mut w: Writer = Writer::new();
        w.write_i16(h.inner.serial_version);
        let timeout = h.get_timeout(&self.timeout);
        self.nson_serialize(&mut w, &timeout);
        let mut opts = SendOptions {
            timeout: timeout,
            retryable: true,
            compartment_id: self.compartment_id.clone(),
            ..Default::default()
        };
        let mut r = h.send_and_receive(w, &mut opts).await?;
        let resp = ListTablesRequest::nson_deserialize(&mut r)?;
        Ok(resp)
    }

    pub(crate) fn nson_serialize(&self, w: &mut Writer, timeout: &Duration) {
        let mut ns = NsonSerializer::start_request(w);
        ns.start_header();
        ns.write_header(OpCode::ListTables, timeout, "");
        ns.end_header();

        // payload
        ns.start_payload();
        ns.write_nonempty_string_field(NAMESPACE, &self.namespace);
        ns.write_nonzero_i32_field(LIST_START_INDEX, self.start_index);
        ns.write_nonzero_i32_field(LIST_MAX_TO_READ, self.limit);
        // TODO: this is currently only in http headers. Add to NSON?
        //ns.write_string_field(COMPARTMENT_OCID, &self.compartment_id);
        ns.end_payload();

        ns.end_request();
    }

    pub(crate) fn nson_deserialize(r: &mut Reader) -> Result<ListTablesResult, NoSQLError> {
        let mut walker = MapWalker::new(r)?;
        let mut res: ListTablesResult = Default::default();
        while walker.has_next() {
            walker.next()?;
            let name = walker.current_name();
            match name.as_str() {
                ERROR_CODE => {
                    walker.handle_error_code()?;
                }
                TABLES => {
                    res.table_names = walker.read_nson_string_array()?;
                    //println!(" table_names={:?}", res.table_names);
                }
                LAST_INDEX => {
                    res.last_table_index = walker.read_nson_i32()?;
                    //println!(" last_index={:?}", res.last_table_index);
                }
                _ => {
                    //println!("   list_tables_result: skipping field '{}'", name);
                    walker.skip_nson_field()?;
                }
            }
        }
        Ok(res)
    }
}

impl NsonRequest for ListTablesRequest {
    fn serialize(&self, w: &mut Writer, timeout: &Duration) {
        self.nson_serialize(w, timeout);
    }
}