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
#![allow(bare_trait_objects)]
use {super::super::ffi, super::super::ColumnDescriptor, super::super::Raii,
super::super::Return, super::super::Handle, super::super::Statement,
Result, super::super::Prepared, super::super::Allocated,
super::super::NoResult, super::super::ResultSetState};
use odbc_safe::AutocommitMode;
use std::error::Error;
impl<'a, 'b, AC: AutocommitMode> Statement<'a, 'b, Allocated, NoResult, AC> {
/// Prepares a statement for execution. Executing a prepared statement is faster than directly
/// executing an unprepared statement, since it is already compiled into an Access Plan. This
/// makes preparing statement a good idea if you want to repeatedly execute a query with a
/// different set of parameters and care about performance.
///
/// # Example
///
/// ```rust
/// # use odbc::{*, safe};
/// # fn doc() -> Result<()>{
// let env = create_environment_v3().map_err(|e| e.unwrap())?;
/// let conn = env.connect("TestDataSource", "", "")?;
/// let stmt = Statement::with_parent(&conn)?;
/// let mut stmt = stmt.prepare("SELECT TITLE FROM MOVIES WHERE YEAR = ?")?;
///
/// fn print_one_movie_from<'a> (year: u16, stmt: Statement<'a,'a, Prepared, NoResult, safe::AutocommitOn>) -> Result<Statement<'a, 'a, Prepared, NoResult, safe::AutocommitOn>>{
/// let stmt = stmt.bind_parameter(1, &year)?;
/// let stmt = if let Data(mut stmt) = stmt.execute()?{
/// if let Some(mut cursor) = stmt.fetch()?{
/// println!("{}", cursor.get_data::<String>(1)?.unwrap());
/// }
/// stmt.close_cursor()?
/// } else {
/// panic!("SELECT statement returned no result set");
/// };
/// stmt.reset_parameters()
/// };
///
/// for year in 1990..2010{
/// stmt = print_one_movie_from(year, stmt)?
/// }
///
/// # Ok(())
/// # }
/// ```
pub fn prepare(mut self, sql_text: &str) -> Result<Statement<'a, 'b, Prepared, NoResult, AC>, Box<dyn Error>> {
self.raii.prepare(sql_text).into_result(&mut self)?;
Ok(Statement::with_raii(self.raii))
}
/// Prepares a statement for execution. Executing a prepared statement is faster than directly
/// executing an unprepared statement, since it is already compiled into an Access Plan. This
/// makes preparing statement a good idea if you want to repeatedly execute a query with a
/// different set of parameters and care about performance.
///
/// # Example
///
/// ```rust
/// # use odbc::*;
// # fn doc() -> Result<()>{
/// let env = create_environment_v3().map_err(|e| e.unwrap())?;
/// let conn = env.connect("TestDataSource", "", "")?;
/// let stmt = Statement::with_parent(&conn)?;
/// // need encode_rs crate
/// // let mut stmt = stmt.prepare_bytes(&GB2312.encode("select '你好' as hello").0)?;
///
/// # Ok(())
/// # }
/// ```
pub fn prepare_bytes(mut self, bytes: &[u8]) -> Result<Statement<'a, 'b, Prepared, NoResult, AC>, Box<dyn Error>> {
self.raii.prepare_byte(bytes).into_result(&mut self)?;
Ok(Statement::with_raii(self.raii))
}
}
impl<'a, 'b, AC: AutocommitMode> Statement<'a, 'b, Prepared, NoResult, AC> {
/// The number of columns in a result set
///
/// Can be called successfully only when the statement is in the prepared, executed, or
/// positioned state. If the statement does not return columns the result will be 0.
pub fn num_result_cols(&self) -> Result<i16, Box<dyn Error>> {
self.raii.num_result_cols().into_result(self)?;
Ok(0)
}
/// Returns description struct for result set column with a given index. Note: indexing is starting from 1.
pub fn describe_col(&self, idx: u16) -> crate::Result<ColumnDescriptor> {
self.raii.describe_col(idx).into_result(self)
}
/// Executes a prepared statement.
pub fn execute(mut self) -> Result<ResultSetState<'a, 'b, Prepared, AC>, Box<dyn Error>> {
if self.raii.execute().into_result(&mut self)? {
let num_cols = self.raii.num_result_cols().into_result(&self)?;
if num_cols > 0 {
Ok(ResultSetState::Data(Statement::with_raii(self.raii)))
} else {
Ok(ResultSetState::NoData(Statement::with_raii(self.raii)))
}
} else {
Ok(ResultSetState::NoData(Statement::with_raii(self.raii)))
}
}
}
impl<'p> Raii<'p, ffi::Stmt> {
fn prepare(&mut self, sql_text: &str) -> Return<()> {
let bytes = unsafe { crate::environment::DB_ENCODING }.encode(sql_text).0;
match unsafe {
ffi::SQLPrepare(
self.handle(),
bytes.as_ptr(),
bytes.len() as ffi::SQLINTEGER,
)
} {
ffi::SQL_SUCCESS => Return::Success(()),
ffi::SQL_SUCCESS_WITH_INFO => Return::SuccessWithInfo(()),
ffi::SQL_ERROR => Return::Error,
r => panic!("SQLPrepare returned unexpected result: {:?}", r),
}
}
fn prepare_byte(&mut self, bytes: &[u8]) -> Return<()> {
match unsafe {
ffi::SQLPrepare(
self.handle(),
bytes.as_ptr(),
bytes.len() as ffi::SQLINTEGER,
)
} {
ffi::SQL_SUCCESS => Return::Success(()),
ffi::SQL_SUCCESS_WITH_INFO => Return::SuccessWithInfo(()),
ffi::SQL_ERROR => Return::Error,
r => panic!("SQLPrepare returned unexpected result: {:?}", r),
}
}
fn execute(&mut self) -> Return<bool> {
match unsafe { ffi::SQLExecute(self.handle()) } {
ffi::SQL_SUCCESS => Return::Success(true),
ffi::SQL_SUCCESS_WITH_INFO => Return::SuccessWithInfo(true),
ffi::SQL_ERROR => Return::Error,
ffi::SQL_NO_DATA => Return::Success(false),
r => panic!("SQLExecute returned unexpected result: {:?}", r),
}
}
}