admin/llgo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

demo: sqlite

Browse Source
This commit is contained in:
xushiwei
2024-05-08 10:43:10 +08:00
parent 52dcfaa452
commit f0e3e556cf
4 changed files with 161 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
_demo/llama2-c/run.go
View File

@@ -1,19 +1,3 @@
/*
* Copyright (c) 2024 The GoPlus Authors (goplus.org). All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package main
import (

59
_demo/sqlite/sqlite.go Normal file
View File

@@ -0,0 +1,59 @@
package main
import (
"github.com/goplus/llgo/c"
"github.com/goplus/llgo/x/sqlite"
)
func main() {
db, err := sqlite.OpenV2(c.Str(":memory:"), sqlite.OpenReadWrite|sqlite.OpenMemory, nil)
check(err)
err = db.Exec(c.Str("CREATE TABLE foo (id INT, name TEXT)"), nil, nil, nil)
check(err)
stmt, err := db.PrepareV3("INSERT INTO foo VALUES (?, ?)", 0, nil)
check(err)
stmt.BindInt(1, 100)
stmt.BindText(2, c.Str("Hello World"), sqlite.Static, nil)
err = stmt.Step()
checkDone(err)
stmt.Reset()
stmt.BindInt(1, 200)
stmt.BindText(2, c.Str("This is llgo"), sqlite.Static, nil)
err = stmt.Step()
checkDone(err)
stmt.Close()
stmt, err = db.PrepareV3("SELECT * FROM foo", 0, nil)
check(err)
for {
if err = stmt.Step(); err != sqlite.HasRow {
break
}
c.Printf(c.Str("==> id=%d, name=%s\n"), stmt.ColumnInt(0), stmt.ColumnText(1))
}
checkDone(err)
stmt.Close()
db.Close()
}
func check(err sqlite.Errno) {
if err != sqlite.OK {
c.Printf(c.Str("==> Error: (%d) %s\n"), err, err.Errstr())
c.Exit(1)
}
}
func checkDone(err sqlite.Errno) {
if err != sqlite.Done {
check(err)
}
}

5
c/c.go
View File

@@ -71,6 +71,11 @@ func GoStringData(string) *Char
// -----------------------------------------------------------------------------
//go:linkname Exit C.exit
func Exit(Int)
// -----------------------------------------------------------------------------
//go:linkname Rand C.rand
func Rand() Int

90
x/sqlite/sqlite.go
View File

@@ -32,12 +32,21 @@ const (
LLGoPackage = "noinit,link"
)
// llgo:type C
type Sqlite3 struct {
}
// llgo:type C
type Stmt struct {
}
// -----------------------------------------------------------------------------
type Errno Int
const (
OK Errno = 0 // Successful result
Error Errno = 1 // Generic error
ErrInternal Errno = 2 // Internal logic error in SQLite
ErrPerm Errno = 3 // Access permission denied
@@ -66,19 +75,22 @@ const (
ErrNotadb Errno = 26 // File opened that is not a database file
ErrNotice Errno = 27 // Notifications from sqlite3_log()
ErrWarning Errno = 28 // Warnings from sqlite3_log()
ErrRow Errno = 100 // sqlite3_step() has another row ready
ErrDone Errno = 101 // sqlite3_step() has finished executing
HasRow Errno = 100 // sqlite3_step() has another row ready
Done Errno = 101 // sqlite3_step() has finished executing
)
// -----------------------------------------------------------------------------
// llgo:link (Errno).Errstr C.sqlite3_errstr
func (err Errno) Errstr() *Char { return nil }
// llgo:type C
type Sqlite3 struct {
}
// llgo:link (*Sqlite3).Errmsg C.sqlite3_errmsg
func (db *Sqlite3) Errmsg() *Char { return nil }
// llgo:type C
type Stmt struct {
}
// llgo:link (*Sqlite3).Errcode C.sqlite3_errcode
func (db *Sqlite3) Errcode() Errno { return 0 }
// llgo:link (*Sqlite3).ExtendedErrcode C.sqlite3_extended_errcode
func (db *Sqlite3) ExtendedErrcode() Errno { return 0 }
// -----------------------------------------------------------------------------
@@ -134,12 +146,12 @@ func OpenV2(filename *Char, flags OpenFlags, zVfs *Char) (db *Sqlite3, err Errno
// Closing A Database Connection
//
// llgo:link (*Sqlite3).Close C.sqlite3_close
func (*Sqlite3) Close() Errno { return 0 }
func (db *Sqlite3) Close() Errno { return 0 }
// Closing A Database Connection
//
// llgo:link (*Sqlite3).CloseV2 C.sqlite3_close_v2
func (*Sqlite3) CloseV2() Errno { return 0 }
func (db *Sqlite3) CloseV2() Errno { return 0 }
// -----------------------------------------------------------------------------
@@ -168,22 +180,27 @@ const (
)
// Compiling An SQL Statement
// tail: Pointer to unused portion of zSql
func (db *Sqlite3) Prepare(sql string) (stmt *Stmt, tail *Char, err Errno) {
err = db.doPrepare(c.GoStringData(sql), c.Int(len(sql)), &stmt, &tail)
// tail: Pointer to unused portion of sql
func (db *Sqlite3) Prepare(sql string, tail **Char) (stmt *Stmt, err Errno) {
err = db.doPrepare(c.GoStringData(sql), c.Int(len(sql)), &stmt, tail)
return
}
func (db *Sqlite3) PrepareV2(sql string) (stmt *Stmt, tail *Char, err Errno) {
err = db.doPrepareV2(c.GoStringData(sql), c.Int(len(sql)), &stmt, &tail)
func (db *Sqlite3) PrepareV2(sql string, tail **Char) (stmt *Stmt, err Errno) {
err = db.doPrepareV2(c.GoStringData(sql), c.Int(len(sql)), &stmt, tail)
return
}
func (db *Sqlite3) PrepareV3(sql string, flags PrepareFlags) (stmt *Stmt, tail *Char, err Errno) {
err = db.doPrepareV3(c.GoStringData(sql), c.Int(len(sql)), flags, &stmt, &tail)
func (db *Sqlite3) PrepareV3(sql string, flags PrepareFlags, tail **Char) (stmt *Stmt, err Errno) {
err = db.doPrepareV3(c.GoStringData(sql), c.Int(len(sql)), flags, &stmt, tail)
return
}
// Destroy A Prepared Statement Object
//
// llgo:link (*Stmt).Close C.sqlite3_finalize
func (stmt *Stmt) Close() Errno { return 0 }
// -----------------------------------------------------------------------------
// llgo:link (*Stmt).BindInt C.sqlite3_bind_int
@@ -192,15 +209,23 @@ func (*Stmt) BindInt(idx Int, val Int) Errno { return 0 }
// llgo:link (*Stmt).BindInt64 C.sqlite3_bind_int64
func (*Stmt) BindInt64(idx Int, val int64) Errno { return 0 }
// llgo:link (*Stmt).doBindText C.sqlite3_bind_text
func (*Stmt) doBindText(Int, *Char, Int, func(Pointer)) Errno { return 0 }
const (
Static Int = 0 // val is a static string
Transient Int = -1 // val is a transient (temporary) string
)
func (stmt *Stmt) BindText(idx Int, val string, xDel func(Pointer)) Errno {
return stmt.doBindText(idx, c.GoStringData(val), c.Int(len(val)), xDel)
}
// llgo:link (*Stmt).BindText C.sqlite3_bind_text
func (*Stmt) BindText(idx Int, val *Char, lenOrKind Int, destructor func(Pointer)) Errno { return 0 }
// -----------------------------------------------------------------------------
// Reset A Prepared Statement Object
//
// llgo:link (*Stmt).Reset C.sqlite3_reset
func (stmt *Stmt) Reset() Errno {
return 0
}
// Evaluate An SQL Statement
//
// llgo:link (*Stmt).Step C.sqlite3_step
@@ -208,12 +233,29 @@ func (*Stmt) Step() Errno { return 0 }
// -----------------------------------------------------------------------------
// llgo:link (*Stmt).ColumnCount C.sqlite3_column_count
func (stmt *Stmt) ColumnCount() Int { return 0 }
// llgo:link (*Stmt).ColumnName C.sqlite3_column_name
func (stmt *Stmt) ColumnName(idx Int) *Char { return nil }
// llgo:link (*Stmt).ColumnInt C.sqlite3_column_int
func (stmt *Stmt) ColumnInt(idx Int) Int { return 0 }
// llgo:link (*Stmt).ColumnInt64 C.sqlite3_column_int64
func (stmt *Stmt) ColumnInt64(idx Int) int64 { return 0 }
// llgo:link (*Stmt).ColumnText C.sqlite3_column_text
func (stmt *Stmt) ColumnText(idx Int) *Char { return nil }
// -----------------------------------------------------------------------------
// One-Step Query Execution Interface
//
// llgo:link (*Sqlite3).Exec C.sqlite3_exec
func (*Sqlite3) Exec(
sql *Char, callback func(arg Pointer, resultCols Int, colVals, colNames **Char) Int,
arg Pointer, errmsg *Char) Errno {
arg Pointer, errmsg **Char) Errno {
return 0
}