rs-odbc 0.2.0

Minimal safe Rust implementation of ODBC
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

use core::{
    cell::UnsafeCell,
    mem::MaybeUninit,
    ops::{Deref, DerefMut},
};

use crate::{
    env::OdbcVersion,
    handle::{RefSQLHDESC, RefUnsafeSQLHDESC, UnsafeSQLHDESC, SQLHDESC},
    Ident, SQLCHAR, SQLWCHAR,
};

pub trait OdbcChar {}

#[repr(transparent)]
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
pub struct OdbcStr<T>([T]);

pub trait Ansi {}
pub trait Unicode {}

impl OdbcChar for SQLCHAR {}
impl OdbcChar for SQLWCHAR {}

impl<T> Deref for OdbcStr<T> {
    type Target = [T];

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl<T> DerefMut for OdbcStr<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
impl AsRef<OdbcStr<SQLCHAR>> for str {
    fn as_ref(&self) -> &OdbcStr<SQLCHAR> {
        self.as_bytes().as_ref()
    }
}
impl AsMut<OdbcStr<SQLCHAR>> for str {
    fn as_mut(&mut self) -> &mut OdbcStr<SQLCHAR> {
        unsafe { self.as_bytes_mut().as_mut() }
    }
}
impl AsRef<OdbcStr<SQLCHAR>> for [SQLCHAR] {
    fn as_ref(&self) -> &OdbcStr<SQLCHAR> {
        unsafe { &*(self as *const [SQLCHAR] as *const OdbcStr<SQLCHAR>) }
    }
}
impl AsMut<OdbcStr<SQLCHAR>> for [SQLCHAR] {
    fn as_mut(&mut self) -> &mut OdbcStr<SQLCHAR> {
        unsafe { &mut *(self as *mut [SQLCHAR] as *mut OdbcStr<SQLCHAR>) }
    }
}
impl AsRef<OdbcStr<SQLWCHAR>> for [SQLWCHAR] {
    fn as_ref(&self) -> &OdbcStr<SQLWCHAR> {
        unsafe { &*(self as *const [SQLWCHAR] as *const OdbcStr<SQLWCHAR>) }
    }
}
impl AsMut<OdbcStr<SQLWCHAR>> for [SQLWCHAR] {
    fn as_mut(&mut self) -> &mut OdbcStr<SQLWCHAR> {
        unsafe { &mut *(self as *mut [SQLWCHAR] as *mut OdbcStr<SQLWCHAR>) }
    }
}
impl AsRef<OdbcStr<UnsafeCell<SQLCHAR>>> for UnsafeCell<str> {
    fn as_ref(&self) -> &OdbcStr<UnsafeCell<SQLCHAR>> {
        // FIXME: Relies on the implicit assumption that str is transmutable into [u8]
        // SAFETY: Types are transparent
        unsafe { core::mem::transmute(self) }
    }
}
impl AsRef<OdbcStr<UnsafeCell<SQLCHAR>>> for UnsafeCell<[SQLCHAR]> {
    fn as_ref(&self) -> &OdbcStr<UnsafeCell<SQLCHAR>> {
        // SAFETY: Types are transparent
        unsafe { core::mem::transmute(self) }
    }
}
impl AsRef<OdbcStr<UnsafeCell<SQLWCHAR>>> for UnsafeCell<[SQLWCHAR]> {
    fn as_ref(&self) -> &OdbcStr<UnsafeCell<SQLWCHAR>> {
        // SAFETY: Types are transparent
        unsafe { core::mem::transmute(self) }
    }
}
impl AsMut<OdbcStr<MaybeUninit<SQLCHAR>>> for [MaybeUninit<SQLCHAR>]
where
    [SQLCHAR]: AsMut<OdbcStr<SQLCHAR>>,
{
    fn as_mut(&mut self) -> &mut OdbcStr<MaybeUninit<SQLCHAR>> {
        unsafe { &mut *(self as *mut [MaybeUninit<SQLCHAR>] as *mut OdbcStr<MaybeUninit<SQLCHAR>>) }
    }
}
impl AsMut<OdbcStr<MaybeUninit<SQLWCHAR>>> for [MaybeUninit<SQLWCHAR>]
where
    [SQLWCHAR]: AsMut<OdbcStr<SQLWCHAR>>,
{
    fn as_mut(&mut self) -> &mut OdbcStr<MaybeUninit<SQLWCHAR>> {
        unsafe {
            &mut *(self as *mut [MaybeUninit<SQLWCHAR>] as *mut OdbcStr<MaybeUninit<SQLWCHAR>>)
        }
    }
}

impl<T: Ident> Ansi for T {} // TODO: This coincidentally implements it for SQLWCHAR as well. May not be a problem?
impl<T: Ident> Unicode for T {} // TODO: This coincidentally implements it for SQLWCHAR as well. May not be a problem?

impl<T: Ident> Ansi for MaybeUninit<T> where T: Ansi {}
impl<T: Ident> Unicode for MaybeUninit<T> where T: Unicode {}

impl Ansi for OdbcStr<SQLCHAR> {}
impl Unicode for OdbcStr<SQLWCHAR> {}

impl Ansi for OdbcStr<MaybeUninit<SQLCHAR>> {}
impl Unicode for OdbcStr<MaybeUninit<SQLWCHAR>> {}

impl<CH: OdbcChar> Ansi for &OdbcStr<CH> where OdbcStr<CH>: Ansi {}
impl<CH: OdbcChar> Unicode for &OdbcStr<CH> where OdbcStr<CH>: Unicode {}

impl<DT, V: OdbcVersion> Ansi for MaybeUninit<RefSQLHDESC<'_, DT, V>> {}
impl<DT, V: OdbcVersion> Unicode for MaybeUninit<RefSQLHDESC<'_, DT, V>> {}

impl<DT, V: OdbcVersion> Ansi for MaybeUninit<RefUnsafeSQLHDESC<'_, DT, V>> {}
impl<DT, V: OdbcVersion> Unicode for MaybeUninit<RefUnsafeSQLHDESC<'_, DT, V>> {}

impl<DT, V: OdbcVersion> Ansi for Option<&SQLHDESC<'_, DT, V>> {}
impl<DT, V: OdbcVersion> Unicode for Option<&SQLHDESC<'_, DT, V>> {}

impl<DT, V: OdbcVersion> Ansi for Option<&UnsafeSQLHDESC<'_, DT, V>> {}
impl<DT, V: OdbcVersion> Unicode for Option<&UnsafeSQLHDESC<'_, DT, V>> {}