tdsql 0.4.1

Ergonomic async Microsoft SQL Server client for Rust, with typed rows and multi-result-set support
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
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

//! Multiple result sets, in the order the server returned them.

use std::ops::Index;
use std::sync::Arc;

use crate::row::{Column, Row};

/// One result set: its columns and its rows.
#[derive(Debug, Clone, PartialEq)]
pub struct DataTable {
    name: String,
    columns: Arc<[Column]>,
    rows: Vec<Row>,
}

impl DataTable {
    /// Construct a table from its name and shared column metadata.
    pub fn new(name: impl Into<String>, columns: Arc<[Column]>) -> Self {
        Self {
            name: name.into(),
            columns,
            rows: Vec::new(),
        }
    }

    /// The name of this result set (`table0`, `table1`, ... by position).
    pub fn name(&self) -> &str {
        &self.name
    }

    /// The columns of this result set.
    pub fn columns(&self) -> &[Column] {
        &self.columns
    }

    /// The rows, in the order the server returned them.
    pub fn rows(&self) -> &[Row] {
        &self.rows
    }

    /// The number of rows.
    pub fn len(&self) -> usize {
        self.rows.len()
    }

    /// Whether this result set has no rows.
    pub fn is_empty(&self) -> bool {
        self.rows.is_empty()
    }

    /// Take ownership of the rows.
    pub fn into_rows(self) -> Vec<Row> {
        self.rows
    }

    pub(crate) fn push(&mut self, row: Row) {
        self.rows.push(row);
    }
}

impl Index<usize> for DataTable {
    type Output = Row;

    fn index(&self, index: usize) -> &Self::Output {
        &self.rows[index]
    }
}

/// Every result set produced by one command, in order.
///
/// Most queries return a single result set, in which case
/// [`Client::query`](crate::Client::query) hands back `Vec<Row>` directly and
/// you never need this type. Reach for `DataSet` when a batch or stored
/// procedure genuinely produces more than one.
#[derive(Debug, Clone, PartialEq, Default)]
pub struct DataSet {
    tables: Vec<DataTable>,
}

impl DataSet {
    /// An empty set.
    pub fn new() -> Self {
        Self::default()
    }

    /// The result sets, in server order.
    pub fn tables(&self) -> &[DataTable] {
        &self.tables
    }

    /// The result set at `index`, if present.
    pub fn table(&self, index: usize) -> Option<&DataTable> {
        self.tables.get(index)
    }

    /// The result set with this name, if present.
    pub fn table_named(&self, name: &str) -> Option<&DataTable> {
        self.tables.iter().find(|t| t.name() == name)
    }

    /// The number of result sets.
    pub fn len(&self) -> usize {
        self.tables.len()
    }

    /// Whether there are no result sets.
    pub fn is_empty(&self) -> bool {
        self.tables.is_empty()
    }

    /// Take the rows of the first result set, discarding any others.
    pub fn into_rows(self) -> Vec<Row> {
        self.tables
            .into_iter()
            .next()
            .map(DataTable::into_rows)
            .unwrap_or_default()
    }

    /// Take ownership of every result set.
    pub fn into_tables(self) -> Vec<DataTable> {
        self.tables
    }

    pub(crate) fn push(&mut self, table: DataTable) {
        self.tables.push(table);
    }
}

impl Index<usize> for DataSet {
    type Output = DataTable;

    fn index(&self, index: usize) -> &Self::Output {
        &self.tables[index]
    }
}

#[cfg(test)]
mod tests;