Merge pull request #1589 from gwenn/inspection

Inspection

libsqlite3-sys/src/error.rs

@@ -285,8 +285,8 @@ pub enum InitError {
     NullFunctionPointer,
 }
 #[cfg(feature = "loadable_extension")]
-impl ::std::fmt::Display for InitError {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+impl fmt::Display for InitError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Self::VersionMismatch {
                 compile_time,

src/blob/pos_io.rs

@@ -208,21 +208,21 @@ mod test {
         blob.seek(std::io::SeekFrom::Start(1)).unwrap();
 
         let one2ten: [u8; 10] = [1u8, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-        blob.write_at(&one2ten, 0).unwrap();
+        blob.write_at(&one2ten, 0)?;
 
         let mut s = [0u8; 10];
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &one2ten, "write should go through");
         blob.read_at_exact(&mut s, 1).unwrap_err();
 
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &one2ten, "should be unchanged");
 
         let mut fives = [0u8; 5];
-        blob.read_at_exact(&mut fives, 0).unwrap();
+        blob.read_at_exact(&mut fives, 0)?;
         assert_eq!(&fives, &[1u8, 2, 3, 4, 5]);
 
-        blob.read_at_exact(&mut fives, 5).unwrap();
+        blob.read_at_exact(&mut fives, 5)?;
         assert_eq!(&fives, &[6u8, 7, 8, 9, 10]);
         blob.read_at_exact(&mut fives, 7).unwrap_err();
         blob.read_at_exact(&mut fives, 12).unwrap_err();
@@ -233,12 +233,12 @@ mod test {
             .unwrap_err();
 
         // zero length writes are fine if in bounds
-        blob.read_at_exact(&mut [], 10).unwrap();
-        blob.read_at_exact(&mut [], 0).unwrap();
-        blob.read_at_exact(&mut [], 5).unwrap();
+        blob.read_at_exact(&mut [], 10)?;
+        blob.read_at_exact(&mut [], 0)?;
+        blob.read_at_exact(&mut [], 5)?;
 
-        blob.write_all_at(&[16, 17, 18, 19, 20], 5).unwrap();
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.write_all_at(&[16, 17, 18, 19, 20], 5)?;
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]);
 
         blob.write_at(&[100, 99, 98, 97, 96], 6).unwrap_err();
@@ -247,19 +247,19 @@ mod test {
         blob.write_at(&[100, 99, 98, 97, 96], i32::MAX as usize + 1)
             .unwrap_err();
 
-        blob.read_at_exact(&mut s, 0).unwrap();
+        blob.read_at_exact(&mut s, 0)?;
         assert_eq!(&s, &[1u8, 2, 3, 4, 5, 16, 17, 18, 19, 20]);
 
         let mut s2: [std::mem::MaybeUninit<u8>; 10] = [std::mem::MaybeUninit::uninit(); 10];
         {
-            let read = blob.raw_read_at_exact(&mut s2, 0).unwrap();
+            let read = blob.raw_read_at_exact(&mut s2, 0)?;
             assert_eq!(read, &s);
             assert!(std::ptr::eq(read.as_ptr(), s2.as_ptr().cast()));
         }
 
         let mut empty = [];
         assert!(std::ptr::eq(
-            blob.raw_read_at_exact(&mut empty, 0).unwrap().as_ptr(),
+            blob.raw_read_at_exact(&mut empty, 0)?.as_ptr(),
             empty.as_ptr().cast(),
         ));
         blob.raw_read_at_exact(&mut s2, 5).unwrap_err();

src/error.rs

@@ -452,7 +452,7 @@ pub unsafe fn error_with_offset(db: *mut ffi::sqlite3, code: c_int, sql: &str) -
 }
 
 pub fn check(code: c_int) -> Result<()> {
-    if code != crate::ffi::SQLITE_OK {
+    if code != ffi::SQLITE_OK {
         Err(error_from_sqlite_code(code, None))
     } else {
         Ok(())

src/functions.rs

@@ -368,7 +368,7 @@ bitflags::bitflags! {
     /// and [Function Flags](https://sqlite.org/c3ref/c_deterministic.html) for details.
     #[derive(Clone, Copy, Debug)]
     #[repr(C)]
-    pub struct FunctionFlags: ::std::os::raw::c_int {
+    pub struct FunctionFlags: c_int {
         /// Specifies UTF-8 as the text encoding this SQL function prefers for its parameters.
         const SQLITE_UTF8     = ffi::SQLITE_UTF8;
         /// Specifies UTF-16 using little-endian byte order as the text encoding this SQL function prefers for its parameters.
@@ -693,7 +693,7 @@ unsafe extern "C" fn call_boxed_step<A, D, T>(
     D: Aggregate<A, T>,
     T: SqlFnOutput,
 {
-    let Some(pac) = aggregate_context(ctx, std::mem::size_of::<*mut A>()) else {
+    let Some(pac) = aggregate_context(ctx, size_of::<*mut A>()) else {
         ffi::sqlite3_result_error_nomem(ctx);
         return;
     };
@@ -739,7 +739,7 @@ unsafe extern "C" fn call_boxed_inverse<A, W, T>(
     W: WindowAggregate<A, T>,
     T: SqlFnOutput,
 {
-    let Some(pac) = aggregate_context(ctx, std::mem::size_of::<*mut A>()) else {
+    let Some(pac) = aggregate_context(ctx, size_of::<*mut A>()) else {
         ffi::sqlite3_result_error_nomem(ctx);
         return;
     };

src/hooks/mod.rs

@@ -869,8 +869,7 @@ mod test {
         use super::{AuthAction, AuthContext, Authorization};
 
         let db = Connection::open_in_memory()?;
-        db.execute_batch("CREATE TABLE foo (public TEXT, private TEXT)")
-            .unwrap();
+        db.execute_batch("CREATE TABLE foo (public TEXT, private TEXT)")?;
 
         let authorizer = move |ctx: AuthContext<'_>| match ctx.action {
             AuthAction::Read {
@@ -885,18 +884,16 @@ mod test {
         db.authorizer(Some(authorizer));
         db.execute_batch(
             "BEGIN TRANSACTION; INSERT INTO foo VALUES ('pub txt', 'priv txt'); COMMIT;",
-        )
-        .unwrap();
+        )?;
         db.query_row_and_then("SELECT * FROM foo", [], |row| -> Result<()> {
             assert_eq!(row.get::<_, String>("public")?, "pub txt");
             assert!(row.get::<_, Option<String>>("private")?.is_none());
             Ok(())
-        })
-        .unwrap();
+        })?;
         db.execute_batch("DROP TABLE foo").unwrap_err();
 
         db.authorizer(None::<fn(AuthContext<'_>) -> Authorization>);
-        db.execute_batch("PRAGMA user_version=1").unwrap(); // Disallowed by first authorizer, but it's now removed.
+        db.execute_batch("PRAGMA user_version=1")?; // Disallowed by first authorizer, but it's now removed.
 
         Ok(())
     }

src/inner_connection.rs

@@ -34,7 +34,7 @@ pub struct InnerConnection {
     #[cfg(feature = "hooks")]
     pub authorizer: Option<crate::hooks::BoxedAuthorizer>,
     #[cfg(feature = "preupdate_hook")]
-    pub free_preupdate_hook: Option<unsafe fn(*mut ::std::os::raw::c_void)>,
+    pub free_preupdate_hook: Option<unsafe fn(*mut std::os::raw::c_void)>,
     owned: bool,
 }
 

src/lib.rs

@@ -46,7 +46,7 @@
 //!     })?;
 //!
 //!     for person in person_iter {
-//!         println!("Found person {:?}", person.unwrap());
+//!         println!("Found person {:?}", person?);
 //!     }
 //!     Ok(())
 //! }
@@ -1169,7 +1169,7 @@ bitflags::bitflags! {
     /// some discussion about these flags.
     #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
     #[repr(C)]
-    pub struct OpenFlags: ::std::os::raw::c_int {
+    pub struct OpenFlags: c_int {
         /// The database is opened in read-only mode.
         /// If the database does not already exist, an error is returned.
         const SQLITE_OPEN_READ_ONLY = ffi::SQLITE_OPEN_READONLY;
@@ -2272,11 +2272,11 @@ mod test {
     #[cfg(feature = "modern_sqlite")]
     fn test_db_name() -> Result<()> {
         let db = Connection::open_in_memory()?;
-        assert_eq!(db.db_name(0).unwrap(), "main");
-        assert_eq!(db.db_name(1).unwrap(), "temp");
+        assert_eq!(db.db_name(0)?, "main");
+        assert_eq!(db.db_name(1)?, "temp");
         assert_eq!(db.db_name(2), Err(Error::InvalidDatabaseIndex(2)));
         db.execute_batch("ATTACH DATABASE ':memory:' AS xyz;")?;
-        assert_eq!(db.db_name(2).unwrap(), "xyz");
+        assert_eq!(db.db_name(2)?, "xyz");
         Ok(())
     }
 

src/session.rs

@@ -333,7 +333,7 @@ impl ChangesetIter<'_> {
 }
 
 impl FallibleStreamingIterator for ChangesetIter<'_> {
-    type Error = crate::error::Error;
+    type Error = Error;
     type Item = ChangesetItem;
 
     #[inline]

src/statement.rs

@@ -1285,9 +1285,9 @@ mod test {
         let conn = Connection::open_in_memory()?;
         let mut stmt = conn.prepare("")?;
         assert_eq!(0, stmt.column_count());
-        stmt.parameter_index("test").unwrap();
+        stmt.parameter_index("test")?;
         stmt.step().unwrap_err();
-        stmt.reset().unwrap(); // SQLITE_OMIT_AUTORESET = false
+        stmt.reset()?; // SQLITE_OMIT_AUTORESET = false
         stmt.execute([]).unwrap_err();
         Ok(())
     }

src/types/chrono.rs

@@ -285,13 +285,13 @@ mod test {
     fn test_sqlite_functions() -> Result<()> {
         let db = checked_memory_handle()?;
         let result: Result<NaiveTime> = db.one_column("SELECT CURRENT_TIME");
-        result.unwrap();
+        result?;
         let result: Result<NaiveDate> = db.one_column("SELECT CURRENT_DATE");
-        result.unwrap();
+        result?;
         let result: Result<NaiveDateTime> = db.one_column("SELECT CURRENT_TIMESTAMP");
-        result.unwrap();
+        result?;
         let result: Result<DateTime<Utc>> = db.one_column("SELECT CURRENT_TIMESTAMP");
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -299,7 +299,7 @@ mod test {
     fn test_naive_date_time_param() -> Result<()> {
         let db = checked_memory_handle()?;
         let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now().naive_utc()], |r| r.get(0));
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -307,7 +307,7 @@ mod test {
     fn test_date_time_param() -> Result<()> {
         let db = checked_memory_handle()?;
         let result: Result<bool> = db.query_row("SELECT 1 WHERE ?1 BETWEEN datetime('now', '-1 minute') AND datetime('now', '+1 minute')", [Utc::now()], |r| r.get(0));
-        result.unwrap();
+        result?;
         Ok(())
     }
 

src/types/time.rs

@@ -1,8 +1,8 @@
 //! Convert formats 1-10 in [Time Values](https://sqlite.org/lang_datefunc.html#time_values) to time types.
-//! [`ToSql`] and [`FromSql`] implementation for [`time::OffsetDateTime`].
-//! [`ToSql`] and [`FromSql`] implementation for [`time::PrimitiveDateTime`].
-//! [`ToSql`] and [`FromSql`] implementation for [`time::Date`].
-//! [`ToSql`] and [`FromSql`] implementation for [`time::Time`].
+//! [`ToSql`] and [`FromSql`] implementation for [`OffsetDateTime`].
+//! [`ToSql`] and [`FromSql`] implementation for [`PrimitiveDateTime`].
+//! [`ToSql`] and [`FromSql`] implementation for [`Date`].
+//! [`ToSql`] and [`FromSql`] implementation for [`Time`].
 //! Time Strings in:
 //!  - Format 2: "YYYY-MM-DD HH:MM"
 //!  - Format 5: "YYYY-MM-DDTHH:MM"
@@ -362,12 +362,10 @@ mod test {
     #[test]
     fn test_sqlite_functions() -> Result<()> {
         let db = checked_memory_handle()?;
-        db.one_column::<Time>("SELECT CURRENT_TIME").unwrap();
-        db.one_column::<Date>("SELECT CURRENT_DATE").unwrap();
-        db.one_column::<PrimitiveDateTime>("SELECT CURRENT_TIMESTAMP")
-            .unwrap();
-        db.one_column::<OffsetDateTime>("SELECT CURRENT_TIMESTAMP")
-            .unwrap();
+        db.one_column::<Time>("SELECT CURRENT_TIME")?;
+        db.one_column::<Date>("SELECT CURRENT_DATE")?;
+        db.one_column::<PrimitiveDateTime>("SELECT CURRENT_TIMESTAMP")?;
+        db.one_column::<OffsetDateTime>("SELECT CURRENT_TIMESTAMP")?;
         Ok(())
     }
 
@@ -380,7 +378,7 @@ mod test {
             [now],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -393,7 +391,7 @@ mod test {
             [now],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -409,7 +407,7 @@ mod test {
             [now],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 
@@ -421,7 +419,7 @@ mod test {
             [OffsetDateTime::now_utc()],
             |r| r.get(0),
         );
-        result.unwrap();
+        result?;
         Ok(())
     }
 }

src/types/to_sql.rs

@@ -445,7 +445,7 @@ mod test {
 
     #[cfg(feature = "i128_blob")]
     #[test]
-    fn test_i128() -> crate::Result<()> {
+    fn test_i128() -> Result<()> {
         use crate::Connection;
         let db = Connection::open_in_memory()?;
         db.execute_batch("CREATE TABLE foo (i128 BLOB, desc TEXT)")?;
@@ -484,7 +484,7 @@ mod test {
 
     #[cfg(feature = "i128_blob")]
     #[test]
-    fn test_non_zero_i128() -> crate::Result<()> {
+    fn test_non_zero_i128() -> Result<()> {
         use std::num::NonZeroI128;
         macro_rules! nz {
             ($x:expr) => {
@@ -532,7 +532,7 @@ mod test {
 
     #[cfg(feature = "uuid")]
     #[test]
-    fn test_uuid() -> crate::Result<()> {
+    fn test_uuid() -> Result<()> {
         use crate::{params, Connection};
         use uuid::Uuid;
 

src/types/url.rs

@@ -1,4 +1,4 @@
-//! [`ToSql`] and [`FromSql`] implementation for [`url::Url`].
+//! [`ToSql`] and [`FromSql`] implementation for [`Url`].
 use crate::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
 use crate::Result;
 use url::Url;

src/vtab/mod.rs

@@ -87,7 +87,7 @@ unsafe impl<'vtab, T: VTab<'vtab>> Send for Module<'vtab, T> {}
 unsafe impl<'vtab, T: VTab<'vtab>> Sync for Module<'vtab, T> {}
 
 union ModuleZeroHack {
-    bytes: [u8; std::mem::size_of::<ffi::sqlite3_module>()],
+    bytes: [u8; size_of::<ffi::sqlite3_module>()],
     module: ffi::sqlite3_module,
 }
 
@@ -96,7 +96,7 @@ union ModuleZeroHack {
 // structs are allowed to be zeroed.
 const ZERO_MODULE: ffi::sqlite3_module = unsafe {
     ModuleZeroHack {
-        bytes: [0_u8; std::mem::size_of::<ffi::sqlite3_module>()],
+        bytes: [0_u8; size_of::<ffi::sqlite3_module>()],
     }
     .module
 };
@@ -372,7 +372,7 @@ bitflags::bitflags! {
     /// See [Function Flags](https://sqlite.org/c3ref/c_index_scan_unique.html) for details.
     #[repr(C)]
     #[derive(Copy, Clone, Debug)]
-    pub struct IndexFlags: ::std::os::raw::c_int {
+    pub struct IndexFlags: c_int {
         /// Default
         const NONE     = 0;
         /// Scan visits at most 1 row.
@@ -940,7 +940,7 @@ unsafe extern "C" fn rust_create<'vtab, T>(
     aux: *mut c_void,
     argc: c_int,
     argv: *const *const c_char,
-    pp_vtab: *mut *mut ffi::sqlite3_vtab,
+    pp_vtab: *mut *mut sqlite3_vtab,
     err_msg: *mut *mut c_char,
 ) -> c_int
 where
@@ -961,7 +961,7 @@ where
                 let rc = ffi::sqlite3_declare_vtab(db, c_sql.as_ptr());
                 if rc == ffi::SQLITE_OK {
                     let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab));
-                    *pp_vtab = boxed_vtab.cast::<ffi::sqlite3_vtab>();
+                    *pp_vtab = boxed_vtab.cast::<sqlite3_vtab>();
                     ffi::SQLITE_OK
                 } else {
                     let err = error_from_sqlite_code(rc, None);
@@ -982,7 +982,7 @@ unsafe extern "C" fn rust_connect<'vtab, T>(
     aux: *mut c_void,
     argc: c_int,
     argv: *const *const c_char,
-    pp_vtab: *mut *mut ffi::sqlite3_vtab,
+    pp_vtab: *mut *mut sqlite3_vtab,
     err_msg: *mut *mut c_char,
 ) -> c_int
 where
@@ -1003,7 +1003,7 @@ where
                 let rc = ffi::sqlite3_declare_vtab(db, c_sql.as_ptr());
                 if rc == ffi::SQLITE_OK {
                     let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab));
-                    *pp_vtab = boxed_vtab.cast::<ffi::sqlite3_vtab>();
+                    *pp_vtab = boxed_vtab.cast::<sqlite3_vtab>();
                     ffi::SQLITE_OK
                 } else {
                     let err = error_from_sqlite_code(rc, None);
@@ -1020,7 +1020,7 @@ where
 }
 
 unsafe extern "C" fn rust_best_index<'vtab, T>(
-    vtab: *mut ffi::sqlite3_vtab,
+    vtab: *mut sqlite3_vtab,
     info: *mut ffi::sqlite3_index_info,
 ) -> c_int
 where
@@ -1043,7 +1043,7 @@ where
     }
 }
 
-unsafe extern "C" fn rust_disconnect<'vtab, T>(vtab: *mut ffi::sqlite3_vtab) -> c_int
+unsafe extern "C" fn rust_disconnect<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
 where
     T: VTab<'vtab>,
 {
@@ -1055,7 +1055,7 @@ where
     ffi::SQLITE_OK
 }
 
-unsafe extern "C" fn rust_destroy<'vtab, T>(vtab: *mut ffi::sqlite3_vtab) -> c_int
+unsafe extern "C" fn rust_destroy<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
 where
     T: CreateVTab<'vtab>,
 {
@@ -1082,8 +1082,8 @@ where
 }
 
 unsafe extern "C" fn rust_open<'vtab, T>(
-    vtab: *mut ffi::sqlite3_vtab,
-    pp_cursor: *mut *mut ffi::sqlite3_vtab_cursor,
+    vtab: *mut sqlite3_vtab,
+    pp_cursor: *mut *mut sqlite3_vtab_cursor,
 ) -> c_int
 where
     T: VTab<'vtab> + 'vtab,
@@ -1092,7 +1092,7 @@ where
     match (*vt).open() {
         Ok(cursor) => {
             let boxed_cursor: *mut T::Cursor = Box::into_raw(Box::new(cursor));
-            *pp_cursor = boxed_cursor.cast::<ffi::sqlite3_vtab_cursor>();
+            *pp_cursor = boxed_cursor.cast::<sqlite3_vtab_cursor>();
             ffi::SQLITE_OK
         }
         Err(Error::SqliteFailure(err, s)) => {
@@ -1108,7 +1108,7 @@ where
     }
 }
 
-unsafe extern "C" fn rust_close<C>(cursor: *mut ffi::sqlite3_vtab_cursor) -> c_int
+unsafe extern "C" fn rust_close<C>(cursor: *mut sqlite3_vtab_cursor) -> c_int
 where
     C: VTabCursor,
 {
@@ -1118,7 +1118,7 @@ where
 }
 
 unsafe extern "C" fn rust_filter<C>(
-    cursor: *mut ffi::sqlite3_vtab_cursor,
+    cursor: *mut sqlite3_vtab_cursor,
     idx_num: c_int,
     idx_str: *const c_char,
     argc: c_int,
@@ -1141,7 +1141,7 @@ where
     cursor_error(cursor, (*cr).filter(idx_num, idx_name, &values))
 }
 
-unsafe extern "C" fn rust_next<C>(cursor: *mut ffi::sqlite3_vtab_cursor) -> c_int
+unsafe extern "C" fn rust_next<C>(cursor: *mut sqlite3_vtab_cursor) -> c_int
 where
     C: VTabCursor,
 {
@@ -1149,7 +1149,7 @@ where
     cursor_error(cursor, (*cr).next())
 }
 
-unsafe extern "C" fn rust_eof<C>(cursor: *mut ffi::sqlite3_vtab_cursor) -> c_int
+unsafe extern "C" fn rust_eof<C>(cursor: *mut sqlite3_vtab_cursor) -> c_int
 where
     C: VTabCursor,
 {
@@ -1158,7 +1158,7 @@ where
 }
 
 unsafe extern "C" fn rust_column<C>(
-    cursor: *mut ffi::sqlite3_vtab_cursor,
+    cursor: *mut sqlite3_vtab_cursor,
     ctx: *mut ffi::sqlite3_context,
     i: c_int,
 ) -> c_int
@@ -1171,7 +1171,7 @@ where
 }
 
 unsafe extern "C" fn rust_rowid<C>(
-    cursor: *mut ffi::sqlite3_vtab_cursor,
+    cursor: *mut sqlite3_vtab_cursor,
     p_rowid: *mut ffi::sqlite3_int64,
 ) -> c_int
 where
@@ -1188,7 +1188,7 @@ where
 }
 
 unsafe extern "C" fn rust_update<'vtab, T>(
-    vtab: *mut ffi::sqlite3_vtab,
+    vtab: *mut sqlite3_vtab,
     argc: c_int,
     argv: *mut *mut ffi::sqlite3_value,
     p_rowid: *mut ffi::sqlite3_int64,
@@ -1233,7 +1233,7 @@ where
 /// Virtual table cursors can set an error message by assigning a string to
 /// `zErrMsg`.
 #[cold]
-unsafe fn cursor_error<T>(cursor: *mut ffi::sqlite3_vtab_cursor, result: Result<T>) -> c_int {
+unsafe fn cursor_error<T>(cursor: *mut sqlite3_vtab_cursor, result: Result<T>) -> c_int {
     match result {
         Ok(_) => ffi::SQLITE_OK,
         Err(Error::SqliteFailure(err, s)) => {
@@ -1252,7 +1252,7 @@ unsafe fn cursor_error<T>(cursor: *mut ffi::sqlite3_vtab_cursor, result: Result<
 /// Virtual tables methods can set an error message by assigning a string to
 /// `zErrMsg`.
 #[cold]
-unsafe fn set_err_msg(vtab: *mut ffi::sqlite3_vtab, err_msg: &str) {
+unsafe fn set_err_msg(vtab: *mut sqlite3_vtab, err_msg: &str) {
     if !(*vtab).zErrMsg.is_null() {
         ffi::sqlite3_free((*vtab).zErrMsg.cast::<c_void>());
     }

src/vtab/series.rs

@@ -29,7 +29,7 @@ const SERIES_COLUMN_STEP: c_int = 3;
 bitflags::bitflags! {
     #[derive(Clone, Copy)]
     #[repr(C)]
-    struct QueryPlanFlags: ::std::os::raw::c_int {
+    struct QueryPlanFlags: c_int {
         // start = $value  -- constraint exists
         const START = 1;
         // stop = $value   -- constraint exists