libpq 1.4.2

Safe binding for libpq
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

#[derive(Clone, Debug, PartialEq)]
pub struct Info {
    pub keyword: String,
    pub envvar: Option<String>,
    pub compiled: Option<String>,
    pub val: Option<String>,
    pub label: Option<String>,
    pub dispchar: String,
    pub dispsize: i32,
}

impl Info {
    /**
     * Returns the default connection options.
     *
     * See [PQconndefaults](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PQCONNDEFAULTS)
     */
    pub fn new() -> Self {
        Self::default()
    }

    /**
     * Returns parsed connection options from the provided connection string.
     *
     * See
     * [PQconninfoParse](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PQCONNINFOPARSE).
     */
    pub fn from(dsn: &str) -> std::result::Result<Vec<Self>, String> {
        let c_dsn = crate::ffi::to_cstr(dsn);

        unsafe {
            let mut errmsg: *mut libc::c_char = std::ptr::null_mut();
            let raw = pq_sys::PQconninfoParse(c_dsn.as_ptr(), &mut errmsg);

            if raw.is_null() {
                if errmsg.is_null() {
                    return Err("Unknow error".to_string());
                } else {
                    let err = crate::ffi::to_string(errmsg);
                    pq_sys::PQfreemem(errmsg as *mut std::ffi::c_void);
                    return Err(err);
                }
            }

            let info = Self::vec_from_nta(raw);
            pq_sys::PQconninfoFree(raw);

            Ok(info)
        }
    }

    fn from_raw(info: *mut pq_sys::_PQconninfoOption) -> Self {
        unsafe {
            Self {
                keyword: crate::ffi::to_string((*info).keyword),
                envvar: if (*info).envvar.is_null() {
                    None
                } else {
                    Some(crate::ffi::to_string((*info).envvar))
                },
                compiled: if (*info).compiled.is_null() {
                    None
                } else {
                    Some(crate::ffi::to_string((*info).compiled))
                },
                val: if (*info).val.is_null() {
                    None
                } else {
                    Some(crate::ffi::to_string((*info).val))
                },
                label: if (*info).label.is_null() {
                    None
                } else {
                    Some(crate::ffi::to_string((*info).label))
                },
                dispchar: crate::ffi::to_string((*info).dispchar),
                dispsize: (*info).dispsize,
            }
        }
    }

    fn vec_from_nta(raw: *mut pq_sys::_PQconninfoOption) -> Vec<Self> {
        let mut vec = Vec::new();

        for x in 0.. {
            unsafe {
                if (*raw.offset(x)).keyword.is_null() {
                    break;
                } else {
                    let info = raw.offset(x).into();
                    vec.push(info);
                }
            }
        }

        vec
    }
}

impl Default for Info {
    fn default() -> Self {
        unsafe {
            let raw = pq_sys::PQconndefaults();
            let info = raw.into();
            pq_sys::PQconninfoFree(raw);

            info
        }
    }
}

#[doc(hidden)]
impl From<*mut pq_sys::_PQconninfoOption> for Info {
    fn from(info: *mut pq_sys::_PQconninfoOption) -> Self {
        Self::from_raw(info)
    }
}

#[cfg(test)]
mod test {
    #[test]
    fn parse_info() {
        assert!(crate::connection::Info::from("host=localhost user=postgres").is_ok());
        assert_eq!(
            crate::connection::Info::from("'"),
            Err("missing \"=\" after \"'\" in connection info string\n".to_string())
        );
    }

    #[test]
    fn defaults() {
        let _ = crate::connection::Info::default();
    }
}