sqlite3_opt_vtable.go raw
1 // Copyright (C) 2019 Yasuhiro Matsumoto <mattn.jp@gmail.com>.
2 //
3 // Use of this source code is governed by an MIT-style
4 // license that can be found in the LICENSE file.
5
6 //go:build sqlite_vtable || vtable
7 // +build sqlite_vtable vtable
8
9 package sqlite3
10
11 /*
12 #cgo CFLAGS: -std=gnu99
13 #cgo CFLAGS: -DSQLITE_ENABLE_RTREE
14 #cgo CFLAGS: -DSQLITE_THREADSAFE
15 #cgo CFLAGS: -DSQLITE_ENABLE_FTS3
16 #cgo CFLAGS: -DSQLITE_ENABLE_FTS3_PARENTHESIS
17 #cgo CFLAGS: -DSQLITE_ENABLE_FTS4_UNICODE61
18 #cgo CFLAGS: -DSQLITE_TRACE_SIZE_LIMIT=15
19 #cgo CFLAGS: -DSQLITE_ENABLE_COLUMN_METADATA=1
20 #cgo CFLAGS: -Wno-deprecated-declarations
21
22 #ifndef USE_LIBSQLITE3
23 #include "sqlite3-binding.h"
24 #else
25 #include <sqlite3.h>
26 #endif
27 #include <stdlib.h>
28 #include <stdint.h>
29 #include <memory.h>
30
31 static inline char *_sqlite3_mprintf(char *zFormat, char *arg) {
32 return sqlite3_mprintf(zFormat, arg);
33 }
34
35 typedef struct goVTab goVTab;
36
37 struct goVTab {
38 sqlite3_vtab base;
39 void *vTab;
40 };
41
42 uintptr_t goMInit(void *db, void *pAux, int argc, char **argv, char **pzErr, int isCreate);
43
44 static int cXInit(sqlite3 *db, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVTab, char **pzErr, int isCreate) {
45 void *vTab = (void *)goMInit(db, pAux, argc, (char**)argv, pzErr, isCreate);
46 if (!vTab || *pzErr) {
47 return SQLITE_ERROR;
48 }
49 goVTab *pvTab = (goVTab *)sqlite3_malloc(sizeof(goVTab));
50 if (!pvTab) {
51 *pzErr = sqlite3_mprintf("%s", "Out of memory");
52 return SQLITE_NOMEM;
53 }
54 memset(pvTab, 0, sizeof(goVTab));
55 pvTab->vTab = vTab;
56
57 *ppVTab = (sqlite3_vtab *)pvTab;
58 *pzErr = 0;
59 return SQLITE_OK;
60 }
61
62 static inline int cXCreate(sqlite3 *db, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVTab, char **pzErr) {
63 return cXInit(db, pAux, argc, argv, ppVTab, pzErr, 1);
64 }
65 static inline int cXConnect(sqlite3 *db, void *pAux, int argc, const char *const*argv, sqlite3_vtab **ppVTab, char **pzErr) {
66 return cXInit(db, pAux, argc, argv, ppVTab, pzErr, 0);
67 }
68
69 char* goVBestIndex(void *pVTab, void *icp);
70
71 static inline int cXBestIndex(sqlite3_vtab *pVTab, sqlite3_index_info *info) {
72 char *pzErr = goVBestIndex(((goVTab*)pVTab)->vTab, info);
73 if (pzErr) {
74 if (pVTab->zErrMsg)
75 sqlite3_free(pVTab->zErrMsg);
76 pVTab->zErrMsg = pzErr;
77 return SQLITE_ERROR;
78 }
79 return SQLITE_OK;
80 }
81
82 char* goVRelease(void *pVTab, int isDestroy);
83
84 static int cXRelease(sqlite3_vtab *pVTab, int isDestroy) {
85 char *pzErr = goVRelease(((goVTab*)pVTab)->vTab, isDestroy);
86 if (pzErr) {
87 if (pVTab->zErrMsg)
88 sqlite3_free(pVTab->zErrMsg);
89 pVTab->zErrMsg = pzErr;
90 return SQLITE_ERROR;
91 }
92 if (pVTab->zErrMsg)
93 sqlite3_free(pVTab->zErrMsg);
94 sqlite3_free(pVTab);
95 return SQLITE_OK;
96 }
97
98 static inline int cXDisconnect(sqlite3_vtab *pVTab) {
99 return cXRelease(pVTab, 0);
100 }
101 static inline int cXDestroy(sqlite3_vtab *pVTab) {
102 return cXRelease(pVTab, 1);
103 }
104
105 typedef struct goVTabCursor goVTabCursor;
106
107 struct goVTabCursor {
108 sqlite3_vtab_cursor base;
109 void *vTabCursor;
110 };
111
112 uintptr_t goVOpen(void *pVTab, char **pzErr);
113
114 static int cXOpen(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor) {
115 void *vTabCursor = (void *)goVOpen(((goVTab*)pVTab)->vTab, &(pVTab->zErrMsg));
116 goVTabCursor *pCursor = (goVTabCursor *)sqlite3_malloc(sizeof(goVTabCursor));
117 if (!pCursor) {
118 return SQLITE_NOMEM;
119 }
120 memset(pCursor, 0, sizeof(goVTabCursor));
121 pCursor->vTabCursor = vTabCursor;
122 *ppCursor = (sqlite3_vtab_cursor *)pCursor;
123 return SQLITE_OK;
124 }
125
126 static int setErrMsg(sqlite3_vtab_cursor *pCursor, char *pzErr) {
127 if (pCursor->pVtab->zErrMsg)
128 sqlite3_free(pCursor->pVtab->zErrMsg);
129 pCursor->pVtab->zErrMsg = pzErr;
130 return SQLITE_ERROR;
131 }
132
133 char* goVClose(void *pCursor);
134
135 static int cXClose(sqlite3_vtab_cursor *pCursor) {
136 char *pzErr = goVClose(((goVTabCursor*)pCursor)->vTabCursor);
137 if (pzErr) {
138 return setErrMsg(pCursor, pzErr);
139 }
140 sqlite3_free(pCursor);
141 return SQLITE_OK;
142 }
143
144 char* goVFilter(void *pCursor, int idxNum, char* idxName, int argc, sqlite3_value **argv);
145
146 static int cXFilter(sqlite3_vtab_cursor *pCursor, int idxNum, const char *idxStr, int argc, sqlite3_value **argv) {
147 char *pzErr = goVFilter(((goVTabCursor*)pCursor)->vTabCursor, idxNum, (char*)idxStr, argc, argv);
148 if (pzErr) {
149 return setErrMsg(pCursor, pzErr);
150 }
151 return SQLITE_OK;
152 }
153
154 char* goVNext(void *pCursor);
155
156 static int cXNext(sqlite3_vtab_cursor *pCursor) {
157 char *pzErr = goVNext(((goVTabCursor*)pCursor)->vTabCursor);
158 if (pzErr) {
159 return setErrMsg(pCursor, pzErr);
160 }
161 return SQLITE_OK;
162 }
163
164 int goVEof(void *pCursor);
165
166 static inline int cXEof(sqlite3_vtab_cursor *pCursor) {
167 return goVEof(((goVTabCursor*)pCursor)->vTabCursor);
168 }
169
170 char* goVColumn(void *pCursor, void *cp, int col);
171
172 static int cXColumn(sqlite3_vtab_cursor *pCursor, sqlite3_context *ctx, int i) {
173 char *pzErr = goVColumn(((goVTabCursor*)pCursor)->vTabCursor, ctx, i);
174 if (pzErr) {
175 return setErrMsg(pCursor, pzErr);
176 }
177 return SQLITE_OK;
178 }
179
180 char* goVRowid(void *pCursor, sqlite3_int64 *pRowid);
181
182 static int cXRowid(sqlite3_vtab_cursor *pCursor, sqlite3_int64 *pRowid) {
183 char *pzErr = goVRowid(((goVTabCursor*)pCursor)->vTabCursor, pRowid);
184 if (pzErr) {
185 return setErrMsg(pCursor, pzErr);
186 }
187 return SQLITE_OK;
188 }
189
190 char* goVUpdate(void *pVTab, int argc, sqlite3_value **argv, sqlite3_int64 *pRowid);
191
192 static int cXUpdate(sqlite3_vtab *pVTab, int argc, sqlite3_value **argv, sqlite3_int64 *pRowid) {
193 char *pzErr = goVUpdate(((goVTab*)pVTab)->vTab, argc, argv, pRowid);
194 if (pzErr) {
195 if (pVTab->zErrMsg)
196 sqlite3_free(pVTab->zErrMsg);
197 pVTab->zErrMsg = pzErr;
198 return SQLITE_ERROR;
199 }
200 return SQLITE_OK;
201 }
202
203 static sqlite3_module goModule = {
204 0, // iVersion
205 cXCreate, // xCreate - create a table
206 cXConnect, // xConnect - connect to an existing table
207 cXBestIndex, // xBestIndex - Determine search strategy
208 cXDisconnect, // xDisconnect - Disconnect from a table
209 cXDestroy, // xDestroy - Drop a table
210 cXOpen, // xOpen - open a cursor
211 cXClose, // xClose - close a cursor
212 cXFilter, // xFilter - configure scan constraints
213 cXNext, // xNext - advance a cursor
214 cXEof, // xEof
215 cXColumn, // xColumn - read data
216 cXRowid, // xRowid - read data
217 cXUpdate, // xUpdate - write data
218 // Not implemented
219 0, // xBegin - begin transaction
220 0, // xSync - sync transaction
221 0, // xCommit - commit transaction
222 0, // xRollback - rollback transaction
223 0, // xFindFunction - function overloading
224 0, // xRename - rename the table
225 0, // xSavepoint
226 0, // xRelease
227 0 // xRollbackTo
228 };
229
230 // See https://sqlite.org/vtab.html#eponymous_only_virtual_tables
231 static sqlite3_module goModuleEponymousOnly = {
232 0, // iVersion
233 0, // xCreate - create a table, which here is null
234 cXConnect, // xConnect - connect to an existing table
235 cXBestIndex, // xBestIndex - Determine search strategy
236 cXDisconnect, // xDisconnect - Disconnect from a table
237 cXDestroy, // xDestroy - Drop a table
238 cXOpen, // xOpen - open a cursor
239 cXClose, // xClose - close a cursor
240 cXFilter, // xFilter - configure scan constraints
241 cXNext, // xNext - advance a cursor
242 cXEof, // xEof
243 cXColumn, // xColumn - read data
244 cXRowid, // xRowid - read data
245 cXUpdate, // xUpdate - write data
246 // Not implemented
247 0, // xBegin - begin transaction
248 0, // xSync - sync transaction
249 0, // xCommit - commit transaction
250 0, // xRollback - rollback transaction
251 0, // xFindFunction - function overloading
252 0, // xRename - rename the table
253 0, // xSavepoint
254 0, // xRelease
255 0 // xRollbackTo
256 };
257
258 void goMDestroy(void*);
259
260 static int _sqlite3_create_module(sqlite3 *db, const char *zName, uintptr_t pClientData) {
261 return sqlite3_create_module_v2(db, zName, &goModule, (void*) pClientData, goMDestroy);
262 }
263
264 static int _sqlite3_create_module_eponymous_only(sqlite3 *db, const char *zName, uintptr_t pClientData) {
265 return sqlite3_create_module_v2(db, zName, &goModuleEponymousOnly, (void*) pClientData, goMDestroy);
266 }
267 */
268 import "C"
269
270 import (
271 "fmt"
272 "math"
273 "reflect"
274 "unsafe"
275 )
276
277 type sqliteModule struct {
278 c *SQLiteConn
279 name string
280 module Module
281 }
282
283 type sqliteVTab struct {
284 module *sqliteModule
285 vTab VTab
286 }
287
288 type sqliteVTabCursor struct {
289 vTab *sqliteVTab
290 vTabCursor VTabCursor
291 }
292
293 // Op is type of operations.
294 type Op uint8
295
296 // Op mean identity of operations.
297 const (
298 OpEQ Op = 2
299 OpGT = 4
300 OpLE = 8
301 OpLT = 16
302 OpGE = 32
303 OpMATCH = 64
304 OpLIKE = 65 /* 3.10.0 and later only */
305 OpGLOB = 66 /* 3.10.0 and later only */
306 OpREGEXP = 67 /* 3.10.0 and later only */
307 OpScanUnique = 1 /* Scan visits at most 1 row */
308 )
309
310 // InfoConstraint give information of constraint.
311 type InfoConstraint struct {
312 Column int
313 Op Op
314 Usable bool
315 }
316
317 // InfoOrderBy give information of order-by.
318 type InfoOrderBy struct {
319 Column int
320 Desc bool
321 }
322
323 func constraints(info *C.sqlite3_index_info) []InfoConstraint {
324 slice := *(*[]C.struct_sqlite3_index_constraint)(unsafe.Pointer(&reflect.SliceHeader{
325 Data: uintptr(unsafe.Pointer(info.aConstraint)),
326 Len: int(info.nConstraint),
327 Cap: int(info.nConstraint),
328 }))
329
330 cst := make([]InfoConstraint, 0, len(slice))
331 for _, c := range slice {
332 var usable bool
333 if c.usable > 0 {
334 usable = true
335 }
336 cst = append(cst, InfoConstraint{
337 Column: int(c.iColumn),
338 Op: Op(c.op),
339 Usable: usable,
340 })
341 }
342 return cst
343 }
344
345 func orderBys(info *C.sqlite3_index_info) []InfoOrderBy {
346 slice := *(*[]C.struct_sqlite3_index_orderby)(unsafe.Pointer(&reflect.SliceHeader{
347 Data: uintptr(unsafe.Pointer(info.aOrderBy)),
348 Len: int(info.nOrderBy),
349 Cap: int(info.nOrderBy),
350 }))
351
352 ob := make([]InfoOrderBy, 0, len(slice))
353 for _, c := range slice {
354 var desc bool
355 if c.desc > 0 {
356 desc = true
357 }
358 ob = append(ob, InfoOrderBy{
359 Column: int(c.iColumn),
360 Desc: desc,
361 })
362 }
363 return ob
364 }
365
366 // IndexResult is a Go struct representation of what eventually ends up in the
367 // output fields for `sqlite3_index_info`
368 // See: https://www.sqlite.org/c3ref/index_info.html
369 type IndexResult struct {
370 Used []bool // aConstraintUsage
371 IdxNum int
372 IdxStr string
373 AlreadyOrdered bool // orderByConsumed
374 EstimatedCost float64
375 EstimatedRows float64
376 }
377
378 // mPrintf is a utility wrapper around sqlite3_mprintf
379 func mPrintf(format, arg string) *C.char {
380 cf := C.CString(format)
381 defer C.free(unsafe.Pointer(cf))
382 ca := C.CString(arg)
383 defer C.free(unsafe.Pointer(ca))
384 return C._sqlite3_mprintf(cf, ca)
385 }
386
387 //export goMInit
388 func goMInit(db, pClientData unsafe.Pointer, argc C.int, argv **C.char, pzErr **C.char, isCreate C.int) C.uintptr_t {
389 m := lookupHandle(pClientData).(*sqliteModule)
390 if m.c.db != (*C.sqlite3)(db) {
391 *pzErr = mPrintf("%s", "Inconsistent db handles")
392 return 0
393 }
394 args := make([]string, argc)
395 var A []*C.char
396 slice := reflect.SliceHeader{Data: uintptr(unsafe.Pointer(argv)), Len: int(argc), Cap: int(argc)}
397 a := reflect.NewAt(reflect.TypeOf(A), unsafe.Pointer(&slice)).Elem().Interface()
398 for i, s := range a.([]*C.char) {
399 args[i] = C.GoString(s)
400 }
401 var vTab VTab
402 var err error
403 if isCreate == 1 {
404 vTab, err = m.module.Create(m.c, args)
405 } else {
406 vTab, err = m.module.Connect(m.c, args)
407 }
408
409 if err != nil {
410 *pzErr = mPrintf("%s", err.Error())
411 return 0
412 }
413 vt := sqliteVTab{m, vTab}
414 *pzErr = nil
415 return C.uintptr_t(uintptr(newHandle(m.c, &vt)))
416 }
417
418 //export goVRelease
419 func goVRelease(pVTab unsafe.Pointer, isDestroy C.int) *C.char {
420 vt := lookupHandle(pVTab).(*sqliteVTab)
421 var err error
422 if isDestroy == 1 {
423 err = vt.vTab.Destroy()
424 } else {
425 err = vt.vTab.Disconnect()
426 }
427 if err != nil {
428 return mPrintf("%s", err.Error())
429 }
430 return nil
431 }
432
433 //export goVOpen
434 func goVOpen(pVTab unsafe.Pointer, pzErr **C.char) C.uintptr_t {
435 vt := lookupHandle(pVTab).(*sqliteVTab)
436 vTabCursor, err := vt.vTab.Open()
437 if err != nil {
438 *pzErr = mPrintf("%s", err.Error())
439 return 0
440 }
441 vtc := sqliteVTabCursor{vt, vTabCursor}
442 *pzErr = nil
443 return C.uintptr_t(uintptr(newHandle(vt.module.c, &vtc)))
444 }
445
446 //export goVBestIndex
447 func goVBestIndex(pVTab unsafe.Pointer, icp unsafe.Pointer) *C.char {
448 vt := lookupHandle(pVTab).(*sqliteVTab)
449 info := (*C.sqlite3_index_info)(icp)
450 csts := constraints(info)
451 res, err := vt.vTab.BestIndex(csts, orderBys(info))
452 if err != nil {
453 return mPrintf("%s", err.Error())
454 }
455 if len(res.Used) != len(csts) {
456 return mPrintf("Result.Used != expected value", "")
457 }
458
459 // Get a pointer to constraint_usage struct so we can update in place.
460
461 slice := *(*[]C.struct_sqlite3_index_constraint_usage)(unsafe.Pointer(&reflect.SliceHeader{
462 Data: uintptr(unsafe.Pointer(info.aConstraintUsage)),
463 Len: int(info.nConstraint),
464 Cap: int(info.nConstraint),
465 }))
466 index := 1
467 for i := range slice {
468 if res.Used[i] {
469 slice[i].argvIndex = C.int(index)
470 slice[i].omit = C.uchar(1)
471 index++
472 }
473 }
474
475 info.idxNum = C.int(res.IdxNum)
476 info.idxStr = (*C.char)(C.sqlite3_malloc(C.int(len(res.IdxStr) + 1)))
477 if info.idxStr == nil {
478 // C.malloc and C.CString ordinarily do this for you. See https://golang.org/cmd/cgo/
479 panic("out of memory")
480 }
481 info.needToFreeIdxStr = C.int(1)
482
483 idxStr := *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
484 Data: uintptr(unsafe.Pointer(info.idxStr)),
485 Len: len(res.IdxStr) + 1,
486 Cap: len(res.IdxStr) + 1,
487 }))
488 copy(idxStr, res.IdxStr)
489 idxStr[len(idxStr)-1] = 0 // null-terminated string
490
491 if res.AlreadyOrdered {
492 info.orderByConsumed = C.int(1)
493 }
494 info.estimatedCost = C.double(res.EstimatedCost)
495 info.estimatedRows = C.sqlite3_int64(res.EstimatedRows)
496
497 return nil
498 }
499
500 //export goVClose
501 func goVClose(pCursor unsafe.Pointer) *C.char {
502 vtc := lookupHandle(pCursor).(*sqliteVTabCursor)
503 err := vtc.vTabCursor.Close()
504 if err != nil {
505 return mPrintf("%s", err.Error())
506 }
507 return nil
508 }
509
510 //export goMDestroy
511 func goMDestroy(pClientData unsafe.Pointer) {
512 m := lookupHandle(pClientData).(*sqliteModule)
513 m.module.DestroyModule()
514 }
515
516 //export goVFilter
517 func goVFilter(pCursor unsafe.Pointer, idxNum C.int, idxName *C.char, argc C.int, argv **C.sqlite3_value) *C.char {
518 vtc := lookupHandle(pCursor).(*sqliteVTabCursor)
519 args := (*[(math.MaxInt32 - 1) / unsafe.Sizeof((*C.sqlite3_value)(nil))]*C.sqlite3_value)(unsafe.Pointer(argv))[:argc:argc]
520 vals := make([]any, 0, argc)
521 for _, v := range args {
522 conv, err := callbackArgGeneric(v)
523 if err != nil {
524 return mPrintf("%s", err.Error())
525 }
526 vals = append(vals, conv.Interface())
527 }
528 err := vtc.vTabCursor.Filter(int(idxNum), C.GoString(idxName), vals)
529 if err != nil {
530 return mPrintf("%s", err.Error())
531 }
532 return nil
533 }
534
535 //export goVNext
536 func goVNext(pCursor unsafe.Pointer) *C.char {
537 vtc := lookupHandle(pCursor).(*sqliteVTabCursor)
538 err := vtc.vTabCursor.Next()
539 if err != nil {
540 return mPrintf("%s", err.Error())
541 }
542 return nil
543 }
544
545 //export goVEof
546 func goVEof(pCursor unsafe.Pointer) C.int {
547 vtc := lookupHandle(pCursor).(*sqliteVTabCursor)
548 err := vtc.vTabCursor.EOF()
549 if err {
550 return 1
551 }
552 return 0
553 }
554
555 //export goVColumn
556 func goVColumn(pCursor, cp unsafe.Pointer, col C.int) *C.char {
557 vtc := lookupHandle(pCursor).(*sqliteVTabCursor)
558 c := (*SQLiteContext)(cp)
559 err := vtc.vTabCursor.Column(c, int(col))
560 if err != nil {
561 return mPrintf("%s", err.Error())
562 }
563 return nil
564 }
565
566 //export goVRowid
567 func goVRowid(pCursor unsafe.Pointer, pRowid *C.sqlite3_int64) *C.char {
568 vtc := lookupHandle(pCursor).(*sqliteVTabCursor)
569 rowid, err := vtc.vTabCursor.Rowid()
570 if err != nil {
571 return mPrintf("%s", err.Error())
572 }
573 *pRowid = C.sqlite3_int64(rowid)
574 return nil
575 }
576
577 //export goVUpdate
578 func goVUpdate(pVTab unsafe.Pointer, argc C.int, argv **C.sqlite3_value, pRowid *C.sqlite3_int64) *C.char {
579 vt := lookupHandle(pVTab).(*sqliteVTab)
580
581 var tname string
582 if n, ok := vt.vTab.(interface {
583 TableName() string
584 }); ok {
585 tname = n.TableName() + " "
586 }
587
588 err := fmt.Errorf("virtual %s table %sis read-only", vt.module.name, tname)
589 if v, ok := vt.vTab.(VTabUpdater); ok {
590 // convert argv
591 args := (*[(math.MaxInt32 - 1) / unsafe.Sizeof((*C.sqlite3_value)(nil))]*C.sqlite3_value)(unsafe.Pointer(argv))[:argc:argc]
592 vals := make([]any, 0, argc)
593 for _, v := range args {
594 conv, err := callbackArgGeneric(v)
595 if err != nil {
596 return mPrintf("%s", err.Error())
597 }
598
599 // work around for SQLITE_NULL
600 x := conv.Interface()
601 if z, ok := x.([]byte); ok && z == nil {
602 x = nil
603 }
604
605 vals = append(vals, x)
606 }
607
608 switch {
609 case argc == 1:
610 err = v.Delete(vals[0])
611
612 case argc > 1 && vals[0] == nil:
613 var id int64
614 id, err = v.Insert(vals[1], vals[2:])
615 if err == nil {
616 *pRowid = C.sqlite3_int64(id)
617 }
618
619 case argc > 1:
620 err = v.Update(vals[1], vals[2:])
621 }
622 }
623
624 if err != nil {
625 return mPrintf("%s", err.Error())
626 }
627
628 return nil
629 }
630
631 // Module is a "virtual table module", it defines the implementation of a
632 // virtual tables. See: http://sqlite.org/c3ref/module.html
633 type Module interface {
634 // http://sqlite.org/vtab.html#xcreate
635 Create(c *SQLiteConn, args []string) (VTab, error)
636 // http://sqlite.org/vtab.html#xconnect
637 Connect(c *SQLiteConn, args []string) (VTab, error)
638 // http://sqlite.org/c3ref/create_module.html
639 DestroyModule()
640 }
641
642 // EponymousOnlyModule is a "virtual table module" (as above), but
643 // for defining "eponymous only" virtual tables See: https://sqlite.org/vtab.html#eponymous_only_virtual_tables
644 type EponymousOnlyModule interface {
645 Module
646 EponymousOnlyModule()
647 }
648
649 // VTab describes a particular instance of the virtual table.
650 // See: http://sqlite.org/c3ref/vtab.html
651 type VTab interface {
652 // http://sqlite.org/vtab.html#xbestindex
653 BestIndex([]InfoConstraint, []InfoOrderBy) (*IndexResult, error)
654 // http://sqlite.org/vtab.html#xdisconnect
655 Disconnect() error
656 // http://sqlite.org/vtab.html#sqlite3_module.xDestroy
657 Destroy() error
658 // http://sqlite.org/vtab.html#xopen
659 Open() (VTabCursor, error)
660 }
661
662 // VTabUpdater is a type that allows a VTab to be inserted, updated, or
663 // deleted.
664 // See: https://sqlite.org/vtab.html#xupdate
665 type VTabUpdater interface {
666 Delete(any) error
667 Insert(any, []any) (int64, error)
668 Update(any, []any) error
669 }
670
671 // VTabCursor describes cursors that point into the virtual table and are used
672 // to loop through the virtual table. See: http://sqlite.org/c3ref/vtab_cursor.html
673 type VTabCursor interface {
674 // http://sqlite.org/vtab.html#xclose
675 Close() error
676 // http://sqlite.org/vtab.html#xfilter
677 Filter(idxNum int, idxStr string, vals []any) error
678 // http://sqlite.org/vtab.html#xnext
679 Next() error
680 // http://sqlite.org/vtab.html#xeof
681 EOF() bool
682 // http://sqlite.org/vtab.html#xcolumn
683 Column(c *SQLiteContext, col int) error
684 // http://sqlite.org/vtab.html#xrowid
685 Rowid() (int64, error)
686 }
687
688 // DeclareVTab declares the Schema of a virtual table.
689 // See: http://sqlite.org/c3ref/declare_vtab.html
690 func (c *SQLiteConn) DeclareVTab(sql string) error {
691 zSQL := C.CString(sql)
692 defer C.free(unsafe.Pointer(zSQL))
693 rv := C.sqlite3_declare_vtab(c.db, zSQL)
694 if rv != C.SQLITE_OK {
695 return c.lastError()
696 }
697 return nil
698 }
699
700 // CreateModule registers a virtual table implementation.
701 // See: http://sqlite.org/c3ref/create_module.html
702 func (c *SQLiteConn) CreateModule(moduleName string, module Module) error {
703 mname := C.CString(moduleName)
704 defer C.free(unsafe.Pointer(mname))
705 udm := sqliteModule{c, moduleName, module}
706 switch module.(type) {
707 case EponymousOnlyModule:
708 rv := C._sqlite3_create_module_eponymous_only(c.db, mname, C.uintptr_t(uintptr(newHandle(c, &udm))))
709 if rv != C.SQLITE_OK {
710 return c.lastError()
711 }
712 return nil
713 case Module:
714 rv := C._sqlite3_create_module(c.db, mname, C.uintptr_t(uintptr(newHandle(c, &udm))))
715 if rv != C.SQLITE_OK {
716 return c.lastError()
717 }
718 return nil
719 }
720 return nil
721 }
722