From 22580234c13976df2ee1aaba06829b68e3b2b37e Mon Sep 17 00:00:00 2001
From: Sean Klein <seanmarionklein@gmail.com>
Date: Mon, 25 May 2020 10:41:11 -0400
Subject: [PATCH 1/2] Replace 'try' with '?' to clear warnings

---
 src/connection.rs |  2 +-
 src/cursor.rs     | 12 ++++++------
 src/statement.rs  |  8 ++++----
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/connection.rs b/src/connection.rs
index d0798d2..bee0c40 100644
--- a/src/connection.rs
+++ b/src/connection.rs
@@ -101,7 +101,7 @@ impl Connection {
     where
         F: FnMut(usize) -> bool + Send + 'static,
     {
-        try!(self.remove_busy_handler());
+        self.remove_busy_handler()?;
         unsafe {
             let callback = Box::new(callback);
             let result = ffi::sqlite3_busy_handler(
diff --git a/src/cursor.rs b/src/cursor.rs
index 5feefe5..b417bd5 100644
--- a/src/cursor.rs
+++ b/src/cursor.rs
@@ -13,9 +13,9 @@ impl<'l> Cursor<'l> {
     /// Bind values to all parameters.
     pub fn bind(&mut self, values: &[Value]) -> Result<()> {
         self.state = None;
-        try!(self.statement.reset());
+        self.statement.reset()?;
         for (i, value) in values.iter().enumerate() {
-            try!(self.statement.bind(i + 1, value));
+            self.statement.bind(i + 1, value)?;
         }
         Ok(())
     }
@@ -32,14 +32,14 @@ impl<'l> Cursor<'l> {
             Some(State::Row) => {}
             Some(State::Done) => return Ok(None),
             _ => {
-                self.state = Some(try!(self.statement.next()));
+                self.state = Some(self.statement.next()?);
                 return self.next();
             }
         }
         self.values = match self.values.take() {
             Some(mut values) => {
                 for (i, value) in values.iter_mut().enumerate() {
-                    *value = try!(self.statement.read(i));
+                    *value = self.statement.read(i)?;
                 }
                 Some(values)
             }
@@ -47,12 +47,12 @@ impl<'l> Cursor<'l> {
                 let count = self.statement.count();
                 let mut values = Vec::with_capacity(count);
                 for i in 0..count {
-                    values.push(try!(self.statement.read(i)));
+                    values.push(self.statement.read(i)?);
                 }
                 Some(values)
             }
         };
-        self.state = Some(try!(self.statement.next()));
+        self.state = Some(self.statement.next()?);
         Ok(Some(self.values.as_ref().unwrap()))
     }
 
diff --git a/src/statement.rs b/src/statement.rs
index 7b80f02..770ed79 100644
--- a/src/statement.rs
+++ b/src/statement.rs
@@ -232,10 +232,10 @@ impl Bindable for () {
 impl Readable for Value {
     fn read(statement: &Statement, i: usize) -> Result<Self> {
         Ok(match statement.kind(i) {
-            Type::Binary => Value::Binary(try!(Readable::read(statement, i))),
-            Type::Float => Value::Float(try!(Readable::read(statement, i))),
-            Type::Integer => Value::Integer(try!(Readable::read(statement, i))),
-            Type::String => Value::String(try!(Readable::read(statement, i))),
+            Type::Binary => Value::Binary(Readable::read(statement, i)?),
+            Type::Float => Value::Float(Readable::read(statement, i)?),
+            Type::Integer => Value::Integer(Readable::read(statement, i)?),
+            Type::String => Value::String(Readable::read(statement, i)?),
             Type::Null => Value::Null,
         })
     }

From 42f9bbfe0129e3d50a50c768891abc989c702874 Mon Sep 17 00:00:00 2001
From: Sean Klein <seanmarionklein@gmail.com>
Date: Mon, 25 May 2020 10:58:46 -0400
Subject: [PATCH 2/2] Avoid memory leak when failing to open connections

---
 src/connection.rs | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/connection.rs b/src/connection.rs
index bee0c40..4e4f176 100644
--- a/src/connection.rs
+++ b/src/connection.rs
@@ -28,12 +28,25 @@ impl Connection {
     pub fn open_with_flags<T: AsRef<Path>>(path: T, flags: OpenFlags) -> Result<Connection> {
         let mut raw = 0 as *mut _;
         unsafe {
-            ok!(ffi::sqlite3_open_v2(
+            let ret = ffi::sqlite3_open_v2(
                 path_to_cstr!(path.as_ref()).as_ptr(),
                 &mut raw,
                 flags.0,
-                0 as *const _,
-            ));
+                0 as *const _ );
+
+            // Explicitly close the connection on error.
+            // This is a quirk of the C API, where the database handle
+            // (raw) is unconditionally allocated.
+            match ret {
+                ffi::SQLITE_OK => {},
+                code => {
+                    ffi::sqlite3_close(raw);
+                    return Err(::Error {
+                        code: Some(code as isize),
+                        message: None
+                    });
+                },
+            }
         }
         Ok(Connection {
             raw: raw,