2015-08-09 15:52:53 +08:00
|
|
|
//! Create or redefine SQL functions
|
2015-12-12 00:41:40 +08:00
|
|
|
use std::ffi::CStr;
|
2015-08-09 15:52:53 +08:00
|
|
|
use std::mem;
|
2015-12-12 03:46:28 +08:00
|
|
|
use std::slice;
|
2015-08-09 15:52:53 +08:00
|
|
|
use std::str;
|
2015-12-12 01:01:05 +08:00
|
|
|
use libc::{c_int, c_double, c_char, c_void};
|
2015-08-09 15:52:53 +08:00
|
|
|
|
|
|
|
use ffi;
|
2015-12-12 00:41:40 +08:00
|
|
|
pub use ffi::sqlite3_context;
|
|
|
|
pub use ffi::sqlite3_value;
|
|
|
|
pub use ffi::sqlite3_value_type;
|
|
|
|
pub use ffi::sqlite3_value_numeric_type;
|
2015-08-09 15:52:53 +08:00
|
|
|
|
|
|
|
use types::Null;
|
|
|
|
|
|
|
|
use {SqliteResult, SqliteError, SqliteConnection, str_to_cstring, InnerSqliteConnection};
|
|
|
|
|
|
|
|
/// A trait for types that can be converted into the result of an SQL function.
|
|
|
|
pub trait ToResult {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context);
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! raw_to_impl(
|
|
|
|
($t:ty, $f:ident) => (
|
|
|
|
impl ToResult for $t {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
2015-08-09 15:52:53 +08:00
|
|
|
ffi::$f(ctx, *self)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
raw_to_impl!(c_int, sqlite3_result_int);
|
|
|
|
raw_to_impl!(i64, sqlite3_result_int64);
|
|
|
|
raw_to_impl!(c_double, sqlite3_result_double);
|
|
|
|
|
2015-08-09 19:06:23 +08:00
|
|
|
impl<'a> ToResult for bool {
|
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
|
|
|
match *self {
|
|
|
|
true => ffi::sqlite3_result_int(ctx, 1),
|
|
|
|
_ => ffi::sqlite3_result_int(ctx, 0),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-09 15:52:53 +08:00
|
|
|
|
|
|
|
impl<'a> ToResult for &'a str {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
2015-08-09 15:52:53 +08:00
|
|
|
let length = self.len();
|
|
|
|
if length > ::std::i32::MAX as usize {
|
|
|
|
ffi::sqlite3_result_error_toobig(ctx);
|
2015-12-12 00:41:40 +08:00
|
|
|
return;
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
match str_to_cstring(self) {
|
2015-12-12 00:41:40 +08:00
|
|
|
Ok(c_str) => {
|
|
|
|
ffi::sqlite3_result_text(ctx,
|
|
|
|
c_str.as_ptr(),
|
|
|
|
length as c_int,
|
|
|
|
ffi::SQLITE_TRANSIENT())
|
|
|
|
}
|
|
|
|
Err(_) => ffi::sqlite3_result_error_code(ctx, ffi::SQLITE_MISUSE), // TODO sqlite3_result_error
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ToResult for String {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
|
|
|
(&self[..]).set_result(ctx)
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> ToResult for &'a [u8] {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
2015-08-09 15:52:53 +08:00
|
|
|
if self.len() > ::std::i32::MAX as usize {
|
|
|
|
ffi::sqlite3_result_error_toobig(ctx);
|
2015-12-12 00:41:40 +08:00
|
|
|
return;
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
2015-12-12 00:41:40 +08:00
|
|
|
ffi::sqlite3_result_blob(ctx,
|
|
|
|
mem::transmute(self.as_ptr()),
|
|
|
|
self.len() as c_int,
|
|
|
|
ffi::SQLITE_TRANSIENT())
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ToResult for Vec<u8> {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
|
|
|
(&self[..]).set_result(ctx)
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T: ToResult> ToResult for Option<T> {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
2015-08-09 15:52:53 +08:00
|
|
|
match *self {
|
|
|
|
None => ffi::sqlite3_result_null(ctx),
|
2015-08-09 19:06:23 +08:00
|
|
|
Some(ref t) => t.set_result(ctx),
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ToResult for Null {
|
2015-08-09 19:06:23 +08:00
|
|
|
unsafe fn set_result(&self, ctx: *mut sqlite3_context) {
|
2015-08-09 15:52:53 +08:00
|
|
|
ffi::sqlite3_result_null(ctx)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// sqlite3_result_error_code, c_int
|
|
|
|
// sqlite3_result_error_nomem
|
|
|
|
// sqlite3_result_error_toobig
|
|
|
|
// sqlite3_result_error, *const c_char, c_int
|
|
|
|
// sqlite3_result_zeroblob
|
|
|
|
// sqlite3_result_value
|
|
|
|
|
|
|
|
/// A trait for types that can be created from a SQLite function parameter value.
|
2015-12-07 04:33:21 +08:00
|
|
|
pub trait FromValue: Sized {
|
2015-08-09 15:52:53 +08:00
|
|
|
unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<Self>;
|
|
|
|
|
|
|
|
/// FromValue types can implement this method and use sqlite3_value_type to check that
|
|
|
|
/// the type reported by SQLite matches a type suitable for Self. This method is used
|
|
|
|
/// by `???` to confirm that the parameter contains a valid type before
|
|
|
|
/// attempting to retrieve the value.
|
|
|
|
unsafe fn parameter_has_valid_sqlite_type(_: *mut sqlite3_value) -> bool {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
macro_rules! raw_from_impl(
|
|
|
|
($t:ty, $f:ident, $c:expr) => (
|
|
|
|
impl FromValue for $t {
|
|
|
|
unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<$t> {
|
|
|
|
Ok(ffi::$f(v))
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn parameter_has_valid_sqlite_type(v: *mut sqlite3_value) -> bool {
|
|
|
|
sqlite3_value_numeric_type(v) == $c
|
|
|
|
}
|
|
|
|
}
|
|
|
|
)
|
|
|
|
);
|
|
|
|
|
|
|
|
raw_from_impl!(c_int, sqlite3_value_int, ffi::SQLITE_INTEGER);
|
|
|
|
raw_from_impl!(i64, sqlite3_value_int64, ffi::SQLITE_INTEGER);
|
|
|
|
|
2015-08-09 19:06:23 +08:00
|
|
|
impl FromValue for bool {
|
|
|
|
unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<bool> {
|
|
|
|
match ffi::sqlite3_value_int(v) {
|
|
|
|
0 => Ok(false),
|
|
|
|
_ => Ok(true),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn parameter_has_valid_sqlite_type(v: *mut sqlite3_value) -> bool {
|
|
|
|
sqlite3_value_numeric_type(v) == ffi::SQLITE_INTEGER
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-09 15:52:53 +08:00
|
|
|
impl FromValue for c_double {
|
|
|
|
unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<c_double> {
|
|
|
|
Ok(ffi::sqlite3_value_double(v))
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn parameter_has_valid_sqlite_type(v: *mut sqlite3_value) -> bool {
|
2015-12-12 00:41:40 +08:00
|
|
|
sqlite3_value_numeric_type(v) == ffi::SQLITE_FLOAT ||
|
|
|
|
sqlite3_value_numeric_type(v) == ffi::SQLITE_INTEGER
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FromValue for String {
|
|
|
|
unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<String> {
|
|
|
|
let c_text = ffi::sqlite3_value_text(v);
|
|
|
|
if c_text.is_null() {
|
|
|
|
Ok("".to_string())
|
|
|
|
} else {
|
|
|
|
let c_slice = CStr::from_ptr(c_text as *const c_char).to_bytes();
|
|
|
|
let utf8_str = str::from_utf8(c_slice);
|
2015-12-12 00:41:40 +08:00
|
|
|
utf8_str.map(|s| s.to_string())
|
|
|
|
.map_err(|e| {
|
|
|
|
SqliteError {
|
|
|
|
code: 0,
|
|
|
|
message: e.to_string(),
|
|
|
|
}
|
|
|
|
})
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn parameter_has_valid_sqlite_type(v: *mut sqlite3_value) -> bool {
|
|
|
|
sqlite3_value_type(v) == ffi::SQLITE_TEXT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl FromValue for Vec<u8> {
|
|
|
|
unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<Vec<u8>> {
|
|
|
|
use std::slice::from_raw_parts;
|
|
|
|
let c_blob = ffi::sqlite3_value_blob(v);
|
|
|
|
let len = ffi::sqlite3_value_bytes(v);
|
|
|
|
|
2015-12-12 00:41:40 +08:00
|
|
|
assert!(len >= 0,
|
|
|
|
"unexpected negative return from sqlite3_value_bytes");
|
2015-08-09 15:52:53 +08:00
|
|
|
let len = len as usize;
|
|
|
|
|
|
|
|
Ok(from_raw_parts(mem::transmute(c_blob), len).to_vec())
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn parameter_has_valid_sqlite_type(v: *mut sqlite3_value) -> bool {
|
|
|
|
sqlite3_value_type(v) == ffi::SQLITE_BLOB
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T: FromValue> FromValue for Option<T> {
|
|
|
|
unsafe fn parameter_value(v: *mut sqlite3_value) -> SqliteResult<Option<T>> {
|
|
|
|
if sqlite3_value_type(v) == ffi::SQLITE_NULL {
|
|
|
|
Ok(None)
|
|
|
|
} else {
|
|
|
|
FromValue::parameter_value(v).map(|t| Some(t))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
unsafe fn parameter_has_valid_sqlite_type(v: *mut sqlite3_value) -> bool {
|
2015-12-12 00:41:40 +08:00
|
|
|
sqlite3_value_type(v) == ffi::SQLITE_NULL || T::parameter_has_valid_sqlite_type(v)
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-12 02:54:08 +08:00
|
|
|
unsafe extern "C" fn free_boxed_value<T>(p: *mut c_void) {
|
|
|
|
let _: Box<T> = Box::from_raw(mem::transmute(p));
|
|
|
|
}
|
|
|
|
|
2015-12-12 03:46:28 +08:00
|
|
|
pub struct Context<'a> {
|
2015-12-12 04:08:40 +08:00
|
|
|
ctx: *mut sqlite3_context,
|
2015-12-12 03:46:28 +08:00
|
|
|
args: &'a [*mut sqlite3_value],
|
2015-12-12 02:54:08 +08:00
|
|
|
}
|
|
|
|
|
2015-12-12 03:46:28 +08:00
|
|
|
impl<'a> Context<'a> {
|
|
|
|
pub fn len(&self) -> usize {
|
|
|
|
self.args.len()
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn get<T: FromValue>(&self, idx: usize) -> SqliteResult<T> {
|
|
|
|
let arg = self.args[idx];
|
|
|
|
unsafe {
|
|
|
|
if T::parameter_has_valid_sqlite_type(arg) {
|
|
|
|
T::parameter_value(arg)
|
|
|
|
} else {
|
|
|
|
Err(SqliteError {
|
|
|
|
code: ffi::SQLITE_MISMATCH,
|
|
|
|
message: "Invalid value type".to_string(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-12 02:54:08 +08:00
|
|
|
pub fn set_aux<T>(&self, arg: c_int, value: T) {
|
|
|
|
let boxed = Box::into_raw(Box::new(value));
|
|
|
|
unsafe {
|
|
|
|
ffi::sqlite3_set_auxdata(self.ctx,
|
|
|
|
arg,
|
|
|
|
mem::transmute(boxed),
|
|
|
|
Some(mem::transmute(free_boxed_value::<T>)))
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
pub unsafe fn get_aux<T>(&self, arg: c_int) -> Option<&T> {
|
|
|
|
let p = ffi::sqlite3_get_auxdata(self.ctx, arg) as *mut T;
|
|
|
|
if p.is_null() {
|
|
|
|
None
|
|
|
|
} else {
|
|
|
|
Some(&*p)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-09 15:52:53 +08:00
|
|
|
impl SqliteConnection {
|
2015-12-12 04:08:40 +08:00
|
|
|
pub fn create_scalar_function<F, T>(&self,
|
|
|
|
fn_name: &str,
|
|
|
|
n_arg: c_int,
|
|
|
|
deterministic: bool,
|
|
|
|
x_func: F)
|
|
|
|
-> SqliteResult<()>
|
|
|
|
where F: FnMut(&Context) -> SqliteResult<T>,
|
|
|
|
T: ToResult
|
2015-12-12 01:01:05 +08:00
|
|
|
{
|
2015-08-09 15:52:53 +08:00
|
|
|
self.db.borrow_mut().create_scalar_function(fn_name, n_arg, deterministic, x_func)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl InnerSqliteConnection {
|
2015-12-12 04:08:40 +08:00
|
|
|
fn create_scalar_function<F, T>(&mut self,
|
|
|
|
fn_name: &str,
|
|
|
|
n_arg: c_int,
|
|
|
|
deterministic: bool,
|
|
|
|
x_func: F)
|
|
|
|
-> SqliteResult<()>
|
|
|
|
where F: FnMut(&Context) -> SqliteResult<T>,
|
|
|
|
T: ToResult
|
2015-12-12 01:01:05 +08:00
|
|
|
{
|
2015-12-12 04:08:40 +08:00
|
|
|
extern "C" fn call_boxed_closure<F, T>(ctx: *mut sqlite3_context,
|
|
|
|
argc: c_int,
|
|
|
|
argv: *mut *mut sqlite3_value)
|
|
|
|
where F: FnMut(&Context) -> SqliteResult<T>,
|
|
|
|
T: ToResult
|
2015-12-12 01:01:05 +08:00
|
|
|
{
|
|
|
|
unsafe {
|
2015-12-12 03:46:28 +08:00
|
|
|
let ctx = Context {
|
|
|
|
ctx: ctx,
|
|
|
|
args: slice::from_raw_parts(argv, argc as usize),
|
|
|
|
};
|
2015-12-12 02:54:08 +08:00
|
|
|
let boxed_f: *mut F = mem::transmute(ffi::sqlite3_user_data(ctx.ctx));
|
2015-12-12 01:01:05 +08:00
|
|
|
assert!(!boxed_f.is_null(), "Internal error - null function pointer");
|
2015-12-12 04:08:40 +08:00
|
|
|
match (*boxed_f)(&ctx) {
|
|
|
|
Ok(r) => r.set_result(ctx.ctx),
|
|
|
|
Err(e) => {
|
|
|
|
ffi::sqlite3_result_error_code(ctx.ctx, e.code);
|
|
|
|
if let Ok(cstr) = str_to_cstring(&e.message) {
|
|
|
|
ffi::sqlite3_result_error(ctx.ctx, cstr.as_ptr(), -1);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
}
|
2015-12-12 01:01:05 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let boxed_f: *mut F = Box::into_raw(Box::new(x_func));
|
2015-08-09 15:52:53 +08:00
|
|
|
let c_name = try!(str_to_cstring(fn_name));
|
|
|
|
let mut flags = ffi::SQLITE_UTF8;
|
|
|
|
if deterministic {
|
|
|
|
flags |= ffi::SQLITE_DETERMINISTIC;
|
|
|
|
}
|
|
|
|
let r = unsafe {
|
2015-12-12 00:41:40 +08:00
|
|
|
ffi::sqlite3_create_function_v2(self.db(),
|
|
|
|
c_name.as_ptr(),
|
|
|
|
n_arg,
|
|
|
|
flags,
|
2015-12-12 01:01:05 +08:00
|
|
|
mem::transmute(boxed_f),
|
2015-12-12 04:08:40 +08:00
|
|
|
Some(call_boxed_closure::<F, T>),
|
2015-12-12 00:41:40 +08:00
|
|
|
None,
|
|
|
|
None,
|
2015-12-12 02:54:08 +08:00
|
|
|
Some(mem::transmute(free_boxed_value::<F>)))
|
2015-08-09 15:52:53 +08:00
|
|
|
};
|
|
|
|
self.decode_result(r)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
2015-08-09 19:06:23 +08:00
|
|
|
extern crate regex;
|
|
|
|
|
2015-12-12 03:46:28 +08:00
|
|
|
use libc::c_double;
|
2015-08-09 19:06:23 +08:00
|
|
|
use self::regex::Regex;
|
|
|
|
|
2015-12-12 04:08:40 +08:00
|
|
|
use {SqliteConnection, SqliteError, SqliteResult};
|
2015-08-09 15:52:53 +08:00
|
|
|
use ffi;
|
2015-12-12 04:08:40 +08:00
|
|
|
use functions::Context;
|
2015-08-09 15:52:53 +08:00
|
|
|
|
2015-12-12 04:08:40 +08:00
|
|
|
fn half(ctx: &Context) -> SqliteResult<c_double> {
|
2015-12-12 03:46:28 +08:00
|
|
|
assert!(ctx.len() == 1, "called with unexpected number of arguments");
|
2015-12-12 04:08:40 +08:00
|
|
|
let value = try!(ctx.get::<c_double>(0));
|
|
|
|
Ok(value / 2f64)
|
2015-08-09 15:52:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2015-12-12 01:01:05 +08:00
|
|
|
fn test_function_half() {
|
2015-08-09 15:52:53 +08:00
|
|
|
let db = SqliteConnection::open_in_memory().unwrap();
|
2015-12-12 01:01:05 +08:00
|
|
|
db.create_scalar_function("half", 1, true, half).unwrap();
|
2015-12-12 00:41:40 +08:00
|
|
|
let result = db.query_row("SELECT half(6)", &[], |r| r.get::<f64>(0));
|
2015-08-09 15:52:53 +08:00
|
|
|
|
|
|
|
assert_eq!(3f64, result.unwrap());
|
|
|
|
}
|
2015-08-09 19:06:23 +08:00
|
|
|
|
2015-12-12 04:08:40 +08:00
|
|
|
fn regexp(ctx: &Context) -> SqliteResult<bool> {
|
2015-12-12 03:46:28 +08:00
|
|
|
assert!(ctx.len() == 2, "called with unexpected number of arguments");
|
|
|
|
|
2015-12-12 02:54:08 +08:00
|
|
|
let saved_re: Option<&Regex> = unsafe { ctx.get_aux(0) };
|
|
|
|
let new_re = match saved_re {
|
2015-12-12 04:08:40 +08:00
|
|
|
None => {
|
|
|
|
let s = try!(ctx.get::<String>(0));
|
|
|
|
let r = try!(Regex::new(&s).map_err(|e| SqliteError {
|
|
|
|
code: ffi::SQLITE_ERROR,
|
|
|
|
message: format!("Invalid regular expression: {}", e),
|
|
|
|
}));
|
|
|
|
Some(r)
|
2015-12-12 02:54:08 +08:00
|
|
|
},
|
|
|
|
Some(_) => None,
|
|
|
|
};
|
2015-08-09 19:06:23 +08:00
|
|
|
|
2015-12-12 04:08:40 +08:00
|
|
|
let is_match = {
|
2015-12-12 02:54:08 +08:00
|
|
|
let re = saved_re.unwrap_or_else(|| new_re.as_ref().unwrap());
|
|
|
|
|
2015-12-12 04:08:40 +08:00
|
|
|
let text = try!(ctx.get::<String>(1));
|
|
|
|
re.is_match(&text)
|
|
|
|
};
|
2015-08-09 19:06:23 +08:00
|
|
|
|
2015-12-12 02:54:08 +08:00
|
|
|
if let Some(re) = new_re {
|
|
|
|
ctx.set_aux(0, re);
|
2015-08-09 19:06:23 +08:00
|
|
|
}
|
2015-12-12 04:08:40 +08:00
|
|
|
|
|
|
|
Ok(is_match)
|
2015-08-09 19:06:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
2015-12-12 03:46:28 +08:00
|
|
|
#[cfg_attr(rustfmt, rustfmt_skip)]
|
2015-12-12 01:01:05 +08:00
|
|
|
fn test_function_regexp() {
|
2015-08-09 19:06:23 +08:00
|
|
|
let db = SqliteConnection::open_in_memory().unwrap();
|
2015-12-12 03:46:28 +08:00
|
|
|
db.execute_batch("BEGIN;
|
|
|
|
CREATE TABLE foo (x string);
|
|
|
|
INSERT INTO foo VALUES ('lisa');
|
|
|
|
INSERT INTO foo VALUES ('lXsi');
|
|
|
|
INSERT INTO foo VALUES ('lisX');
|
|
|
|
END;").unwrap();
|
2015-12-12 01:01:05 +08:00
|
|
|
db.create_scalar_function("regexp", 2, true, regexp).unwrap();
|
2015-12-12 03:46:28 +08:00
|
|
|
|
2015-08-09 19:06:23 +08:00
|
|
|
let result = db.query_row("SELECT regexp('l.s[aeiouy]', 'lisa')",
|
2015-12-12 00:41:40 +08:00
|
|
|
&[],
|
|
|
|
|r| r.get::<bool>(0));
|
2015-08-09 19:06:23 +08:00
|
|
|
|
|
|
|
assert_eq!(true, result.unwrap());
|
2015-12-12 03:46:28 +08:00
|
|
|
|
|
|
|
let result = db.query_row("SELECT COUNT(*) FROM foo WHERE regexp('l.s[aeiouy]', x) == 1",
|
|
|
|
&[],
|
|
|
|
|r| r.get::<i64>(0));
|
|
|
|
|
|
|
|
assert_eq!(2, result.unwrap());
|
2015-08-09 19:06:23 +08:00
|
|
|
}
|
2015-12-07 04:33:21 +08:00
|
|
|
}
|