wip, generate code for deferred using zombiezen sqlite driver

Author: eloff

.gitignore

@@ -9,3 +9,6 @@ __pycache__
 .devenv*
 devenv.local.nix
 
+# Binaries
+sqlc
+

internal/codegen/golang/field.go

@@ -11,22 +11,86 @@ import (
 )
 
 type Field struct {
-	Name    string // CamelCased name for Go
-	DBName  string // Name as used in the DB
-	Type    string
-	Tags    map[string]string
-	Comment string
-	Column  *plugin.Column
+	Name             string // CamelCased name for Go
+	VariableForField string // Variable name for the field (including structVar.name, if part of a struct)
+	DBName           string // Name as used in the DB
+	Type             string
+	Tags             map[string]string
+	Comment          string
+	Column           *plugin.Column
 	// EmbedFields contains the embedded fields that require scanning.
 	EmbedFields []Field
 }
 
-func (gf Field) Tag() string {
+func (gf *Field) Tag() string {
 	return TagsToString(gf.Tags)
 }
 
-func (gf Field) HasSqlcSlice() bool {
-	return gf.Column.IsSqlcSlice
+func (gf *Field) HasSqlcSlice() bool {
+	return gf.Column != nil && gf.Column.IsSqlcSlice
+}
+
+func (gf *Field) IsNullable() bool {
+	return strings.HasPrefix(gf.Type, "types.Null") || strings.HasSuffix(gf.Type, "ID") || gf.Column != nil && !gf.Column.NotNull
+}
+
+func (gf *Field) Serialize() bool {
+	return strings.HasPrefix(gf.Type, "*") || strings.HasSuffix(gf.Type, "ID")
+}
+
+func (gf *Field) HasLen() bool {
+	return gf.Type == "[]byte" || gf.Type == "string"
+}
+
+func (gf *Field) Is64Bit() bool {
+	return strings.HasSuffix(gf.Type, "64")
+}
+
+func (gf *Field) BindType() string {
+	ty := gf.Type
+	if gf.HasSqlcSlice() {
+		ty = ty[2:]
+	}
+	switch {
+	case ty == "uint8", ty == "int8", ty == "uint32":
+		return "int64"
+	case ty == "float32":
+		return "float64"
+	case ty == "TimeOrderedID":
+		return "[]byte"
+	case strings.HasSuffix(ty, "Bool"):
+		return "bool"
+	case strings.HasSuffix(ty, "ID"):
+		return "int64"
+	default:
+		return ty
+	}
+}
+
+func (gf *Field) BindMethod() string {
+	bindType := gf.BindType()
+	switch bindType {
+	case "string":
+		return "r.bindString"
+	case "[]byte":
+		return "r.bindBytes"
+	case "float64":
+		return "r.stmt.BindFloat"
+	default:
+		return "r.stmt.Bind" + toPascalCase(bindType)
+	}
+}
+
+func (gf *Field) FetchMethod() string {
+	bindType := gf.BindType()
+	switch bindType {
+	case "[]byte":
+		return "r.stmt.ColumnBytes"
+	case "float64":
+		return "r.stmt.ColumnFloat"
+	default:
+		return "r.stmt.Column" + toPascalCase(bindType)
+	}
 }
 
 func TagsToString(tags map[string]string) string {

internal/codegen/golang/gen.go

@@ -17,13 +17,14 @@ import (
 )
 
 type tmplCtx struct {
-	Q           string
-	Package     string
-	SQLDriver   opts.SQLDriver
-	Enums       []Enum
-	Structs     []Struct
-	GoQueries   []Query
-	SqlcVersion string
+	Q            string
+	Package      string
+	SQLDriver    opts.SQLDriver
+	Enums        []Enum
+	Structs      []Struct
+	ReadQueries  []Query
+	WriteQueries []Query
+	SqlcVersion  string
 
 	// TODO: Race conditions
 	SourceName string
@@ -104,6 +105,23 @@ func (t *tmplCtx) codegenQueryRetval(q Query) (string, error) {
 	}
 }
 
+func (t *tmplCtx) AllQueries(sourceFile string) []Query {
+	var allQueries []Query
+	for i := range t.ReadQueries {
+		q := &t.ReadQueries[i]
+		if q.SourceName == sourceFile {
+			allQueries = append(allQueries, *q)
+		}
+	}
+	for i := range t.WriteQueries {
+		q := &t.WriteQueries[i]
+		if q.SourceName == sourceFile {
+			allQueries = append(allQueries, *q)
+		}
+	}
+	return allQueries
+}
+
 func Generate(ctx context.Context, req *plugin.GenerateRequest) (*plugin.GenerateResponse, error) {
 	options, err := opts.Parse(req)
 	if err != nil {
@@ -235,11 +253,34 @@ func generate(req *plugin.GenerateRequest, options *opts.Options, enums []Enum,
 	execute := func(name, templateName string) error {
 		imports := i.Imports(name)
 		replacedQueries := replaceConflictedArg(imports, queries)
+		var readQueries []Query
+		var writeQueries []Query
+		for _, q := range replacedQueries {
+			if q.Arg.Struct != nil {
+				for i := range q.Arg.Struct.Fields {
+					f := &q.Arg.Struct.Fields[i]
+					f.VariableForField = q.Arg.VariableForField(*f)
+				}
+			}
+			if q.Ret.Struct != nil {
+				for i := range q.Ret.Struct.Fields {
+					f := &q.Ret.Struct.Fields[i]
+					f.VariableForField = q.Ret.VariableForField(*f)
+				}
+			}
+
+			if q.IsReadOnly() {
+				readQueries = append(readQueries, q)
+			} else {
+				writeQueries = append(writeQueries, q)
+			}
+		}
 
 		var b bytes.Buffer
 		w := bufio.NewWriter(&b)
 		tctx.SourceName = name
-		tctx.GoQueries = replacedQueries
+		tctx.ReadQueries = readQueries
+		tctx.WriteQueries = writeQueries
 		err := tmpl.ExecuteTemplate(w, templateName, &tctx)
 		w.Flush()
 		if err != nil {

internal/codegen/golang/imports.go

@@ -119,10 +119,10 @@ func (i *importer) Imports(filename string) [][]ImportSpec {
 }
 
 func (i *importer) dbImports() fileImports {
-	var pkg []ImportSpec
-	std := []ImportSpec{
-		{Path: "context"},
+	pkg := []ImportSpec{
+		{Path: "github.com/deferred-dev/deferred/lib"},
 	}
+	var std []ImportSpec
 
 	sqlpkg := parseDriver(i.Options.SqlPackage)
 	switch sqlpkg {
@@ -133,7 +133,7 @@ func (i *importer) dbImports() fileImports {
 		pkg = append(pkg, ImportSpec{Path: "github.com/jackc/pgx/v5/pgconn"})
 		pkg = append(pkg, ImportSpec{Path: "github.com/jackc/pgx/v5"})
 	default:
-		std = append(std, ImportSpec{Path: "database/sql"})
+		std = append(std, ImportSpec{Path: "zombiezen.com/go/sqlite"})
 		if i.Options.EmitPreparedQueries {
 			std = append(std, ImportSpec{Path: "fmt"})
 		}
@@ -162,6 +162,7 @@ var pqtypeTypes = map[string]struct{}{
 
 func buildImports(options *opts.Options, queries []Query, uses func(string) bool) (map[string]struct{}, map[ImportSpec]struct{}) {
 	pkg := make(map[ImportSpec]struct{})
+	pkg[ImportSpec{Path: "github.com/deferred-dev/deferred/lib"}] = struct{}{}
 	std := make(map[string]struct{})
 
 	if uses("sql.Null") {
@@ -298,16 +299,12 @@ func sortedImports(std map[string]struct{}, pkg map[ImportSpec]struct{}) fileImp
 
 func (i *importer) queryImports(filename string) fileImports {
 	var gq []Query
-	anyNonCopyFrom := false
 	for _, query := range i.Queries {
 		if usesBatch([]Query{query}) {
 			continue
 		}
 		if query.SourceName == filename {
 			gq = append(gq, query)
-			if query.Cmd != metadata.CmdCopyFrom {
-				anyNonCopyFrom = true
-			}
 		}
 	}
 
@@ -390,10 +387,6 @@ func (i *importer) queryImports(filename string) fileImports {
 		return false
 	}
 
-	if anyNonCopyFrom {
-		std["context"] = struct{}{}
-	}
-
 	sqlpkg := parseDriver(i.Options.SqlPackage)
 	if sqlcSliceScan() && !sqlpkg.IsPGX() {
 		std["strings"] = struct{}{}