sqlite: fix NULL handling

Author: mehcode

sqlx-core/src/sqlite/types/mod.rs

@@ -18,7 +18,6 @@ pub(crate) enum SqliteType {
  Float = 2,
  Text = 3,
  Blob = 4,
- Null = 5,
 
  // Non-standard extensions
  Boolean,
@@ -52,7 +51,6 @@ impl SqliteTypeInfo {
 impl Display for SqliteTypeInfo {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  f.write_str(match self.r#type {
- SqliteType::Null => "NULL",
  SqliteType::Text => "TEXT",
  SqliteType::Boolean => "BOOLEAN",
  SqliteType::Integer => "INTEGER",
@@ -73,9 +71,10 @@ where
  T: Decode<'de, Sqlite>,
 {
  fn decode(value: SqliteValue<'de>) -> crate::Result<Self> {
- match value.r#type() {
- SqliteType::Null => Ok(None),
- _ => <T as Decode<Sqlite>>::decode(value).map(Some),
+ if value.is_null() {
+ Ok(None)
+ } else {
+ <T as Decode<Sqlite>>::decode(value).map(Some)
  }
  }
 }

sqlx-core/src/sqlite/types/str.rs

@@ -1,5 +1,6 @@
 use crate::decode::Decode;
 use crate::encode::Encode;
+use crate::error::UnexpectedNullError;
 use crate::sqlite::types::{SqliteType, SqliteTypeAffinity};
 use crate::sqlite::{Sqlite, SqliteArgumentValue, SqliteTypeInfo, SqliteValue};
 use crate::types::Type;
@@ -31,7 +32,9 @@ impl Encode<Sqlite> for String {
 
 impl<'de> Decode<'de, Sqlite> for &'de str {
  fn decode(value: SqliteValue<'de>) -> crate::Result<&'de str> {
- Ok(value.text())
+ value
+ .text()
+ .ok_or_else(|| crate::Error::decode(UnexpectedNullError))
  }
 }
 

sqlx-core/src/sqlite/value.rs

@@ -5,22 +5,23 @@ use std::str::from_utf8_unchecked;
 
 use libsqlite3_sys::{
  sqlite3_column_blob, sqlite3_column_bytes, sqlite3_column_double, sqlite3_column_int,
- sqlite3_column_int64, sqlite3_column_text, sqlite3_column_type, SQLITE_BLOB, SQLITE_FLOAT,
- SQLITE_INTEGER, SQLITE_NULL, SQLITE_TEXT,
+ sqlite3_column_int64, sqlite3_column_text, sqlite3_column_type, SQLITE_NULL,
 };
 
 use crate::sqlite::statement::Statement;
-use crate::sqlite::types::SqliteType;
 
 pub struct SqliteValue<'c> {
- index: usize,
+ index: i32,
  statement: &'c Statement,
 }
 
 impl<'c> SqliteValue<'c> {
  #[inline]
  pub(super) fn new(statement: &'c Statement, index: usize) -> Self {
- Self { statement, index }
+ Self {
+ statement,
+ index: index as i32,
+ }
  }
 }
 
@@ -30,72 +31,71 @@ impl<'c> SqliteValue<'c> {
 // These routines return information about a single column of the current result row of a query.
 
 impl<'c> SqliteValue<'c> {
- /// Returns the initial data type of the result column.
- pub(super) fn r#type(&self) -> SqliteType {
+ /// Returns true if the value should be intrepreted as NULL.
+ pub(super) fn is_null(&self) -> bool {
  #[allow(unsafe_code)]
- let type_code = unsafe { sqlite3_column_type(self.statement.handle(), self.index as i32) };
-
- match type_code {
- SQLITE_INTEGER => SqliteType::Integer,
- SQLITE_FLOAT => SqliteType::Float,
- SQLITE_BLOB => SqliteType::Blob,
- SQLITE_NULL => SqliteType::Null,
- SQLITE_TEXT => SqliteType::Text,
-
- _ => unreachable!(),
- }
+ let type_code = unsafe { sqlite3_column_type(self.statement.handle(), self.index) };
+ type_code == SQLITE_NULL
  }
 
  /// Returns the 32-bit INTEGER result.
  pub(super) fn int(&self) -> i32 {
  #[allow(unsafe_code)]
  unsafe {
- sqlite3_column_int(self.statement.handle(), self.index as i32)
+ sqlite3_column_int(self.statement.handle(), self.index)
  }
  }
 
  /// Returns the 64-bit INTEGER result.
  pub(super) fn int64(&self) -> i64 {
  #[allow(unsafe_code)]
  unsafe {
- sqlite3_column_int64(self.statement.handle(), self.index as i32)
+ sqlite3_column_int64(self.statement.handle(), self.index)
  }
  }
 
  /// Returns the 64-bit, REAL result.
  pub(super) fn double(&self) -> f64 {
  #[allow(unsafe_code)]
  unsafe {
- sqlite3_column_double(self.statement.handle(), self.index as i32)
+ sqlite3_column_double(self.statement.handle(), self.index)
  }
  }
 
  /// Returns the UTF-8 TEXT result.
- pub(super) fn text(&self) -> &'c str {
+ pub(super) fn text(&self) -> Option<&'c str> {
  #[allow(unsafe_code)]
  unsafe {
- let ptr = sqlite3_column_text(self.statement.handle(), self.index as i32) as *const i8;
-
- debug_assert!(!ptr.is_null());
+ let ptr = sqlite3_column_text(self.statement.handle(), self.index) as *const i8;
 
- from_utf8_unchecked(CStr::from_ptr(ptr).to_bytes())
+ if ptr.is_null() {
+ None
+ } else {
+ Some(from_utf8_unchecked(CStr::from_ptr(ptr).to_bytes()))
+ }
  }
  }
 
+ fn bytes(&self) -> usize {
+ // Returns the size of the result in bytes.
+ #[allow(unsafe_code)]
+ let len = unsafe { sqlite3_column_bytes(self.statement.handle(), self.index) };
+ len as usize
+ }
+
  /// Returns the BLOB result.
  pub(super) fn blob(&self) -> &'c [u8] {
- let index = self.index as i32;
-
  #[allow(unsafe_code)]
- let ptr = unsafe { sqlite3_column_blob(self.statement.handle(), index) };
+ let ptr = unsafe { sqlite3_column_blob(self.statement.handle(), self.index) };
 
- // Returns the size of the BLOB result in bytes.
- #[allow(unsafe_code)]
- let len = unsafe { sqlite3_column_bytes(self.statement.handle(), index) };
+ if ptr.is_null() {
+ // Empty BLOBs are received as null pointers
+ return &[];
+ }
 
  #[allow(unsafe_code)]
  unsafe {
- slice::from_raw_parts(ptr as *const u8, len as usize)
+ slice::from_raw_parts(ptr as *const u8, self.bytes())
  }
  }
 }