Rename sql3util.

util/sql3util/README.md

@@ -0,0 +1,9 @@
+# SQLite utility functions 
+
+This package implements assorted SQLite utilities
+useful to extension writers.
+
+It also wraps a [parser](https://github.com/marcobambini/sqlite-createtable-parser)
+for the [`CREATE`](https://sqlite.org/lang_createtable.html) and
+[`ALTER TABLE`](https://sqlite.org/lang_altertable.html) commands,
+created by [Marco Bambini](https://github.com/marcobambini).

util/sql3util/arg.go

@@ -0,0 +1,60 @@
+package sql3util
+
+import "strings"
+
+// NamedArg splits an named arg into a key and value,
+// around an equals sign.
+// Spaces are trimmed around both key and value.
+func NamedArg(arg string) (key, val string) {
+	key, val, _ = strings.Cut(arg, "=")
+	key = strings.TrimSpace(key)
+	val = strings.TrimSpace(val)
+	return
+}
+
+// Unquote unquotes a string.
+func Unquote(val string) string {
+	if len(val) < 2 {
+		return val
+	}
+	fst := val[0]
+	lst := val[len(val)-1]
+	rst := val[1 : len(val)-1]
+	if fst == '[' && lst == ']' {
+		return rst
+	}
+	if fst != lst {
+		return val
+	}
+	var old, new string
+	switch fst {
+	default:
+		return val
+	case '`':
+		old, new = "``", "`"
+	case '"':
+		old, new = `""`, `"`
+	case '\'':
+		old, new = `''`, `'`
+	}
+	return strings.ReplaceAll(rst, old, new)
+}
+
+func ParseBool(s string) (b, ok bool) {
+	if len(s) == 0 {
+		return false, false
+	}
+	if s[0] == '0' {
+		return false, true
+	}
+	if '1' <= s[0] && s[0] <= '9' {
+		return true, true
+	}
+	switch strings.ToLower(s) {
+	case "true", "yes", "on":
+		return true, true
+	case "false", "no", "off":
+		return false, true
+	}
+	return false, false
+}

util/sql3util/arg_test.go

@@ -0,0 +1,55 @@
+package sql3util_test
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/util/sql3util"
+)
+
+func TestUnquote(t *testing.T) {
+	tests := []struct {
+		val  string
+		want string
+	}{
+		{"a", "a"},
+		{"abc", "abc"},
+		{"abba", "abba"},
+		{"`ab``c`", "ab`c"},
+		{"'ab''c'", "ab'c"},
+		{"'ab``c'", "ab``c"},
+		{"[ab``c]", "ab``c"},
+		{`"ab""c"`, `ab"c`},
+	}
+	for _, tt := range tests {
+		t.Run(tt.val, func(t *testing.T) {
+			if got := sql3util.Unquote(tt.val); got != tt.want {
+				t.Errorf("Unquote(%s) = %s, want %s", tt.val, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestParseBool(t *testing.T) {
+	tests := []struct {
+		str string
+		val bool
+		ok  bool
+	}{
+		{"", false, false},
+		{"0", false, true},
+		{"1", true, true},
+		{"9", true, true},
+		{"T", false, false},
+		{"true", true, true},
+		{"FALSE", false, true},
+		{"false?", false, false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.str, func(t *testing.T) {
+			gotVal, gotOK := sql3util.ParseBool(tt.str)
+			if gotVal != tt.val || gotOK != tt.ok {
+				t.Errorf("ParseBool(%q) = (%v, %v) want (%v, %v)", tt.str, gotVal, gotOK, tt.val, tt.ok)
+			}
+		})
+	}
+}

util/sql3util/const.go

@@ -0,0 +1,61 @@
+package sql3util
+
+const (
+	_NONE = iota
+	_MEMORY
+	_SYNTAX
+	_UNSUPPORTEDSQL
+)
+
+type ConflictClause uint32
+
+const (
+	CONFLICT_NONE ConflictClause = iota
+	CONFLICT_ROLLBACK
+	CONFLICT_ABORT
+	CONFLICT_FAIL
+	CONFLICT_IGNORE
+	CONFLICT_REPLACE
+)
+
+type OrderClause uint32
+
+const (
+	ORDER_NONE OrderClause = iota
+	ORDER_ASC
+	ORDER_DESC
+)
+
+type FKAction uint32
+
+const (
+	FKACTION_NONE FKAction = iota
+	FKACTION_SETNULL
+	FKACTION_SETDEFAULT
+	FKACTION_CASCADE
+	FKACTION_RESTRICT
+	FKACTION_NOACTION
+)
+
+type FKDefType uint32
+
+const (
+	DEFTYPE_NONE FKDefType = iota
+	DEFTYPE_DEFERRABLE
+	DEFTYPE_DEFERRABLE_INITIALLY_DEFERRED
+	DEFTYPE_DEFERRABLE_INITIALLY_IMMEDIATE
+	DEFTYPE_NOTDEFERRABLE
+	DEFTYPE_NOTDEFERRABLE_INITIALLY_DEFERRED
+	DEFTYPE_NOTDEFERRABLE_INITIALLY_IMMEDIATE
+)
+
+type StatementType uint32
+
+const (
+	CREATE_UNKNOWN StatementType = iota
+	CREATE_TABLE
+	ALTER_RENAME_TABLE
+	ALTER_RENAME_COLUMN
+	ALTER_ADD_COLUMN
+	ALTER_DROP_COLUMN
+)

util/sql3util/parse.go

@@ -0,0 +1,210 @@
+package sql3util
+
+import (
+	"context"
+	_ "embed"
+	"sync"
+
+	"github.com/tetratelabs/wazero"
+	"github.com/tetratelabs/wazero/api"
+
+	"github.com/ncruces/go-sqlite3/internal/util"
+)
+
+const (
+	errp = 4
+	sqlp = 8
+)
+
+var (
+	//go:embed parse/sql3parse_table.wasm
+	binary   []byte
+	once     sync.Once
+	runtime  wazero.Runtime
+	compiled wazero.CompiledModule
+)
+
+// ParseTable parses a [CREATE] or [ALTER TABLE] command.
+//
+// [CREATE]: https://sqlite.org/lang_createtable.html
+// [ALTER TABLE]: https://sqlite.org/lang_altertable.html
+func ParseTable(sql string) (_ *Table, err error) {
+	once.Do(func() {
+		ctx := context.Background()
+		cfg := wazero.NewRuntimeConfigInterpreter()
+		runtime = wazero.NewRuntimeWithConfig(ctx, cfg)
+		compiled, err = runtime.CompileModule(ctx, binary)
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	ctx := context.Background()
+	mod, err := runtime.InstantiateModule(ctx, compiled, wazero.NewModuleConfig().WithName(""))
+	if err != nil {
+		return nil, err
+	}
+	defer mod.Close(ctx)
+
+	if buf, ok := mod.Memory().Read(sqlp, uint32(len(sql))); ok {
+		copy(buf, sql)
+	}
+
+	stack := [...]uint64{sqlp, uint64(len(sql)), errp}
+	err = mod.ExportedFunction("sql3parse_table").CallWithStack(ctx, stack[:])
+	if err != nil {
+		return nil, err
+	}
+
+	c, _ := mod.Memory().ReadUint32Le(errp)
+	switch c {
+	case _MEMORY:
+		panic(util.OOMErr)
+	case _SYNTAX:
+		return nil, util.ErrorString("sql3parse: invalid syntax")
+	case _UNSUPPORTEDSQL:
+		return nil, util.ErrorString("sql3parse: unsupported SQL")
+	}
+
+	var tab Table
+	tab.load(mod, uint32(stack[0]), sql)
+	return &tab, nil
+}
+
+// Table holds metadata about a table.
+type Table struct {
+	Name           string
+	Schema         string
+	Comment        string
+	IsTemporary    bool
+	IsIfNotExists  bool
+	IsWithoutRowID bool
+	IsStrict       bool
+	Columns        []Column
+	Type           StatementType
+	CurrentName    string
+	NewName        string
+}
+
+func (t *Table) load(mod api.Module, ptr uint32, sql string) {
+	t.Name = loadString(mod, ptr+0, sql)
+	t.Schema = loadString(mod, ptr+8, sql)
+	t.Comment = loadString(mod, ptr+16, sql)
+
+	t.IsTemporary = loadBool(mod, ptr+24)
+	t.IsIfNotExists = loadBool(mod, ptr+25)
+	t.IsWithoutRowID = loadBool(mod, ptr+26)
+	t.IsStrict = loadBool(mod, ptr+27)
+
+	t.Columns = loadSlice(mod, ptr+28, func(ptr uint32, res *Column) {
+		p, _ := mod.Memory().ReadUint32Le(ptr)
+		res.load(mod, p, sql)
+	})
+
+	t.Type = loadEnum[StatementType](mod, ptr+44)
+	t.CurrentName = loadString(mod, ptr+48, sql)
+	t.NewName = loadString(mod, ptr+56, sql)
+}
+
+// Column holds metadata about a column.
+type Column struct {
+	Name                  string
+	Type                  string
+	Length                string
+	ConstraintName        string
+	Comment               string
+	IsPrimaryKey          bool
+	IsAutoIncrement       bool
+	IsNotNull             bool
+	IsUnique              bool
+	PKOrder               OrderClause
+	PKConflictClause      ConflictClause
+	NotNullConflictClause ConflictClause
+	UniqueConflictClause  ConflictClause
+	CheckExpr             string
+	DefaultExpr           string
+	CollateName           string
+	ForeignKeyClause      *ForeignKey
+}
+
+func (c *Column) load(mod api.Module, ptr uint32, sql string) {
+	c.Name = loadString(mod, ptr+0, sql)
+	c.Type = loadString(mod, ptr+8, sql)
+	c.Length = loadString(mod, ptr+16, sql)
+	c.ConstraintName = loadString(mod, ptr+24, sql)
+	c.Comment = loadString(mod, ptr+32, sql)
+
+	c.IsPrimaryKey = loadBool(mod, ptr+40)
+	c.IsAutoIncrement = loadBool(mod, ptr+41)
+	c.IsNotNull = loadBool(mod, ptr+42)
+	c.IsUnique = loadBool(mod, ptr+43)
+
+	c.PKOrder = loadEnum[OrderClause](mod, ptr+44)
+	c.PKConflictClause = loadEnum[ConflictClause](mod, ptr+48)
+	c.NotNullConflictClause = loadEnum[ConflictClause](mod, ptr+52)
+	c.UniqueConflictClause = loadEnum[ConflictClause](mod, ptr+56)
+
+	c.CheckExpr = loadString(mod, ptr+60, sql)
+	c.DefaultExpr = loadString(mod, ptr+68, sql)
+	c.CollateName = loadString(mod, ptr+76, sql)
+
+	if ptr, _ := mod.Memory().ReadUint32Le(ptr + 84); ptr != 0 {
+		c.ForeignKeyClause = &ForeignKey{}
+		c.ForeignKeyClause.load(mod, ptr, sql)
+	}
+}
+
+type ForeignKey struct {
+	Table      string
+	Columns    []string
+	OnDelete   FKAction
+	OnUpdate   FKAction
+	Match      string
+	Deferrable FKDefType
+}
+
+func (f *ForeignKey) load(mod api.Module, ptr uint32, sql string) {
+	f.Table = loadString(mod, ptr+0, sql)
+
+	f.Columns = loadSlice(mod, ptr+8, func(ptr uint32, res *string) {
+		*res = loadString(mod, ptr, sql)
+	})
+
+	f.OnDelete = loadEnum[FKAction](mod, ptr+16)
+	f.OnUpdate = loadEnum[FKAction](mod, ptr+20)
+	f.Match = loadString(mod, ptr+24, sql)
+	f.Deferrable = loadEnum[FKDefType](mod, ptr+32)
+}
+
+func loadString(mod api.Module, ptr uint32, sql string) string {
+	off, _ := mod.Memory().ReadUint32Le(ptr + 0)
+	if off == 0 {
+		return ""
+	}
+	len, _ := mod.Memory().ReadUint32Le(ptr + 4)
+	return sql[off-sqlp : off+len-sqlp]
+}
+
+func loadSlice[T any](mod api.Module, ptr uint32, fn func(uint32, *T)) []T {
+	ref, _ := mod.Memory().ReadUint32Le(ptr + 4)
+	if ref == 0 {
+		return nil
+	}
+	len, _ := mod.Memory().ReadUint32Le(ptr + 0)
+	res := make([]T, len)
+	for i := range res {
+		fn(ref, &res[i])
+		ref += 4
+	}
+	return res
+}
+
+func loadEnum[T ~uint32](mod api.Module, ptr uint32) T {
+	val, _ := mod.Memory().ReadUint32Le(ptr)
+	return T(val)
+}
+
+func loadBool(mod api.Module, ptr uint32) bool {
+	val, _ := mod.Memory().ReadByte(ptr)
+	return val != 0
+}

util/sql3util/parse/.gitignore

@@ -0,0 +1,2 @@
+sql3parse_table.c
+sql3parse_table.h

util/sql3util/parse/build.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+ROOT=../../../
+BINARYEN="$ROOT/tools/binaryen/bin"
+WASI_SDK="$ROOT/tools/wasi-sdk/bin"
+
+trap 'rm -f sql3parse_table.tmp' EXIT
+
+"$WASI_SDK/clang" --target=wasm32-wasi -std=c23 -g0 -Oz \
+	-Wall -Wextra -o sql3parse_table.wasm main.c \
+	-mexec-model=reactor \
+	-msimd128 -mmutable-globals -mmultivalue \
+	-mbulk-memory -mreference-types \
+	-mnontrapping-fptoint -msign-ext \
+	-fno-stack-protector -fno-stack-clash-protection \
+	-Wl,--stack-first \
+	-Wl,--import-undefined \
+	-Wl,--export=sql3parse_table
+
+"$BINARYEN/wasm-ctor-eval" -c _initialize sql3parse_table.wasm -o sql3parse_table.tmp
+"$BINARYEN/wasm-opt" --strip --strip-debug --strip-producers -c -Oz \
+	sql3parse_table.tmp -o sql3parse_table.wasm \
+	--enable-simd --enable-mutable-globals --enable-multivalue \
+	--enable-bulk-memory --enable-reference-types \
+	--enable-nontrapping-float-to-int --enable-sign-ext

util/sql3util/parse/download.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd -P -- "$(dirname -- "$0")"
+
+curl -#OL "https://github.com/ncruces/sqlite-createtable-parser/raw/master/sql3parse_table.c"
+curl -#OL "https://github.com/ncruces/sqlite-createtable-parser/raw/master/sql3parse_table.h"

util/sql3util/parse/main.c

@@ -0,0 +1,42 @@
+#include <stddef.h>
+
+#include "sql3parse_table.c"
+
+static_assert(offsetof(sql3table, name) == 0, "Unexpected offset");
+static_assert(offsetof(sql3table, schema) == 8, "Unexpected offset");
+static_assert(offsetof(sql3table, comment) == 16, "Unexpected offset");
+static_assert(offsetof(sql3table, is_temporary) == 24, "Unexpected offset");
+static_assert(offsetof(sql3table, is_ifnotexists) == 25, "Unexpected offset");
+static_assert(offsetof(sql3table, is_withoutrowid) == 26, "Unexpected offset");
+static_assert(offsetof(sql3table, is_strict) == 27, "Unexpected offset");
+static_assert(offsetof(sql3table, num_columns) == 28, "Unexpected offset");
+static_assert(offsetof(sql3table, columns) == 32, "Unexpected offset");
+static_assert(offsetof(sql3table, type) == 44, "Unexpected offset");
+static_assert(offsetof(sql3table, current_name) == 48, "Unexpected offset");
+static_assert(offsetof(sql3table, new_name) == 56, "Unexpected offset");
+
+static_assert(offsetof(sql3column, name) == 0, "Unexpected offset");
+static_assert(offsetof(sql3column, type) == 8, "Unexpected offset");
+static_assert(offsetof(sql3column, length) == 16, "Unexpected offset");
+static_assert(offsetof(sql3column, constraint_name) == 24, "Unexpected offset");
+static_assert(offsetof(sql3column, comment) == 32, "Unexpected offset");
+static_assert(offsetof(sql3column, is_primarykey) == 40, "Unexpected offset");
+static_assert(offsetof(sql3column, is_autoincrement) == 41, "Unexpected offset");
+static_assert(offsetof(sql3column, is_notnull) == 42, "Unexpected offset");
+static_assert(offsetof(sql3column, is_unique) == 43, "Unexpected offset");
+static_assert(offsetof(sql3column, pk_order) == 44, "Unexpected offset");
+static_assert(offsetof(sql3column, pk_conflictclause) == 48, "Unexpected offset");
+static_assert(offsetof(sql3column, notnull_conflictclause) == 52, "Unexpected offset");
+static_assert(offsetof(sql3column, unique_conflictclause) == 56, "Unexpected offset");
+static_assert(offsetof(sql3column, check_expr) == 60, "Unexpected offset");
+static_assert(offsetof(sql3column, default_expr) == 68, "Unexpected offset");
+static_assert(offsetof(sql3column, collate_name) == 76, "Unexpected offset");
+static_assert(offsetof(sql3column, foreignkey_clause) == 84, "Unexpected offset");
+
+static_assert(offsetof(sql3foreignkey, table) == 0, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, num_columns) == 8, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, column_name) == 12, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, on_delete) == 16, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, on_update) == 20, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, match) == 24, "Unexpected offset");
+static_assert(offsetof(sql3foreignkey, deferrable) == 32, "Unexpected offset");

util/sql3util/parse_test.go

@@ -0,0 +1,31 @@
+package sql3util_test
+
+import (
+	"testing"
+
+	"github.com/ncruces/go-sqlite3/util/sql3util"
+)
+
+func TestParse(t *testing.T) {
+	tab, err := sql3util.ParseTable(`CREATE TABLE child(x REFERENCES parent)`)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if got := tab.Name; got != "child" {
+		t.Errorf("got %s, want child", got)
+	}
+	if got := len(tab.Columns); got != 1 {
+		t.Errorf("got %d, want 1", got)
+	}
+
+	col := tab.Columns[0]
+	if got := col.Name; got != "x" {
+		t.Errorf("got %s, want x", got)
+	}
+
+	fk := col.ForeignKeyClause
+	if got := fk.Table; got != "parent" {
+		t.Errorf("got %s, want parent", got)
+	}
+}

util/sql3util/sql3util.go

@@ -0,0 +1,2 @@
+// Package sql3util implements SQLite utilities.
+package sql3util