vendor/github.com/ncruces/go-sqlite3/sqlite.go · crush

git.iko.soy/crush

on e2bb970 help sign in

crush/vendor/github.com/ncruces/go-sqlite3/sqlite.go

344 lines 8.7 kB history raw

1// Package sqlite3 wraps the C SQLite API.

2package sqlite3

4import (

5 "context"

6 "math/bits"

7 "os"

8 "sync"

9 "unsafe"

11 "github.com/tetratelabs/wazero"

12 "github.com/tetratelabs/wazero/api"

14 "github.com/ncruces/go-sqlite3/internal/util"

15 "github.com/ncruces/go-sqlite3/vfs"

16)

18// Configure SQLite Wasm.

19//

20// Importing package embed initializes [Binary]

21// with an appropriate build of SQLite:

22//

23// import _ "github.com/ncruces/go-sqlite3/embed"

24var (

25 Binary []byte // Wasm binary to load.

26 Path string // Path to load the binary from.

28 RuntimeConfig wazero.RuntimeConfig

29)

31// Initialize decodes and compiles the SQLite Wasm binary.

32// This is called implicitly when the first connection is openned,

33// but is potentially slow, so you may want to call it at a more convenient time.

34func Initialize() error {

35 instance.once.Do(compileSQLite)

36 return instance.err

37}

39var instance struct {

40 runtime wazero.Runtime

41 compiled wazero.CompiledModule

42 err error

43 once sync.Once

44}

46func compileSQLite() {

47 ctx := context.Background()

48 cfg := RuntimeConfig

49 if cfg == nil {

50 cfg = wazero.NewRuntimeConfig()

51 if bits.UintSize < 64 {

52 cfg = cfg.WithMemoryLimitPages(512) // 32MB

53 } else {

54 cfg = cfg.WithMemoryLimitPages(4096) // 256MB

55 }

56 cfg = cfg.WithCoreFeatures(api.CoreFeaturesV2)

57 }

59 instance.runtime = wazero.NewRuntimeWithConfig(ctx, cfg)

61 env := instance.runtime.NewHostModuleBuilder("env")

62 env = vfs.ExportHostFunctions(env)

63 env = exportCallbacks(env)

64 _, instance.err = env.Instantiate(ctx)

65 if instance.err != nil {

66 return

67 }

69 bin := Binary

70 if bin == nil && Path != "" {

71 bin, instance.err = os.ReadFile(Path)

72 if instance.err != nil {

73 return

74 }

75 }

76 if bin == nil {

77 instance.err = util.NoBinaryErr

78 return

79 }

81 instance.compiled, instance.err = instance.runtime.CompileModule(ctx, bin)

82}

84type sqlite struct {

85 ctx context.Context

86 mod api.Module

87 funcs struct {

88 fn [32]api.Function

89 id [32]*byte

90 mask uint32

91 }

92 stack [9]stk_t

93}

95func instantiateSQLite() (sqlt *sqlite, err error) {

96 if err := Initialize(); err != nil {

97 return nil, err

98 }

100 sqlt = new(sqlite)

101 sqlt.ctx = util.NewContext(context.Background())

102

103 sqlt.mod, err = instance.runtime.InstantiateModule(sqlt.ctx,

104 instance.compiled, wazero.NewModuleConfig().WithName(""))

105 if err != nil {

106 return nil, err

107 }

108 if sqlt.getfn("sqlite3_progress_handler_go") == nil {

109 return nil, util.BadBinaryErr

110 }

111 return sqlt, nil

112}

113

114func (sqlt *sqlite) close() error {

115 return sqlt.mod.Close(sqlt.ctx)

116}

117

118func (sqlt *sqlite) error(rc res_t, handle ptr_t, sql ...string) error {

119 if rc == _OK {

120 return nil

121 }

122

123 if ErrorCode(rc) == NOMEM || xErrorCode(rc) == IOERR_NOMEM {

124 panic(util.OOMErr)

125 }

126

127 if handle != 0 {

128 var msg, query string

129 if ptr := ptr_t(sqlt.call("sqlite3_errmsg", stk_t(handle))); ptr != 0 {

130 msg = util.ReadString(sqlt.mod, ptr, _MAX_LENGTH)

131 switch {

132 case msg == "not an error":

133 msg = ""

134 case msg == util.ErrorCodeString(uint32(rc))[len("sqlite3: "):]:

135 msg = ""

136 }

137 }

138

139 if len(sql) != 0 {

140 if i := int32(sqlt.call("sqlite3_error_offset", stk_t(handle))); i != -1 {

141 query = sql[0][i:]

142 }

143 }

144

145 if msg != "" || query != "" {

146 return &Error{code: rc, msg: msg, sql: query}

147 }

148 }

149 return xErrorCode(rc)

150}

151

152func (sqlt *sqlite) getfn(name string) api.Function {

153 c := &sqlt.funcs

154 p := unsafe.StringData(name)

155 for i := range c.id {

156 if c.id[i] == p {

157 c.id[i] = nil

158 c.mask &^= uint32(1) << i

159 return c.fn[i]

160 }

161 }

162 return sqlt.mod.ExportedFunction(name)

163}

164

165func (sqlt *sqlite) putfn(name string, fn api.Function) {

166 c := &sqlt.funcs

167 p := unsafe.StringData(name)

168 i := bits.TrailingZeros32(^c.mask)

169 if i < 32 {

170 c.id[i] = p

171 c.fn[i] = fn

172 c.mask |= uint32(1) << i

173 } else {

174 c.id[0] = p

175 c.fn[0] = fn

176 c.mask = uint32(1)

177 }

178}

179

180func (sqlt *sqlite) call(name string, params ...stk_t) stk_t {

181 copy(sqlt.stack[:], params)

182 fn := sqlt.getfn(name)

183 err := fn.CallWithStack(sqlt.ctx, sqlt.stack[:])

184 if err != nil {

185 panic(err)

186 }

187 sqlt.putfn(name, fn)

188 return stk_t(sqlt.stack[0])

189}

190

191func (sqlt *sqlite) free(ptr ptr_t) {

192 if ptr == 0 {

193 return

194 }

195 sqlt.call("sqlite3_free", stk_t(ptr))

196}

197

198func (sqlt *sqlite) new(size int64) ptr_t {

199 ptr := ptr_t(sqlt.call("sqlite3_malloc64", stk_t(size)))

200 if ptr == 0 && size != 0 {

201 panic(util.OOMErr)

202 }

203 return ptr

204}

205

206func (sqlt *sqlite) realloc(ptr ptr_t, size int64) ptr_t {

207 ptr = ptr_t(sqlt.call("sqlite3_realloc64", stk_t(ptr), stk_t(size)))

208 if ptr == 0 && size != 0 {

209 panic(util.OOMErr)

210 }

211 return ptr

212}

213

214func (sqlt *sqlite) newBytes(b []byte) ptr_t {

215 if len(b) == 0 {

216 return 0

217 }

218 ptr := sqlt.new(int64(len(b)))

219 util.WriteBytes(sqlt.mod, ptr, b)

220 return ptr

221}

222

223func (sqlt *sqlite) newString(s string) ptr_t {

224 ptr := sqlt.new(int64(len(s)) + 1)

225 util.WriteString(sqlt.mod, ptr, s)

226 return ptr

227}

228

229const arenaSize = 4096

230

231func (sqlt *sqlite) newArena() arena {

232 return arena{

233 sqlt: sqlt,

234 base: sqlt.new(arenaSize),

235 }

236}

237

238type arena struct {

239 sqlt *sqlite

240 ptrs []ptr_t

241 base ptr_t

242 next int32

243}

244

245func (a *arena) free() {

246 if a.sqlt == nil {

247 return

248 }

249 for _, ptr := range a.ptrs {

250 a.sqlt.free(ptr)

251 }

252 a.sqlt.free(a.base)

253 a.sqlt = nil

254}

255

256func (a *arena) mark() (reset func()) {

257 ptrs := len(a.ptrs)

258 next := a.next

259 return func() {

260 rest := a.ptrs[ptrs:]

261 for _, ptr := range a.ptrs[:ptrs] {

262 a.sqlt.free(ptr)

263 }

264 a.ptrs = rest

265 a.next = next

266 }

267}

268

269func (a *arena) new(size int64) ptr_t {

270 // Align the next address, to 4 or 8 bytes.

271 if size&7 != 0 {

272 a.next = (a.next + 3) &^ 3

273 } else {

274 a.next = (a.next + 7) &^ 7

275 }

276 if size <= arenaSize-int64(a.next) {

277 ptr := a.base + ptr_t(a.next)

278 a.next += int32(size)

279 return ptr_t(ptr)

280 }

281 ptr := a.sqlt.new(size)

282 a.ptrs = append(a.ptrs, ptr)

283 return ptr_t(ptr)

284}

285

286func (a *arena) bytes(b []byte) ptr_t {

287 if len(b) == 0 {

288 return 0

289 }

290 ptr := a.new(int64(len(b)))

291 util.WriteBytes(a.sqlt.mod, ptr, b)

292 return ptr

293}

294

295func (a *arena) string(s string) ptr_t {

296 ptr := a.new(int64(len(s)) + 1)

297 util.WriteString(a.sqlt.mod, ptr, s)

298 return ptr

299}

300

301func exportCallbacks(env wazero.HostModuleBuilder) wazero.HostModuleBuilder {

302 util.ExportFuncII(env, "go_progress_handler", progressCallback)

303 util.ExportFuncIII(env, "go_busy_timeout", timeoutCallback)

304 util.ExportFuncIII(env, "go_busy_handler", busyCallback)

305 util.ExportFuncII(env, "go_commit_hook", commitCallback)

306 util.ExportFuncVI(env, "go_rollback_hook", rollbackCallback)

307 util.ExportFuncVIIIIJ(env, "go_update_hook", updateCallback)

308 util.ExportFuncIIIII(env, "go_wal_hook", walCallback)

309 util.ExportFuncIIIII(env, "go_trace", traceCallback)

310 util.ExportFuncIIIIII(env, "go_autovacuum_pages", autoVacuumCallback)

311 util.ExportFuncIIIIIII(env, "go_authorizer", authorizerCallback)

312 util.ExportFuncVIII(env, "go_log", logCallback)

313 util.ExportFuncVI(env, "go_destroy", destroyCallback)

314 util.ExportFuncVIIII(env, "go_func", funcCallback)

315 util.ExportFuncVIIIII(env, "go_step", stepCallback)

316 util.ExportFuncVIIII(env, "go_value", valueCallback)

317 util.ExportFuncVIIII(env, "go_inverse", inverseCallback)

318 util.ExportFuncVIIII(env, "go_collation_needed", collationCallback)

319 util.ExportFuncIIIIII(env, "go_compare", compareCallback)

320 util.ExportFuncIIIIII(env, "go_vtab_create", vtabModuleCallback(xCreate))

321 util.ExportFuncIIIIII(env, "go_vtab_connect", vtabModuleCallback(xConnect))

322 util.ExportFuncII(env, "go_vtab_disconnect", vtabDisconnectCallback)

323 util.ExportFuncII(env, "go_vtab_destroy", vtabDestroyCallback)

324 util.ExportFuncIII(env, "go_vtab_best_index", vtabBestIndexCallback)

325 util.ExportFuncIIIII(env, "go_vtab_update", vtabUpdateCallback)

326 util.ExportFuncIII(env, "go_vtab_rename", vtabRenameCallback)

327 util.ExportFuncIIIII(env, "go_vtab_find_function", vtabFindFuncCallback)

328 util.ExportFuncII(env, "go_vtab_begin", vtabBeginCallback)

329 util.ExportFuncII(env, "go_vtab_sync", vtabSyncCallback)

330 util.ExportFuncII(env, "go_vtab_commit", vtabCommitCallback)

331 util.ExportFuncII(env, "go_vtab_rollback", vtabRollbackCallback)

332 util.ExportFuncIII(env, "go_vtab_savepoint", vtabSavepointCallback)

333 util.ExportFuncIII(env, "go_vtab_release", vtabReleaseCallback)

334 util.ExportFuncIII(env, "go_vtab_rollback_to", vtabRollbackToCallback)

335 util.ExportFuncIIIIII(env, "go_vtab_integrity", vtabIntegrityCallback)

336 util.ExportFuncIII(env, "go_cur_open", cursorOpenCallback)

337 util.ExportFuncII(env, "go_cur_close", cursorCloseCallback)

338 util.ExportFuncIIIIII(env, "go_cur_filter", cursorFilterCallback)

339 util.ExportFuncII(env, "go_cur_next", cursorNextCallback)

340 util.ExportFuncII(env, "go_cur_eof", cursorEOFCallback)

341 util.ExportFuncIIII(env, "go_cur_column", cursorColumnCallback)

342 util.ExportFuncIII(env, "go_cur_rowid", cursorRowIDCallback)

343 return env

344}