Struct mysql::Stmt

source ·

pub struct Stmt<'a> { /* private fields */ }

Expand description

Mysql prepared statement.

Implementations§

source §

impl<'a> Stmt<'a>

source

pub fn params_ref(&self) -> Option<&[Column]>

Returns a slice of a Columns which represents Stmt’s params if any.

source

pub fn columns_ref(&self) -> Option<&[Column]>

Returns a slice of a Columns which represents Stmt’s columns if any.

source

pub fn column_index<T: AsRef<str>>(&self, name: T) -> Option<usize>

Returns index of a Stmt’s column by name.

source

pub fn execute<'s, T: Into<Params>>(
&'s mut self,
params: T
) -> MyResult<QueryResult<'s>>

Executes prepared statement with parameters passed as a Into<Params> implementor.

let mut stmt0 = pool.prepare("SELECT 42").unwrap();
let mut stmt1 = pool.prepare("SELECT ?").unwrap();
let mut stmt2 = pool.prepare("SELECT ?, ?").unwrap();
let mut stmt13 = pool.prepare("SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?").unwrap();

// It is better to pass params as a tuple when executing statements of arity <= 12
for row in stmt0.execute(()).unwrap() {
    let cell = from_row::<u8>(row.unwrap());
    assert_eq!(cell, 42u8);
}
// just do not forget about trailing comma in case of arity = 1
for row in stmt1.execute((42,)).unwrap() {
    let cell = from_row::<u8>(row.unwrap());
    assert_eq!(cell, 42u8);
}

// If you don't want to lose ownership of param, then you should pass it by reference
let word = "hello".to_string();
for row in stmt2.execute((&word, &word)).unwrap() {
    let (cell1, cell2) = from_row::<(String, String)>(row.unwrap());
    assert_eq!(cell1, "hello");
    assert_eq!(cell2, "hello");
}

// If you want to execute statement of arity > 12, then you can pass params as &[&ToValue].
let params: &[&ToValue] = &[&1, &2, &3, &4, &5, &6, &7, &8, &9, &10, &11, &12, &13];
for row in stmt13.execute(params).unwrap() {
    let row: Vec<u8> = row.unwrap().unwrap().into_iter().map(from_value::<u8>).collect();
    assert_eq!(row, vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
}
// but be aware of implicit copying, so if you have huge params and do not care
// about ownership, then better to use plain Vec<Value>.
let mut params: Vec<Value> = Vec::with_capacity(13);
for i in 1..14 {
    params.push(repeat('A').take(i * 1000).collect::<String>().into());
}
for row in stmt13.execute(params).unwrap() {
    let row = row.unwrap();
    let row: Vec<String> = row.unwrap().into_iter().map(from_value::<String>).collect();
    for i in 1..14 {
        assert_eq!(row[i-1], repeat('A').take(i * 1000).collect::<String>());
    }
}