1use std::borrow::Cow::{self, Borrowed, Owned};
13use std::ffi::{CStr, c_char, c_int, c_uint, c_void};
14use std::marker::PhantomData;
15use std::ops::Deref;
16use std::ptr;
17use std::slice;
18
19use crate::ffi::{sqlite3_context, sqlite3_free, sqlite3_value};
20
21use crate::context::set_result;
22use crate::error::{check, error_from_sqlite_code, to_sqlite_error};
23use crate::ffi;
24pub use crate::ffi::{sqlite3_vtab, sqlite3_vtab_cursor};
25use crate::types::{FromSql, FromSqlError, ToSql, ValueRef};
26use crate::util::{alloc, free_boxed_value};
27use crate::{Connection, Error, InnerConnection, Name, Result, str_to_cstring};
28
29pub enum VTabKind {
65 Default,
67 Eponymous,
71 EponymousOnly,
78}
79
80#[repr(transparent)]
84pub struct Module<'vtab, T: VTab<'vtab>> {
85 base: ffi::sqlite3_module,
86 phantom: PhantomData<&'vtab T>,
87}
88
89union ModuleZeroHack {
90 bytes: [u8; size_of::<ffi::sqlite3_module>()],
91 module: ffi::sqlite3_module,
92}
93
94const ZERO_MODULE: ffi::sqlite3_module = unsafe {
98 ModuleZeroHack {
99 bytes: [0_u8; size_of::<ffi::sqlite3_module>()],
100 }
101 .module
102};
103
104impl<'vtab, T: VTab<'vtab>> Module<'vtab, T> {
105 #[must_use]
109 pub const fn eponymous_only_module() -> Self {
110 Module {
112 base: ffi::sqlite3_module {
113 iVersion: 1,
115 xCreate: None,
116 xConnect: Some(rust_connect::<T>),
117 xBestIndex: Some(rust_best_index::<T>),
118 xDisconnect: Some(rust_disconnect::<T>),
119 xDestroy: None,
120 xOpen: Some(rust_open::<T>),
121 xClose: Some(rust_close::<T::Cursor>),
122 xFilter: Some(rust_filter::<T::Cursor>),
123 xNext: Some(rust_next::<T::Cursor>),
124 xEof: Some(rust_eof::<T::Cursor>),
125 xColumn: Some(rust_column::<T::Cursor>),
126 xRowid: Some(rust_rowid::<T::Cursor>),
127 xUpdate: None,
128 xBegin: None,
129 xSync: None,
130 xCommit: None,
131 xRollback: None,
132 xFindFunction: None,
133 xRename: None,
134 ..ZERO_MODULE
135 },
136 phantom: PhantomData::<&'vtab T>,
137 }
138 }
139
140 #[must_use]
144 pub const fn read_only_module() -> Self
145 where
146 T: CreateVTab<'vtab>,
147 {
148 let mut module = Self::eponymous_only_module();
149 match T::KIND {
150 VTabKind::EponymousOnly => module,
151 VTabKind::Eponymous => {
152 module.base.xCreate = module.base.xConnect;
155 module.base.xDestroy = module.base.xDisconnect;
156 module
157 }
158 _ => {
159 module.base.xCreate = Some(rust_create::<T>);
162 module.base.xDestroy = Some(rust_destroy::<T>);
163 module
164 }
165 }
166 }
167
168 #[must_use]
172 pub const fn update_module() -> Self
173 where
174 T: UpdateVTab<'vtab>,
175 {
176 let mut module = Self::read_only_module();
177 module.base.xUpdate = Some(rust_update::<T>);
178 module
179 }
180
181 #[must_use]
185 pub const fn update_module_with_tx() -> Self
186 where
187 T: TransactionVTab<'vtab>,
188 {
189 let mut module = Self::update_module();
190 module.base.xBegin = Some(rust_begin::<T>);
191 module.base.xSync = Some(rust_sync::<T>);
192 module.base.xCommit = Some(rust_commit::<T>);
193 module.base.xRollback = Some(rust_rollback::<T>);
194 module
195 }
196
197 #[must_use]
199 pub const fn without_rowid(mut self) -> Self {
200 self.base.xRowid = None;
201 self
202 }
203
204 #[must_use]
206 pub const fn without_sync(mut self) -> Self
207 where
208 T: TransactionVTab<'vtab>,
209 {
210 self.base.xSync = None;
211 self
212 }
213}
214
215#[repr(i32)]
217#[non_exhaustive]
218#[derive(Debug, Clone, Copy, Eq, PartialEq)]
219pub enum VTabConfig {
220 ConstraintSupport = 1,
222 Innocuous = 2,
224 DirectOnly = 3,
226 UsesAllSchemas = 4,
228}
229
230pub struct VTabConnection(*mut ffi::sqlite3);
232
233impl VTabConnection {
234 pub fn config(&mut self, config: VTabConfig) -> Result<()> {
236 check(unsafe { ffi::sqlite3_vtab_config(self.0, config as c_int) })
237 }
238
239 pub unsafe fn handle(&mut self) -> *mut ffi::sqlite3 {
253 self.0
254 }
255}
256
257pub unsafe trait VTab<'vtab>: Sized {
275 type Aux: Send + Sync + 'static;
277 type Cursor: VTabCursor;
279
280 fn connect(
284 db: &mut VTabConnection,
285 aux: Option<&Self::Aux>,
286 module_name: &[u8],
287 database_name: &[u8],
288 table_name: &[u8],
289 args: &[&[u8]],
290 ) -> Result<(Cow<'static, CStr>, Self)>;
291
292 fn best_index(&self, info: &mut IndexInfo) -> Result<bool>;
296
297 fn open(&'vtab mut self) -> Result<Self::Cursor>;
300}
301
302pub trait CreateVTab<'vtab>: VTab<'vtab> {
306 const KIND: VTabKind;
310 fn create(
318 db: &mut VTabConnection,
319 aux: Option<&Self::Aux>,
320 module_name: &[u8],
321 database_name: &[u8],
322 table_name: &[u8],
323 args: &[&[u8]],
324 ) -> Result<(Cow<'static, CStr>, Self)> {
325 Self::connect(db, aux, module_name, database_name, table_name, args)
326 }
327
328 fn destroy(&self) -> Result<()> {
334 Ok(())
335 }
336}
337
338pub trait UpdateVTab<'vtab>: CreateVTab<'vtab> {
342 fn delete(&mut self, arg: ValueRef<'_>) -> Result<()>;
344 fn insert(&mut self, args: &Inserts<'_>) -> Result<i64>;
350 fn update(&mut self, args: &Updates<'_>) -> Result<()>;
353}
354
355pub trait TransactionVTab<'vtab>: UpdateVTab<'vtab> {
359 fn begin(&mut self) -> Result<()> {
361 Ok(())
362 }
363 fn sync(&mut self) -> Result<()> {
365 Ok(())
366 }
367 fn commit(&mut self) -> Result<()> {
369 Ok(())
370 }
371 fn rollback(&mut self) -> Result<()> {
373 Ok(())
374 }
375}
376
377#[derive(Debug, Eq, PartialEq)]
380#[allow(missing_docs)]
381#[expect(non_camel_case_types)]
382pub enum IndexConstraintOp {
383 SQLITE_INDEX_CONSTRAINT_EQ,
384 SQLITE_INDEX_CONSTRAINT_GT,
385 SQLITE_INDEX_CONSTRAINT_LE,
386 SQLITE_INDEX_CONSTRAINT_LT,
387 SQLITE_INDEX_CONSTRAINT_GE,
388 SQLITE_INDEX_CONSTRAINT_MATCH,
389 SQLITE_INDEX_CONSTRAINT_LIKE, SQLITE_INDEX_CONSTRAINT_GLOB, SQLITE_INDEX_CONSTRAINT_REGEXP, SQLITE_INDEX_CONSTRAINT_NE, SQLITE_INDEX_CONSTRAINT_ISNOT, SQLITE_INDEX_CONSTRAINT_ISNOTNULL, SQLITE_INDEX_CONSTRAINT_ISNULL, SQLITE_INDEX_CONSTRAINT_IS, SQLITE_INDEX_CONSTRAINT_LIMIT, SQLITE_INDEX_CONSTRAINT_OFFSET, SQLITE_INDEX_CONSTRAINT_FUNCTION(u8), }
401
402impl From<u8> for IndexConstraintOp {
403 fn from(code: u8) -> Self {
404 match code {
405 2 => Self::SQLITE_INDEX_CONSTRAINT_EQ,
406 4 => Self::SQLITE_INDEX_CONSTRAINT_GT,
407 8 => Self::SQLITE_INDEX_CONSTRAINT_LE,
408 16 => Self::SQLITE_INDEX_CONSTRAINT_LT,
409 32 => Self::SQLITE_INDEX_CONSTRAINT_GE,
410 64 => Self::SQLITE_INDEX_CONSTRAINT_MATCH,
411 65 => Self::SQLITE_INDEX_CONSTRAINT_LIKE,
412 66 => Self::SQLITE_INDEX_CONSTRAINT_GLOB,
413 67 => Self::SQLITE_INDEX_CONSTRAINT_REGEXP,
414 68 => Self::SQLITE_INDEX_CONSTRAINT_NE,
415 69 => Self::SQLITE_INDEX_CONSTRAINT_ISNOT,
416 70 => Self::SQLITE_INDEX_CONSTRAINT_ISNOTNULL,
417 71 => Self::SQLITE_INDEX_CONSTRAINT_ISNULL,
418 72 => Self::SQLITE_INDEX_CONSTRAINT_IS,
419 73 => Self::SQLITE_INDEX_CONSTRAINT_LIMIT,
420 74 => Self::SQLITE_INDEX_CONSTRAINT_OFFSET,
421 v => Self::SQLITE_INDEX_CONSTRAINT_FUNCTION(v),
422 }
423 }
424}
425
426bitflags::bitflags! {
427 #[repr(C)]
430 #[derive(Copy, Clone, Debug)]
431 pub struct IndexFlags: c_int {
432 const NONE = 0;
434 const SQLITE_INDEX_SCAN_UNIQUE = ffi::SQLITE_INDEX_SCAN_UNIQUE;
436 const SQLITE_INDEX_SCAN_HEX = 0x0000_0002; }
439}
440
441#[derive(Debug)]
446pub struct IndexInfo(*mut ffi::sqlite3_index_info);
447
448impl IndexInfo {
449 #[inline]
451 pub fn constraints_and_usages(&mut self) -> IndexConstraintAndUsageIter<'_> {
452 let constraints =
453 unsafe { slice::from_raw_parts((*self.0).aConstraint, (*self.0).nConstraint as usize) };
454 let constraint_usages = unsafe {
455 slice::from_raw_parts_mut((*self.0).aConstraintUsage, (*self.0).nConstraint as usize)
456 };
457 IndexConstraintAndUsageIter {
458 iter: constraints.iter().zip(constraint_usages.iter_mut()),
459 }
460 }
461
462 #[inline]
464 #[must_use]
465 pub fn constraints(&self) -> IndexConstraintIter<'_> {
466 let constraints =
467 unsafe { slice::from_raw_parts((*self.0).aConstraint, (*self.0).nConstraint as usize) };
468 IndexConstraintIter {
469 iter: constraints.iter(),
470 }
471 }
472
473 #[inline]
475 #[must_use]
476 pub fn order_bys(&self) -> OrderByIter<'_> {
477 let order_bys =
478 unsafe { slice::from_raw_parts((*self.0).aOrderBy, (*self.0).nOrderBy as usize) };
479 OrderByIter {
480 iter: order_bys.iter(),
481 }
482 }
483
484 #[inline]
486 #[must_use]
487 pub fn num_of_order_by(&self) -> usize {
488 unsafe { (*self.0).nOrderBy as usize }
489 }
490
491 #[inline]
493 pub fn constraint_usage(&mut self, constraint_idx: usize) -> IndexConstraintUsage<'_> {
494 let constraint_usages = unsafe {
495 slice::from_raw_parts_mut((*self.0).aConstraintUsage, (*self.0).nConstraint as usize)
496 };
497 IndexConstraintUsage(&mut constraint_usages[constraint_idx])
498 }
499
500 #[inline]
502 pub fn set_idx_num(&mut self, idx_num: c_int) {
503 unsafe {
504 (*self.0).idxNum = idx_num;
505 }
506 }
507
508 pub fn set_idx_str(&mut self, idx_str: &str) {
510 unsafe {
511 if (*self.0).needToFreeIdxStr == 1 {
512 sqlite3_free((*self.0).idxStr.cast());
513 }
514 (*self.0).idxStr = alloc(idx_str);
515 (*self.0).needToFreeIdxStr = 1;
516 }
517 }
518
519 pub fn set_idx_cstr(&mut self, idx_str: &'static CStr) {
521 unsafe {
522 if (*self.0).needToFreeIdxStr == 1 {
523 sqlite3_free((*self.0).idxStr.cast());
524 }
525 (*self.0).idxStr = idx_str.as_ptr().cast_mut();
526 (*self.0).needToFreeIdxStr = 0;
527 }
528 }
529
530 #[inline]
532 pub fn set_order_by_consumed(&mut self, order_by_consumed: bool) {
533 unsafe {
534 (*self.0).orderByConsumed = c_int::from(order_by_consumed);
535 }
536 }
537
538 #[inline]
540 pub fn set_estimated_cost(&mut self, estimated_ost: f64) {
541 unsafe {
542 (*self.0).estimatedCost = estimated_ost;
543 }
544 }
545
546 #[inline]
548 pub fn set_estimated_rows(&mut self, estimated_rows: i64) {
549 unsafe {
550 (*self.0).estimatedRows = estimated_rows;
551 }
552 }
553
554 #[inline]
556 pub fn set_idx_flags(&mut self, flags: IndexFlags) {
557 unsafe { (*self.0).idxFlags = flags.bits() };
558 }
559
560 #[inline]
562 #[must_use]
563 pub fn col_used(&self) -> u64 {
564 unsafe { (*self.0).colUsed }
565 }
566
567 pub fn collation(&self, constraint_idx: usize) -> Result<&str> {
569 let idx = constraint_idx as c_int;
570 let collation = unsafe { ffi::sqlite3_vtab_collation(self.0, idx) };
571 if collation.is_null() {
572 return Err(err!(ffi::SQLITE_MISUSE, "{constraint_idx} is out of range"));
573 }
574 Ok(unsafe { CStr::from_ptr(collation) }.to_str()?)
575 }
576
577 #[must_use]
579 pub fn distinct(&self) -> DistinctMode {
580 match unsafe { ffi::sqlite3_vtab_distinct(self.0) } {
581 0 => DistinctMode::Ordered,
582 1 => DistinctMode::Grouped,
583 2 => DistinctMode::Distinct,
584 3 => DistinctMode::DistinctOrdered,
585 _ => DistinctMode::Ordered,
586 }
587 }
588
589 pub fn rhs_value(&self, constraint_idx: usize) -> Result<Option<ValueRef<'_>>> {
591 let idx = constraint_idx as c_int;
592 let mut p_value: *mut sqlite3_value = ptr::null_mut();
593 let rc = unsafe { ffi::sqlite3_vtab_rhs_value(self.0, idx, &raw mut p_value) };
594 if rc == ffi::SQLITE_NOTFOUND {
595 return Ok(None);
596 }
597 check(rc)?;
598 assert!(!p_value.is_null());
599 Ok(Some(unsafe { ValueRef::from_value(p_value) }))
600 }
601
602 pub fn is_in_constraint(&self, constraint_idx: usize) -> Result<bool> {
604 self.check_constraint_index(constraint_idx)?;
605 let idx = constraint_idx as c_int;
606 Ok(unsafe { ffi::sqlite3_vtab_in(self.0, idx, -1) != 0 })
607 }
608
609 pub fn set_in_constraint(&mut self, constraint_idx: usize, filter_all: bool) -> Result<bool> {
611 self.check_constraint_index(constraint_idx)?;
612 let idx = constraint_idx as c_int;
613 Ok(unsafe { ffi::sqlite3_vtab_in(self.0, idx, c_int::from(filter_all)) != 0 })
614 }
615
616 fn check_constraint_index(&self, idx: usize) -> Result<()> {
617 if idx >= unsafe { (*self.0).nConstraint } as usize {
618 return Err(err!(ffi::SQLITE_MISUSE, "{idx} is out of range"));
619 }
620 Ok(())
621 }
622}
623
624#[non_exhaustive]
626#[derive(Debug, Eq, PartialEq)]
627pub enum DistinctMode {
628 Ordered,
630 Grouped,
632 Distinct,
634 DistinctOrdered,
636}
637
638pub struct IndexConstraintAndUsageIter<'a> {
640 iter: std::iter::Zip<
641 slice::Iter<'a, ffi::sqlite3_index_constraint>,
642 slice::IterMut<'a, ffi::sqlite3_index_constraint_usage>,
643 >,
644}
645
646impl<'a> Iterator for IndexConstraintAndUsageIter<'a> {
647 type Item = (IndexConstraint<'a>, IndexConstraintUsage<'a>);
648
649 #[inline]
650 fn next(&mut self) -> Option<(IndexConstraint<'a>, IndexConstraintUsage<'a>)> {
651 self.iter
652 .next()
653 .map(|raw| (IndexConstraint(raw.0), IndexConstraintUsage(raw.1)))
654 }
655
656 #[inline]
657 fn size_hint(&self) -> (usize, Option<usize>) {
658 self.iter.size_hint()
659 }
660}
661
662pub struct IndexConstraintIter<'a> {
664 iter: slice::Iter<'a, ffi::sqlite3_index_constraint>,
665}
666
667impl<'a> Iterator for IndexConstraintIter<'a> {
668 type Item = IndexConstraint<'a>;
669
670 #[inline]
671 fn next(&mut self) -> Option<IndexConstraint<'a>> {
672 self.iter.next().map(IndexConstraint)
673 }
674
675 #[inline]
676 fn size_hint(&self) -> (usize, Option<usize>) {
677 self.iter.size_hint()
678 }
679}
680
681pub struct IndexConstraint<'a>(&'a ffi::sqlite3_index_constraint);
683
684impl IndexConstraint<'_> {
685 #[inline]
687 #[must_use]
688 pub fn column(&self) -> c_int {
689 self.0.iColumn
690 }
691
692 #[inline]
694 #[must_use]
695 pub fn operator(&self) -> IndexConstraintOp {
696 IndexConstraintOp::from(self.0.op)
697 }
698
699 #[inline]
701 #[must_use]
702 pub fn is_usable(&self) -> bool {
703 self.0.usable != 0
704 }
705}
706
707pub struct IndexConstraintUsage<'a>(&'a mut ffi::sqlite3_index_constraint_usage);
710
711impl IndexConstraintUsage<'_> {
712 #[inline]
715 pub fn set_argv_index(&mut self, argv_index: c_int) {
716 self.0.argvIndex = argv_index;
717 }
718
719 #[inline]
721 pub fn set_omit(&mut self, omit: bool) {
722 self.0.omit = std::ffi::c_uchar::from(omit);
723 }
724}
725
726pub struct OrderByIter<'a> {
728 iter: slice::Iter<'a, ffi::sqlite3_index_orderby>,
729}
730
731impl<'a> Iterator for OrderByIter<'a> {
732 type Item = OrderBy<'a>;
733
734 #[inline]
735 fn next(&mut self) -> Option<OrderBy<'a>> {
736 self.iter.next().map(OrderBy)
737 }
738
739 #[inline]
740 fn size_hint(&self) -> (usize, Option<usize>) {
741 self.iter.size_hint()
742 }
743}
744
745pub struct OrderBy<'a>(&'a ffi::sqlite3_index_orderby);
747
748impl OrderBy<'_> {
749 #[inline]
751 #[must_use]
752 pub fn column(&self) -> c_int {
753 self.0.iColumn
754 }
755
756 #[inline]
758 #[must_use]
759 pub fn is_order_by_desc(&self) -> bool {
760 self.0.desc != 0
761 }
762}
763
764pub unsafe trait VTabCursor: Sized {
780 fn filter(&mut self, idx_num: c_int, idx_str: Option<&str>, args: &Filters<'_>) -> Result<()>;
783 fn next(&mut self) -> Result<()>;
786 fn eof(&self) -> bool;
790 fn column(&self, ctx: &mut Context, i: c_int) -> Result<()>;
795 fn rowid(&self) -> Result<i64>;
798}
799
800pub struct Context(*mut sqlite3_context);
803
804impl Context {
805 #[inline]
807 pub fn set_result<T: ToSql>(&mut self, value: T) -> Result<()> {
808 let t = value.to_sql()?;
809 unsafe { set_result(self.0, &[], t) }
810 }
811
812 #[inline]
814 #[must_use]
815 pub fn no_change(&self) -> bool {
816 unsafe { ffi::sqlite3_vtab_nochange(self.0) != 0 }
817 }
818
819 pub unsafe fn get_connection(&self) -> Result<ConnectionRef<'_>> {
825 Ok(ConnectionRef {
826 conn: unsafe {
827 let handle = ffi::sqlite3_context_db_handle(self.0);
828 Connection::from_handle(handle)?
829 },
830 phantom: PhantomData,
831 })
832 }
833}
834
835pub struct ConnectionRef<'ctx> {
837 conn: Connection,
840 phantom: PhantomData<&'ctx Context>,
841}
842
843impl Deref for ConnectionRef<'_> {
844 type Target = Connection;
845
846 #[inline]
847 fn deref(&self) -> &Connection {
848 &self.conn
849 }
850}
851
852pub struct Filters<'a> {
855 values: Values<'a>,
856}
857impl<'a> Deref for Filters<'a> {
858 type Target = Values<'a>;
859
860 fn deref(&self) -> &Self::Target {
861 &self.values
862 }
863}
864impl Filters<'_> {
865 pub fn in_values(&self, idx: usize) -> Result<InValues<'_>> {
867 let list = self.args[idx];
868 Ok(InValues {
869 list,
870 phantom: PhantomData,
871 first: true,
872 })
873 }
874}
875
876pub struct InValues<'a> {
878 list: *mut sqlite3_value,
879 phantom: PhantomData<Filters<'a>>,
880 first: bool,
881}
882impl<'a> fallible_iterator::FallibleIterator for InValues<'a> {
883 type Error = Error;
884 type Item = ValueRef<'a>;
885
886 fn next(&mut self) -> Result<Option<Self::Item>> {
887 let mut val: *mut sqlite3_value = ptr::null_mut();
888 let rc = unsafe {
889 if self.first {
890 self.first = false;
891 ffi::sqlite3_vtab_in_first(self.list, &raw mut val)
892 } else {
893 ffi::sqlite3_vtab_in_next(self.list, &raw mut val)
894 }
895 };
896 match rc {
897 ffi::SQLITE_OK => Ok(Some(unsafe { ValueRef::from_value(val) })),
898 ffi::SQLITE_DONE => Ok(None),
899 _ => Err(error_from_sqlite_code(rc, None)),
900 }
901 }
902}
903
904pub struct Values<'a> {
906 args: &'a [*mut sqlite3_value],
907}
908
909impl Values<'_> {
910 #[inline]
912 #[must_use]
913 pub fn len(&self) -> usize {
914 self.args.len()
915 }
916
917 #[inline]
919 #[must_use]
920 pub fn is_empty(&self) -> bool {
921 self.args.is_empty()
922 }
923
924 pub fn get<T: FromSql>(&self, idx: usize) -> Result<T> {
926 let arg = self.args[idx];
927 let value = unsafe { ValueRef::from_value(arg) };
928 FromSql::column_result(value).map_err(|err| match err {
929 FromSqlError::InvalidType => Error::InvalidFilterParameterType(idx, value.data_type()),
930 FromSqlError::Other(err) => {
931 Error::FromSqlConversionFailure(idx, value.data_type(), err)
932 }
933 FromSqlError::InvalidBlobSize { .. } => {
934 Error::FromSqlConversionFailure(idx, value.data_type(), Box::new(err))
935 }
936 FromSqlError::OutOfRange(i) => Error::IntegralValueOutOfRange(idx, i),
937 FromSqlError::Utf8Error(err) => Error::Utf8Error(idx, err),
938 })
939 }
940
941 #[inline]
948 #[must_use]
949 pub fn get_subtype(&self, idx: usize) -> c_uint {
950 let arg = self.args[idx];
951 unsafe { ffi::sqlite3_value_subtype(arg) }
952 }
953
954 #[cfg(feature = "pointer")]
960 #[must_use]
961 pub unsafe fn get_pointer<'a, T: 'static>(
962 &self,
963 idx: usize,
964 ptr_type: &'static CStr,
965 ) -> Option<&'a T> {
966 let arg = self.args[idx];
967 debug_assert_eq!(unsafe { ffi::sqlite3_value_type(arg) }, ffi::SQLITE_NULL);
968 unsafe {
969 ffi::sqlite3_value_pointer(arg, ptr_type.as_ptr())
970 .cast::<T>()
971 .as_ref()
972 }
973 }
974
975 #[inline]
977 #[must_use]
978 pub fn iter(&self) -> ValueIter<'_> {
979 ValueIter {
980 iter: self.args.iter(),
981 }
982 }
983}
984
985impl<'a> IntoIterator for &'a Values<'a> {
986 type IntoIter = ValueIter<'a>;
987 type Item = ValueRef<'a>;
988
989 #[inline]
990 fn into_iter(self) -> ValueIter<'a> {
991 self.iter()
992 }
993}
994
995pub struct ValueIter<'a> {
997 iter: slice::Iter<'a, *mut sqlite3_value>,
998}
999
1000impl<'a> Iterator for ValueIter<'a> {
1001 type Item = ValueRef<'a>;
1002
1003 #[inline]
1004 fn next(&mut self) -> Option<ValueRef<'a>> {
1005 self.iter
1006 .next()
1007 .map(|&raw| unsafe { ValueRef::from_value(raw) })
1008 }
1009
1010 #[inline]
1011 fn size_hint(&self) -> (usize, Option<usize>) {
1012 self.iter.size_hint()
1013 }
1014}
1015
1016pub struct Inserts<'a> {
1018 values: Values<'a>,
1019}
1020impl<'a> Deref for Inserts<'a> {
1021 type Target = Values<'a>;
1022
1023 fn deref(&self) -> &Self::Target {
1024 &self.values
1025 }
1026}
1027impl Inserts<'_> {
1028 #[must_use]
1033 pub unsafe fn on_conflict(&self, db: *mut ffi::sqlite3) -> ConflictMode {
1034 ConflictMode::from(unsafe { ffi::sqlite3_vtab_on_conflict(db) })
1035 }
1036}
1037
1038pub struct Updates<'a> {
1040 values: Values<'a>,
1041}
1042impl<'a> Deref for Updates<'a> {
1043 type Target = Values<'a>;
1044
1045 fn deref(&self) -> &Self::Target {
1046 &self.values
1047 }
1048}
1049impl Updates<'_> {
1050 #[inline]
1054 #[must_use]
1055 pub fn no_change(&self, idx: usize) -> bool {
1056 unsafe { ffi::sqlite3_value_nochange(self.values.args[idx]) != 0 }
1057 }
1058
1059 #[must_use]
1064 pub unsafe fn on_conflict(&self, db: *mut ffi::sqlite3) -> ConflictMode {
1065 ConflictMode::from(unsafe { ffi::sqlite3_vtab_on_conflict(db) })
1066 }
1067}
1068
1069#[non_exhaustive]
1071#[derive(Debug, Eq, PartialEq)]
1072pub enum ConflictMode {
1073 Rollback,
1075 Ignore,
1077 Fail,
1079 Abort,
1081 Replace,
1083}
1084impl From<c_int> for ConflictMode {
1085 fn from(value: c_int) -> Self {
1086 match value {
1087 ffi::SQLITE_ROLLBACK => ConflictMode::Rollback,
1088 ffi::SQLITE_IGNORE => ConflictMode::Ignore,
1089 ffi::SQLITE_FAIL => ConflictMode::Fail,
1090 ffi::SQLITE_ABORT => ConflictMode::Abort,
1091 ffi::SQLITE_REPLACE => ConflictMode::Replace,
1092 _ => unreachable!("sqlite3_vtab_on_conflict returned invalid value"),
1093 }
1094 }
1095}
1096
1097impl Connection {
1098 #[inline]
1103 pub fn create_module<'vtab, T: VTab<'vtab>, M: Name>(
1104 &self,
1105 module_name: M,
1106 module: &'static Module<'vtab, T>,
1107 aux: Option<T::Aux>,
1108 ) -> Result<()> {
1109 self.db.borrow_mut().create_module(module_name, module, aux)
1110 }
1111}
1112
1113impl InnerConnection {
1114 fn create_module<'vtab, T: VTab<'vtab>, M: Name>(
1115 &mut self,
1116 module_name: M,
1117 module: &'static Module<'vtab, T>,
1118 aux: Option<T::Aux>,
1119 ) -> Result<()> {
1120 use crate::version;
1121 if version::version_number() < 3_009_000 && module.base.xCreate.is_none() {
1122 return Err(Error::ModuleError(format!(
1123 "Eponymous-only virtual table not supported by SQLite version {}",
1124 version::version()
1125 )));
1126 }
1127 let c_name = module_name.as_cstr()?;
1128 let r = match aux {
1129 Some(aux) => {
1130 let boxed_aux: *mut T::Aux = Box::into_raw(Box::new(aux));
1131 unsafe {
1132 ffi::sqlite3_create_module_v2(
1133 self.db(),
1134 c_name.as_ptr(),
1135 &raw const module.base,
1136 boxed_aux.cast::<c_void>(),
1137 Some(free_boxed_value::<T::Aux>),
1138 )
1139 }
1140 }
1141 None => unsafe {
1142 ffi::sqlite3_create_module_v2(
1143 self.db(),
1144 c_name.as_ptr(),
1145 &raw const module.base,
1146 ptr::null_mut(),
1147 None,
1148 )
1149 },
1150 };
1151 self.decode_result(r)
1152 }
1153}
1154
1155#[must_use]
1158pub fn escape_double_quote(identifier: &str) -> Cow<'_, str> {
1159 if identifier.contains('"') {
1160 Owned(identifier.replace('"', "\"\""))
1162 } else {
1163 Borrowed(identifier)
1164 }
1165}
1166#[must_use]
1168pub fn dequote(mut s: &str) -> Cow<'_, str> {
1169 let mut chars = s.chars();
1170 let (Some(first), Some(last)) = (chars.next(), chars.next_back()) else {
1171 return Borrowed(s);
1172 };
1173 if (first == '"' || first == '\'' || first == '`' || first == '[')
1174 && (last == first || first == '[' && last == ']')
1175 {
1176 s = chars.as_str();
1177 if first != '[' && s.contains(first) {
1178 let mut owned = String::with_capacity(s.len());
1180 let mut escaped = false;
1181 for c in s.chars() {
1182 if c == first {
1183 if !escaped {
1184 escaped = true;
1185 continue;
1186 }
1187 escaped = false;
1188 } else if escaped {
1189 return Borrowed(s);
1191 }
1192 owned.push(c);
1193 }
1194 if !escaped {
1195 return Owned(owned);
1196 }
1197 }
1198 }
1199 Borrowed(s)
1200}
1201#[must_use]
1207pub fn parse_boolean(s: &str) -> Option<bool> {
1208 if s.eq_ignore_ascii_case("yes")
1209 || s.eq_ignore_ascii_case("on")
1210 || s.eq_ignore_ascii_case("true")
1211 || s.eq("1")
1212 {
1213 Some(true)
1214 } else if s.eq_ignore_ascii_case("no")
1215 || s.eq_ignore_ascii_case("off")
1216 || s.eq_ignore_ascii_case("false")
1217 || s.eq("0")
1218 {
1219 Some(false)
1220 } else {
1221 None
1222 }
1223}
1224
1225pub fn parameter(c_slice: &[u8]) -> Result<(&str, Cow<'_, str>)> {
1227 let arg = std::str::from_utf8(c_slice)?.trim();
1228 match arg.split_once('=') {
1229 Some((key, value)) => {
1230 let param = key.trim();
1231 let value = dequote(value.trim());
1232 Ok((param, value))
1233 }
1234 _ => Err(Error::ModuleError(format!("illegal argument: '{arg}'"))),
1235 }
1236}
1237
1238unsafe extern "C" fn rust_create<'vtab, T>(
1239 db: *mut ffi::sqlite3,
1240 aux: *mut c_void,
1241 argc: c_int,
1242 argv: *const *const c_char,
1243 pp_vtab: *mut *mut sqlite3_vtab,
1244 err_msg: *mut *mut c_char,
1245) -> c_int
1246where
1247 T: CreateVTab<'vtab>,
1248{
1249 let mut conn = VTabConnection(db);
1250 let aux = aux.cast::<T::Aux>();
1251 unsafe {
1252 let args = slice::from_raw_parts(argv, argc as usize);
1253 let vec = args
1254 .iter()
1255 .map(|&cs| CStr::from_ptr(cs).to_bytes()) .collect::<Vec<_>>();
1257 match T::create(&mut conn, aux.as_ref(), vec[0], vec[1], vec[2], &vec[3..]) {
1258 Ok((sql, vtab)) => {
1259 let rc = ffi::sqlite3_declare_vtab(db, sql.as_ptr());
1260 if rc == ffi::SQLITE_OK {
1261 let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab));
1262 *pp_vtab = boxed_vtab.cast::<sqlite3_vtab>();
1263 ffi::SQLITE_OK
1264 } else {
1265 let err = error_from_sqlite_code(rc, None);
1266 to_sqlite_error(&err, err_msg)
1267 }
1268 }
1269 Err(err) => to_sqlite_error(&err, err_msg),
1270 }
1271 }
1272}
1273
1274unsafe extern "C" fn rust_connect<'vtab, T>(
1275 db: *mut ffi::sqlite3,
1276 aux: *mut c_void,
1277 argc: c_int,
1278 argv: *const *const c_char,
1279 pp_vtab: *mut *mut sqlite3_vtab,
1280 err_msg: *mut *mut c_char,
1281) -> c_int
1282where
1283 T: VTab<'vtab>,
1284{
1285 let mut conn = VTabConnection(db);
1286 let aux = aux.cast::<T::Aux>();
1287 unsafe {
1288 let args = slice::from_raw_parts(argv, argc as usize);
1289 let vec = args
1290 .iter()
1291 .map(|&cs| CStr::from_ptr(cs).to_bytes()) .collect::<Vec<_>>();
1293 match T::connect(&mut conn, aux.as_ref(), vec[0], vec[1], vec[2], &vec[3..]) {
1294 Ok((sql, vtab)) => {
1295 let rc = ffi::sqlite3_declare_vtab(db, sql.as_ptr());
1296 if rc == ffi::SQLITE_OK {
1297 let boxed_vtab: *mut T = Box::into_raw(Box::new(vtab));
1298 *pp_vtab = boxed_vtab.cast::<sqlite3_vtab>();
1299 ffi::SQLITE_OK
1300 } else {
1301 let err = error_from_sqlite_code(rc, None);
1302 to_sqlite_error(&err, err_msg)
1303 }
1304 }
1305 Err(err) => to_sqlite_error(&err, err_msg),
1306 }
1307 }
1308}
1309
1310unsafe extern "C" fn rust_best_index<'vtab, T>(
1311 vtab: *mut sqlite3_vtab,
1312 info: *mut ffi::sqlite3_index_info,
1313) -> c_int
1314where
1315 T: VTab<'vtab>,
1316{
1317 let vt = vtab.cast::<T>();
1318 let mut idx_info = IndexInfo(info);
1319 unsafe {
1320 match (*vt).best_index(&mut idx_info) {
1321 Ok(true) => ffi::SQLITE_OK,
1322 Ok(false) => ffi::SQLITE_CONSTRAINT,
1323 err => vtab_error(vtab, err),
1324 }
1325 }
1326}
1327
1328unsafe extern "C" fn rust_disconnect<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
1329where
1330 T: VTab<'vtab>,
1331{
1332 if vtab.is_null() {
1333 return ffi::SQLITE_OK;
1334 }
1335 let vtab = vtab.cast::<T>();
1336 drop(unsafe { Box::from_raw(vtab) });
1337 ffi::SQLITE_OK
1338}
1339
1340unsafe extern "C" fn rust_destroy<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
1341where
1342 T: CreateVTab<'vtab>,
1343{
1344 if vtab.is_null() {
1345 return ffi::SQLITE_OK;
1346 }
1347 let vt = vtab.cast::<T>();
1348 unsafe {
1349 match (*vt).destroy() {
1350 Ok(()) => {
1351 drop(Box::from_raw(vt));
1352 ffi::SQLITE_OK
1353 }
1354 err => vtab_error(vtab, err),
1355 }
1356 }
1357}
1358
1359unsafe extern "C" fn rust_open<'vtab, T>(
1360 vtab: *mut sqlite3_vtab,
1361 pp_cursor: *mut *mut sqlite3_vtab_cursor,
1362) -> c_int
1363where
1364 T: VTab<'vtab> + 'vtab,
1365{
1366 let vt = vtab.cast::<T>();
1367 unsafe {
1368 match (*vt).open() {
1369 Ok(cursor) => {
1370 let boxed_cursor: *mut T::Cursor = Box::into_raw(Box::new(cursor));
1371 *pp_cursor = boxed_cursor.cast::<sqlite3_vtab_cursor>();
1372 ffi::SQLITE_OK
1373 }
1374 err => vtab_error(vtab, err),
1375 }
1376 }
1377}
1378
1379unsafe extern "C" fn rust_close<C>(cursor: *mut sqlite3_vtab_cursor) -> c_int
1380where
1381 C: VTabCursor,
1382{
1383 let cr = cursor.cast::<C>();
1384 drop(unsafe { Box::from_raw(cr) });
1385 ffi::SQLITE_OK
1386}
1387
1388unsafe extern "C" fn rust_filter<C>(
1389 cursor: *mut sqlite3_vtab_cursor,
1390 idx_num: c_int,
1391 idx_str: *const c_char,
1392 argc: c_int,
1393 argv: *mut *mut sqlite3_value,
1394) -> c_int
1395where
1396 C: VTabCursor,
1397{
1398 use std::str;
1399 unsafe {
1400 let idx_name = if idx_str.is_null() {
1401 None
1402 } else {
1403 let c_slice = CStr::from_ptr(idx_str).to_bytes();
1404 Some(str::from_utf8_unchecked(c_slice))
1405 };
1406 let args = slice::from_raw_parts_mut(argv, argc as usize);
1407 let values = Values { args };
1408 let cr = cursor.cast::<C>();
1409 cursor_error(cursor, (*cr).filter(idx_num, idx_name, &Filters { values }))
1410 }
1411}
1412
1413unsafe extern "C" fn rust_next<C>(cursor: *mut sqlite3_vtab_cursor) -> c_int
1414where
1415 C: VTabCursor,
1416{
1417 let cr = cursor.cast::<C>();
1418 unsafe { cursor_error(cursor, (*cr).next()) }
1419}
1420
1421unsafe extern "C" fn rust_eof<C>(cursor: *mut sqlite3_vtab_cursor) -> c_int
1422where
1423 C: VTabCursor,
1424{
1425 let cr = cursor.cast::<C>();
1426 unsafe { c_int::from((*cr).eof()) }
1427}
1428
1429unsafe extern "C" fn rust_column<C>(
1430 cursor: *mut sqlite3_vtab_cursor,
1431 ctx: *mut sqlite3_context,
1432 i: c_int,
1433) -> c_int
1434where
1435 C: VTabCursor,
1436{
1437 let cr = cursor.cast::<C>();
1438 let mut ctxt = Context(ctx);
1439 unsafe { result_error(ctx, (*cr).column(&mut ctxt, i)) }
1440}
1441
1442unsafe extern "C" fn rust_rowid<C>(
1443 cursor: *mut sqlite3_vtab_cursor,
1444 p_rowid: *mut ffi::sqlite3_int64,
1445) -> c_int
1446where
1447 C: VTabCursor,
1448{
1449 let cr = cursor.cast::<C>();
1450 unsafe {
1451 match (*cr).rowid() {
1452 Ok(rowid) => {
1453 *p_rowid = rowid;
1454 ffi::SQLITE_OK
1455 }
1456 err => cursor_error(cursor, err),
1457 }
1458 }
1459}
1460
1461unsafe extern "C" fn rust_update<'vtab, T>(
1462 vtab: *mut sqlite3_vtab,
1463 argc: c_int,
1464 argv: *mut *mut sqlite3_value,
1465 p_rowid: *mut ffi::sqlite3_int64,
1466) -> c_int
1467where
1468 T: UpdateVTab<'vtab> + 'vtab,
1469{
1470 assert!(argc >= 1);
1471 let vt = vtab.cast::<T>();
1472 unsafe {
1473 let args = slice::from_raw_parts_mut(argv, argc as usize);
1474 let r = if args.len() == 1 {
1475 (*vt).delete(ValueRef::from_value(args[0]))
1476 } else if ffi::sqlite3_value_type(args[0]) == ffi::SQLITE_NULL {
1477 let values = Values { args };
1479 match (*vt).insert(&Inserts { values }) {
1480 Ok(rowid) => {
1481 *p_rowid = rowid;
1482 Ok(())
1483 }
1484 Err(e) => Err(e),
1485 }
1486 } else {
1487 let values = Values { args };
1488 (*vt).update(&Updates { values })
1489 };
1490 vtab_error(vtab, r)
1491 }
1492}
1493
1494unsafe extern "C" fn rust_begin<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
1495where
1496 T: TransactionVTab<'vtab>,
1497{
1498 let vt = vtab.cast::<T>();
1499 unsafe { vtab_error(vtab, (*vt).begin()) }
1500}
1501unsafe extern "C" fn rust_sync<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
1502where
1503 T: TransactionVTab<'vtab>,
1504{
1505 let vt = vtab.cast::<T>();
1506 unsafe { vtab_error(vtab, (*vt).sync()) }
1507}
1508unsafe extern "C" fn rust_commit<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
1509where
1510 T: TransactionVTab<'vtab>,
1511{
1512 let vt = vtab.cast::<T>();
1513 unsafe { vtab_error(vtab, (*vt).commit()) }
1514}
1515unsafe extern "C" fn rust_rollback<'vtab, T>(vtab: *mut sqlite3_vtab) -> c_int
1516where
1517 T: TransactionVTab<'vtab>,
1518{
1519 let vt = vtab.cast::<T>();
1520 unsafe { vtab_error(vtab, (*vt).rollback()) }
1521}
1522
1523unsafe fn cursor_error<T>(cursor: *mut sqlite3_vtab_cursor, result: Result<T>) -> c_int {
1526 unsafe { vtab_error((*cursor).pVtab, result) }
1527}
1528
1529unsafe fn vtab_error<T>(vtab: *mut sqlite3_vtab, result: Result<T>) -> c_int {
1532 unsafe {
1533 match result {
1534 Ok(_) => ffi::SQLITE_OK,
1535 Err(Error::SqliteFailure(err, s)) => {
1536 if let Some(err_msg) = s {
1537 set_err_msg(vtab, &err_msg);
1538 }
1539 err.extended_code
1540 }
1541 Err(err) => {
1542 set_err_msg(vtab, &err.to_string());
1543 ffi::SQLITE_ERROR
1544 }
1545 }
1546 }
1547}
1548
1549#[cold]
1552unsafe fn set_err_msg(vtab: *mut sqlite3_vtab, err_msg: &str) {
1553 unsafe {
1554 if !(*vtab).zErrMsg.is_null() {
1555 sqlite3_free((*vtab).zErrMsg.cast::<c_void>());
1556 }
1557 (*vtab).zErrMsg = alloc(err_msg);
1558 }
1559}
1560
1561#[cold]
1564unsafe fn result_error<T>(ctx: *mut sqlite3_context, result: Result<T>) -> c_int {
1565 unsafe {
1566 match result {
1567 Ok(_) => ffi::SQLITE_OK,
1568 Err(Error::SqliteFailure(err, s)) => {
1569 match err.extended_code {
1570 ffi::SQLITE_TOOBIG => {
1571 ffi::sqlite3_result_error_toobig(ctx);
1572 }
1573 ffi::SQLITE_NOMEM => {
1574 ffi::sqlite3_result_error_nomem(ctx);
1575 }
1576 code => {
1577 ffi::sqlite3_result_error_code(ctx, code);
1578 if let Some(Ok(cstr)) = s.map(|s| str_to_cstring(&s)) {
1579 ffi::sqlite3_result_error(ctx, cstr.as_ptr(), -1);
1580 }
1581 }
1582 }
1583 err.extended_code
1584 }
1585 Err(err) => {
1586 ffi::sqlite3_result_error_code(ctx, ffi::SQLITE_ERROR);
1587 if let Ok(cstr) = str_to_cstring(&err.to_string()) {
1588 ffi::sqlite3_result_error(ctx, cstr.as_ptr(), -1);
1589 }
1590 ffi::SQLITE_ERROR
1591 }
1592 }
1593 }
1594}
1595
1596#[cfg(feature = "array")]
1597pub mod array;
1598#[cfg(feature = "csvtab")]
1599pub mod csvtab;
1600#[cfg(feature = "series")]
1601pub mod series; #[cfg(all(test, not(miri)))]
1603mod vtablog;
1604
1605#[cfg(test)]
1606mod test {
1607 use std::borrow::Cow;
1608
1609 #[cfg(all(target_family = "wasm", target_os = "unknown"))]
1610 use wasm_bindgen_test::wasm_bindgen_test as test;
1611
1612 #[test]
1613 fn test_dequote() {
1614 assert_eq!("", super::dequote(""));
1615 assert_eq!("'", super::dequote("'"));
1616 assert_eq!("\"", super::dequote("\""));
1617
1618 assert_eq!("'\"", super::dequote("'\""));
1619
1620 assert_eq!("", super::dequote("''"));
1621 assert_eq!("", super::dequote("\"\""));
1622 assert_eq!("", super::dequote("``"));
1623 assert_eq!("", super::dequote("[]"));
1624
1625 assert_eq!("x", super::dequote("'x'"));
1626 assert_eq!("x", super::dequote("\"x\""));
1627 assert_eq!("x", super::dequote("x"));
1628 assert_eq!("x", super::dequote("`x`"));
1629 assert_eq!("x", super::dequote("[x]"));
1630
1631 assert_eq!("x'", super::dequote("'x'''"));
1632 assert_eq!("x`", super::dequote("`x```"));
1633
1634 assert_eq!("x'", super::dequote("'x''"));
1635 assert_eq!("x`", super::dequote("`x``"));
1636 }
1637 #[test]
1638 fn test_parse_boolean() {
1639 assert_eq!(None, super::parse_boolean(""));
1640 assert_eq!(Some(true), super::parse_boolean("1"));
1641 assert_eq!(Some(true), super::parse_boolean("yes"));
1642 assert_eq!(Some(true), super::parse_boolean("on"));
1643 assert_eq!(Some(true), super::parse_boolean("true"));
1644 assert_eq!(Some(false), super::parse_boolean("0"));
1645 assert_eq!(Some(false), super::parse_boolean("no"));
1646 assert_eq!(Some(false), super::parse_boolean("off"));
1647 assert_eq!(Some(false), super::parse_boolean("false"));
1648 }
1649 #[test]
1650 fn test_parse_parameters() {
1651 assert_eq!(
1652 Ok(("key", Cow::Borrowed("value"))),
1653 super::parameter(b"key='value'")
1654 );
1655 assert_eq!(
1656 Ok(("key", Cow::Borrowed("foo=bar"))),
1657 super::parameter(b"key='foo=bar'")
1658 );
1659 }
1660
1661 #[cfg(all(feature = "functions", not(miri)))]
1662 #[test]
1663 fn test_values_get_subtype() -> crate::Result<()> {
1664 use std::ffi::{CStr, c_int, c_uint};
1665 use std::sync::atomic::{AtomicU32, Ordering};
1666
1667 use crate::ffi;
1668 use crate::functions::{FunctionFlags, SqlFnArg, SubType};
1669 use crate::types::Value;
1670 use crate::vtab::{
1671 Context, CreateVTab, Filters, IndexConstraintOp, IndexInfo, Inserts, Module,
1672 UpdateVTab, Updates, VTab, VTabConnection, VTabCursor, VTabKind,
1673 };
1674 use crate::{Connection, Result};
1675
1676 static FILTER_SUBTYPE: AtomicU32 = AtomicU32::new(0);
1677 static INSERT_SUBTYPE: AtomicU32 = AtomicU32::new(0);
1678
1679 fn set_subtype(ctx: &crate::functions::Context<'_>) -> Result<(SqlFnArg, SubType)> {
1680 let value = ctx.get_arg(0);
1681 let sub_type = ctx.get::<c_uint>(1)?;
1682 Ok((value, Some(sub_type)))
1683 }
1684
1685 #[repr(C)]
1686 struct SubTypeVTab {
1687 base: ffi::sqlite3_vtab,
1688 }
1689 #[repr(C)]
1690 struct SubTypeVTabCursor {
1691 base: ffi::sqlite3_vtab_cursor,
1692 }
1693
1694 unsafe impl<'vtab> VTab<'vtab> for SubTypeVTab {
1695 type Aux = ();
1696 type Cursor = SubTypeVTabCursor;
1697
1698 fn connect(
1699 _db: &mut VTabConnection,
1700 _aux: Option<&Self::Aux>,
1701 _module_name: &[u8],
1702 _database_name: &[u8],
1703 _table_name: &[u8],
1704 _args: &[&[u8]],
1705 ) -> Result<(Cow<'static, CStr>, Self)> {
1706 Ok((
1707 Cow::Borrowed(c"CREATE TABLE x(value BLOB)"),
1708 Self {
1709 base: ffi::sqlite3_vtab::default(),
1710 },
1711 ))
1712 }
1713
1714 fn best_index(&self, info: &mut IndexInfo) -> Result<bool> {
1715 let mut argv_index = 1;
1716 let mut usable_constraints = Vec::new();
1717 for (i, constraint) in info.constraints().enumerate() {
1718 if constraint.is_usable()
1719 && constraint.operator() == IndexConstraintOp::SQLITE_INDEX_CONSTRAINT_EQ
1720 {
1721 usable_constraints.push(i);
1722 }
1723 }
1724 for i in usable_constraints {
1725 let mut usage = info.constraint_usage(i);
1726 usage.set_argv_index(argv_index);
1727 usage.set_omit(true);
1728 argv_index += 1;
1729 }
1730 info.set_estimated_cost(1.0);
1731 Ok(true)
1732 }
1733
1734 fn open(&'vtab mut self) -> Result<Self::Cursor> {
1735 Ok(SubTypeVTabCursor {
1736 base: ffi::sqlite3_vtab_cursor::default(),
1737 })
1738 }
1739 }
1740
1741 impl CreateVTab<'_> for SubTypeVTab {
1742 const KIND: VTabKind = VTabKind::Default;
1743 }
1744
1745 impl UpdateVTab<'_> for SubTypeVTab {
1746 fn delete(&mut self, _arg: crate::types::ValueRef<'_>) -> Result<()> {
1747 Ok(())
1748 }
1749
1750 fn insert(&mut self, args: &Inserts<'_>) -> Result<i64> {
1751 INSERT_SUBTYPE.store(args.get_subtype(2), Ordering::SeqCst);
1755 Ok(0)
1756 }
1757
1758 fn update(&mut self, _args: &Updates<'_>) -> Result<()> {
1759 Ok(())
1760 }
1761 }
1762
1763 unsafe impl VTabCursor for SubTypeVTabCursor {
1764 fn filter(
1765 &mut self,
1766 _idx_num: c_int,
1767 _idx_str: Option<&str>,
1768 args: &Filters<'_>,
1769 ) -> Result<()> {
1770 FILTER_SUBTYPE.store(args.get_subtype(0), Ordering::SeqCst);
1771 Ok(())
1772 }
1773
1774 fn next(&mut self) -> Result<()> {
1775 Ok(())
1776 }
1777
1778 fn eof(&self) -> bool {
1779 true
1780 }
1781
1782 fn column(&self, ctx: &mut Context, _i: c_int) -> Result<()> {
1783 ctx.set_result(Value::Null)
1784 }
1785
1786 fn rowid(&self) -> Result<i64> {
1787 Ok(0)
1788 }
1789 }
1790
1791 let db = Connection::open_in_memory()?;
1792 db.create_scalar_function(
1793 c"set_subtype",
1794 2,
1795 FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_RESULT_SUBTYPE,
1796 set_subtype,
1797 )?;
1798 const MODULE: Module<SubTypeVTab> = Module::update_module();
1799 db.create_module(c"subtype_vtab", &MODULE, None)?;
1800
1801 db.execute("CREATE VIRTUAL TABLE st USING subtype_vtab()", [])?;
1802
1803 FILTER_SUBTYPE.store(0, Ordering::SeqCst);
1804 INSERT_SUBTYPE.store(0, Ordering::SeqCst);
1805
1806 let _: Result<String> = db.query_row(
1808 "SELECT value FROM st WHERE value = set_subtype('a', 223)",
1809 [],
1810 |row| row.get(0),
1811 );
1812 assert_eq!(FILTER_SUBTYPE.load(Ordering::SeqCst), 223);
1813
1814 db.execute(
1817 "INSERT INTO st(rowid, value) VALUES (1, set_subtype(X'62', 225))",
1818 [],
1819 )?;
1820 assert_eq!(INSERT_SUBTYPE.load(Ordering::SeqCst), 225);
1821
1822 Ok(())
1823 }
1824}