Added support for uuid7

Author: LucaCappelletti94

CHANGELOG.md

@@ -5,7 +5,8 @@
 
 ### Added
 
-* Added support for the SQLite `uuid` extension, enabled via the `uuid` feature flag.
+* Added support for the SQLite `uuid4` extension, enabled via the `uuid4` feature flag.
+* Added support for the Postgres18 `uuid7` extension, enabled via the `uuid7` feature flag, ported from PostgreSQL implementation.
 
 ### Fixed
 

Cargo.toml

@@ -24,7 +24,8 @@ js-sys = { version = "0.3.81", default-features = false }
 # <https://utelle.github.io/SQLite3MultipleCiphers>
 sqlite3mc = []
 # Link the uuid extension to the library.
-uuid = []
+uuid4 = []
+uuid7 = []
 
 [build-dependencies]
 cc = "1.2.27"

build.rs

@@ -264,8 +264,11 @@ fn compile() {
     #[allow(unused_mut)]
     let mut extensions: Vec<(&str, &str)> = Vec::new();
 
-    #[cfg(feature = "uuid")]
-    extensions.push(("uuid", "sqlite3/ext/uuid.c"));
+    #[cfg(feature = "uuid4")]
+    extensions.push(("uuid4", "sqlite3/ext/uuid4.c"));
+
+    #[cfg(feature = "uuid7")]
+    extensions.push(("uuid7", "sqlite3/ext/uuid7.c"));
 
     for (_feature, source) in &extensions {
         cc.file(source);

shim/wasm-shim.h

@@ -2,6 +2,9 @@
 #include <stdint.h>
 #include <time.h>
 
+#define clock_gettime rust_sqlite_wasm_clock_gettime
+int rust_sqlite_wasm_clock_gettime(clockid_t clock_id, struct timespec *tp);
+
 /* string */
 #define strcmp rust_sqlite_wasm_strcmp
 int rust_sqlite_wasm_strcmp(const char *l, const char *r);

sqlite3/ext/uuid.c sqlite3/ext/uuid4.csqlite3/ext/uuid.c renamed to sqlite3/ext/uuid4.c

@@ -228,7 +228,7 @@ static void sqlite3UuidBlobFunc(
 #ifdef _WIN32
 __declspec(dllexport)
 #endif
-int sqlite3_uuid_init(
+int sqlite3_uuid4_init(
   sqlite3 *db,
   char **pzErrMsg,
   const sqlite3_api_routines *pApi

sqlite3/ext/uuid7.c

@@ -0,0 +1,157 @@
+/*
+** SQLite extension for UUIDv7.
+** Adapted from PostgreSQL implementation.
+** Original source:
+** <https://github.com/postgres/postgres/blob/master/src/backend/utils/adt/uuid.c>
+*/
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+#include <assert.h>
+#include <string.h>
+#include <time.h>
+#include <stdint.h>
+
+/*
+** We use a local implementation of isxdigit to avoid a dependency on <ctype.h>.
+*/
+static int sqlite3Isxdigit(int c){
+  return (c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F');
+}
+
+/*
+** Helper to convert hex to int.
+*/
+static unsigned char sqlite3UuidHexToInt(int h){
+  assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
+  if( h>='0' && h<='9' ) return h - '0';
+  if( h>='a' && h<='f' ) return h - 'a' + 10;
+  return h - 'A' + 10;
+}
+
+/*
+** Convert blob to UUID string.
+*/
+static void sqlite3UuidBlobToStr(const unsigned char *aBlob, unsigned char *zStr){
+  static const char zDigits[] = "0123456789abcdef";
+  int i, k;
+  unsigned char x;
+  k = 0;
+  for(i=0, k=0x550; i<16; i++, k=k>>1){
+    if( k&1 ){
+      zStr[0] = '-';
+      zStr++;
+    }
+    x = aBlob[i];
+    zStr[0] = zDigits[x>>4];
+    zStr[1] = zDigits[x&0xf];
+    zStr += 2;
+  }
+  *zStr = 0;
+}
+
+/* 
+** UUIDv7 Generation Logic 
+*/
+
+#define NS_PER_S	1000000000LL
+#define NS_PER_MS	1000000LL
+
+/*
+** UUID version 7 uses 12 bits in "rand_a" to store 1/4096 (or 2^12) fractions of
+** sub-millisecond.
+*/
+#define SUBMS_BITS	12
+#define SUBMS_MINIMAL_STEP_NS ((NS_PER_MS / (1 << 12)) + 1)
+
+static int64_t get_real_time_ns_ascending(void)
+{
+    static int64_t last_time_ns = 0;
+    struct timespec ts;
+    int64_t now_ns;
+
+    clock_gettime(CLOCK_REALTIME, &ts);
+    now_ns = (int64_t)ts.tv_sec * NS_PER_S + ts.tv_nsec;
+
+    /*
+     * If the clock moved backwards or stalled, we must advance it to
+     * maintain monotonicity as required by UUIDv7.
+     */
+    if (now_ns <= last_time_ns)
+    {
+        now_ns = last_time_ns + SUBMS_MINIMAL_STEP_NS;
+    }
+
+    last_time_ns = now_ns;
+    return now_ns;
+}
+
+static void generate_uuidv7(unsigned char *uuid_out)
+{
+    int64_t current_ns;
+    uint64_t unix_ts_ms;
+    uint32_t sub_ms;
+    
+    current_ns = get_real_time_ns_ascending();
+    
+    unix_ts_ms = current_ns / NS_PER_MS;
+    /* Calculate sub-millisecond fraction, scaled to 12 bits (4096) */
+    sub_ms = (uint32_t)(((current_ns % NS_PER_MS) * 4096) / NS_PER_MS);
+
+    /* Fill with random data first */
+    sqlite3_randomness(16, uuid_out);
+
+    /* 
+    ** uuid[0-5]: unix_ts_ms (48 bits)
+    ** uuid[6]: ver (4 bits) | rand_a (4 bits from sub_ms)
+    ** uuid[7]: rand_a (8 bits from sub_ms)
+    ** uuid[8]: var (2 bits) | rand_b (6 bits)
+    */
+
+    /* Encode timestamp (big-endian) */
+    uuid_out[0] = (unsigned char)(unix_ts_ms >> 40);
+    uuid_out[1] = (unsigned char)(unix_ts_ms >> 32);
+    uuid_out[2] = (unsigned char)(unix_ts_ms >> 24);
+    uuid_out[3] = (unsigned char)(unix_ts_ms >> 16);
+    uuid_out[4] = (unsigned char)(unix_ts_ms >> 8);
+    uuid_out[5] = (unsigned char)(unix_ts_ms);
+
+    /* Version 7 and top 4 bits of sub_ms */
+    uuid_out[6] = 0x70 | ((sub_ms >> 8) & 0x0F);
+    
+    /* Lower 8 bits of sub_ms */
+    uuid_out[7] = (unsigned char)(sub_ms & 0xFF);
+
+    /* Variant 1 (0b10xx) */
+    uuid_out[8] = (uuid_out[8] & 0x3F) | 0x80;
+}
+
+static void sqlite3Uuid7Func(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  unsigned char aBlob[16];
+  unsigned char zStr[37];
+  (void)argc;
+  (void)argv;
+  
+  generate_uuidv7(aBlob);
+  sqlite3UuidBlobToStr(aBlob, zStr);
+  sqlite3_result_text(context, (char*)zStr, 36, SQLITE_TRANSIENT);
+}
+
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int sqlite3_uuid7_init(
+  sqlite3 *db,
+  char **pzErrMsg,
+  const sqlite3_api_routines *pApi
+){
+  int rc = SQLITE_OK;
+  SQLITE_EXTENSION_INIT2(pApi);
+  (void)pzErrMsg;
+  rc = sqlite3_create_function_v2(db, "uuid7", 0, SQLITE_UTF8|SQLITE_INNOCUOUS, 0,
+                               sqlite3Uuid7Func, 0, 0, 0);
+  return rc;
+}

src/lib.rs

@@ -40,18 +40,34 @@ pub use self::shim::WasmOsCallback;
 /// In-memory VFS implementation.
 pub use rsqlite_vfs::memvfs::{MemVfsError, MemVfsUtil};
 
-#[cfg(feature = "uuid")]
+#[cfg(feature = "uuid4")]
 extern "C" {
-    pub fn sqlite3_uuid_init(
+    pub fn sqlite3_uuid4_init(
         db: *mut sqlite3,
         pzErrMsg: *mut *mut core::ffi::c_char,
         pApi: *const sqlite3_api_routines,
     ) -> core::ffi::c_int;
 }
 
-#[cfg(feature = "uuid")]
-pub fn register_uuid_extension() {
+#[cfg(feature = "uuid4")]
+pub fn register_uuid4_extension() {
     unsafe {
-        sqlite3_auto_extension(Some(sqlite3_uuid_init));
+        sqlite3_auto_extension(Some(sqlite3_uuid4_init));
+    }
+}
+
+#[cfg(feature = "uuid7")]
+extern "C" {
+    pub fn sqlite3_uuid7_init(
+        db: *mut sqlite3,
+        pzErrMsg: *mut *mut core::ffi::c_char,
+        pApi: *const sqlite3_api_routines,
+    ) -> core::ffi::c_int;
+}
+
+#[cfg(feature = "uuid7")]
+pub fn register_uuid7_extension() {
+    unsafe {
+        sqlite3_auto_extension(Some(sqlite3_uuid7_init));
     }
 }

src/shim.rs

@@ -276,6 +276,55 @@ pub unsafe extern "C" fn sqlite3_os_end() -> core::ffi::c_int {
     crate::bindings::SQLITE_OK
 }
 
+/// Polyfill for `clock_gettime` to support UUIDv7 generation.
+///
+/// This function provides a monotonic-ish time source based on `Date::now()` for the C
+/// `uuid7` extension. UUIDv7 requires a timestamp to ensure k-sortable IDs.
+///
+/// # Arguments
+/// * `_clock_id`: Ignored. We always use the JS `Date::now()` time.
+/// * `tp`: Pointer to `struct timespec`.
+///
+/// # Safety
+/// This function is unsafe because it dereferences raw pointers.
+/// It assumes `tp` points to a valid `struct timespec` compatible with the
+/// `musl` definition used during compilation of the C extensions.
+///
+/// # Implementation Details
+/// The assumed `struct timespec` layout for the target `wasm32-unknown-unknown` (via musl) is:
+/// ```c
+/// struct timespec {
+///     long long tv_sec; // 64-bit seconds
+///     long tv_nsec;     // 32-bit nanoseconds
+/// };
+/// ```
+/// Note: Integers align to their size, so `tv_nsec` typically usually follows `tv_sec`
+/// immediately or with padding depending on architecture. Here we treat `tv_sec` as 64-bit
+/// aligned (offset 0) and `tv_nsec` as 32-bit.
+#[no_mangle]
+pub unsafe extern "C" fn rust_sqlite_wasm_clock_gettime(
+    _clock_id: c_int,
+    tp: *mut c_void,
+) -> c_int {
+    let now = Date::now(); // ms
+    let seconds = (now / 1000.0) as i64;
+    let nanoseconds = ((now % 1000.0) * 1_000_000.0) as i32;
+
+    // struct timespec { time_t tv_sec; long tv_nsec; ... }
+    // time_t is 64-bit on musl (generic), long is 32-bit.
+    // Alignment of structure is 8 bytes.
+    let tp = tp as *mut i64;
+    *tp = seconds;
+
+    // Offset by 8 bytes for next field (64-bit integer takes 8 bytes)
+    // We cast to *mut i32 to treat the memory after the 64-bit int as 32-bit ints.
+    // Since `tp` is *mut i64, `tp.offset(1)` moves 8 bytes forward.
+    let tp_nsec = tp.offset(1) as *mut i32;
+    *tp_nsec = nanoseconds;
+
+    0
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

tests/Cargo.toml

@@ -11,7 +11,8 @@ wasm-bindgen-test = "0.3.54"
 
 [features]
 sqlite3mc = ["sqlite-wasm-rs/sqlite3mc"]
-uuid = ["sqlite-wasm-rs/uuid"]
+uuid4 = ["sqlite-wasm-rs/uuid4"]
+uuid7 = ["sqlite-wasm-rs/uuid7"]
 
 [[test]]
 name = "integration_tests"

tests/tests/full/mod.rs

@@ -1,7 +1,9 @@
 #[cfg(feature = "sqlite3mc")]
 mod sqlite3mc;
-#[cfg(feature = "uuid")]
-mod uuid_verify;
+#[cfg(feature = "uuid4")]
+mod uuid4_verify;
+#[cfg(feature = "uuid7")]
+mod uuid7_verify;
 mod vfs;
 
 use sqlite_wasm_rs::*;
@@ -116,3 +118,65 @@ pub fn drop_or_create_foo_table(db: *mut sqlite3) -> bool {
 
     true
 }
+
+/// Helper to execute a SQL statement ignoring result rows.
+/// Panics if execution fails.
+///
+/// # Arguments
+/// * `db` - Pointer to the open SQLite database connection.
+/// * `sql` - The SQL statement to execute.
+pub fn exec(db: *mut sqlite3, sql: &str) {
+    let sql_c = std::ffi::CString::new(sql).unwrap();
+    let ret = unsafe {
+        sqlite3_exec(
+            db,
+            sql_c.as_ptr().cast(),
+            None,
+            std::ptr::null_mut(),
+            std::ptr::null_mut(),
+        )
+    };
+    assert_eq!(ret, SQLITE_OK, "exec failed for: {}", sql);
+}
+
+/// Helper to prepare a SQL statement.
+/// Returns the raw statement pointer.
+/// Panics if preparation fails.
+///
+/// # Arguments
+/// * `db` - Pointer to the open SQLite database connection.
+/// * `sql` - The SQL statement to prepare.
+pub fn prepare(db: *mut sqlite3, sql: &str) -> *mut sqlite3_stmt {
+    let sql_c = std::ffi::CString::new(sql).unwrap();
+    let mut stmt = std::ptr::null_mut();
+    let ret = unsafe {
+        sqlite3_prepare_v2(
+            db,
+            sql_c.as_ptr().cast(),
+            -1,
+            &mut stmt,
+            std::ptr::null_mut(),
+        )
+    };
+    assert_eq!(ret, SQLITE_OK, "prepare failed for: {}", sql);
+    stmt
+}
+
+/// Helper to read a text column from the current row of a statement.
+/// Returns an empty string if NULL.
+///
+/// # Arguments
+/// * `stmt` - Pointer to the prepared statement.
+/// * `col` - Zero-based index of the column to read.
+pub fn text_from_col(stmt: *mut sqlite3_stmt, col: i32) -> String {
+    unsafe {
+        let ptr = sqlite3_column_text(stmt, col);
+        if ptr.is_null() {
+            String::new()
+        } else {
+            std::ffi::CStr::from_ptr(ptr.cast())
+                .to_string_lossy()
+                .into_owned()
+        }
+    }
+}