lib/go
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 11 Wiki Activity

Compare commits

base: lib:main
Branches Tags
lib:main
lib:v0.8.0
lib:v0.7.3
lib:v0.7.2
lib:v0.7.1
lib:v0.7.0
lib:v0.6.0
lib:v0.5.0
lib:v0.4.0
lib:v0.3.0
lib:v0.2.0
lib:v0.1.0
..
compare: lib:v0.7.1
Branches Tags
lib:main
lib:v0.8.0
lib:v0.7.3
lib:v0.7.2
lib:v0.7.1
lib:v0.7.0
lib:v0.6.0
lib:v0.5.0
lib:v0.4.0
lib:v0.3.0
lib:v0.2.0
lib:v0.1.0

No commits in common. "main" and "v0.7.1" have entirely different histories.
main ... v0.7.1

10 changed files with 55 additions and 308 deletions
Show Stats Expand all files Collapse all files

151
fts5/fts5.go
View File

@ -1,151 +0,0 @@
package fts5
import (
"database/sql"
"fmt"
"iter"
"strings"
_ "github.com/mattn/go-sqlite3"
)
type FTS5 struct {
colNames []string
db *sql.DB
insertStmt *sql.Stmt
matchStmt *sql.Stmt
}
func OpenMem(columnNames ...string) (*FTS5, error) {
db, err := sql.Open("sqlite3", ":memory:")
if err != nil {
return nil, err
}
return newInternal(db, columnNames)
}
func Open(path string, columnNames ...string) (*FTS5, error) {
db, err := sql.Open("sqlite3", path)
if err != nil {
return nil, err
}
return newInternal(db, columnNames)
}
func newInternal(db *sql.DB, columnNames []string) (*FTS5, error) {
_, err := db.Exec(fmt.Sprintf(
`CREATE VIRTUAL TABLE IF NOT EXISTS search USING fts5(%s, tokenize='porter')`,
strings.Join(columnNames, ",")))
if err != nil {
db.Close()
return nil, err
}
insertStmt, err := prepareInsertStmt(db, columnNames)
if err != nil {
db.Close()
return nil, err
}
matchStmt, err := db.Prepare(`SELECT rowid,rank FROM search WHERE search=? ` +
`ORDER BY rank ` +
`LIMIT ? OFFSET ?`)
if err != nil {
db.Close()
return nil, err
}
return &FTS5{
colNames: columnNames,
db: db,
insertStmt: insertStmt,
matchStmt: matchStmt,
}, nil
}
func (fts *FTS5) Close() error {
return fts.db.Close()
}
func (fts *FTS5) Upsert(id int64, data map[string]string) error {
return execInsertStmt(fts.insertStmt, fts.colNames, id, data)
}
type Item struct {
ID int64
Data map[string]string
}
func (fts *FTS5) UpsertBulk(src iter.Seq2[Item, error]) error {
tx, err := fts.db.Begin()
if err != nil {
return err
}
insertStmt, err := prepareInsertStmt(tx, fts.colNames)
if err != nil {
tx.Rollback()
return err
}
for item, err := range src {
if err != nil {
tx.Rollback()
return err
}
if err := execInsertStmt(insertStmt, fts.colNames, item.ID, item.Data); err != nil {
tx.Rollback()
return err
}
}
return tx.Commit()
}
func (fts *FTS5) Delete(id int64) (bool, error) {
result, err := fts.db.Exec(`DELETE FROM search WHERE rowid=?`, id)
if err != nil {
return false, err
}
count, err := result.RowsAffected()
if err != nil {
panic(err)
}
if count > 1 {
panic("multiple rows deleted")
}
return count > 0, nil
}
func (fts *FTS5) DeleteAll() error {
_, err := fts.db.Exec(`DELETE FROM search`)
return err
}
type Result struct {
ID int64
Rank float64
}
func (fts *FTS5) Match(query string, limit, offset int) ([]Result, error) {
results := make([]Result, 0, limit)
rows, err := fts.matchStmt.Query(query, limit, offset)
if err != nil {
return nil, err
}
defer rows.Close()
for rows.Next() {
result := Result{}
if err := rows.Scan(&result.ID, &result.Rank); err != nil {
return nil, err
}
results = append(results, result)
}
return results, nil
}

59
fts5/fts5_test.go
View File

@ -1,59 +0,0 @@
package fts5
import (
"testing"
)
func TestMatch(t *testing.T) {
fts, err := OpenMem("Title", "Text")
if err != nil {
t.Fatal(err)
}
fts.Upsert(100, map[string]string{
"Title": "Peter Rabbit",
"Text": "Peter Rabbit is a fictional animal character in various children's stories by English author Beatrix Potter.",
})
fts.Upsert(200, map[string]string{
"Title": "Baloo",
"Text": "Fictional bear from the Jungle Book.",
})
fts.Upsert(300, map[string]string{
"Title": "Barney Bear",
"Text": "A grumpy brown bear.",
})
fts.Upsert(400, map[string]string{
"Title": "Peter the Panda",
"Text": "A secret agent panda from Seattle.",
})
// Should have 2 results for "peter".
results, err := fts.Match("peter", 3, 0)
if err != nil {
t.Fatal(err)
}
if len(results) != 2 {
t.Fatal(results)
}
// Try limit.
results, err = fts.Match("peter", 1, 0)
if err != nil {
t.Fatal(err)
}
if len(results) != 1 {
t.Fatal(results)
}
// Try offset.
results, err = fts.Match("peter", 3, 1)
if err != nil {
t.Fatal(err)
}
if len(results) != 1 {
t.Fatal(results)
}
}

36
fts5/query.go
View File

@ -1,36 +0,0 @@
package fts5
import (
"database/sql"
"fmt"
"strings"
)
type preparer interface {
Prepare(string) (*sql.Stmt, error)
}
func prepareInsertStmt(
db preparer,
columnNames []string,
) (*sql.Stmt, error) {
insertQuery := fmt.Sprintf(`INSERT INTO search(rowid,%s) VALUES (?%s)`,
strings.Join(columnNames, ","),
strings.Repeat(",?", len(columnNames)))
return db.Prepare(insertQuery)
}
func execInsertStmt(
stmt *sql.Stmt,
colNames []string,
id int64,
data map[string]string,
) error {
values := make([]any, len(colNames)+1)
values[0] = id
for i, col := range colNames {
values[i+1] = data[col]
}
_, err := stmt.Exec(values...)
return err
}

9
fts5/requiretag.go
View File

@ -1,9 +0,0 @@
//go:build !fts5
package fts5
import "log"
func init() {
log.Fatal("You must provide build tag `-tags fts5`.")
}

16
sqlgen/main.go
View File

@ -5,19 +5,14 @@ import (
"os"
)
const (
DRIVER_SQLITE = "sqlite"
DRIVER_POSTGRES = "postgres"
)
func Main() {
usage := func() {
fmt.Fprintf(os.Stderr, `
%s DRIVER DEFS_PATH OUTPUT_PATH
Drivers are one of: %s %s
Drivers are one of: sqlite, postgres
`,
os.Args[0], DRIVER_SQLITE, DRIVER_POSTGRES)
os.Args[0])
os.Exit(1)
}
@ -26,20 +21,21 @@ Drivers are one of: %s %s
}
var (
template string
driver = os.Args[1]
defsPath = os.Args[2]
outputPath = os.Args[3]
)
switch driver {
case DRIVER_SQLITE, DRIVER_POSTGRES:
// OK
case "sqlite":
template = sqliteTemplate
default:
fmt.Fprintf(os.Stderr, "Unknown driver: %s", driver)
usage()
}
err := render(driver, defsPath, outputPath)
err := render(template, defsPath, outputPath)
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %v", err)
os.Exit(1)

11
sqlgen/parse.go
View File

@ -6,15 +6,15 @@ import (
"strings"
)
func parsePath(driver, filePath string) (*schema, error) {
func parsePath(filePath string) (*schema, error) {
fileBytes, err := os.ReadFile(filePath)
if err != nil {
return nil, err
}
return parseBytes(driver, fileBytes)
return parseBytes(fileBytes)
}
func parseBytes(driver string, fileBytes []byte) (*schema, error) {
func parseBytes(fileBytes []byte) (*schema, error) {
s := string(fileBytes)
for _, c := range []string{",", "(", ")", ";"} {
s = strings.ReplaceAll(s, c, " "+c+" ")
@ -29,7 +29,7 @@ func parseBytes(driver string, fileBytes []byte) (*schema, error) {
for len(tokens) > 0 {
switch tokens[0] {
case "TABLE":
tokens, err = parseTable(driver, schema, tokens)
tokens, err = parseTable(schema, tokens)
if err != nil {
return nil, err
}
@ -42,7 +42,7 @@ func parseBytes(driver string, fileBytes []byte) (*schema, error) {
return schema, nil
}
func parseTable(driver string, schema *schema, tokens []string) ([]string, error) {
func parseTable(schema *schema, tokens []string) ([]string, error) {
tokens = tokens[1:]
if len(tokens) < 3 {
return tokens, errors.New("incomplete table definition")
@ -52,7 +52,6 @@ func parseTable(driver string, schema *schema, tokens []string) ([]string, error
}
table := &table{
driver: driver,
Name: tokens[0],
Type: tokens[2],
}

2
sqlgen/parse_test.go
View File

@ -22,7 +22,7 @@ func TestParse(t *testing.T) {
for _, defPath := range paths {
t.Run(filepath.Base(defPath), func(t *testing.T) {
parsed, err := parsePath("", defPath)
parsed, err := parsePath(defPath)
if err != nil {
t.Fatal(err)
}

24
sqlgen/schema.go
View File

@ -10,7 +10,6 @@ type schema struct {
}
type table struct {
driver string //
Name string // Name in SQL
Type string // Go type
NoInsert bool
@ -30,19 +29,6 @@ type column struct {
// ----------------------------------------------------------------------------
func (t *table) translateQuery(in string) string {
if t.driver == DRIVER_SQLITE {
return in
}
i := 1
for strings.Contains(in, "?") {
in = strings.Replace(in, "?", fmt.Sprintf("$%d", i), 1)
i++
}
return in
}
func (t *table) colSQLNames() []string {
names := make([]string, len(t.Columns))
for i := range names {
@ -86,7 +72,7 @@ func (t *table) InsertQuery() string {
b.WriteString(`?`)
}
b.WriteString(`)`)
return t.translateQuery(b.String())
return b.String()
}
func (t *table) InsertArgs() string {
@ -130,7 +116,7 @@ func (t *table) UpdateQuery() string {
b.WriteString(` ` + c.SqlName + `=?`)
}
return t.translateQuery(b.String())
return b.String()
}
func (t *table) UpdateArgs() string {
@ -180,7 +166,7 @@ func (t *table) UpdateFullQuery() string {
b.WriteString(` ` + c.SqlName + `=?`)
}
return t.translateQuery(b.String())
return b.String()
}
func (t *table) UpdateFullArgs() string {
@ -236,7 +222,7 @@ func (t *table) DeleteQuery() string {
b.WriteString(col.SqlName)
b.WriteString(`=?`)
}
return t.translateQuery(b.String())
return b.String()
}
func (t *table) DeleteArgs() string {
@ -262,7 +248,7 @@ func (t *table) GetQuery() string {
}
b.WriteString(col.SqlName + `=?`)
}
return t.translateQuery(b.String())
return b.String()
}
func (t *table) ScanArgs() string {

41
sqlgen/gen.go.tmpl → sqlgen/sqlite.go.tmpl
View File

@ -2,9 +2,30 @@ package {{.PackageName}}
import (
"database/sql"
"errors"
"iter"
"github.com/mattn/go-sqlite3"
)
var (
ErrConstraint = errors.New("constraint violation")
ErrNotFound = errors.New("not found")
)
func translateError(err error) error {
if err == nil {
return nil
}
if e, ok := err.(sqlite3.Error); ok && e.Code == 19 {
return ErrConstraint
}
if errors.Is(err, sql.ErrNoRows) {
return ErrNotFound
}
return err
}
type TX interface {
Exec(query string, args ...any) (sql.Result, error)
Query(query string, args ...any) (*sql.Rows, error)
@ -36,7 +57,7 @@ func {{.Type}}_Insert(
}
_, err = tx.Exec("{{.InsertQuery}}", {{.InsertArgs}})
return err
return translateError(err)
}
{{- end}} {{/* if not .NoInsert */}}
@ -56,7 +77,7 @@ func {{.Type}}_Update(
result, err := tx.Exec("{{.UpdateQuery}}", {{.UpdateArgs}})
if err != nil {
return err
return translateError(err)
}
n, err := result.RowsAffected()
@ -65,7 +86,7 @@ func {{.Type}}_Update(
}
switch n {
case 0:
return sql.ErrNoRows
return ErrNotFound
case 1:
return nil
default:
@ -87,7 +108,7 @@ func {{.Type}}_UpdateFull(
result, err := tx.Exec("{{.UpdateFullQuery}}", {{.UpdateFullArgs}})
if err != nil {
return err
return translateError(err)
}
n, err := result.RowsAffected()
@ -96,7 +117,7 @@ func {{.Type}}_UpdateFull(
}
switch n {
case 0:
return sql.ErrNoRows
return ErrNotFound
case 1:
return nil
default:
@ -116,7 +137,7 @@ func {{.Type}}_Delete(
) (err error) {
result, err := tx.Exec("{{.DeleteQuery}}", {{.DeleteArgs}})
if err != nil {
return err
return translateError(err)
}
n, err := result.RowsAffected()
@ -125,7 +146,7 @@ func {{.Type}}_Delete(
}
switch n {
case 0:
return sql.ErrNoRows
return ErrNotFound
case 1:
return nil
default:
@ -144,7 +165,7 @@ func {{.Type}}_Get(
) {
row = &{{.Type}}{}
r := tx.QueryRow("{{.GetQuery}}", {{.DeleteArgs}})
err = r.Scan({{.ScanArgs}})
err = translateError(r.Scan({{.ScanArgs}}))
return
}
@ -159,7 +180,7 @@ func {{.Type}}_GetWhere(
) {
row = &{{.Type}}{}
r := tx.QueryRow(query, args...)
err = r.Scan({{.ScanArgs}})
err = translateError(r.Scan({{.ScanArgs}}))
return
}
@ -183,7 +204,7 @@ func {{.Type}}_Iterate(
defer rows.Close()
for rows.Next() {
row := &{{.Type}}{}
err := rows.Scan({{.ScanArgs}})
err := translateError(rows.Scan({{.ScanArgs}}))
if !yield(row, err) {
return
}

10
sqlgen/template.go
View File

@ -8,16 +8,16 @@ import (
"text/template"
)
//go:embed gen.go.tmpl
var fileTemplate string
//go:embed sqlite.go.tmpl
var sqliteTemplate string
func render(driver, schemaPath, outputPath string) error {
sch, err := parsePath(driver, schemaPath)
func render(templateStr, schemaPath, outputPath string) error {
sch, err := parsePath(schemaPath)
if err != nil {
return err
}
tmpl := template.Must(template.New("").Parse(fileTemplate))
tmpl := template.Must(template.New("").Parse(templateStr))
fOut, err := os.Create(outputPath)
if err != nil {
return err