Call mysql_stmt_execute before mysql_stmt_result_metadata

Unlike PostgreSQL, we don't tell MySQL the types of the bind parameters
when we prepare the statement. Instead, we do it at the point where the
query is executed. That means that unless we've executed the query,
MySQL cannot possibly know the return type of a query where there is a
bind parameter in the select statement.

This fixes the problem by moving the call to
`mysql_stmt_result_metadata` to after the statement has been executed,
but before the data has been loaded into the buffers.

Author: sgrif

CHANGELOG.md

@@ -19,6 +19,12 @@ for Rust libraries in [RFC #1105](https://github.com/rust-lang/rfcs/blob/master/
 * Deprecated specifying a column name as `#[column_name(foo)]`. `#[column_name =
   "foo"]` should be used instead.
 
+### Fixed
+
+* `sql_query` now works properly on MySQL with queries where bind parameters
+  appear in the select clause. Previously, attempting to do `SELECT ? AS id`
+  would error if the bind parameter was any type other than a string.
+
 ## [1.0.0] - 2018-01-02
 
 ### Added

diesel/src/mysql/connection/stmt/iterator.rs

@@ -125,7 +125,7 @@ impl<'a> NamedRow<Mysql> for NamedMysqlRow<'a> {
 fn execute_statement(stmt: &mut Statement, binds: &mut Binds) -> QueryResult<()> {
     unsafe {
         binds.with_mysql_binds(|bind_ptr| stmt.bind_result(bind_ptr))?;
-        stmt.execute()?;
+        stmt.store_results()?;
     }
     Ok(())
 }

diesel/src/mysql/connection/stmt/mod.rs

@@ -56,11 +56,26 @@ impl Statement {
     /// have no return value. It should never be called on a statement on
     /// which `results` has previously been called?
     pub unsafe fn execute(&self) -> QueryResult<()> {
+        self.execute_without_store()?;
+        self.store_results()?;
+        Ok(())
+    }
+
+    /// This function should only be called internally by other functions which
+    /// will later call `store_results`. Failure to do so will poison the
+    /// connection.
+    unsafe fn execute_without_store(&self) -> QueryResult<()> {
         ffi::mysql_stmt_execute(self.stmt);
-        self.did_an_error_occur()?;
+        self.did_an_error_occur()
+    }
+
+    /// This method should only be called by the structs in `stmt::iterator`. It
+    /// is only valid if `execute_without_store` was previously called. Calling
+    /// this method any number of times other than exactly once per call to
+    /// `execute_without_store` will poison the connection.
+    pub unsafe fn store_results(&self) -> QueryResult<()> {
         ffi::mysql_stmt_store_result(self.stmt);
-        self.did_an_error_occur()?;
-        Ok(())
+        self.did_an_error_occur()
     }
 
     pub fn affected_rows(&self) -> usize {
@@ -72,13 +87,15 @@ impl Statement {
     /// have a return value. After calling this function, `execute` can never
     /// be called on this statement.
     pub unsafe fn results(&mut self, types: Vec<MysqlType>) -> QueryResult<StatementIterator> {
+        self.execute_without_store()?;
         StatementIterator::new(self, types)
     }
 
     /// This function should be called instead of `execute` for queries which
     /// have a return value. After calling this function, `execute` can never
     /// be called on this statement.
     pub unsafe fn named_results(&mut self) -> QueryResult<NamedStatementIterator> {
+        self.execute_without_store()?;
         NamedStatementIterator::new(self)
     }
 

diesel_tests/tests/raw_sql.rs

@@ -52,3 +52,22 @@ fn sql_query_can_take_bind_params() {
 
     assert_eq!(Ok(expected), users);
 }
+
+#[test]
+fn sql_query_can_deal_with_bind_params_in_select_clause() {
+    use diesel::types::{Integer, Text};
+    let conn = connection();
+
+    let query = if cfg!(feature = "postgres") {
+        sql_query("SELECT $1 as id, $2 as name, $3 as hair_color")
+    } else {
+        sql_query("SELECT ? as id, ? as name, ? as hair_color")
+    };
+    let user = query.bind::<Integer, _>(1)
+        .bind::<Text, _>("Sean")
+        .bind::<Text, _>("black")
+        .get_result(&conn);
+    let expected = User::with_hair_color(1, "Sean", "black");
+
+    assert_eq!(Ok(expected), user);
+}