two issues with sum_int:

1. double free issue in test_sum_int.rs
2. can't load the plugin: Error: dlsym(0x808c4010, sqlite3_sumint_init): symbol not found

Author: Buggaboo

Cargo.toml

@@ -42,3 +42,7 @@ crate-type = ["cdylib"]
 [[example]]
 name = "load_permanent"
 crate-type = ["cdylib"]
+
+[[example]]
+name = "sum_int"
+crate-type = ["cdylib"]

examples/sum_int.rs

@@ -0,0 +1,48 @@
+//! cargo build --example sum_int
+//! sqlite3 :memory: '.read examples/test.sql'
+
+use libsqlite3_sys::sqlite3_int64;
+use sqlite_loadable::prelude::*;
+use sqlite_loadable::window::{WindowFunctionCallbacks, define_window_function};
+use sqlite_loadable::{api, Result};
+
+/// Example inspired by sqlite3's sumint
+/// https://www.sqlite.org/windowfunctions.html#user_defined_aggregate_window_functions
+pub fn x_step(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
+    assert!(values.len() == 1);
+    let new_value = api::value_int64(values.get(0).expect("should be one"));
+    let previous_value = api::get_aggregate_context_value::<sqlite3_int64>(context)?;
+    api::set_aggregate_context_value::<sqlite3_int64>(context, previous_value + new_value)?;
+    Ok(())
+}
+
+
+pub fn x_final(context: *mut sqlite3_context) -> Result<()> {
+    let value = api::get_aggregate_context_value::<sqlite3_int64>(context)?;
+    api::result_int64(context, value);
+    Ok(())
+}
+
+
+pub fn x_value(context: *mut sqlite3_context) -> Result<()> {
+    let value = api::get_aggregate_context_value::<sqlite3_int64>(context)?;
+    api::result_int64(context, value);
+    Ok(())
+}
+
+pub fn x_inverse(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
+    assert!(values.len() == 1);
+    let new_value = api::value_int64(values.get(0).expect("should be one"));
+    let previous_value = api::get_aggregate_context_value::<sqlite3_int64>(context)?;
+    api::set_aggregate_context_value::<sqlite3_int64>(context, previous_value - new_value)?;
+    Ok(())
+}
+
+#[sqlite_entrypoint]
+pub fn sqlite3_sum_int_init(db: *mut sqlite3) -> Result<()> {
+    let flags = FunctionFlags::UTF8 | FunctionFlags::DETERMINISTIC;
+    define_window_function(db, "sum_int", -1, flags,
+    WindowFunctionCallbacks::new(x_step, x_final, x_value, x_inverse))?;
+    Ok(())
+}
+

sqlite-loadable-macros/Cargo.lock

@@ -19,7 +19,7 @@ use crate::ext::{
 use crate::Error;
 use sqlite3ext_sys::{
     sqlite3, sqlite3_context, sqlite3_mprintf, sqlite3_value, SQLITE_BLOB, SQLITE_FLOAT,
-    SQLITE_INTEGER, SQLITE_NULL, SQLITE_TEXT,
+    SQLITE_INTEGER, SQLITE_NULL, SQLITE_TEXT, sqlite3_aggregate_context,
 };
 use std::os::raw::c_int;
 use std::slice::from_raw_parts;
@@ -571,3 +571,41 @@ impl ExtendedColumnAffinity {
         ExtendedColumnAffinity::Numeric
     }
 }
+
+// TODO write test
+pub fn get_aggregate_context_value<T>(context: *mut sqlite3_context) -> Result<T, String>
+where
+    T: Copy,
+{
+    let p_value: *mut T = unsafe {
+        sqlite3_aggregate_context(context, std::mem::size_of::<T>() as i32) as *mut T
+    };
+
+    if p_value.is_null() {
+        return Err("sqlite3_aggregate_context returned a null pointer.".to_string());
+    }
+
+    let value: T = unsafe { *p_value };
+
+    Ok(value)
+}
+
+// TODO write test
+pub fn set_aggregate_context_value<T>(context: *mut sqlite3_context, value: T) -> Result<(), String>
+where
+    T: Copy,
+{
+    let p_value: *mut T = unsafe {
+        sqlite3_aggregate_context(context, std::mem::size_of::<T>() as i32) as *mut T
+    };
+
+    if p_value.is_null() {
+        return Err("sqlite3_aggregate_context returned a null pointer.".to_string());
+    }
+
+    unsafe {
+        *p_value = value;
+    }
+
+    Ok(())
+}

src/api.rs

@@ -0,0 +1,27 @@
+use bitflags::bitflags;
+
+use sqlite3ext_sys::{
+    SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_INNOCUOUS, SQLITE_SUBTYPE, SQLITE_UTF16,
+    SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8,
+};
+
+bitflags! {
+    /// Represents the possible flag values that can be passed into sqlite3_create_function_v2
+    /// or sqlite3_create_window_function, as the 4th "eTextRep" parameter.
+    /// Includes both the encoding options (utf8, utf16, etc.) and function-level parameters
+    /// (deterministion, innocuous, etc.).
+    pub struct FunctionFlags: i32 {
+        const UTF8 = SQLITE_UTF8 as i32;
+        const UTF16LE = SQLITE_UTF16LE as i32;
+        const UTF16BE = SQLITE_UTF16BE as i32;
+        const UTF16 = SQLITE_UTF16 as i32;
+
+        /// "... to signal that the function will always return the same result given the same
+        /// inputs within a single SQL statement."
+        /// <https://www.sqlite.org/c3ref/create_function.html#:~:text=ORed%20with%20SQLITE_DETERMINISTIC>
+        const DETERMINISTIC = SQLITE_DETERMINISTIC as i32;
+        const DIRECTONLY = SQLITE_DIRECTONLY as i32;
+        const SUBTYPE = SQLITE_SUBTYPE as i32;
+        const INNOCUOUS = SQLITE_INNOCUOUS as i32;
+    }
+}

src/bit_flags.rs

@@ -45,6 +45,7 @@ impl Error {
             ErrorKind::CStringUtf8Error(_) => "utf8 err".to_owned(),
             ErrorKind::Message(msg) => msg,
             ErrorKind::TableFunction(_) => "table func error".to_owned(),
+            ErrorKind::DefineWindowFunction(_) => "Error defining window function".to_owned(),
         }
     }
 }
@@ -53,6 +54,7 @@ impl Error {
 #[derive(Debug, PartialEq, Eq)]
 pub enum ErrorKind {
     DefineScalarFunction(c_int),
+    DefineWindowFunction(c_int),
     CStringError(NulError),
     CStringUtf8Error(std::str::Utf8Error),
     TableFunction(c_int),

src/errors.rs

@@ -26,7 +26,7 @@ use sqlite3ext_sys::{
     sqlite3_result_pointer, sqlite3_result_text, sqlite3_set_auxdata, sqlite3_step, sqlite3_stmt,
     sqlite3_value, sqlite3_value_blob, sqlite3_value_bytes, sqlite3_value_double,
     sqlite3_value_int, sqlite3_value_int64, sqlite3_value_pointer, sqlite3_value_subtype,
-    sqlite3_value_text, sqlite3_value_type,
+    sqlite3_value_text, sqlite3_value_type, sqlite3_create_window_function,
 };
 
 /// If creating a dynmically loadable extension, this MUST be redefined to point
@@ -316,6 +316,29 @@ pub unsafe fn sqlite3ext_get_auxdata(context: *mut sqlite3_context, n: c_int) ->
     ((*SQLITE3_API).get_auxdata.expect(EXPECT_MESSAGE))(context, n)
 }
 
+pub unsafe fn sqlite3ext_create_window_function(
+    db: *mut sqlite3,
+    s: *const c_char,
+    argc: i32,
+    text_rep: i32,
+    p_app: *mut c_void,
+    x_step: Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)>,
+    x_final: Option<unsafe extern "C" fn(*mut sqlite3_context)>,
+    x_value: Option<unsafe extern "C" fn(*mut sqlite3_context)>,
+    x_inverse: Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)>,
+    destroy: Option<unsafe extern "C" fn(*mut c_void)>
+) -> c_int {
+    if SQLITE3_API.is_null() {
+        sqlite3_create_window_function(
+            db, s, argc, text_rep, p_app, x_step, x_final, x_value, x_inverse, destroy,
+        )
+    } else {
+        ((*SQLITE3_API).create_window_function.expect(EXPECT_MESSAGE))(
+            db, s, argc, text_rep, p_app, x_step, x_final, x_value, x_inverse, destroy,
+        )
+    }
+}
+
 pub unsafe fn sqlite3ext_create_function_v2(
     db: *mut sqlite3,
     s: *const c_char,

src/ext.rs

@@ -14,12 +14,20 @@ pub mod prelude;
 pub mod scalar;
 pub mod table;
 pub mod vtab_argparse;
+pub mod window;
+pub mod bit_flags;
 
 #[doc(inline)]
 pub use errors::{Error, ErrorKind, Result};
 
 #[doc(inline)]
-pub use scalar::{define_scalar_function, define_scalar_function_with_aux, FunctionFlags};
+pub use bit_flags::FunctionFlags;
+
+#[doc(inline)]
+pub use scalar::{define_scalar_function, define_scalar_function_with_aux};
+
+#[doc(inline)]
+pub use window::{WindowFunctionCallbacksWithAux, define_window_function_with_aux};
 
 #[doc(inline)]
 pub use collation::define_collation;

src/lib.rs

@@ -11,38 +11,10 @@ use crate::{
     api,
     constants::{SQLITE_INTERNAL, SQLITE_OKAY},
     errors::{Error, ErrorKind, Result},
-    ext::sqlite3ext_create_function_v2,
+    ext::sqlite3ext_create_function_v2, FunctionFlags,
 };
 use sqlite3ext_sys::{sqlite3, sqlite3_context, sqlite3_user_data, sqlite3_value};
 
-use bitflags::bitflags;
-
-use sqlite3ext_sys::{
-    SQLITE_DETERMINISTIC, SQLITE_DIRECTONLY, SQLITE_INNOCUOUS, SQLITE_SUBTYPE, SQLITE_UTF16,
-    SQLITE_UTF16BE, SQLITE_UTF16LE, SQLITE_UTF8,
-};
-
-bitflags! {
-    /// Represents the possible flag values that can be passed into sqlite3_create_function_v2
-    /// or sqlite3_create_window_function, as the 4th "eTextRep" parameter.
-    /// Includes both the encoding options (utf8, utf16, etc.) and function-level parameters
-    /// (deterministion, innocuous, etc.).
-    pub struct FunctionFlags: i32 {
-        const UTF8 = SQLITE_UTF8 as i32;
-        const UTF16LE = SQLITE_UTF16LE as i32;
-        const UTF16BE = SQLITE_UTF16BE as i32;
-        const UTF16 = SQLITE_UTF16 as i32;
-
-        /// "... to signal that the function will always return the same result given the same
-        /// inputs within a single SQL statement."
-        /// <https://www.sqlite.org/c3ref/create_function.html#:~:text=ORed%20with%20SQLITE_DETERMINISTIC>
-        const DETERMINISTIC = SQLITE_DETERMINISTIC as i32;
-        const DIRECTONLY = SQLITE_DIRECTONLY as i32;
-        const SUBTYPE = SQLITE_SUBTYPE as i32;
-        const INNOCUOUS = SQLITE_INNOCUOUS as i32;
-    }
-}
-
 fn create_function_v2(
     db: *mut sqlite3,
     name: &str,
@@ -53,14 +25,15 @@ fn create_function_v2(
     x_step: Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)>,
     x_final: Option<unsafe extern "C" fn(*mut sqlite3_context)>,
     destroy: Option<unsafe extern "C" fn(*mut c_void)>,
-) -> Result<()> {
+) -> Result<()>
+{
     let cname = CString::new(name)?;
     let result = unsafe {
         sqlite3ext_create_function_v2(
             db,
             cname.as_ptr(),
             num_args,
-            func_flags.bits,
+            func_flags.bits(),
             p_app,
             x_func,
             x_step,
@@ -240,3 +213,4 @@ where
 
     x_func_wrapper::<F>
 }
+