Merge pull request #14 from wangfenjin/bind_varchar

bind varchar with length

Author: wangfenjin

.github/workflows/rust.yaml

@@ -36,7 +36,7 @@ jobs:
           targets: ${{ matrix.target }}
           components: 'rustfmt, clippy'
       - run: cargo fmt --all -- --check
-      - run: cargo clippy --all-targets --workspace --features bundled
+      - run: cargo clippy --all-targets --workspace --features bundled -- -D warnings -A clippy::redundant-closure
       - name: Run cargo-tarpaulin
         uses: actions-rs/[email protected]
         with:

examples/appender.rs

@@ -1,29 +1,34 @@
 extern crate duckdb;
 use std::convert::TryFrom;
 
+use duckdb::DropBehavior;
 use duckdb::{params, Connection, Result};
 
 fn main() -> Result<()> {
-    let db = Connection::open_in_memory()?;
+    //let mut db = Connection::open("10m.db")?;
+    let mut db = Connection::open_in_memory()?;
 
     let create_table_sql = "
         create table IF NOT EXISTS test
         (
-            id INTEGER not null primary key,
+            id INTEGER not null, -- primary key,
             area CHAR(6),
             age TINYINT not null,
             active TINYINT not null
         );";
     db.execute_batch(create_table_sql)?;
 
+    let row_count = 10_000_000;
     {
-        let mut app = db.appender("test")?;
+        let mut tx = db.transaction()?;
+        tx.set_drop_behavior(DropBehavior::Commit);
+        let mut app = tx.appender("test")?;
         // use generator
         // for u in firstn(1_000_000) {
         //     app.append_row(params![u.id, u.area, u.age, u.active])?;
         // }
 
-        for i in 0..1_000_000 {
+        for i in 0..row_count {
             app.append_row(params![
                 i,
                 get_random_area_code(),
@@ -34,7 +39,7 @@ fn main() -> Result<()> {
     }
 
     let val = db.query_row("SELECT count(1) FROM test", [], |row| <(u32,)>::try_from(row))?;
-    assert_eq!(val, (1_000_000,));
+    assert_eq!(val, (row_count,));
     Ok(())
 }
 

src/appender.rs

@@ -1,8 +1,9 @@
 use super::ffi;
 use super::{AppenderParams, Connection, Result, ValueRef};
-use std::ffi::{c_void, CString};
+use std::ffi::c_void;
 use std::fmt;
 use std::iter::IntoIterator;
+use std::os::raw::c_char;
 
 use crate::error::result_from_duckdb_code;
 use crate::types::{ToSql, ToSqlOutput};
@@ -60,9 +61,9 @@ impl Appender<'_> {
     /// Will return `Err` if append column count not the same with the table schema
     #[inline]
     pub fn append_row<P: AppenderParams>(&mut self, params: P) -> Result<()> {
-        let rc = unsafe { ffi::duckdb_appender_begin_row(self.app) };
-        result_from_duckdb_code(rc, None)?;
+        let _ = unsafe { ffi::duckdb_appender_begin_row(self.app) };
         params.__bind_in(self)?;
+        // NOTE: we only check end_row return value
         let rc = unsafe { ffi::duckdb_appender_end_row(self.app) };
         result_from_duckdb_code(rc, None)
     }
@@ -87,8 +88,10 @@ impl Appender<'_> {
             ToSqlOutput::Borrowed(v) => v,
             ToSqlOutput::Owned(ref v) => ValueRef::from(v),
         };
+        // NOTE: we ignore the return value here
+        //       because if anything failed, end_row will fail
         // TODO: append more
-        let rc = match value {
+        let _ = match value {
             ValueRef::Null => unsafe { ffi::duckdb_append_null(ptr) },
             ValueRef::Boolean(i) => unsafe { ffi::duckdb_append_bool(ptr, i) },
             ValueRef::TinyInt(i) => unsafe { ffi::duckdb_append_int8(ptr, i) },
@@ -102,13 +105,11 @@ impl Appender<'_> {
             ValueRef::Float(r) => unsafe { ffi::duckdb_append_float(ptr, r) },
             ValueRef::Double(r) => unsafe { ffi::duckdb_append_double(ptr, r) },
             ValueRef::Text(s) => unsafe {
-                let c_str = CString::new(s).expect("can't convert into c_str");
-                ffi::duckdb_append_varchar(ptr, c_str.as_ptr())
+                ffi::duckdb_append_varchar_length(ptr, s.as_ptr() as *const c_char, s.len() as u64)
             },
             ValueRef::Blob(b) => unsafe { ffi::duckdb_append_blob(ptr, b.as_ptr() as *const c_void, b.len() as u64) },
             _ => unreachable!("not supported"),
         };
-        result_from_duckdb_code(rc, Some("append error".to_owned()))?;
         Ok(())
     }
 

src/column.rs

@@ -107,7 +107,7 @@ impl Statement<'_> {
         for i in 0..n {
             // Note: `column_name` is only fallible if `i` is out of bounds,
             // which we've already checked.
-            if name.eq_ignore_ascii_case(&self.stmt.column_name(i).unwrap()) {
+            if name.eq_ignore_ascii_case(self.stmt.column_name(i).unwrap()) {
                 return Ok(i);
             }
         }

src/error.rs

@@ -210,13 +210,11 @@ impl error::Error for Error {
 
 // These are public but not re-exported by lib.rs, so only visible within crate.
 
-#[cold]
 #[inline]
 fn error_from_duckdb_code(code: c_uint, message: Option<String>) -> Result<()> {
     Err(Error::DuckDBFailure(ffi::Error::new(code as u32), message))
 }
 
-#[cold]
 #[inline]
 pub fn result_from_duckdb_code(code: c_uint, message: Option<String>) -> Result<()> {
     if code == ffi::DuckDBSuccess {

src/lib.rs

@@ -169,10 +169,10 @@ pub enum DatabaseName<'a> {
 
 impl<'a> fmt::Display for DatabaseName<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &DatabaseName::Main => write!(f, "main"),
-            &DatabaseName::Temp => write!(f, "temp"),
-            &DatabaseName::Attached(s) => write!(f, "{}", s),
+        match *self {
+            DatabaseName::Main => write!(f, "main"),
+            DatabaseName::Temp => write!(f, "temp"),
+            DatabaseName::Attached(s) => write!(f, "{}", s),
         }
     }
 }
@@ -418,7 +418,7 @@ impl Connection {
             .query(params)?
             .get_expected_row()
             .map_err(E::from)
-            .and_then(|r| f(&r))
+            .and_then(|r| f(r))
     }
 
     /// Prepare a SQL statement for execution.

src/pragma.rs

@@ -169,8 +169,7 @@ impl Connection {
         let mut stmt = self.prepare(&query)?;
         let mut rows = stmt.query([])?;
         while let Some(result_row) = rows.next()? {
-            let row = result_row;
-            f(&row)?;
+            f(result_row)?;
         }
         Ok(())
     }
@@ -206,7 +205,7 @@ impl Connection {
         let mut rows = stmt.query([])?;
         while let Some(result_row) = rows.next()? {
             let row = result_row;
-            f(&row)?;
+            f(row)?;
         }
         Ok(())
     }

src/row.rs

@@ -168,7 +168,7 @@ where
         self.rows
             .next()
             .transpose()
-            .map(|row_result| row_result.and_then(|row| (map)(&row)))
+            .map(|row_result| row_result.and_then(|row| (map)(row)))
     }
 }
 
@@ -193,7 +193,7 @@ where
         self.rows
             .next()
             .transpose()
-            .map(|row_result| row_result.map_err(E::from).and_then(|row| (map)(&row)))
+            .map(|row_result| row_result.map_err(E::from).and_then(|row| (map)(row)))
     }
 }
 

src/statement.rs

@@ -1,6 +1,6 @@
 use std::ffi::c_void;
-use std::ffi::CString;
 use std::iter::IntoIterator;
+use std::os::raw::c_char;
 use std::{convert, fmt, str};
 
 use super::ffi;
@@ -279,7 +279,7 @@ impl Statement<'_> {
         P: Params,
         F: FnOnce(&Row<'_>) -> Result<T>,
     {
-        self.query(params)?.get_expected_row().and_then(|r| f(&r))
+        self.query(params)?.get_expected_row().and_then(|r| f(r))
     }
 
     /// Return the row count
@@ -426,8 +426,7 @@ impl Statement<'_> {
             ValueRef::Float(r) => unsafe { ffi::duckdb_bind_float(ptr, col as u64, r) },
             ValueRef::Double(r) => unsafe { ffi::duckdb_bind_double(ptr, col as u64, r) },
             ValueRef::Text(s) => unsafe {
-                let c_str = CString::new(s).expect("can't convert into c_str");
-                ffi::duckdb_bind_varchar(ptr, col as u64, c_str.as_ptr())
+                ffi::duckdb_bind_varchar_length(ptr, col as u64, s.as_ptr() as *const c_char, s.len() as u64)
             },
             ValueRef::Blob(b) => unsafe {
                 ffi::duckdb_bind_blob(ptr, col as u64, b.as_ptr() as *const c_void, b.len() as u64)