From c044d1df8f0af83697315c4ca29c26c2bb425357 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Wed, 7 Jan 2015 09:16:28 -0500 Subject: [PATCH 1/7] s/deriving/derive/ in README --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 10319a0..fb44ef1 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ extern crate time; use time::Timespec; use rusqlite::SqliteConnection; -#[deriving(Show)] +#[derive(Show)] struct Person { id: i32, name: String, From d427ddd7a591f5ddafc34dd8fa29c4eaf7ba31f0 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Wed, 7 Jan 2015 09:18:14 -0500 Subject: [PATCH 2/7] Use new closure syntax --- src/lib.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index 76fa645..f8456a4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -244,7 +244,8 @@ impl SqliteConnection { /// * The query does not successfully return at least one row. /// /// If the query returns more than one row, all rows except the first are ignored. - pub fn query_row(&self, sql: &str, params: &[&ToSql], f: |SqliteRow| -> T) -> T { + pub fn query_row(&self, sql: &str, params: &[&ToSql], f: F) -> T + where F: FnOnce(SqliteRow) -> T { let mut stmt = self.prepare(sql).unwrap(); let mut rows = stmt.query(params).unwrap(); f(rows.next().expect("Query did not return a row").unwrap()) From 39d34c6ba86c1d5c0bf33a9cf4d1dce9db96b235 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Wed, 7 Jan 2015 09:18:49 -0500 Subject: [PATCH 3/7] Bump to version 0.0.5 --- Cargo.toml | 2 +- Changelog.md | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/Cargo.toml b/Cargo.toml index 3ed7810..1aca7a3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "rusqlite" -version = "0.0.4" +version = "0.0.5" authors = ["John Gallagher "] description = "Ergonomic wrapper for SQLite" homepage = "https://github.com/jgallagher/rusqlite" diff --git a/Changelog.md b/Changelog.md index 0d5832a..cdb3638 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,3 +1,7 @@ +# Version 0.0.5 (2014-01-07) + +* Updates to track latest rustc changes (closure syntax). + # Version 0.0.4 (2014-01-05) * Updates to track latest rustc changes. From b69e3d083deaa8cd2d9c3ce2d427c2826249ef7e Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Wed, 7 Jan 2015 11:24:48 -0500 Subject: [PATCH 4/7] Remove now-unneeded directives --- src/lib.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index f8456a4..2355168 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -47,10 +47,7 @@ //! } //! } //! ``` -#![feature(globs)] #![feature(unsafe_destructor)] -#![feature(macro_rules)] -#![feature(associated_types)] extern crate libc; From e02442c531bd1bde228520cba4434a357f0ead15 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Wed, 7 Jan 2015 14:05:36 -0500 Subject: [PATCH 5/7] Update for rust's std::c_str -> std::ffi --- src/lib.rs | 31 +++++++++++++++++++------------ src/types.rs | 22 ++++++++++++---------- 2 files changed, 31 insertions(+), 22 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 2355168..a1bf52a 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -56,7 +56,9 @@ use std::ptr; use std::fmt; use std::rc::{Rc}; use std::cell::{RefCell, Cell}; -use std::c_str::{CString, ToCStr}; +use std::ffi::{CString}; +use std::ffi as std_ffi; +use std::str; use libc::{c_int, c_void, c_char}; use types::{ToSql, FromSql}; @@ -77,8 +79,9 @@ mod transaction; pub type SqliteResult = Result; unsafe fn errmsg_to_string(errmsg: *const c_char) -> String { - let c_str = CString::new(errmsg, false); - c_str.as_str().unwrap_or("Invalid error message encoding").to_string() + let c_slice = std_ffi::c_str_to_bytes(&errmsg); + let utf8_str = str::from_utf8(c_slice); + utf8_str.unwrap_or("Invalid string encoding").to_string() } /// Encompasses an error result from a call to the SQLite C API. @@ -311,9 +314,10 @@ bitflags! { impl InnerSqliteConnection { fn open_with_flags(path: &str, flags: SqliteOpenFlags) -> SqliteResult { - path.with_c_str(|c_path| unsafe { + let c_path = CString::from_slice(path.as_bytes()); + unsafe { let mut db: *mut ffi::sqlite3 = mem::uninitialized(); - let r = ffi::sqlite3_open_v2(c_path, &mut db, flags.bits(), ptr::null()); + let r = ffi::sqlite3_open_v2(c_path.as_ptr(), &mut db, flags.bits(), ptr::null()); if r != ffi::SQLITE_OK { let e = if db.is_null() { SqliteError{ code: r, @@ -333,7 +337,7 @@ impl InnerSqliteConnection { return Err(e); } Ok(InnerSqliteConnection{ db: db }) - }) + } } fn decode_result(&mut self, code: c_int) -> SqliteResult<()> { @@ -351,9 +355,10 @@ impl InnerSqliteConnection { } fn execute_batch(&mut self, sql: &str) -> SqliteResult<()> { - sql.with_c_str(|c_sql| unsafe { + let c_sql = CString::from_slice(sql.as_bytes()); + unsafe { let mut errmsg: *mut c_char = mem::uninitialized(); - let r = ffi::sqlite3_exec(self.db, c_sql, None, ptr::null_mut(), &mut errmsg); + let r = ffi::sqlite3_exec(self.db, c_sql.as_ptr(), None, ptr::null_mut(), &mut errmsg); if r == ffi::SQLITE_OK { Ok(()) } else { @@ -361,7 +366,7 @@ impl InnerSqliteConnection { ffi::sqlite3_free(errmsg as *mut c_void); Err(SqliteError{ code: r, message: message }) } - }) + } } fn last_insert_rowid(&self) -> i64 { @@ -374,10 +379,12 @@ impl InnerSqliteConnection { conn: &'a SqliteConnection, sql: &str) -> SqliteResult> { let mut c_stmt: *mut ffi::sqlite3_stmt = unsafe { mem::uninitialized() }; - let r = sql.with_c_str(|c_sql| unsafe { + let c_sql = CString::from_slice(sql.as_bytes()); + let r = unsafe { let len_with_nul = (sql.len() + 1) as c_int; - ffi::sqlite3_prepare_v2(self.db, c_sql, len_with_nul, &mut c_stmt, ptr::null_mut()) - }); + ffi::sqlite3_prepare_v2(self.db, c_sql.as_ptr(), len_with_nul, &mut c_stmt, + ptr::null_mut()) + }; self.decode_result(r).map(|_| { SqliteStatement::new(conn, c_stmt) }) diff --git a/src/types.rs b/src/types.rs index 6dc2b64..c4cbe47 100644 --- a/src/types.rs +++ b/src/types.rs @@ -54,9 +54,11 @@ extern crate time; -use libc::{c_int, c_double}; -use std::c_str::{CString, ToCStr}; +use libc::{c_int, c_double, c_char}; +use std::ffi as std_ffi; +use std::ffi::{CString}; use std::mem; +use std::str; use super::ffi; use super::{SqliteResult, SqliteError}; @@ -88,9 +90,8 @@ raw_to_impl!(c_double, sqlite3_bind_double); impl<'a> ToSql for &'a str { unsafe fn bind_parameter(&self, stmt: *mut ffi::sqlite3_stmt, col: c_int) -> c_int { - self.with_c_str(|c_str| { - ffi::sqlite3_bind_text(stmt, col, c_str, -1, Some(ffi::SQLITE_TRANSIENT())) - }) + let c_str = CString::from_slice(self.as_bytes()); + ffi::sqlite3_bind_text(stmt, col, c_str.as_ptr(), -1, Some(ffi::SQLITE_TRANSIENT())) } } @@ -170,11 +171,12 @@ impl FromSql for String { if c_text.is_null() { Ok("".to_string()) } else { - match CString::new(mem::transmute(c_text), false).as_str() { - Some(s) => Ok(s.to_string()), - None => Err(SqliteError{ code: ffi::SQLITE_MISMATCH, - message: "Could not convert text to UTF-8".to_string() }) - } + let c_text = c_text as *const c_char; + let c_slice = std_ffi::c_str_to_bytes(&c_text); + let utf8_str = str::from_utf8(c_slice); + utf8_str + .map(|s| { s.to_string() }) + .map_err(|e| { SqliteError{code: 0, message: e.to_string()} }) } } } From 830758c8f824b3f836eeea12edef8e2904db0a4a Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Wed, 7 Jan 2015 14:06:21 -0500 Subject: [PATCH 6/7] Update for new directive name --- src/ffi/bindgen.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ffi/bindgen.rs b/src/ffi/bindgen.rs index 04c4779..e6d3871 100644 --- a/src/ffi/bindgen.rs +++ b/src/ffi/bindgen.rs @@ -1,4 +1,4 @@ -#![allow(raw_pointer_deriving)] +#![allow(raw_pointer_derive)] /* Running `target/bindgen /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk/usr/include/sqlite3.h -I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/6.0/include` */ /* automatically generated by rust-bindgen */ From 06626579f7dbe38df6e4f91affa2133617197bb4 Mon Sep 17 00:00:00 2001 From: John Gallagher Date: Wed, 7 Jan 2015 14:16:51 -0500 Subject: [PATCH 7/7] Update Changelog --- Changelog.md | 1 + 1 file changed, 1 insertion(+) diff --git a/Changelog.md b/Changelog.md index cdb3638..8bd5da6 100644 --- a/Changelog.md +++ b/Changelog.md @@ -1,6 +1,7 @@ # Version 0.0.5 (2014-01-07) * Updates to track latest rustc changes (closure syntax). +* Updates to track latest rust stdlib changes (`std::c_str` -> `std::ffi`). # Version 0.0.4 (2014-01-05)