mirror of
https://github.com/superseriousbusiness/gotosocial
synced 2025-06-05 21:59:39 +02:00
[chore] bump ncruces go-sqlite3 => v0.23.0 (#3785)
* bump ncruces go-sqlite3 => v0.23.0 * whoops, add missing vendor changes...
This commit is contained in:
kim
GitHub
186
vendor/github.com/ncruces/go-sqlite3/vtab.go
generated
vendored
186
vendor/github.com/ncruces/go-sqlite3/vtab.go
generated
vendored
@ -2,6 +2,7 @@ package sqlite3
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"reflect"
|
||||
|
||||
"github.com/tetratelabs/wazero/api"
|
||||
@ -58,15 +59,15 @@ func CreateModule[T VTab](db *Conn, name string, create, connect VTabConstructor
|
||||
flags |= VTAB_SHADOWTABS
|
||||
}
|
||||
|
||||
var modulePtr uint32
|
||||
var modulePtr ptr_t
|
||||
defer db.arena.mark()()
|
||||
namePtr := db.arena.string(name)
|
||||
if connect != nil {
|
||||
modulePtr = util.AddHandle(db.ctx, module[T]{create, connect})
|
||||
}
|
||||
r := db.call("sqlite3_create_module_go", uint64(db.handle),
|
||||
uint64(namePtr), uint64(flags), uint64(modulePtr))
|
||||
return db.error(r)
|
||||
rc := res_t(db.call("sqlite3_create_module_go", stk_t(db.handle),
|
||||
stk_t(namePtr), stk_t(flags), stk_t(modulePtr)))
|
||||
return db.error(rc)
|
||||
}
|
||||
|
||||
func implements[T any](typ reflect.Type) bool {
|
||||
@ -80,8 +81,8 @@ func implements[T any](typ reflect.Type) bool {
|
||||
func (c *Conn) DeclareVTab(sql string) error {
|
||||
defer c.arena.mark()()
|
||||
sqlPtr := c.arena.string(sql)
|
||||
r := c.call("sqlite3_declare_vtab", uint64(c.handle), uint64(sqlPtr))
|
||||
return c.error(r)
|
||||
rc := res_t(c.call("sqlite3_declare_vtab", stk_t(c.handle), stk_t(sqlPtr)))
|
||||
return c.error(rc)
|
||||
}
|
||||
|
||||
// VTabConflictMode is a virtual table conflict resolution mode.
|
||||
@ -101,8 +102,7 @@ const (
|
||||
//
|
||||
// https://sqlite.org/c3ref/vtab_on_conflict.html
|
||||
func (c *Conn) VTabOnConflict() VTabConflictMode {
|
||||
r := c.call("sqlite3_vtab_on_conflict", uint64(c.handle))
|
||||
return VTabConflictMode(r)
|
||||
return VTabConflictMode(c.call("sqlite3_vtab_on_conflict", stk_t(c.handle)))
|
||||
}
|
||||
|
||||
// VTabConfigOption is a virtual table configuration option.
|
||||
@ -121,14 +121,14 @@ const (
|
||||
//
|
||||
// https://sqlite.org/c3ref/vtab_config.html
|
||||
func (c *Conn) VTabConfig(op VTabConfigOption, args ...any) error {
|
||||
var i uint64
|
||||
var i int32
|
||||
if op == VTAB_CONSTRAINT_SUPPORT && len(args) > 0 {
|
||||
if b, ok := args[0].(bool); ok && b {
|
||||
i = 1
|
||||
}
|
||||
}
|
||||
r := c.call("sqlite3_vtab_config_go", uint64(c.handle), uint64(op), i)
|
||||
return c.error(r)
|
||||
rc := res_t(c.call("sqlite3_vtab_config_go", stk_t(c.handle), stk_t(op), stk_t(i)))
|
||||
return c.error(rc)
|
||||
}
|
||||
|
||||
// VTabConstructor is a virtual table constructor function.
|
||||
@ -263,7 +263,7 @@ type IndexInfo struct {
|
||||
// Inputs
|
||||
Constraint []IndexConstraint
|
||||
OrderBy []IndexOrderBy
|
||||
ColumnsUsed int64
|
||||
ColumnsUsed uint64
|
||||
// Outputs
|
||||
ConstraintUsage []IndexConstraintUsage
|
||||
IdxNum int
|
||||
@ -274,7 +274,7 @@ type IndexInfo struct {
|
||||
EstimatedRows int64
|
||||
// Internal
|
||||
c *Conn
|
||||
handle uint32
|
||||
handle ptr_t
|
||||
}
|
||||
|
||||
// An IndexConstraint describes virtual table indexing constraint information.
|
||||
@ -309,14 +309,14 @@ type IndexConstraintUsage struct {
|
||||
func (idx *IndexInfo) RHSValue(column int) (Value, error) {
|
||||
defer idx.c.arena.mark()()
|
||||
valPtr := idx.c.arena.new(ptrlen)
|
||||
r := idx.c.call("sqlite3_vtab_rhs_value", uint64(idx.handle),
|
||||
uint64(column), uint64(valPtr))
|
||||
if err := idx.c.error(r); err != nil {
|
||||
rc := res_t(idx.c.call("sqlite3_vtab_rhs_value", stk_t(idx.handle),
|
||||
stk_t(column), stk_t(valPtr)))
|
||||
if err := idx.c.error(rc); err != nil {
|
||||
return Value{}, err
|
||||
}
|
||||
return Value{
|
||||
c: idx.c,
|
||||
handle: util.ReadUint32(idx.c.mod, valPtr),
|
||||
handle: util.Read32[ptr_t](idx.c.mod, valPtr),
|
||||
}, nil
|
||||
}
|
||||
|
||||
@ -324,26 +324,26 @@ func (idx *IndexInfo) RHSValue(column int) (Value, error) {
|
||||
//
|
||||
// https://sqlite.org/c3ref/vtab_collation.html
|
||||
func (idx *IndexInfo) Collation(column int) string {
|
||||
r := idx.c.call("sqlite3_vtab_collation", uint64(idx.handle),
|
||||
uint64(column))
|
||||
return util.ReadString(idx.c.mod, uint32(r), _MAX_NAME)
|
||||
ptr := ptr_t(idx.c.call("sqlite3_vtab_collation", stk_t(idx.handle),
|
||||
stk_t(column)))
|
||||
return util.ReadString(idx.c.mod, ptr, _MAX_NAME)
|
||||
}
|
||||
|
||||
// Distinct determines if a virtual table query is DISTINCT.
|
||||
//
|
||||
// https://sqlite.org/c3ref/vtab_distinct.html
|
||||
func (idx *IndexInfo) Distinct() int {
|
||||
r := idx.c.call("sqlite3_vtab_distinct", uint64(idx.handle))
|
||||
return int(r)
|
||||
i := int32(idx.c.call("sqlite3_vtab_distinct", stk_t(idx.handle)))
|
||||
return int(i)
|
||||
}
|
||||
|
||||
// In identifies and handles IN constraints.
|
||||
//
|
||||
// https://sqlite.org/c3ref/vtab_in.html
|
||||
func (idx *IndexInfo) In(column, handle int) bool {
|
||||
r := idx.c.call("sqlite3_vtab_in", uint64(idx.handle),
|
||||
uint64(column), uint64(handle))
|
||||
return r != 0
|
||||
b := int32(idx.c.call("sqlite3_vtab_in", stk_t(idx.handle),
|
||||
stk_t(column), stk_t(handle)))
|
||||
return b != 0
|
||||
}
|
||||
|
||||
func (idx *IndexInfo) load() {
|
||||
@ -351,34 +351,35 @@ func (idx *IndexInfo) load() {
|
||||
mod := idx.c.mod
|
||||
ptr := idx.handle
|
||||
|
||||
idx.Constraint = make([]IndexConstraint, util.ReadUint32(mod, ptr+0))
|
||||
idx.ConstraintUsage = make([]IndexConstraintUsage, util.ReadUint32(mod, ptr+0))
|
||||
idx.OrderBy = make([]IndexOrderBy, util.ReadUint32(mod, ptr+8))
|
||||
nConstraint := util.Read32[int32](mod, ptr+0)
|
||||
idx.Constraint = make([]IndexConstraint, nConstraint)
|
||||
idx.ConstraintUsage = make([]IndexConstraintUsage, nConstraint)
|
||||
idx.OrderBy = make([]IndexOrderBy, util.Read32[int32](mod, ptr+8))
|
||||
|
||||
constraintPtr := util.ReadUint32(mod, ptr+4)
|
||||
constraintPtr := util.Read32[ptr_t](mod, ptr+4)
|
||||
constraint := idx.Constraint
|
||||
for i := range idx.Constraint {
|
||||
constraint[i] = IndexConstraint{
|
||||
Column: int(int32(util.ReadUint32(mod, constraintPtr+0))),
|
||||
Op: IndexConstraintOp(util.ReadUint8(mod, constraintPtr+4)),
|
||||
Usable: util.ReadUint8(mod, constraintPtr+5) != 0,
|
||||
Column: int(util.Read32[int32](mod, constraintPtr+0)),
|
||||
Op: util.Read[IndexConstraintOp](mod, constraintPtr+4),
|
||||
Usable: util.Read[byte](mod, constraintPtr+5) != 0,
|
||||
}
|
||||
constraintPtr += 12
|
||||
}
|
||||
|
||||
orderByPtr := util.ReadUint32(mod, ptr+12)
|
||||
orderByPtr := util.Read32[ptr_t](mod, ptr+12)
|
||||
orderBy := idx.OrderBy
|
||||
for i := range orderBy {
|
||||
orderBy[i] = IndexOrderBy{
|
||||
Column: int(int32(util.ReadUint32(mod, orderByPtr+0))),
|
||||
Desc: util.ReadUint8(mod, orderByPtr+4) != 0,
|
||||
Column: int(util.Read32[int32](mod, orderByPtr+0)),
|
||||
Desc: util.Read[byte](mod, orderByPtr+4) != 0,
|
||||
}
|
||||
orderByPtr += 8
|
||||
}
|
||||
|
||||
idx.EstimatedCost = util.ReadFloat64(mod, ptr+40)
|
||||
idx.EstimatedRows = int64(util.ReadUint64(mod, ptr+48))
|
||||
idx.ColumnsUsed = int64(util.ReadUint64(mod, ptr+64))
|
||||
idx.EstimatedRows = util.Read64[int64](mod, ptr+48)
|
||||
idx.ColumnsUsed = util.Read64[uint64](mod, ptr+64)
|
||||
}
|
||||
|
||||
func (idx *IndexInfo) save() {
|
||||
@ -386,26 +387,26 @@ func (idx *IndexInfo) save() {
|
||||
mod := idx.c.mod
|
||||
ptr := idx.handle
|
||||
|
||||
usagePtr := util.ReadUint32(mod, ptr+16)
|
||||
usagePtr := util.Read32[ptr_t](mod, ptr+16)
|
||||
for _, usage := range idx.ConstraintUsage {
|
||||
util.WriteUint32(mod, usagePtr+0, uint32(usage.ArgvIndex))
|
||||
util.Write32(mod, usagePtr+0, int32(usage.ArgvIndex))
|
||||
if usage.Omit {
|
||||
util.WriteUint8(mod, usagePtr+4, 1)
|
||||
util.Write(mod, usagePtr+4, int8(1))
|
||||
}
|
||||
usagePtr += 8
|
||||
}
|
||||
|
||||
util.WriteUint32(mod, ptr+20, uint32(idx.IdxNum))
|
||||
util.Write32(mod, ptr+20, int32(idx.IdxNum))
|
||||
if idx.IdxStr != "" {
|
||||
util.WriteUint32(mod, ptr+24, idx.c.newString(idx.IdxStr))
|
||||
util.WriteUint32(mod, ptr+28, 1) // needToFreeIdxStr
|
||||
util.Write32(mod, ptr+24, idx.c.newString(idx.IdxStr))
|
||||
util.Write32(mod, ptr+28, int32(1)) // needToFreeIdxStr
|
||||
}
|
||||
if idx.OrderByConsumed {
|
||||
util.WriteUint32(mod, ptr+32, 1)
|
||||
util.Write32(mod, ptr+32, int32(1))
|
||||
}
|
||||
util.WriteFloat64(mod, ptr+40, idx.EstimatedCost)
|
||||
util.WriteUint64(mod, ptr+48, uint64(idx.EstimatedRows))
|
||||
util.WriteUint32(mod, ptr+56, uint32(idx.IdxFlags))
|
||||
util.Write64(mod, ptr+48, idx.EstimatedRows)
|
||||
util.Write32(mod, ptr+56, idx.IdxFlags)
|
||||
}
|
||||
|
||||
// IndexConstraintOp is a virtual table constraint operator code.
|
||||
@ -442,42 +443,39 @@ const (
|
||||
INDEX_SCAN_UNIQUE IndexScanFlag = 1
|
||||
)
|
||||
|
||||
func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, _, _, _, _, _ uint32) uint32 {
|
||||
return func(ctx context.Context, mod api.Module, pMod, nArg, pArg, ppVTab, pzErr uint32) uint32 {
|
||||
func vtabModuleCallback(i vtabConstructor) func(_ context.Context, _ api.Module, _ ptr_t, _ int32, _, _, _ ptr_t) res_t {
|
||||
return func(ctx context.Context, mod api.Module, pMod ptr_t, nArg int32, pArg, ppVTab, pzErr ptr_t) res_t {
|
||||
arg := make([]reflect.Value, 1+nArg)
|
||||
arg[0] = reflect.ValueOf(ctx.Value(connKey{}))
|
||||
|
||||
for i := uint32(0); i < nArg; i++ {
|
||||
ptr := util.ReadUint32(mod, pArg+i*ptrlen)
|
||||
for i := range nArg {
|
||||
ptr := util.Read32[ptr_t](mod, pArg+ptr_t(i)*ptrlen)
|
||||
arg[i+1] = reflect.ValueOf(util.ReadString(mod, ptr, _MAX_SQL_LENGTH))
|
||||
}
|
||||
|
||||
module := vtabGetHandle(ctx, mod, pMod)
|
||||
res := reflect.ValueOf(module).Index(int(i)).Call(arg)
|
||||
err, _ := res[1].Interface().(error)
|
||||
val := reflect.ValueOf(module).Index(int(i)).Call(arg)
|
||||
err, _ := val[1].Interface().(error)
|
||||
if err == nil {
|
||||
vtabPutHandle(ctx, mod, ppVTab, res[0].Interface())
|
||||
vtabPutHandle(ctx, mod, ppVTab, val[0].Interface())
|
||||
}
|
||||
|
||||
return vtabError(ctx, mod, pzErr, _PTR_ERROR, err)
|
||||
}
|
||||
}
|
||||
|
||||
func vtabDisconnectCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
|
||||
func vtabDisconnectCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
|
||||
err := vtabDelHandle(ctx, mod, pVTab)
|
||||
return vtabError(ctx, mod, 0, _PTR_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabDestroyCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
|
||||
func vtabDestroyCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabDestroyer)
|
||||
err := vtab.Destroy()
|
||||
if cerr := vtabDelHandle(ctx, mod, pVTab); err == nil {
|
||||
err = cerr
|
||||
}
|
||||
err := errors.Join(vtab.Destroy(), vtabDelHandle(ctx, mod, pVTab))
|
||||
return vtabError(ctx, mod, 0, _PTR_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo uint32) uint32 {
|
||||
func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo ptr_t) res_t {
|
||||
var info IndexInfo
|
||||
info.handle = pIdxInfo
|
||||
info.c = ctx.Value(connKey{}).(*Conn)
|
||||
@ -490,7 +488,7 @@ func vtabBestIndexCallback(ctx context.Context, mod api.Module, pVTab, pIdxInfo
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab, nArg, pArg, pRowID uint32) uint32 {
|
||||
func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg int32, pArg, pRowID ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabUpdater)
|
||||
|
||||
db := ctx.Value(connKey{}).(*Conn)
|
||||
@ -498,33 +496,33 @@ func vtabUpdateCallback(ctx context.Context, mod api.Module, pVTab, nArg, pArg,
|
||||
callbackArgs(db, args, pArg)
|
||||
rowID, err := vtab.Update(args...)
|
||||
if err == nil {
|
||||
util.WriteUint64(mod, pRowID, uint64(rowID))
|
||||
util.Write64(mod, pRowID, rowID)
|
||||
}
|
||||
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabRenameCallback(ctx context.Context, mod api.Module, pVTab, zNew uint32) uint32 {
|
||||
func vtabRenameCallback(ctx context.Context, mod api.Module, pVTab, zNew ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabRenamer)
|
||||
err := vtab.Rename(util.ReadString(mod, zNew, _MAX_NAME))
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabFindFuncCallback(ctx context.Context, mod api.Module, pVTab uint32, nArg int32, zName, pxFunc uint32) uint32 {
|
||||
func vtabFindFuncCallback(ctx context.Context, mod api.Module, pVTab ptr_t, nArg int32, zName, pxFunc ptr_t) int32 {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabOverloader)
|
||||
f, op := vtab.FindFunction(int(nArg), util.ReadString(mod, zName, _MAX_NAME))
|
||||
if op != 0 {
|
||||
var wrapper uint32
|
||||
var wrapper ptr_t
|
||||
wrapper = util.AddHandle(ctx, func(c Context, arg ...Value) {
|
||||
defer util.DelHandle(ctx, wrapper)
|
||||
f(c, arg...)
|
||||
})
|
||||
util.WriteUint32(mod, pxFunc, wrapper)
|
||||
util.Write32(mod, pxFunc, wrapper)
|
||||
}
|
||||
return uint32(op)
|
||||
return int32(op)
|
||||
}
|
||||
|
||||
func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema, zTabName, mFlags, pzErr uint32) uint32 {
|
||||
func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema, zTabName ptr_t, mFlags uint32, pzErr ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabChecker)
|
||||
schema := util.ReadString(mod, zSchema, _MAX_NAME)
|
||||
table := util.ReadString(mod, zTabName, _MAX_NAME)
|
||||
@ -536,49 +534,49 @@ func vtabIntegrityCallback(ctx context.Context, mod api.Module, pVTab, zSchema,
|
||||
return code
|
||||
}
|
||||
|
||||
func vtabBeginCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
|
||||
func vtabBeginCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
|
||||
err := vtab.Begin()
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabSyncCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
|
||||
func vtabSyncCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
|
||||
err := vtab.Sync()
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabCommitCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
|
||||
func vtabCommitCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
|
||||
err := vtab.Commit()
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabRollbackCallback(ctx context.Context, mod api.Module, pVTab uint32) uint32 {
|
||||
func vtabRollbackCallback(ctx context.Context, mod api.Module, pVTab ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabTxn)
|
||||
err := vtab.Rollback()
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabSavepointCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
|
||||
func vtabSavepointCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
|
||||
err := vtab.Savepoint(int(id))
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabReleaseCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
|
||||
func vtabReleaseCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
|
||||
err := vtab.Release(int(id))
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func vtabRollbackToCallback(ctx context.Context, mod api.Module, pVTab uint32, id int32) uint32 {
|
||||
func vtabRollbackToCallback(ctx context.Context, mod api.Module, pVTab ptr_t, id int32) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTabSavepointer)
|
||||
err := vtab.RollbackTo(int(id))
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur uint32) uint32 {
|
||||
func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur ptr_t) res_t {
|
||||
vtab := vtabGetHandle(ctx, mod, pVTab).(VTab)
|
||||
|
||||
cursor, err := vtab.Open()
|
||||
@ -589,12 +587,12 @@ func cursorOpenCallback(ctx context.Context, mod api.Module, pVTab, ppCur uint32
|
||||
return vtabError(ctx, mod, pVTab, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func cursorCloseCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
|
||||
func cursorCloseCallback(ctx context.Context, mod api.Module, pCur ptr_t) res_t {
|
||||
err := vtabDelHandle(ctx, mod, pCur)
|
||||
return vtabError(ctx, mod, 0, _VTAB_ERROR, err)
|
||||
}
|
||||
|
||||
func cursorFilterCallback(ctx context.Context, mod api.Module, pCur uint32, idxNum int32, idxStr, nArg, pArg uint32) uint32 {
|
||||
func cursorFilterCallback(ctx context.Context, mod api.Module, pCur ptr_t, idxNum int32, idxStr ptr_t, nArg int32, pArg ptr_t) res_t {
|
||||
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
|
||||
db := ctx.Value(connKey{}).(*Conn)
|
||||
args := make([]Value, nArg)
|
||||
@ -607,7 +605,7 @@ func cursorFilterCallback(ctx context.Context, mod api.Module, pCur uint32, idxN
|
||||
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
|
||||
}
|
||||
|
||||
func cursorEOFCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
|
||||
func cursorEOFCallback(ctx context.Context, mod api.Module, pCur ptr_t) int32 {
|
||||
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
|
||||
if cursor.EOF() {
|
||||
return 1
|
||||
@ -615,25 +613,25 @@ func cursorEOFCallback(ctx context.Context, mod api.Module, pCur uint32) uint32
|
||||
return 0
|
||||
}
|
||||
|
||||
func cursorNextCallback(ctx context.Context, mod api.Module, pCur uint32) uint32 {
|
||||
func cursorNextCallback(ctx context.Context, mod api.Module, pCur ptr_t) res_t {
|
||||
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
|
||||
err := cursor.Next()
|
||||
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
|
||||
}
|
||||
|
||||
func cursorColumnCallback(ctx context.Context, mod api.Module, pCur, pCtx uint32, n int32) uint32 {
|
||||
func cursorColumnCallback(ctx context.Context, mod api.Module, pCur, pCtx ptr_t, n int32) res_t {
|
||||
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
|
||||
db := ctx.Value(connKey{}).(*Conn)
|
||||
err := cursor.Column(Context{db, pCtx}, int(n))
|
||||
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
|
||||
}
|
||||
|
||||
func cursorRowIDCallback(ctx context.Context, mod api.Module, pCur, pRowID uint32) uint32 {
|
||||
func cursorRowIDCallback(ctx context.Context, mod api.Module, pCur, pRowID ptr_t) res_t {
|
||||
cursor := vtabGetHandle(ctx, mod, pCur).(VTabCursor)
|
||||
|
||||
rowID, err := cursor.RowID()
|
||||
if err == nil {
|
||||
util.WriteUint64(mod, pRowID, uint64(rowID))
|
||||
util.Write64(mod, pRowID, rowID)
|
||||
}
|
||||
|
||||
return vtabError(ctx, mod, pCur, _CURSOR_ERROR, err)
|
||||
@ -645,7 +643,7 @@ const (
|
||||
_CURSOR_ERROR
|
||||
)
|
||||
|
||||
func vtabError(ctx context.Context, mod api.Module, ptr, kind uint32, err error) uint32 {
|
||||
func vtabError(ctx context.Context, mod api.Module, ptr ptr_t, kind uint32, err error) res_t {
|
||||
const zErrMsgOffset = 8
|
||||
msg, code := errorCode(err, ERROR)
|
||||
if msg != "" && ptr != 0 {
|
||||
@ -653,32 +651,32 @@ func vtabError(ctx context.Context, mod api.Module, ptr, kind uint32, err error)
|
||||
case _VTAB_ERROR:
|
||||
ptr = ptr + zErrMsgOffset // zErrMsg
|
||||
case _CURSOR_ERROR:
|
||||
ptr = util.ReadUint32(mod, ptr) + zErrMsgOffset // pVTab->zErrMsg
|
||||
ptr = util.Read32[ptr_t](mod, ptr) + zErrMsgOffset // pVTab->zErrMsg
|
||||
}
|
||||
db := ctx.Value(connKey{}).(*Conn)
|
||||
if ptr := util.ReadUint32(mod, ptr); ptr != 0 {
|
||||
if ptr := util.Read32[ptr_t](mod, ptr); ptr != 0 {
|
||||
db.free(ptr)
|
||||
}
|
||||
util.WriteUint32(mod, ptr, db.newString(msg))
|
||||
util.Write32(mod, ptr, db.newString(msg))
|
||||
}
|
||||
return code
|
||||
}
|
||||
|
||||
func vtabGetHandle(ctx context.Context, mod api.Module, ptr uint32) any {
|
||||
func vtabGetHandle(ctx context.Context, mod api.Module, ptr ptr_t) any {
|
||||
const handleOffset = 4
|
||||
handle := util.ReadUint32(mod, ptr-handleOffset)
|
||||
handle := util.Read32[ptr_t](mod, ptr-handleOffset)
|
||||
return util.GetHandle(ctx, handle)
|
||||
}
|
||||
|
||||
func vtabDelHandle(ctx context.Context, mod api.Module, ptr uint32) error {
|
||||
func vtabDelHandle(ctx context.Context, mod api.Module, ptr ptr_t) error {
|
||||
const handleOffset = 4
|
||||
handle := util.ReadUint32(mod, ptr-handleOffset)
|
||||
handle := util.Read32[ptr_t](mod, ptr-handleOffset)
|
||||
return util.DelHandle(ctx, handle)
|
||||
}
|
||||
|
||||
func vtabPutHandle(ctx context.Context, mod api.Module, pptr uint32, val any) {
|
||||
func vtabPutHandle(ctx context.Context, mod api.Module, pptr ptr_t, val any) {
|
||||
const handleOffset = 4
|
||||
handle := util.AddHandle(ctx, val)
|
||||
ptr := util.ReadUint32(mod, pptr)
|
||||
util.WriteUint32(mod, ptr-handleOffset, handle)
|
||||
ptr := util.Read32[ptr_t](mod, pptr)
|
||||
util.Write32(mod, ptr-handleOffset, handle)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user