welds-sqlx-mssql 1.7.0

Mssql driver implementation for SQLx. Not for direct use; (Fork of sqlx mssql driver starting from the when it was dropped.)
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

use bitflags::bitflags;
use bytes::{Buf, Bytes};

use crate::error::Error;
use crate::io::MssqlBufExt;
use crate::protocol::col_meta_data::Flags;
#[cfg(test)]
use crate::protocol::type_info::DataType;
use crate::protocol::type_info::TypeInfo;

#[allow(dead_code)]
#[derive(Debug)]
pub(crate) struct ReturnValue {
    param_ordinal: u16,
    param_name: String,
    status: ReturnValueStatus,
    user_type: u32,
    flags: Flags,
    pub(crate) type_info: TypeInfo,
    pub(crate) value: Option<Bytes>,
}

bitflags! {
    pub(crate) struct ReturnValueStatus: u8 {
        // If ReturnValue corresponds to OUTPUT parameter of a stored procedure invocation
        const OUTPUT_PARAM = 0x01;

        // If ReturnValue corresponds to return value of User Defined Function.
        const USER_DEFINED = 0x02;
    }
}

impl ReturnValue {
    pub(crate) fn get(buf: &mut Bytes) -> Result<Self, Error> {
        let ordinal = buf.get_u16_le();
        let name = buf.get_b_varchar()?;
        let status = ReturnValueStatus::from_bits_truncate(buf.get_u8());
        let user_type = buf.get_u32_le();
        let flags = Flags::from_bits_truncate(buf.get_u16_le());
        let type_info = TypeInfo::get(buf)?;
        let value = type_info.get_value(buf);

        Ok(Self {
            param_ordinal: ordinal,
            param_name: name,
            status,
            user_type,
            flags,
            type_info,
            value,
        })
    }
}

#[test]
fn test_get() {
    #[rustfmt::skip]
    let mut buf = Bytes::from_static(&[
        0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0x26, 4, 4, 1, 0, 0, 0, 0xfe, 0, 0, 0xe0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    ]);

    let return_value = ReturnValue::get(&mut buf).unwrap();

    assert_eq!(return_value.param_ordinal, 0);
    assert_eq!(return_value.param_name, "");
    assert_eq!(
        return_value.status,
        ReturnValueStatus::from_bits_truncate(1)
    );
    assert_eq!(return_value.user_type, 0);
    assert_eq!(return_value.flags, Flags::from_bits_truncate(0));
    assert_eq!(return_value.type_info, TypeInfo::new(DataType::IntN, 4));
    assert_eq!(
        return_value.value,
        Some(Bytes::from_static(&[0x01, 0, 0, 0]))
    );
}