From 62d5ffe67826b6568b7faa93496771071352bc6f Mon Sep 17 00:00:00 2001 From: gwenn Date: Sat, 2 Feb 2019 11:04:46 +0100 Subject: [PATCH] Fix some enum representation --- libsqlite3-sys/src/error.rs | 7 ++++--- libsqlite3-sys/src/lib.rs | 36 ++++++++++++++++++++---------------- src/hooks.rs | 7 ++++--- src/session.rs | 18 ++++++++++-------- 4 files changed, 38 insertions(+), 30 deletions(-) diff --git a/libsqlite3-sys/src/error.rs b/libsqlite3-sys/src/error.rs index bf1367f..9e318e0 100644 --- a/libsqlite3-sys/src/error.rs +++ b/libsqlite3-sys/src/error.rs @@ -115,9 +115,10 @@ impl error::Error for Error { } // Result codes. -// Note: These are not public because our bindgen bindings export whichever constants are present -// in the current version of SQLite. We repeat them here so we don't have to worry about which -// version of SQLite added which constants, and we only use them to implement code_to_str below. +// Note: These are not public because our bindgen bindings export whichever +// constants are present in the current version of SQLite. We repeat them here +// so we don't have to worry about which version of SQLite added which +// constants, and we only use them to implement code_to_str below. const SQLITE_NOTICE: c_int = 27; const SQLITE_WARNING: c_int = 28; diff --git a/libsqlite3-sys/src/lib.rs b/libsqlite3-sys/src/lib.rs index 0e76759..795d604 100644 --- a/libsqlite3-sys/src/lib.rs +++ b/libsqlite3-sys/src/lib.rs @@ -16,32 +16,36 @@ pub fn SQLITE_TRANSIENT() -> sqlite3_destructor_type { } /// Run-Time Limit Categories -#[repr(C)] +#[repr(i32)] pub enum Limit { /// The maximum size of any string or BLOB or table row, in bytes. - SQLITE_LIMIT_LENGTH = SQLITE_LIMIT_LENGTH as isize, + SQLITE_LIMIT_LENGTH = SQLITE_LIMIT_LENGTH, /// The maximum length of an SQL statement, in bytes. - SQLITE_LIMIT_SQL_LENGTH = SQLITE_LIMIT_SQL_LENGTH as isize, - /// The maximum number of columns in a table definition or in the result set of a SELECT - /// or the maximum number of columns in an index or in an ORDER BY or GROUP BY clause. - SQLITE_LIMIT_COLUMN = SQLITE_LIMIT_COLUMN as isize, + SQLITE_LIMIT_SQL_LENGTH = SQLITE_LIMIT_SQL_LENGTH, + /// The maximum number of columns in a table definition or in the result set + /// of a SELECT or the maximum number of columns in an index or in an + /// ORDER BY or GROUP BY clause. + SQLITE_LIMIT_COLUMN = SQLITE_LIMIT_COLUMN, /// The maximum depth of the parse tree on any expression. - SQLITE_LIMIT_EXPR_DEPTH = SQLITE_LIMIT_EXPR_DEPTH as isize, + SQLITE_LIMIT_EXPR_DEPTH = SQLITE_LIMIT_EXPR_DEPTH, /// The maximum number of terms in a compound SELECT statement. - SQLITE_LIMIT_COMPOUND_SELECT = SQLITE_LIMIT_COMPOUND_SELECT as isize, - /// The maximum number of instructions in a virtual machine program used to implement an SQL statement. - SQLITE_LIMIT_VDBE_OP = SQLITE_LIMIT_VDBE_OP as isize, + SQLITE_LIMIT_COMPOUND_SELECT = SQLITE_LIMIT_COMPOUND_SELECT, + /// The maximum number of instructions in a virtual machine program used to + /// implement an SQL statement. + SQLITE_LIMIT_VDBE_OP = SQLITE_LIMIT_VDBE_OP, /// The maximum number of arguments on a function. - SQLITE_LIMIT_FUNCTION_ARG = SQLITE_LIMIT_FUNCTION_ARG as isize, + SQLITE_LIMIT_FUNCTION_ARG = SQLITE_LIMIT_FUNCTION_ARG, /// The maximum number of attached databases. - SQLITE_LIMIT_ATTACHED = SQLITE_LIMIT_ATTACHED as isize, - /// The maximum length of the pattern argument to the LIKE or GLOB operators. - SQLITE_LIMIT_LIKE_PATTERN_LENGTH = SQLITE_LIMIT_LIKE_PATTERN_LENGTH as isize, + SQLITE_LIMIT_ATTACHED = SQLITE_LIMIT_ATTACHED, + /// The maximum length of the pattern argument to the LIKE or GLOB + /// operators. + SQLITE_LIMIT_LIKE_PATTERN_LENGTH = SQLITE_LIMIT_LIKE_PATTERN_LENGTH, /// The maximum index number of any parameter in an SQL statement. - SQLITE_LIMIT_VARIABLE_NUMBER = SQLITE_LIMIT_VARIABLE_NUMBER as isize, + SQLITE_LIMIT_VARIABLE_NUMBER = SQLITE_LIMIT_VARIABLE_NUMBER, /// The maximum depth of recursion for triggers. SQLITE_LIMIT_TRIGGER_DEPTH = 10, - /// The maximum number of auxiliary worker threads that a single prepared statement may start. + /// The maximum number of auxiliary worker threads that a single prepared + /// statement may start. SQLITE_LIMIT_WORKER_THREADS = 11, } diff --git a/src/hooks.rs b/src/hooks.rs index 9397ca0..3ca3345 100644 --- a/src/hooks.rs +++ b/src/hooks.rs @@ -11,11 +11,12 @@ use crate::{Connection, InnerConnection}; /// Action Codes #[derive(Clone, Copy, Debug, PartialEq)] +#[repr(i32)] pub enum Action { UNKNOWN = -1, - SQLITE_DELETE = ffi::SQLITE_DELETE as isize, - SQLITE_INSERT = ffi::SQLITE_INSERT as isize, - SQLITE_UPDATE = ffi::SQLITE_UPDATE as isize, + SQLITE_DELETE = ffi::SQLITE_DELETE, + SQLITE_INSERT = ffi::SQLITE_INSERT, + SQLITE_UPDATE = ffi::SQLITE_UPDATE, } impl From for Action { diff --git a/src/session.rs b/src/session.rs index 6c92aea..2fad29a 100644 --- a/src/session.rs +++ b/src/session.rs @@ -608,14 +608,15 @@ impl Connection { } /// Constants passed to the conflict handler +#[repr(i32)] #[derive(Debug, PartialEq)] pub enum ConflictType { UNKNOWN = -1, - SQLITE_CHANGESET_DATA = ffi::SQLITE_CHANGESET_DATA as isize, - SQLITE_CHANGESET_NOTFOUND = ffi::SQLITE_CHANGESET_NOTFOUND as isize, - SQLITE_CHANGESET_CONFLICT = ffi::SQLITE_CHANGESET_CONFLICT as isize, - SQLITE_CHANGESET_CONSTRAINT = ffi::SQLITE_CHANGESET_CONSTRAINT as isize, - SQLITE_CHANGESET_FOREIGN_KEY = ffi::SQLITE_CHANGESET_FOREIGN_KEY as isize, + SQLITE_CHANGESET_DATA = ffi::SQLITE_CHANGESET_DATA, + SQLITE_CHANGESET_NOTFOUND = ffi::SQLITE_CHANGESET_NOTFOUND, + SQLITE_CHANGESET_CONFLICT = ffi::SQLITE_CHANGESET_CONFLICT, + SQLITE_CHANGESET_CONSTRAINT = ffi::SQLITE_CHANGESET_CONSTRAINT, + SQLITE_CHANGESET_FOREIGN_KEY = ffi::SQLITE_CHANGESET_FOREIGN_KEY, } impl From for ConflictType { fn from(code: i32) -> ConflictType { @@ -631,11 +632,12 @@ impl From for ConflictType { } /// Constants returned by the conflict handler +#[repr(i32)] #[derive(Debug, PartialEq)] pub enum ConflictAction { - SQLITE_CHANGESET_OMIT = ffi::SQLITE_CHANGESET_OMIT as isize, - SQLITE_CHANGESET_REPLACE = ffi::SQLITE_CHANGESET_REPLACE as isize, - SQLITE_CHANGESET_ABORT = ffi::SQLITE_CHANGESET_ABORT as isize, + SQLITE_CHANGESET_OMIT = ffi::SQLITE_CHANGESET_OMIT, + SQLITE_CHANGESET_REPLACE = ffi::SQLITE_CHANGESET_REPLACE, + SQLITE_CHANGESET_ABORT = ffi::SQLITE_CHANGESET_ABORT, } unsafe extern "C" fn call_filter(p_ctx: *mut c_void, tbl_str: *const c_char) -> c_int