+1

.gitignore

Reviewed

··· 1 1 + __debug*

+5

README.md

Reviewed

··· 1 1 # PureGo SQLite 2 2 + 3 3 + Pure Go database driver for [SQLite](https://sqlite.org) using 4 4 + [`purego`](https://github.com/ebitengine/purego). 5 5 + 6 6 + Requires the SQLite shared library installed. You probably already have it.

+399

driver.go

Reviewed

··· 1 1 + package sqlite 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "database/sql" 6 6 + "database/sql/driver" 7 7 + "encoding/json" 8 8 + "errors" 9 9 + "fmt" 10 10 + "hash/maphash" 11 11 + "io" 12 12 + "runtime" 13 13 + "strings" 14 14 + ) 15 15 + 16 16 + var ( 17 17 + ErrDeprecated = errors.New("This function is deprecated by [database/sql/driver]") 18 18 + ErrAlreadyClosed = errors.Join(driver.ErrBadConn, errors.New("Already closed")) 19 19 + ErrBadColumn = errors.New("Bad column name or index") 20 20 + ) 21 21 + 22 22 + func init() { 23 23 + sql.Register("sqlite", Driver{}) 24 24 + } 25 25 + 26 26 + type Driver struct { 27 27 + lib *Library 28 28 + } 29 29 + 30 30 + // Open implements [driver.Driver]. 31 31 + func (d Driver) Open(name string) (driver.Conn, error) { 32 32 + return nil, ErrDeprecated 33 33 + } 34 34 + 35 35 + // OpenConnector implements [driver.DriverContext]. 36 36 + func (d Driver) OpenConnector(name string) (driver.Connector, error) { 37 37 + lib, err := Open() 38 38 + if err != nil { 39 39 + return nil, err 40 40 + } 41 41 + d.lib = lib 42 42 + 43 43 + return Connector{name, &d}, nil 44 44 + } 45 45 + 46 46 + type Connector struct { 47 47 + name string 48 48 + driver *Driver 49 49 + } 50 50 + 51 51 + // Connect implements [driver.Connector]. 52 52 + func (c Connector) Connect(context.Context) (driver.Conn, error) { 53 53 + var handle DbHandle 54 54 + errno := c.driver.lib.Open(c.name, &handle) 55 55 + if errno != Ok { 56 56 + return nil, errno 57 57 + } 58 58 + 59 59 + return Conn{ 60 60 + lib: c.driver.lib, 61 61 + handle: handle, 62 62 + seed: maphash.MakeSeed(), 63 63 + prepared: make(map[uint64]Stmt), 64 64 + }, nil 65 65 + } 66 66 + 67 67 + // Driver implements [driver.Connector]. 68 68 + func (c Connector) Driver() driver.Driver { 69 69 + return c.driver 70 70 + } 71 71 + 72 72 + type Conn struct { 73 73 + lib *Library 74 74 + handle DbHandle 75 75 + seed maphash.Seed 76 76 + prepared map[uint64]Stmt 77 77 + } 78 78 + 79 79 + // Begin implements [driver.Conn]. 80 80 + func (c Conn) Begin() (driver.Tx, error) { 81 81 + return nil, ErrDeprecated 82 82 + } 83 83 + 84 84 + // Close implements [driver.Conn]. 85 85 + func (c Conn) Close() error { 86 86 + if c.handle == nil { 87 87 + return ErrAlreadyClosed 88 88 + } 89 89 + 90 90 + errno := c.lib.Close(c.handle) 91 91 + if errno != Ok { 92 92 + return errno 93 93 + } 94 94 + 95 95 + c.handle = nil 96 96 + return nil 97 97 + } 98 98 + 99 99 + // Prepare implements [driver.Conn]. 100 100 + func (c Conn) Prepare(query string) (driver.Stmt, error) { 101 101 + return nil, ErrDeprecated 102 102 + } 103 103 + 104 104 + // PrepareContext implements [driver.ConnPrepareContext]. 105 105 + func (c Conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error) { 106 106 + if c.handle == nil { 107 107 + return nil, ErrAlreadyClosed 108 108 + } 109 109 + 110 110 + // Hash and check manually to avoid storing query strings 111 111 + h := maphash.String(c.seed, strings.TrimSpace(query)) 112 112 + stmt, ok := c.prepared[h] 113 113 + if ok { 114 114 + return stmt, nil 115 115 + } 116 116 + 117 117 + var stmtHandle StmtHandle 118 118 + errno := c.lib.Prepare(c.handle, query, len(query), &stmtHandle, nil) 119 119 + if errno != Ok { 120 120 + return nil, errno 121 121 + } 122 122 + 123 123 + stmt = Stmt{&c, stmtHandle} 124 124 + // Make sure that statements are fully cleaned up 125 125 + // https://pkg.go.dev/runtime#AddCleanup 126 126 + runtime.AddCleanup(&stmt, func(handle StmtHandle) { 127 127 + errno = c.lib.Stmt.Finalize(handle) 128 128 + if errno != Ok { 129 129 + panic(errno) 130 130 + } 131 131 + }, stmt.handle) 132 132 + c.prepared[h] = stmt 133 133 + 134 134 + return stmt, nil 135 135 + } 136 136 + 137 137 + type Tx struct { 138 138 + conn *Conn 139 139 + } 140 140 + 141 141 + // Commit implements [driver.Tx]. 142 142 + func (t Tx) Commit() error { 143 143 + errno := t.conn.lib.Exec(t.conn.handle, "COMMIT;", nil, nil, nil) 144 144 + if errno != Ok { 145 145 + return errno 146 146 + } 147 147 + return nil 148 148 + } 149 149 + 150 150 + // Rollback implements [driver.Tx]. 151 151 + func (t Tx) Rollback() error { 152 152 + errno := t.conn.lib.Exec(t.conn.handle, "ROLLBACK;", nil, nil, nil) 153 153 + if errno != Ok { 154 154 + return errno 155 155 + } 156 156 + return nil 157 157 + } 158 158 + 159 159 + // BeginTx implements [driver.ConnBeginTx]. 160 160 + func (c Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) { 161 161 + errno := c.lib.Exec(c.handle, "BEGIN;", nil, nil, nil) 162 162 + if errno != Ok { 163 163 + return nil, errno 164 164 + } 165 165 + 166 166 + return Tx{&c}, nil 167 167 + } 168 168 + 169 169 + type Stmt struct { 170 170 + conn *Conn 171 171 + handle StmtHandle 172 172 + } 173 173 + 174 174 + // Exec implements [driver.Stmt]. 175 175 + func (s Stmt) Exec(args []driver.Value) (driver.Result, error) { 176 176 + return nil, ErrDeprecated 177 177 + } 178 178 + 179 179 + // Query implements [driver.Stmt]. 180 180 + func (s Stmt) Query(args []driver.Value) (driver.Rows, error) { 181 181 + return nil, ErrDeprecated 182 182 + } 183 183 + 184 184 + type Result struct { 185 185 + count int64 186 186 + last_id int64 187 187 + } 188 188 + 189 189 + // LastInsertId implements [driver.Result]. 190 190 + func (r Result) LastInsertId() (int64, error) { 191 191 + return r.last_id, nil 192 192 + } 193 193 + 194 194 + // RowsAffected implements [driver.Result]. 195 195 + func (r Result) RowsAffected() (int64, error) { 196 196 + return r.count, nil 197 197 + } 198 198 + 199 199 + // ExecContext implements [driver.StmtExecContext]. 200 200 + func (s Stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error) { 201 201 + var lib = s.conn.lib 202 202 + 203 203 + err := s.bindArgs(ctx, args) 204 204 + if err != nil { 205 205 + return nil, err 206 206 + } 207 207 + 208 208 + // Eagerly performs the full query stepping 209 209 + for { 210 210 + errno := lib.Step(s.handle) 211 211 + switch errno { 212 212 + case Ok, Row: 213 213 + continue 214 214 + case Done: 215 215 + return Result{ 216 216 + count: lib.Changes(s.conn.handle), 217 217 + last_id: lib.LastId(s.conn.handle), 218 218 + }, nil 219 219 + default: 220 220 + return nil, errno 221 221 + } 222 222 + } 223 223 + } 224 224 + 225 225 + type Rows struct { 226 226 + stmt *Stmt 227 227 + } 228 228 + 229 229 + // Close implements [driver.Rows]. 230 230 + func (r Rows) Close() error { 231 231 + if r.stmt == nil { 232 232 + return ErrAlreadyClosed 233 233 + } 234 234 + 235 235 + r.stmt.Close() 236 236 + r.stmt = nil 237 237 + return nil 238 238 + } 239 239 + 240 240 + // Columns implements [driver.Rows]. 241 241 + func (r Rows) Columns() []string { 242 242 + lib := r.stmt.conn.lib 243 243 + count := lib.Stmt.Column.Count(r.stmt.handle) 244 244 + out := make([]string, count) 245 245 + for i := range count { 246 246 + str := lib.Stmt.Column.Name(r.stmt.handle, i) 247 247 + out = append(out, str) 248 248 + } 249 249 + return out 250 250 + } 251 251 + 252 252 + // Next implements [driver.Rows]. 253 253 + func (r Rows) Next(dest []driver.Value) error { 254 254 + lib := r.stmt.conn.lib 255 255 + handle := r.stmt.handle 256 256 + 257 257 + errno := lib.Step(handle) 258 258 + if errno == Done { 259 259 + return io.EOF 260 260 + } 261 261 + if errno != Ok { 262 262 + return errno 263 263 + } 264 264 + 265 265 + count := lib.Stmt.Column.Count(handle) 266 266 + for i := range count { 267 267 + dataType := lib.Stmt.Column.Type(handle, i) 268 268 + switch dataType { 269 269 + case Int: 270 270 + dest[i] = lib.Stmt.Column.Int(handle, i) 271 271 + case Double: 272 272 + dest[i] = lib.Stmt.Column.Double(handle, i) 273 273 + case Text: 274 274 + dest[i] = lib.Stmt.Column.Text(handle, i) 275 275 + case Blob: 276 276 + dest[i] = lib.Stmt.Column.Blob(handle, i) 277 277 + case Null: 278 278 + dest[i] = nil 279 279 + } 280 280 + } 281 281 + 282 282 + return nil 283 283 + } 284 284 + 285 285 + // QueryContext implements [driver.StmtQueryContext]. 286 286 + func (s Stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error) { 287 287 + err := s.bindArgs(ctx, args) 288 288 + if err != nil { 289 289 + return nil, err 290 290 + } 291 291 + 292 292 + return Rows{&s}, nil 293 293 + } 294 294 + 295 295 + func (s Stmt) bindArgs(ctx context.Context, args []driver.NamedValue) error { 296 296 + lib := s.conn.lib 297 297 + for _, arg := range args { 298 298 + // Handle deadline 299 299 + if ctx.Err() != nil { 300 300 + return ctx.Err() 301 301 + } 302 302 + 303 303 + index := arg.Ordinal 304 304 + if arg.Name != "" { 305 305 + index = lib.Stmt.Index(s.handle, arg.Name) 306 306 + if index == 0 { 307 307 + return ErrBadColumn 308 308 + } 309 309 + } 310 310 + 311 311 + if arg.Value == nil { 312 312 + lib.Stmt.Bind.Null(s.handle, index) 313 313 + continue 314 314 + } 315 315 + 316 316 + // See [Stmt.CheckNamedValue] for conversion process 317 317 + var errno ErrCode 318 318 + switch arg.Value.(type) { 319 319 + case int64: 320 320 + errno = lib.Stmt.Bind.Int(s.handle, index, arg.Value.(int64)) 321 321 + case float64: 322 322 + errno = lib.Stmt.Bind.Double(s.handle, index, arg.Value.(float64)) 323 323 + case string: 324 324 + str := arg.Value.(string) 325 325 + errno = lib.Stmt.Bind.Text(s.handle, index, str, len(str), Transient) 326 326 + case []byte: 327 327 + blob := arg.Value.([]byte) 328 328 + errno = lib.Stmt.Bind.Blob(s.handle, index, blob, len(blob), Transient) 329 329 + default: 330 330 + return fmt.Errorf("Unsupported value: %s", arg.Value) 331 331 + } 332 332 + if errno != Ok { 333 333 + return errno 334 334 + } 335 335 + } 336 336 + 337 337 + return nil 338 338 + } 339 339 + 340 340 + // Close implements [driver.Stmt]. 341 341 + func (s Stmt) Close() error { 342 342 + if s.handle == nil { 343 343 + return ErrAlreadyClosed 344 344 + } 345 345 + 346 346 + errno := s.conn.lib.Stmt.Reset(s.handle) 347 347 + if errno != Ok { 348 348 + return errno 349 349 + } 350 350 + errno = s.conn.lib.Stmt.Reset(s.handle) 351 351 + if errno != Ok { 352 352 + return errno 353 353 + } 354 354 + 355 355 + s.handle = nil 356 356 + return nil 357 357 + } 358 358 + 359 359 + // NumInput implements [driver.Stmt]. 360 360 + func (s Stmt) NumInput() int { 361 361 + return s.conn.lib.Stmt.Count(s.handle) 362 362 + } 363 363 + 364 364 + // CheckNamedValue implements [driver.NamedValueChecker] 365 365 + func (s Stmt) CheckNamedValue(arg *driver.NamedValue) error { 366 366 + switch v := arg.Value.(type) { 367 367 + // The types we don't need to convert 368 368 + case int64, float64, string, []byte: 369 369 + break 370 370 + case int8: 371 371 + arg.Value = int64(v) 372 372 + case int16: 373 373 + arg.Value = int64(v) 374 374 + case int32: 375 375 + arg.Value = int64(v) 376 376 + case uint: 377 377 + arg.Value = int64(v) 378 378 + case uint8: 379 379 + arg.Value = int64(v) 380 380 + case uint16: 381 381 + arg.Value = int64(v) 382 382 + case uint32: 383 383 + arg.Value = int64(v) 384 384 + case uint64: 385 385 + arg.Value = int64(v) 386 386 + case uintptr: 387 387 + arg.Value = int64(v) 388 388 + case float32: 389 389 + arg.Value = float64(v) 390 390 + default: 391 391 + // All else fails we use JSON 392 392 + data, err := json.Marshal(arg.Value) 393 393 + if err != nil { 394 394 + return err 395 395 + } 396 396 + arg.Value = data 397 397 + } 398 398 + return nil 399 399 + }

+57

driver_test.go

Reviewed

··· 1 1 + package sqlite 2 2 + 3 3 + import ( 4 4 + "database/sql" 5 5 + "testing" 6 6 + ) 7 7 + 8 8 + func Test_Registered(t *testing.T) { 9 9 + db, err := sql.Open("sqlite", ":memory:") 10 10 + if err != nil { 11 11 + t.Error(err) 12 12 + } 13 13 + db.Close() 14 14 + } 15 15 + 16 16 + func Test_OpenConnector(t *testing.T) { 17 17 + connector, err := Driver{}.OpenConnector(":memory:") 18 18 + if err != nil { 19 19 + t.Error(err) 20 20 + } 21 21 + db := sql.OpenDB(connector) 22 22 + db.Close() 23 23 + } 24 24 + 25 25 + func Test_CreateInsertQuery(t *testing.T) { 26 26 + db, err := sql.Open("sqlite", ":memory:") 27 27 + if err != nil { 28 28 + t.Error(err) 29 29 + } 30 30 + defer db.Close() 31 31 + 32 32 + _, err = db.Exec("CREATE TABLE test (foo INT, bar BLOB);") 33 33 + if err != nil { 34 34 + t.Error(err) 35 35 + } 36 36 + _, err = db.Exec("INSERT INTO test (foo, bar) VALUES (?, ?);", 10, "blah blah") 37 37 + if err != nil { 38 38 + t.Error(err) 39 39 + } 40 40 + 41 41 + /* */ 42 42 + row := db.QueryRow("SELECT * FROM test;") 43 43 + if row.Err() != nil { 44 44 + t.Error(row.Err()) 45 45 + } 46 46 + for err == Row { 47 47 + var ( 48 48 + foo int 49 49 + bar []byte 50 50 + ) 51 51 + err = row.Scan(&foo, &bar) 52 52 + t.Logf("%d %s", foo, bar) 53 53 + } 54 54 + if err != nil { 55 55 + t.Error(err) 56 56 + } 57 57 + }

+2

go.mod

Reviewed

··· 1 1 module tangled.org/rushsteve1/purego-sqlite 2 2 3 3 go 1.26.3 4 4 + 5 5 + require github.com/ebitengine/purego v0.10.0

+2

go.sum

Reviewed

··· 1 1 + github.com/ebitengine/purego v0.10.0 h1:QIw4xfpWT6GWTzaW5XEKy3HXoqrJGx1ijYHzTF0/ISU= 2 2 + github.com/ebitengine/purego v0.10.0/go.mod h1:iIjxzd6CiRiOG0UyXP+V1+jWqUXVjPKLAI0mRfJZTmQ=

+160

library.go

Reviewed

··· 1 1 + package sqlite 2 2 + 3 3 + import ( 4 4 + "fmt" 5 5 + "runtime" 6 6 + "unsafe" 7 7 + 8 8 + "github.com/ebitengine/purego" 9 9 + ) 10 10 + 11 11 + type LibraryHandle = uintptr 12 12 + type DbHandle unsafe.Pointer 13 13 + type StmtHandle unsafe.Pointer 14 14 + 15 15 + // https://sqlite.org/rescode.html 16 16 + type ErrCode int 17 17 + 18 18 + const ( 19 19 + Ok ErrCode = 0 20 20 + Done ErrCode = 101 21 21 + Row ErrCode = 100 22 22 + ) 23 23 + 24 24 + // https://sqlite.org/c3ref/c_static.html 25 25 + var Transient unsafe.Pointer = unsafe.Pointer(^uintptr(0)) 26 26 + 27 27 + // https://sqlite.org/c3ref/c_blob.html 28 28 + type DataType int 29 29 + 30 30 + const ( 31 31 + Int DataType = 1 32 32 + Double DataType = 2 33 33 + Text DataType = 3 34 34 + Blob DataType = 4 35 35 + Null DataType = 5 36 36 + ) 37 37 + 38 38 + // Store a copy of the loaded library. loading it again is meaningless 39 39 + var memoizedLibrary *Library 40 40 + 41 41 + // Error implements [error] 42 42 + func (c ErrCode) Error() string { 43 43 + if memoizedLibrary != nil { 44 44 + return fmt.Sprintf("SQLite error [%d]: %s", c, memoizedLibrary.ErrStr(c)) 45 45 + } else { 46 46 + return fmt.Sprintf("SQLite error [%d] (without loaded library?)", c) 47 47 + } 48 48 + } 49 49 + 50 50 + // Vtable of functions loaded from shared library 51 51 + type Library struct { 52 52 + handle LibraryHandle 53 53 + // https://sqlite.org/c3ref/open.html 54 54 + Open func(name string, handle *DbHandle) ErrCode 55 55 + // https://sqlite.org/c3ref/close.html 56 56 + Close func(handle DbHandle) ErrCode 57 57 + // https://sqlite.org/c3ref/exec.html 58 58 + Exec func(handle DbHandle, sql string, cb func(unsafe.Pointer, int, *string, *string), cba unsafe.Pointer, err *string) ErrCode 59 59 + // https://sqlite.org/c3ref/prepare.html 60 60 + Prepare func(handle DbHandle, sql string, len int, stmt *StmtHandle, tail *unsafe.Pointer) ErrCode 61 61 + // https://sqlite.org/c3ref/step.html 62 62 + Step func(handle StmtHandle) ErrCode 63 63 + // https://sqlite.org/c3ref/errcode.html 64 64 + ErrStr func(code ErrCode) string 65 65 + // https://sqlite.org/c3ref/changes.html 66 66 + Changes func(handle DbHandle) int64 67 67 + // https://sqlite.org/c3ref/last_insert_rowid.html 68 68 + LastId func(handle DbHandle) int64 69 69 + 70 70 + Stmt struct { 71 71 + // https://sqlite.org/c3ref/bind_parameter_count.html 72 72 + Count func(handle StmtHandle) int 73 73 + // https://sqlite.org/c3ref/reset.html 74 74 + Reset func(handle StmtHandle) ErrCode 75 75 + // https://sqlite.org/c3ref/clear_bindings.html 76 76 + Clear func(handle StmtHandle) ErrCode 77 77 + // https://sqlite.org/c3ref/finalize.html 78 78 + Finalize func(handle StmtHandle) ErrCode 79 79 + // https://sqlite.org/c3ref/bind_parameter_index.html 80 80 + Index func(handle StmtHandle, name string) int 81 81 + // https://sqlite.org/c3ref/bind_blob.html 82 82 + Bind struct { 83 83 + Int func(handle StmtHandle, index int, value int64) ErrCode 84 84 + Double func(handle StmtHandle, index int, value float64) ErrCode 85 85 + Text func(handle StmtHandle, index int, value string, len int, cb unsafe.Pointer) ErrCode 86 86 + Blob func(handle StmtHandle, index int, value []byte, len int, cb unsafe.Pointer) ErrCode 87 87 + Null func(handle StmtHandle, index int) ErrCode 88 88 + } 89 89 + 90 90 + // https://sqlite.org/c3ref/column_blob.html 91 91 + Column struct { 92 92 + // https://sqlite.org/c3ref/column_count.html 93 93 + Count func(handle StmtHandle) int 94 94 + // https://sqlite.org/c3ref/column_name.html 95 95 + Name func(handle StmtHandle, index int) string 96 96 + Type func(handle StmtHandle, index int) DataType 97 97 + 98 98 + Int func(handle StmtHandle, index int) int 99 99 + Double func(handle StmtHandle, index int) float64 100 100 + Text func(handle StmtHandle, index int) string 101 101 + Blob func(handle StmtHandle, index int) []byte 102 102 + } 103 103 + } 104 104 + } 105 105 + 106 106 + // Opens the shared library and binds to the vtable [Library] 107 107 + func Open() (*Library, error) { 108 108 + if memoizedLibrary != nil { 109 109 + return memoizedLibrary, nil 110 110 + } 111 111 + 112 112 + var path string 113 113 + switch runtime.GOOS { 114 114 + case "darwin": 115 115 + path = "libsqlite3.0.dylib" 116 116 + case "linux": 117 117 + path = "libsqlite3.0.so" 118 118 + } 119 119 + 120 120 + handle, err := purego.Dlopen(path, 0) 121 121 + if err != nil { 122 122 + return nil, err 123 123 + } 124 124 + 125 125 + var lib Library 126 126 + lib.handle = handle 127 127 + 128 128 + purego.RegisterLibFunc(&lib.Open, lib.handle, "sqlite3_open") 129 129 + purego.RegisterLibFunc(&lib.Close, lib.handle, "sqlite3_close_v2") 130 130 + purego.RegisterLibFunc(&lib.Exec, lib.handle, "sqlite3_exec") 131 131 + purego.RegisterLibFunc(&lib.Prepare, lib.handle, "sqlite3_prepare_v2") 132 132 + purego.RegisterLibFunc(&lib.Step, lib.handle, "sqlite3_step") 133 133 + purego.RegisterLibFunc(&lib.ErrStr, lib.handle, "sqlite3_errstr") 134 134 + purego.RegisterLibFunc(&lib.Changes, lib.handle, "sqlite3_changes") 135 135 + purego.RegisterLibFunc(&lib.LastId, lib.handle, "sqlite3_last_insert_rowid") 136 136 + 137 137 + purego.RegisterLibFunc(&lib.Stmt.Count, lib.handle, "sqlite3_bind_parameter_count") 138 138 + purego.RegisterLibFunc(&lib.Stmt.Reset, lib.handle, "sqlite3_reset") 139 139 + purego.RegisterLibFunc(&lib.Stmt.Clear, lib.handle, "sqlite3_clear_bindings") 140 140 + purego.RegisterLibFunc(&lib.Stmt.Finalize, lib.handle, "sqlite3_finalize") 141 141 + purego.RegisterLibFunc(&lib.Stmt.Index, lib.handle, "sqlite3_bind_parameter_index") 142 142 + 143 143 + purego.RegisterLibFunc(&lib.Stmt.Bind.Int, lib.handle, "sqlite3_bind_int64") 144 144 + purego.RegisterLibFunc(&lib.Stmt.Bind.Double, lib.handle, "sqlite3_bind_double") 145 145 + purego.RegisterLibFunc(&lib.Stmt.Bind.Text, lib.handle, "sqlite3_bind_text") 146 146 + purego.RegisterLibFunc(&lib.Stmt.Bind.Blob, lib.handle, "sqlite3_bind_blob64") 147 147 + purego.RegisterLibFunc(&lib.Stmt.Bind.Null, lib.handle, "sqlite3_bind_null") 148 148 + 149 149 + purego.RegisterLibFunc(&lib.Stmt.Column.Count, lib.handle, "sqlite3_column_count") 150 150 + purego.RegisterLibFunc(&lib.Stmt.Column.Name, lib.handle, "sqlite3_column_name") 151 151 + purego.RegisterLibFunc(&lib.Stmt.Column.Type, lib.handle, "sqlite3_column_type") 152 152 + 153 153 + purego.RegisterLibFunc(&lib.Stmt.Column.Int, lib.handle, "sqlite3_column_int64") 154 154 + purego.RegisterLibFunc(&lib.Stmt.Column.Double, lib.handle, "sqlite3_column_double") 155 155 + purego.RegisterLibFunc(&lib.Stmt.Column.Text, lib.handle, "sqlite3_column_text") 156 156 + purego.RegisterLibFunc(&lib.Stmt.Column.Blob, lib.handle, "sqlite3_column_blob") 157 157 + 158 158 + memoizedLibrary = &lib 159 159 + return memoizedLibrary, nil 160 160 + }

+14

library_test.go

Reviewed

··· 1 1 + package sqlite 2 2 + 3 3 + import "testing" 4 4 + 5 5 + func Test_LibraryOpen(t *testing.T) { 6 6 + lib, err := Open() 7 7 + if err != nil { 8 8 + t.Error(err) 9 9 + } 10 10 + 11 11 + if lib.Open == nil { 12 12 + t.Error("Missing SQLite Open") 13 13 + } 14 14 + }