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

use crate::{buffers::FixedSizedCType, handles::Statement, DataType, Error};
use odbc_sys::{CDataType, Len, ParamType, Pointer};
use std::{convert::TryInto, ptr::null_mut};

/// SQL Parameters used to execute a query.
///
/// ODBC allows to place question marks (`?`) in the statement text as placeholders. For each such
/// placeholder a parameter needs to be bound to the statement before executing it.
pub unsafe trait Parameters {
    /// # Safety
    ///
    /// Implementers should take care that the values bound by this method to the statement live at
    /// least for the Duration of `self`. The most straight forward way of achieving this is of
    /// course, to bind members.
    unsafe fn bind_input_parameters(&self, stmt: &mut Statement) -> Result<(), Error>;
}

/// Can be bound to a single `Placeholder` in an SQL statement.
///
/// Users usually won't utilize this trait directly, but implementations of `Parameters` are likely
/// to bind one or more instances of SingleParameter to a statement.
pub unsafe trait SingleParameter {
    /// # Parameters
    ///
    /// * `stmt`: Statement handle the parameter should be bound to.
    /// * `parameter_number`: 1 based index of the parameter. The index refers to the position of
    ///   the `?` placeholder in the SQL statement text.
    ///
    /// # Safety
    ///
    /// Implementers should take care that the values bound by this method to the statement live at
    /// least for the Duration of `self`. The most straight forward way of achieving this is of
    /// course, to bind members.
    unsafe fn bind_single_input_parameter(
        &self,
        stmt: &mut Statement,
        parameter_number: u16,
    ) -> Result<(), Error>;
}

/// The unit type is used to signal no parameters.
unsafe impl Parameters for () {
    unsafe fn bind_input_parameters(&self, _stmt: &mut Statement) -> Result<(), Error> {
        Ok(())
    }
}

unsafe impl<T> Parameters for T
where
    T: SingleParameter,
{
    unsafe fn bind_input_parameters(&self, stmt: &mut Statement) -> Result<(), Error> {
        self.bind_single_input_parameter(stmt, 1)
    }
}

unsafe impl<A, B> Parameters for (A, B)
where
    A: SingleParameter,
    B: SingleParameter,
{
    unsafe fn bind_input_parameters(&self, stmt: &mut Statement) -> Result<(), Error> {
        self.0.bind_single_input_parameter(stmt, 1)?;
        self.1.bind_single_input_parameter(stmt, 2)?;
        Ok(())
    }
}

unsafe impl<T> Parameters for &[T]
where
    T: SingleParameter,
{
    unsafe fn bind_input_parameters(&self, stmt: &mut Statement) -> Result<(), Error> {
        for (index, parameter) in self.iter().enumerate() {
            parameter.bind_single_input_parameter(stmt, index as u16 + 1)?;
        }
        Ok(())
    }
}

pub struct WithDataType<T> {
    pub value: T,
    pub data_type: DataType,
}

unsafe impl<T> SingleParameter for WithDataType<T>
where
    T: FixedSizedCType,
{
    unsafe fn bind_single_input_parameter(
        &self,
        stmt: &mut Statement<'_>,
        parameter_number: u16,
    ) -> Result<(), Error> {
        stmt.bind_parameter(
            parameter_number,
            ParamType::Input,
            T::C_DATA_TYPE,
            DataType::Integer,
            &self.value as *const T as *mut T as Pointer,
            0,
            null_mut(),
        )
        .unwrap();
        Ok(())
    }
}

/// Binds a byte array as a VarChar input parameter.
///
/// While a byte array can provide us with a pointer to the start of the array and the length of the
/// array itself, it can not provide us with a pointer to the length of the buffer. So to bind
/// strings which are not zero terminated we need to store the length in a seperate value.
pub struct VarCharParam<'a> {
    value: &'a [u8],
    /// Will be set to value.len() by constructor.
    length: Len,
}

impl<'a> VarCharParam<'a> {
    pub fn new(value: &'a [u8]) -> Self {
        VarCharParam {
            value,
            length: value.len().try_into().unwrap(),
        }
    }
}

unsafe impl SingleParameter for VarCharParam<'_> {
    unsafe fn bind_single_input_parameter(
        &self,
        stmt: &mut Statement<'_>,
        parameter_number: u16,
    ) -> Result<(), Error> {
        stmt.bind_parameter(
            parameter_number,
            ParamType::Input,
            CDataType::Char,
            DataType::Varchar {
                length: self.value.len().try_into().unwrap(),
            },
            self.value.as_ptr() as Pointer,
            self.length, // Since we only bind a single input parameter this value should be ignored.
            &self.length as *const Len as *mut Len,
        )
    }
}