ops/gas_init_test.sh

@@ -41,7 +41,6 @@ create table items (
     rowid integer primary key,
     description text not null default '',
     flavor integer references item_flavor(rowid),
-    data blob not null,
     thing text not null unique,
     created_at integer not null,
     updated_at integer not null

pkg/codegen/modelgenerate/ast_helpers.go

@@ -76,35 +76,28 @@ func FprintWithComments(w io.Writer, file *ast.File) error {
 		return fmt.Errorf("re-parsing pretty-print: %w", err)
 	}
 
+	// Convert the tree-of-nodes into a slice-of-nodes
+	collectNodes := func(node ast.Node) []ast.Node {
+		var nodes []ast.Node
+		ast.Inspect(node, func(n ast.Node) bool {
+			// Filter out comments, as they only appear in the
+			switch n.(type) {
+			case *ast.CommentGroup, *ast.Comment:
+				return false
+			}
+			nodes = append(nodes, n)
+			return true
+		})
+		return nodes
+	}
+
 	// Parallel walk: apply TrailingComments from the side map.
 	// Both trees have identical structure (the reparse is just a positioned copy),
 	// so ast.Inspect visits nodes in the same order.  We skip comment nodes to
 	// avoid mismatches from Doc fields.
 	if len(TrailingComments) > 0 {
-		// Helper: convert the tree-of-nodes into a slice-of-nodes
-		collectNodes := func(node ast.Node) []ast.Node {
-			var nodes []ast.Node
-			ast.Inspect(node, func(n ast.Node) bool {
-				// Filter out comments, as they only appear in the
-				switch n.(type) {
-				case *ast.CommentGroup, *ast.Comment:
-					return false
-				}
-				nodes = append(nodes, n)
-				return true
-			})
-			return nodes
-		}
-
 		origNodes := collectNodes(file)
 		reparsedNodes := collectNodes(parsed)
-		if len(origNodes) != len(reparsedNodes) {
-			panic(fmt.Sprintf(
-				"origNodes: %d; reparsedNodes: %d.  The AST generator is likely generating an invalid AST",
-				len(origNodes), len(reparsedNodes),
-			))
-		}
-
 		for i, orig := range origNodes {
 			text, isOk := TrailingComments[orig]
 			if !isOk {

pkg/codegen/modelgenerate/generate_model.go

@@ -27,33 +27,6 @@ func SQLFieldsConstIdent(tbl schema.Table) *ast.Ident {
 	return ast.NewIdent(strings.ToLower(tbl.GoTypeName) + "SQLFields")
 }
 
-// GoTypeForColumn returns a type expression for this column.
-//
-// For most columns this isjust its mapped name as a `ast.NewIdent`, but for "blob" it needs
-// a slice expression (`[]byte`).
-func GoTypeForColumn(c schema.Column) ast.Expr {
-	if c.IsNonCodeTableForeignKey() {
-		return ast.NewIdent(schema.TypenameFromTablename(c.ForeignKeyTargetTable) + "ID")
-	}
-	switch c.Type {
-	case "integer", "int":
-		if strings.HasPrefix(c.Name, "is_") || strings.HasPrefix(c.Name, "has_") {
-			return ast.NewIdent("bool")
-		} else if strings.HasSuffix(c.Name, "_at") {
-			return ast.NewIdent("Timestamp")
-		}
-		return ast.NewIdent("int")
-	case "text":
-		return ast.NewIdent("string")
-	case "real":
-		return ast.NewIdent("float32")
-	case "blob":
-		return &ast.ArrayType{Elt: ast.NewIdent("byte")}
-	default:
-		panic("Unrecognized sqlite column type: " + c.Type)
-	}
-}
-
 // ---------------
 // Generators
 // ---------------
@@ -90,9 +63,10 @@ func GenerateModelAST(table schema.Table) *ast.GenDecl {
 					Tag:   &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("`db:\"%s\" json:\"%s\"`", col.Name, col.Name)},
 				})
 			} else {
+				typeName := col.GoTypeName()
 				fields = append(fields, &ast.Field{
 					Names: []*ast.Ident{ast.NewIdent(textutils.SnakeToCamel(col.Name))},
-					Type:  GoTypeForColumn(col),
+					Type:  ast.NewIdent(typeName),
 					Tag:   &ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("`db:\"%s\" json:\"%s\"`", col.Name, col.Name)},
 				})
 			}
@@ -209,7 +183,7 @@ func buildFKCheckLambda(tbl schema.Table) (*ast.AssignStmt, bool) {
 														Fun: ast.NewIdent("NewForeignKeyError"),
 														Args: []ast.Expr{
 															&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", structFieldName)},
-															&ast.BasicLit{Kind: token.STRING, Value: fmt.Sprintf("%q", col.ForeignKeyTargetTable)},
+															ast.NewIdent(fmt.Sprintf("%q", col.ForeignKeyTargetTable)),
 															structField,
 														},
 													},
@@ -504,7 +478,7 @@ func GenerateGetItemByUniqColFunc(tbl schema.Table, col schema.Column) *ast.Func
 		Name: ast.NewIdent("Get" + schema.TypenameFromTablename(tbl.TableName) + "By" + col.GoFieldName()),
 		Type: &ast.FuncType{
 			Params: &ast.FieldList{List: []*ast.Field{
-				{Names: []*ast.Ident{param}, Type: GoTypeForColumn(col)},
+				{Names: []*ast.Ident{param}, Type: ast.NewIdent(col.GoTypeName())},
 			}},
 			Results: &ast.FieldList{List: []*ast.Field{
 				{Names: []*ast.Ident{ast.NewIdent("ret")}, Type: ast.NewIdent(tbl.GoTypeName)},

pkg/codegen/modelgenerate/generate_testfile.go

@@ -32,24 +32,6 @@ func GenerateModelTestAST(tbl pkgschema.Table, schema pkgschema.Schema, gomodNam
 					Results: []ast.Expr{
 						&ast.CompositeLit{
 							Type: ast.NewIdent(tbl.GoTypeName),
-							Elts: []ast.Expr{
-								&ast.KeyValueExpr{
-									Key: ast.NewIdent("Data"),
-									Value: &ast.CompositeLit{
-										Type: &ast.ArrayType{
-											Elt: ast.NewIdent("byte"),
-										},
-										Elts: []ast.Expr{},
-									},
-								},
-								&ast.KeyValueExpr{
-									Key: ast.NewIdent("Description"),
-									Value: &ast.BasicLit{
-										Kind:  token.STRING,
-										Value: `""`,
-									},
-								},
-							},
 						},
 					},
 				},
@@ -59,7 +41,7 @@ func GenerateModelTestAST(tbl pkgschema.Table, schema pkgschema.Schema, gomodNam
 
 	testObj := ast.NewIdent("item")
 	testObj2 := ast.NewIdent("item2")
-	fieldName := ast.NewIdent("Description") // TODO
+	fieldName := ast.NewIdent("Description")
 	description1 := `"an item"`
 	description2 := `"a big item"`
 	testDB := ast.NewIdent("TestDB")
@@ -90,27 +72,19 @@ func GenerateModelTestAST(tbl pkgschema.Table, schema pkgschema.Schema, gomodNam
 				stmts := []ast.Stmt{
 					Comment("Create"),
 
-					// item := MakeItem()
+					// item := Item{Description: "an item"}
 					&ast.AssignStmt{
 						Lhs: []ast.Expr{testObj},
 						Tok: token.DEFINE,
-						Rhs: []ast.Expr{&ast.CallExpr{Fun: ast.NewIdent("MakeItem"), Args: nil}},
+						Rhs: []ast.Expr{&ast.CompositeLit{
-					},
+							Type: ast.NewIdent(tbl.GoTypeName),
-					// item.Description = "an item"
+							Elts: []ast.Expr{
-					&ast.AssignStmt{
+								&ast.KeyValueExpr{
-						Lhs: []ast.Expr{
+									Key:   fieldName,
-							&ast.SelectorExpr{
+									Value: &ast.BasicLit{Kind: token.STRING, Value: description1},
-								X:   ast.NewIdent("item"),
+								},
-								Sel: ast.NewIdent("Description"),
 							},
-						},
+						}},
-						Tok: token.ASSIGN,
-						Rhs: []ast.Expr{
-							&ast.BasicLit{
-								Kind:  token.STRING,
-								Value: `"an item"`,
-							},
-						},
 					},
 
 					// TestDB.SaveItem(&item)

pkg/schema/table.go

@@ -57,6 +57,29 @@ func (c Column) GoVarName() string {
 	return strings.ToLower(fieldname)[0:1] + fieldname[1:]
 }
 
+func (c Column) GoTypeName() string {
+	if c.IsNonCodeTableForeignKey() {
+		return TypenameFromTablename(c.ForeignKeyTargetTable) + "ID"
+	}
+	switch c.Type {
+	case "integer", "int":
+		if strings.HasPrefix(c.Name, "is_") || strings.HasPrefix(c.Name, "has_") {
+			return "bool"
+		} else if strings.HasSuffix(c.Name, "_at") {
+			return "Timestamp"
+		}
+		return "int"
+	case "text":
+		return "string"
+	case "real":
+		return "float32"
+	case "blob":
+		return "[]byte"
+	default:
+		panic("Unrecognized sqlite column type: " + c.Type)
+	}
+}
+
 // Table is a single SQLite table.
 type Table struct {
 	TableName string `db:"name"`