bump sqlite-loadable=0.0.6-alpha.2, add ->> overload to regex_captures

Author: asg017

Cargo.lock

@@ -10,7 +10,7 @@ keywords = ["sqlite", "sqlite-extension"]
 license = "MIT/Apache-2.0"
 
 [dependencies]
-sqlite-loadable = "0.0.5"
+sqlite-loadable = "0.0.6-alpha.2"
 regex = "1"
 
 [lib]

Cargo.toml

@@ -1,7 +1,8 @@
 use regex::{Captures, Regex};
 use sqlite_loadable::{
     api,
-    table::{ConstraintOperator, IndexInfo, VTab, VTabArguments, VTabCursor},
+    scalar::scalar_function_raw,
+    table::{ConstraintOperator, IndexInfo, VTab, VTabArguments, VTabCursor, VTabFind},
     BestIndexError, Result,
 };
 use sqlite_loadable::{prelude::*, Error};
@@ -90,6 +91,19 @@ impl<'vtab> VTab<'vtab> for RegexCapturesTable {
     }
 }
 
+impl<'vtab> VTabFind<'vtab> for RegexCapturesTable {
+    fn find_function(
+        &mut self,
+        argc: i32,
+        name: &str,
+    ) -> Option<unsafe extern "C" fn(*mut sqlite3_context, i32, *mut *mut sqlite3_value)> {
+        if name == "->>" && argc == 2 {
+            return Some(scalar_function_raw(crate::regex_capture2));
+        }
+        None
+    }
+}
+
 #[repr(C)]
 pub struct RegexCapturesCursor<'vtab> {
     /// Base class. Must be first
@@ -122,6 +136,7 @@ impl VTabCursor for RegexCapturesCursor<'_> {
                 .get(0)
                 .ok_or_else(|| Error::new_message("expected 1st argument as regex"))?,
         )?;
+        let r = unsafe { &*r };
         let contents = api::value_text_notnull(
             values
                 .get(1)
@@ -132,8 +147,7 @@ impl VTabCursor for RegexCapturesCursor<'_> {
         for captures in r.captures_iter(contents) {
             res.push(captures)
         }
-        self.r_clone = Some((*r).clone());
-        Box::into_raw(r);
+        self.r_clone = Some((r).clone());
         self.all_captures = Some(res);
         self.curr = 0;
         Ok(())

src/captures.rs

@@ -127,6 +127,7 @@ impl VTabCursor for RegexFindAllCursor<'_> {
                 .get(0)
                 .ok_or_else(|| Error::new_message("expected 1st argument as regex"))?,
         )?;
+        let r = unsafe { &*r };
         let contents = api::value_text_notnull(
             values
                 .get(1)
@@ -137,7 +138,6 @@ impl VTabCursor for RegexFindAllCursor<'_> {
         for m in r.find_iter(contents) {
             res.push((m.start(), m.end(), m.as_str().to_string()))
         }
-        Box::into_raw(r);
         self.matches = Some(res);
         self.curr = 0;
         Ok(())

src/find_all.rs

@@ -10,7 +10,8 @@ mod utils;
 use regexset_matches::RegexSetMatchesTable;
 use sqlite_loadable::prelude::*;
 use sqlite_loadable::{
-    define_scalar_function, define_table_function, errors::Result, FunctionFlags,
+    define_scalar_function, define_table_function, errors::Result,
+    table::define_table_function_with_find, FunctionFlags,
 };
 
 use crate::{
@@ -43,7 +44,7 @@ pub fn sqlite3_regex_init(db: *mut sqlite3) -> Result<()> {
 
     define_table_function::<RegexFindAllTable>(db, "regex_find_all", None)?;
     define_table_function::<RegexSplitTable>(db, "regex_split", None)?;
-    define_table_function::<RegexCapturesTable>(db, "regex_captures", None)?;
+    define_table_function_with_find::<RegexCapturesTable>(db, "regex_captures", None)?;
 
     define_scalar_function(db, "regexset", -1, regexset, flags)?;
     define_scalar_function(db, "regexset_print", 1, regexset_print, flags)?;

src/lib.rs

@@ -10,8 +10,8 @@ use sqlite_loadable::{api, Error, Result};
 // regex(pattern [, flags])
 pub fn regex_print(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let regex = value_regex(values.get(0).ok_or("asdf")?)?;
+    let regex = unsafe { &mut *regex };
     api::result_text(context, regex.as_str())?;
-    Box::into_raw(regex);
     Ok(())
 }
 
@@ -28,10 +28,11 @@ pub fn regex(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Re
 /// regex_matches(regex, text)
 pub fn regex_matches(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let (regex, input_type) = regex_from_value_or_cache(context, values, 0)?;
+    let regex = unsafe { &mut *regex };
     let content =
         api::value_text_notnull(values.get(1).ok_or("expected 2nd argument as contents")?)?;
 
-    api::result_bool(context, regex.as_ref().is_match(content));
+    api::result_bool(context, regex.is_match(content));
     cleanup_regex_value_cached(context, regex, input_type);
     Ok(())
 }
@@ -56,13 +57,13 @@ pub fn regex_valid(context: *mut sqlite3_context, values: &[*mut sqlite3_value])
 /// regex_find(regex, contents)
 pub fn regex_find(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let (regex, input_type) = regex_from_value_or_cache(context, values, 0)?;
-
+    let regex = unsafe { &mut *regex };
     let arg_content = values
         .get(1)
         .ok_or_else(|| Error::new_message("expected 2nd argument as contents"))?;
 
     let content = api::value_text_notnull(arg_content)?;
-    match regex.as_ref().find(content) {
+    match regex.find(content) {
         Some(m) => {
             api::result_text(context, m.as_str())?;
         }
@@ -78,7 +79,7 @@ pub fn regex_find(context: *mut sqlite3_context, values: &[*mut sqlite3_value])
 /// regex_find_at(regex, contents, offset)
 pub fn regex_find_at(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let (regex, input_type) = regex_from_value_or_cache(context, values, 0)?;
-
+    let regex = unsafe { &mut *regex };
     let arg_content = values
         .get(1)
         .ok_or_else(|| Error::new_message("expected 2nd argument as contents"))?;
@@ -88,7 +89,7 @@ pub fn regex_find_at(context: *mut sqlite3_context, values: &[*mut sqlite3_value
 
     let content = api::value_text_notnull(arg_content)?;
     let offset = api::value_int(arg_offset) as usize;
-    match regex.as_ref().find_at(content, offset) {
+    match regex.find_at(content, offset) {
         Some(m) => {
             api::result_text(context, m.as_str())?;
         }
@@ -105,7 +106,7 @@ pub fn regex_find_at(context: *mut sqlite3_context, values: &[*mut sqlite3_value
 /// regex_replace(regex, contents, replacement)
 pub fn regex_replace(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let (regex, input_type) = regex_from_value_or_cache(context, values, 0)?;
-
+    let regex = unsafe { &mut *regex };
     let content = api::value_text_notnull(
         values
             .get(1)
@@ -117,9 +118,9 @@ pub fn regex_replace(context: *mut sqlite3_context, values: &[*mut sqlite3_value
             .ok_or_else(|| Error::new_message("expected 3rd argument as replacement"))?,
     )?;
 
-    let result = regex.as_ref().replace(content, replacement);
+    let result = regex.replace(content, replacement);
 
-    api::result_text(context, &result)?;
+    api::result_text(context, result)?;
     cleanup_regex_value_cached(context, regex, input_type);
 
     Ok(())
@@ -131,7 +132,7 @@ pub fn regex_replace_all(
     values: &[*mut sqlite3_value],
 ) -> Result<()> {
     let (regex, input_type) = regex_from_value_or_cache(context, values, 0)?;
-
+    let regex = unsafe { &mut *regex };
     let content = api::value_text_notnull(
         values
             .get(1)
@@ -142,8 +143,8 @@ pub fn regex_replace_all(
             .get(2)
             .ok_or_else(|| Error::new_message("expected 3rd argument as replacement"))?,
     )?;
-    let result = regex.as_ref().replace_all(content, replacement);
-    api::result_text(context, &result)?;
+    let result = regex.replace_all(content, replacement);
+    api::result_text(context, result)?;
 
     cleanup_regex_value_cached(context, regex, input_type);
     Ok(())
@@ -152,7 +153,7 @@ pub fn regex_replace_all(
 /// regex_capture(regex, contents, group)
 pub fn regex_capture(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let (regex, input_type) = regex_from_value_or_cache(context, values, 0)?;
-
+    let regex = unsafe { &mut *regex };
     let content = api::value_text_notnull(
         values
             .get(1)
@@ -162,7 +163,7 @@ pub fn regex_capture(context: *mut sqlite3_context, values: &[*mut sqlite3_value
         .get(2)
         .ok_or_else(|| Error::new_message("expected 3rd argument as group index or name"))?;
 
-    let result = regex.as_ref().captures(content);
+    let result = regex.captures(content);
     match result {
         None => api::result_null(context),
         Some(captures) => {
@@ -185,13 +186,14 @@ pub fn regex_capture(context: *mut sqlite3_context, values: &[*mut sqlite3_value
     Ok(())
 }
 
-/// regex_capture(regex, contents, group)
+/// regex_capture(captures, group)
 pub fn regex_capture2(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let captures = value_regex_captures(
         values
             .get(0)
             .ok_or_else(|| Error::new_message("expected 1st argument as capture group"))?,
     )?;
+    let captures = unsafe { &*captures };
     let group_arg = values
         .get(1)
         .ok_or_else(|| Error::new_message("expected 3rd argument as group index or name"))?;
@@ -225,6 +227,5 @@ pub fn regex_capture2(context: *mut sqlite3_context, values: &[*mut sqlite3_valu
             None => api::result_null(context),
         },
     }
-    Box::into_raw(captures);
     Ok(())
 }

src/regex.rs

@@ -19,8 +19,8 @@ pub fn regexset(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) ->
 /// regexset_print(regexset)
 pub fn regexset_print(context: *mut sqlite3_context, values: &[*mut sqlite3_value]) -> Result<()> {
     let regexset = value_regexset(values.get(0).ok_or_else(|| Error::new_message(""))?)?;
+    let regexset = unsafe { &*regexset };
     api::result_json(context, regexset.patterns().into())?;
-    Box::into_raw(regexset);
     Ok(())
 }
 
@@ -30,8 +30,8 @@ pub fn regexset_is_match(
     values: &[*mut sqlite3_value],
 ) -> Result<()> {
     let regexset = value_regexset(values.get(0).ok_or_else(|| Error::new_message(""))?)?;
+    let regexset = unsafe { &*regexset };
     let text = api::value_text_notnull(values.get(1).ok_or_else(|| Error::new_message(""))?)?;
     api::result_bool(context, regexset.is_match(text));
-    Box::into_raw(regexset);
     Ok(())
 }

src/regexset.rs

@@ -123,13 +123,14 @@ impl VTabCursor for RegexSetMatchesCursor {
         let r = value_regexset(values.get(0).ok_or_else(|| {
             Error::new_message("internal error: pattern not passed into xFilter")
         })?)?;
+        let r = unsafe { &mut *r };
         let contents = api::value_text_notnull(values.get(1).ok_or_else(|| {
             Error::new_message("internal error: contents not passed into xFilter")
         })?)?;
-        self.regex_set = Some((*r).clone());
+
+        self.regex_set = Some(r.clone());
         self.matches = Some(r.matches(contents).into_iter().collect());
         self.rowid = 0;
-        Box::into_raw(r);
         Ok(())
     }
 

src/regexset_matches.rs

@@ -123,6 +123,7 @@ impl VTabCursor for RegexSplitCursor<'_> {
                 .get(0)
                 .ok_or_else(|| Error::new_message("expected 1st argument as regex"))?,
         )?;
+        let r = unsafe { &*r };
         let contents = api::value_text_notnull(
             values
                 .get(1)
@@ -131,7 +132,6 @@ impl VTabCursor for RegexSplitCursor<'_> {
 
         let split = r.split(contents);
         self.split = Some(split.map(|i| i.to_string()).collect());
-        Box::into_raw(r);
         self.rowid = 0;
         self.contents = Some(contents.to_owned());
         Ok(())