Struct mysql::QueryResult [] [src]

pub struct QueryResult<'a> {
    // some fields omitted
}

Mysql result set for text and binary protocols.

If you want to get rows from QueryResult you should rely on implementation of Iterator over MyResult<Row> on QueryResult.

Row is the current row representation. To get something useful from Row you should rely on FromRow trait implemented for tuples of FromValue implementors up to arity 12, or on FromValue trait for rows with higher arity.

use mysql::value::from_row;
let mut conn = pool.get_conn().unwrap();

for row in conn.prep_exec("SELECT ?, ?", (42, 2.5)).unwrap() {
    let (a, b) = from_row(row.unwrap());
    assert_eq!((a, b), (42u8, 2.5_f32));
}

For more info on how to work with values please look at Value documentation.

Methods

impl<'a> QueryResult<'a>

fn affected_rows(&self) -> u64

Returns OkPacket's affected rows.

fn last_insert_id(&self) -> u64

Returns OkPacket's last insert id.

fn warnings(&self) -> u16

Returns OkPacket's warnings count.

fn info(&self) -> Vec<u8>

Returns OkPacket's info.

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

Returns index of a QueryResult's column by name.

fn column_indexes<'b, 'c>(&'b self) -> HashMap<String, usize, BldHshrDflt<FnvHasher>>

Returns HashMap which maps column names to column indexes.

fn columns_ref(&self) -> &[Column]

Returns a slice of a Columns which represents QueryResult's columns if any.

fn more_results_exists(&self) -> bool

This predicate will help you if you are expecting multiple result sets.

For example:

conn.query(r#"
           CREATE PROCEDURE multi() BEGIN
               SELECT 1;
               SELECT 2;
           END
           "#);
let mut result = conn.query("CALL multi()").unwrap();
while result.more_results_exists() {
    for x in result.by_ref() {
        // On first iteration of `while` you will get result set from
        // SELECT 1 and from SELECT 2 on second.
    }
}

Trait Implementations

impl<'a> Iterator for QueryResult<'a>

type Item = MyResult<Row>

fn next(&mut self) -> Option<MyResult<Row>>

fn size_hint(&self) -> (usize, Option<usize>)

fn count(self) -> usize

fn last(self) -> Option<Self::Item>

fn nth(&mut self, n: usize) -> Option<Self::Item>

fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where U: IntoIterator<Item=Self::Item>

fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where U: IntoIterator

fn map<B, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> B

fn filter<P>(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option<B>

fn enumerate(self) -> Enumerate<Self>

fn peekable(self) -> Peekable<Self>

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool

fn skip(self, n: usize) -> Skip<Self>

fn take(self, n: usize) -> Take<Self>

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where F: FnMut(&mut St, Self::Item) -> Option<B>

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where F: FnMut(Self::Item) -> U, U: IntoIterator

fn fuse(self) -> Fuse<Self>

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item) -> ()

fn by_ref(&mut self) -> &mut Self

fn collect<B>(self) -> B where B: FromIterator<Self::Item>

fn partition<B, F>(self, f: F) -> (B, B) where F: FnMut(&Self::Item) -> bool, B: Default + Extend<Self::Item>

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, Self::Item) -> B

fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool

fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool

fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool

fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator

fn max(self) -> Option<Self::Item> where Self::Item: Ord

fn min(self) -> Option<Self::Item> where Self::Item: Ord

fn max_by<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B

fn min_by<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where F: FnMut(&Self::Item) -> B, B: Ord

fn rev(self) -> Rev<Self> where Self: DoubleEndedIterator

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromB: Default + Extend<B>, FromA: Default + Extend<A>, Self: Iterator<Item=(A, B)>

fn cloned<'a, T>(self) -> Cloned<Self> where T: 'a + Clone, Self: Iterator<Item=&'a T>

fn cycle(self) -> Cycle<Self> where Self: Clone

fn sum<S>(self) -> S where S: Add<Self::Item, Output=S> + Zero

fn product<P>(self) -> P where P: Mul<Self::Item, Output=P> + One

fn cmp<I>(self, other: I) -> Ordering where I: IntoIterator<Item=Self::Item>, Self::Item: Ord

fn partial_cmp<I>(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<I::Item>

fn eq<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>

fn ne<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<I::Item>

fn lt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

fn le<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

fn gt<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

fn ge<I>(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<I::Item>

impl<'a> Drop for QueryResult<'a>

fn drop(&mut self)

Derived Implementations

impl<'a> Debug for QueryResult<'a>

fn fmt(&self, __arg_0: &mut Formatter) -> Result