Check sqlite3 version on load

Author: simolus3

crates/core/src/constants.rs

@@ -0,0 +1,14 @@
+use core::ffi::c_int;
+
+pub const CORE_PKG_VERSION: &'static str = env!("CARGO_PKG_VERSION");
+pub const FULL_GIT_HASH: &'static str = env!("GIT_HASH");
+
+// We need 3.44 or later to use an `ORDER BY` in an aggregate function invocation.
+//
+// When raising the minimum version requirement, also change the CI to ensure we're testing on the
+// oldest SQLite version we claim to support.
+pub const MIN_SQLITE_VERSION_NUMBER: c_int = 3044000;
+
+pub fn short_git_hash() -> &'static str {
+    &FULL_GIT_HASH[..8]
+}

crates/core/src/error.rs

@@ -1,15 +1,18 @@
-use core::{error::Error, fmt::Display};
+use core::{error::Error, ffi::c_int, fmt::Display};
 
 use alloc::{
     borrow::Cow,
     boxed::Box,
     string::{String, ToString},
 };
 use num_traits::FromPrimitive;
-use sqlite_nostd::{context, sqlite3, Connection, Context, ResultCode};
+use sqlite_nostd::{self as sqlite, context, sqlite3, Connection, Context, ResultCode};
 use thiserror::Error;
 
-use crate::bson::BsonError;
+use crate::{
+    bson::BsonError,
+    constants::{CORE_PKG_VERSION, MIN_SQLITE_VERSION_NUMBER},
+};
 
 /// A [RawPowerSyncError], but boxed.
 ///
@@ -125,7 +128,8 @@ impl PowerSyncError {
             StateError { .. } => ResultCode::MISUSE,
             MissingClientId
             | SyncProtocolError { .. }
-            | DownMigrationDidNotUpdateVersion { .. } => ResultCode::ABORT,
+            | DownMigrationDidNotUpdateVersion { .. }
+            | SqliteVersionMismatch { .. } => ResultCode::ABORT,
             LocalDataError { .. } => ResultCode::CORRUPT,
             Internal { .. } => ResultCode::INTERNAL,
         }
@@ -144,6 +148,20 @@ impl PowerSyncError {
             _ => false,
         }
     }
+
+    pub fn check_sqlite3_version() -> Result<(), PowerSyncError> {
+        let actual_version = sqlite::libversion_number();
+
+        if actual_version < MIN_SQLITE_VERSION_NUMBER {
+            Err(RawPowerSyncError::SqliteVersionMismatch {
+                libversion_number: actual_version,
+                libversion: sqlite::libversion(),
+            }
+            .into())
+        } else {
+            Ok(())
+        }
+    }
 }
 
 impl Display for PowerSyncError {
@@ -221,6 +239,15 @@ enum RawPowerSyncError {
     /// A catch-all for remaining internal errors that are very unlikely to happen.
     #[error("Internal PowerSync error. {cause}")]
     Internal { cause: PowerSyncErrorCause },
+    #[error(
+        "Version {} of the PowerSync SQLite extension requires SQLite version number {} or later, but was loaded against {libversion} ({libversion_number})",
+        CORE_PKG_VERSION,
+        MIN_SQLITE_VERSION_NUMBER
+    )]
+    SqliteVersionMismatch {
+        libversion_number: c_int,
+        libversion: &'static str,
+    },
 }
 
 #[derive(Debug)]

crates/core/src/lib.rs

@@ -9,14 +9,15 @@ extern crate alloc;
 
 use core::ffi::{c_char, c_int};
 
-use alloc::sync::Arc;
+use alloc::{ffi::CString, format, sync::Arc};
 use sqlite::ResultCode;
 use sqlite_nostd as sqlite;
 
-use crate::state::DatabaseState;
+use crate::{error::PowerSyncError, state::DatabaseState};
 
 mod bson;
 mod checkpoint;
+mod constants;
 mod crud_vtab;
 mod diff;
 mod error;
@@ -42,21 +43,29 @@ mod vtab_util;
 #[no_mangle]
 pub extern "C" fn sqlite3_powersync_init(
     db: *mut sqlite::sqlite3,
-    _err_msg: *mut *mut c_char,
+    err_msg: *mut *mut c_char,
     api: *mut sqlite::api_routines,
 ) -> c_int {
+    debug_assert!(unsafe { *err_msg }.is_null());
     sqlite::EXTENSION_INIT2(api);
 
     let result = init_extension(db);
 
     return if let Err(code) = result {
-        code as c_int
+        if let Ok(desc) = CString::new(format!("Could not initialize PowerSync: {}", code)) {
+            // Note: This is fine since we're using sqlite3_malloc to allocate in Rust
+            unsafe { *err_msg = desc.into_raw() as *mut c_char };
+        }
+
+        code.sqlite_error_code() as c_int
     } else {
         ResultCode::OK as c_int
     };
 }
 
-fn init_extension(db: *mut sqlite::sqlite3) -> Result<(), ResultCode> {
+fn init_extension(db: *mut sqlite::sqlite3) -> Result<(), PowerSyncError> {
+    PowerSyncError::check_sqlite3_version()?;
+
     let state = Arc::new(DatabaseState::new());
 
     crate::version::register(db)?;

crates/core/src/version.rs

@@ -8,16 +8,15 @@ use sqlite::ResultCode;
 use sqlite_nostd as sqlite;
 use sqlite_nostd::{Connection, Context};
 
+use crate::constants::{short_git_hash, CORE_PKG_VERSION};
 use crate::create_sqlite_text_fn;
 use crate::error::PowerSyncError;
 
 fn powersync_rs_version_impl(
     _ctx: *mut sqlite::context,
     _args: &[*mut sqlite::value],
 ) -> Result<String, ResultCode> {
-    let cargo_version = env!("CARGO_PKG_VERSION");
-    let full_hash = String::from(env!("GIT_HASH"));
-    let version = format!("{}/{}", cargo_version, &full_hash[0..8]);
+    let version = format!("{}/{}", CORE_PKG_VERSION, short_git_hash());
     Ok(version)
 }