Enums as generated Go types, and your own types with go_type
On this page
On ClickHouse:
- An Enum8 or Enum16 column becomes a named string type in models.go, named after its table and column (store.BoatsStatus), with a constant per label and a Valid method; ClickHouse refuses a label the enum does not list
- The status parameter is {status:String}; the server converts the label to the Enum8 on insert and comparison
- sgl.column(status, go_type: ...) types only that query's result rows, so parameters stay string and the example converts with string(domain.StatusInDock)
An enum column accepts only the labels it declares, and the database refuses anything else. Go has no enum type for Seagull to map that to, so by default an enum column arrives as a plain string: correct, but it says nothing about which strings are allowed. Seagull does not invent enum types of its own. You write the Go type you want, with a constant per label and any methods you like, and point the column at it with a go_type override. The generated code then hands you that type instead of a string.
This example gives a harbour's boats a status: moored, fishing or in dock.
The schema
An Enum8 lists its labels on the column, each with the small number ClickHouse stores it as.
db/migrations/0001_boats.up.sql
CREATE TABLE boats (
id UInt64,
name String,
status Enum8('moored' = 1, 'fishing' = 2, 'in_dock' = 3)
) ENGINE = MergeTree() ORDER BY id;
As a string
ListBoats selects the column as it is, so Status is a string, the label. It is a string in models.go and in every Params struct too.
internal/store
type ListBoatsRow struct {
ID uint64 `json:"id"`
Name string `json:"name"`
Status BoatsStatus `json:"status"`
}
type BoatsStatus string
func (queries *Queries) ListBoats(ctx context.Context) ([]ListBoatsRow, error) {
rows, err := queries.reader.QueryContext(ctx, listBoatsSQL)
if err != nil {
return nil, err
}
defer rows.Close()
var results []ListBoatsRow
for rows.Next() {
var row ListBoatsRow
if err := rows.Scan(&row.ID, &row.Name, &row.Status); err != nil {
return nil, err
}
results = append(results, row)
}
if err := rows.Err(); err != nil {
return nil, err
}
return results, nil
}
As your own type
The program's own package, internal/domain, declares type Status string with a constant for each label (StatusMoored, StatusFishing and StatusInDock) and an AtSea method. BoatsNotIn names it with an sgl.column directive in its header, giving the type's full import path:
db/queries/boats.sql
-- sgl.query(BoatsNotIn, many)
-- sgl.column(status, go_type: "seagull.sh/seagull/examples/clickhouse/007_enums/internal/domain.Status")
SELECT id, name, status FROM boats WHERE status != {status:String} ORDER BY id;
Its rows now carry a domain.Status, and the generated file imports the package for you:
internal/store
type BoatsNotInRow struct {
ID uint64 `json:"id"`
Name string `json:"name"`
Status domain.Status `json:"status"`
}
func (queries *Queries) BoatsNotIn(ctx context.Context, status string) ([]BoatsNotInRow, error) {
rows, err := queries.reader.QueryContext(ctx, boatsNotInSQL, clickhouse.Named("p_status", sglClickHouseShapedValue(status, sglClickHouseShapes[1])))
if err != nil {
return nil, err
}
defer rows.Close()
var results []BoatsNotInRow
for rows.Next() {
var row BoatsNotInRow
if err := rows.Scan(&row.ID, &row.Name, &row.Status); err != nil {
return nil, err
}
results = append(results, row)
}
if err := rows.Err(); err != nil {
return nil, err
}
return results, nil
}
The directive applies to this one query. A types.overrides entry in sgl.yaml would apply it to every query that returns the column as it is.
Parameters stay strings
An override changes the columns a query returns, not what it takes.
models.go and every Params field keep string, and the {status:String} placeholder is a string too, so the program converts on the way in: string(domain.StatusInDock). The server turns the label into the Enum8 value when it inserts or compares.
The database still checks
A Go type with constants does not stop a caller passing any string it likes, but the enum does: the database refuses a label it does not list when the statement runs. The program tries it on purpose and prints the refusal.
Using it
example.go
package main
import (
"context"
"database/sql"
"fmt"
"io"
"strings"
"seagull.sh/seagull/examples/clickhouse/007_enums/internal/domain"
"seagull.sh/seagull/examples/clickhouse/007_enums/internal/store"
)
// run berths four boats and lists them twice. boats.status is an Enum8, and Seagull
// declares a named Go type for it in models.go, named after the table and column that
// hold it: store.BoatsStatus, with a constant for each label, such as
// store.BoatsStatusMoored, and a Valid method. ListBoats returns Status as a
// store.BoatsStatus. The status parameters are written {status:String}, so they are plain
// strings, and the server converts the label to the Enum8.
//
// BoatsNotIn adds sgl.column(status, go_type: "…/internal/domain.Status"), so its rows
// carry the harbour's own domain.Status type, with its constants and methods. The
// override changes only that query's result rows: parameters stay string, so the example
// converts with string(domain.StatusInDock) on the way in. A types.overrides entry in
// sgl.yaml would change every query's rows the same way.
//
// ClickHouse checks every label against the Enum8, so a status that is not one of its
// labels is refused by the server, not stored.
//
// Takes database (*sql.DB) which is a migrated database.
// Takes output (io.Writer) which receives both listings and the refusal.
//
// Returns error when a query fails or a bad status is accepted.
func run(ctx context.Context, database *sql.DB, output io.Writer) error {
queries := store.New(database)
boats := []store.AddBoatParams{
{ID: 1, Name: "Kittiwake", Status: string(domain.StatusMoored)},
{ID: 2, Name: "Salty Chip", Status: string(domain.StatusFishing)},
{ID: 3, Name: "Gull Wing", Status: string(domain.StatusInDock)},
{ID: 4, Name: "Driftwood", Status: string(domain.StatusFishing)},
}
for _, boat := range boats {
if err := queries.AddBoat(ctx, boat); err != nil {
return fmt.Errorf("adding %s: %w", boat.Name, err)
}
}
listed, err := queries.ListBoats(ctx)
if err != nil {
return fmt.Errorf("listing boats: %w", err)
}
fmt.Fprintln(output, "all boats, status as store.BoatsStatus:")
for _, boat := range listed {
fmt.Fprintf(output, " %d %-11s %s\n", boat.ID, boat.Name, boat.Status)
}
afloat, err := queries.BoatsNotIn(ctx, string(domain.StatusInDock))
if err != nil {
return fmt.Errorf("listing boats not in dock: %w", err)
}
fmt.Fprintln(output, "not in dock, status as domain.Status:")
for _, boat := range afloat {
fmt.Fprintf(output, " %d %-11s %-8s at sea: %t\n", boat.ID, boat.Name, boat.Status, boat.Status.AtSea())
}
sunk := store.AddBoatParams{ID: 5, Name: "Old Barnacle", Status: "sunk"}
err = queries.AddBoat(ctx, sunk)
if err == nil {
return fmt.Errorf("adding status %q: got no error, want the server's refusal", sunk.Status)
}
if !strings.Contains(err.Error(), "Unknown element 'sunk' for enum") {
return fmt.Errorf("adding status %q: got %w, want the server's refusal", sunk.Status, err)
}
fmt.Fprintf(output, "status %q refused: not one of the Enum8 labels\n", sunk.Status)
return nil
}
What it prints
all boats, status as store.BoatsStatus:
1 Kittiwake moored
2 Salty Chip fishing
3 Gull Wing in_dock
4 Driftwood fishing
not in dock, status as domain.Status:
1 Kittiwake moored at sea: false
2 Salty Chip fishing at sea: true
4 Driftwood fishing at sea: true
status "sunk" refused: not one of the Enum8 labels
Type overrides covers go_type and the other override forms in more depth.
Run it locally
From the directory you cloned the Seagull repository into:
cd seagull/examples/clickhouse && go run ./007_enums
Its test runs it too, and checks what it prints against output.txt:
cd seagull/examples/clickhouse && SGL_EXAMPLE_DSN=clickhouse://localhost:9000/default go test ./007_enums
Needs a running ClickHouse server: it connects to clickhouse://localhost:9000/default, or pass -dsn with the address of an empty database.
The files
Every file of the example, as it is in the Seagull repository.
sgl.yaml
# Copyright 2026 PolitePixels Limited
#
# 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.
# This project stands against fascism, authoritarianism, and all forms of
# oppression. We built this to empower people, not to enable those who would
# strip others of their rights and dignity.
version: 1
databases:
- name: harbour
dialect: clickhouse
migrations: db/migrations
queries: db/queries
go:
package: store
out: internal/store
db/migrations/0001_boats.up.sql
CREATE TABLE boats (
id UInt64,
name String,
status Enum8('moored' = 1, 'fishing' = 2, 'in_dock' = 3)
) ENGINE = MergeTree() ORDER BY id;
db/migrations/0001_boats.down.sql
DROP TABLE boats;
db/queries/boats.sql
-- sgl.query(AddBoat, exec)
INSERT INTO boats (id, name, status) VALUES ({id:UInt64}, {name:String}, {status:String});
-- sgl.query(ListBoats, many)
SELECT id, name, status FROM boats ORDER BY id;
-- sgl.query(BoatsNotIn, many)
-- sgl.column(status, go_type: "seagull.sh/seagull/examples/clickhouse/007_enums/internal/domain.Status")
SELECT id, name, status FROM boats WHERE status != {status:String} ORDER BY id;
example.go
package main
import (
"context"
"database/sql"
"fmt"
"io"
"strings"
"seagull.sh/seagull/examples/clickhouse/007_enums/internal/domain"
"seagull.sh/seagull/examples/clickhouse/007_enums/internal/store"
)
// run berths four boats and lists them twice. boats.status is an Enum8, and Seagull
// declares a named Go type for it in models.go, named after the table and column that
// hold it: store.BoatsStatus, with a constant for each label, such as
// store.BoatsStatusMoored, and a Valid method. ListBoats returns Status as a
// store.BoatsStatus. The status parameters are written {status:String}, so they are plain
// strings, and the server converts the label to the Enum8.
//
// BoatsNotIn adds sgl.column(status, go_type: "…/internal/domain.Status"), so its rows
// carry the harbour's own domain.Status type, with its constants and methods. The
// override changes only that query's result rows: parameters stay string, so the example
// converts with string(domain.StatusInDock) on the way in. A types.overrides entry in
// sgl.yaml would change every query's rows the same way.
//
// ClickHouse checks every label against the Enum8, so a status that is not one of its
// labels is refused by the server, not stored.
//
// Takes database (*sql.DB) which is a migrated database.
// Takes output (io.Writer) which receives both listings and the refusal.
//
// Returns error when a query fails or a bad status is accepted.
func run(ctx context.Context, database *sql.DB, output io.Writer) error {
queries := store.New(database)
boats := []store.AddBoatParams{
{ID: 1, Name: "Kittiwake", Status: string(domain.StatusMoored)},
{ID: 2, Name: "Salty Chip", Status: string(domain.StatusFishing)},
{ID: 3, Name: "Gull Wing", Status: string(domain.StatusInDock)},
{ID: 4, Name: "Driftwood", Status: string(domain.StatusFishing)},
}
for _, boat := range boats {
if err := queries.AddBoat(ctx, boat); err != nil {
return fmt.Errorf("adding %s: %w", boat.Name, err)
}
}
listed, err := queries.ListBoats(ctx)
if err != nil {
return fmt.Errorf("listing boats: %w", err)
}
fmt.Fprintln(output, "all boats, status as store.BoatsStatus:")
for _, boat := range listed {
fmt.Fprintf(output, " %d %-11s %s\n", boat.ID, boat.Name, boat.Status)
}
afloat, err := queries.BoatsNotIn(ctx, string(domain.StatusInDock))
if err != nil {
return fmt.Errorf("listing boats not in dock: %w", err)
}
fmt.Fprintln(output, "not in dock, status as domain.Status:")
for _, boat := range afloat {
fmt.Fprintf(output, " %d %-11s %-8s at sea: %t\n", boat.ID, boat.Name, boat.Status, boat.Status.AtSea())
}
sunk := store.AddBoatParams{ID: 5, Name: "Old Barnacle", Status: "sunk"}
err = queries.AddBoat(ctx, sunk)
if err == nil {
return fmt.Errorf("adding status %q: got no error, want the server's refusal", sunk.Status)
}
if !strings.Contains(err.Error(), "Unknown element 'sunk' for enum") {
return fmt.Errorf("adding status %q: got %w, want the server's refusal", sunk.Status, err)
}
fmt.Fprintf(output, "status %q refused: not one of the Enum8 labels\n", sunk.Status)
return nil
}
internal/domain/status.go
// Package domain holds the harbour's own types, which the generated store uses through
// go_type overrides.
package domain
// Status is where a boat is: the labels of the boats.status Enum8 column.
type Status string
const (
// StatusMoored is a boat tied up in the harbour.
StatusMoored Status = "moored"
// StatusFishing is a boat out at sea.
StatusFishing Status = "fishing"
// StatusInDock is a boat out of the water for repairs.
StatusInDock Status = "in_dock"
)
// AtSea reports whether a boat with this status is out of the harbour.
//
// Returns bool which is true for StatusFishing.
func (status Status) AtSea() bool {
return status == StatusFishing
}
main.go
// Command 007_enums applies its migrations to a ClickHouse database, then runs the
// example in example.go: boats with an Enum8 status are listed with the status as the
// enum type Seagull generates and as the harbour's own domain.Status type.
//
// Run it with `go run .` against a local server, or `go run . -dsn <dsn>` to choose the
// database; give it an empty one.
package main
import (
"context"
"database/sql"
"embed"
"flag"
"fmt"
"log"
"os"
_ "github.com/ClickHouse/clickhouse-go/v2"
"seagull.sh/seagull/sdk/migrate"
"seagull.sh/seagull/sdk/migrate/migrate_backend_clickhouse"
)
// migrations holds the migration files, compiled into the binary.
//
//go:embed db/migrations
var migrations embed.FS
func main() {
dsn := flag.String("dsn", "clickhouse://localhost:9000/default", "ClickHouse DSN of an empty database")
flag.Parse()
if err := execute(context.Background(), *dsn); err != nil {
log.Fatal(err)
}
}
// execute opens and migrates the database the DSN names, and runs the example against it.
//
// Takes dsn (string) which names the ClickHouse database.
//
// Returns error when the database cannot be prepared or the example fails.
func execute(ctx context.Context, dsn string) error {
database, err := sql.Open("clickhouse", dsn)
if err != nil {
return err
}
defer func() { _ = database.Close() }()
migrator, err := migrate.NewMigrator(database, migrate_backend_clickhouse.New(), migrations, "db/migrations")
if err != nil {
return err
}
if _, err := migrator.Up(ctx); err != nil {
return fmt.Errorf("migrating: %w", err)
}
return run(ctx, database, os.Stdout)
}
internal/store/boats.sql.go
// Code generated by sgl. DO NOT EDIT.
package store
import (
"context"
"github.com/ClickHouse/clickhouse-go/v2"
"seagull.sh/seagull/examples/clickhouse/007_enums/internal/domain"
)
const addBoatSQL = `INSERT INTO boats (id, name, status) VALUES ({p_id:UInt64}, {p_name:String}, {p_status:String});`
type AddBoatParams struct {
ID uint64
Name string
Status string
}
func (queries *Queries) AddBoat(ctx context.Context, params AddBoatParams) error {
_, err := queries.writer.ExecContext(ctx, addBoatSQL, clickhouse.Named("p_id", sglClickHouseShapedValue(params.ID, sglClickHouseShapes[0])), clickhouse.Named("p_name", sglClickHouseShapedValue(params.Name, sglClickHouseShapes[1])), clickhouse.Named("p_status", sglClickHouseShapedValue(params.Status, sglClickHouseShapes[1])))
return err
}
const boatsNotInSQL = `SELECT id, name, status FROM boats WHERE status != {p_status:String} ORDER BY id;`
type BoatsNotInRow struct {
ID uint64 `json:"id"`
Name string `json:"name"`
Status domain.Status `json:"status"`
}
func (queries *Queries) BoatsNotIn(ctx context.Context, status string) ([]BoatsNotInRow, error) {
rows, err := queries.reader.QueryContext(ctx, boatsNotInSQL, clickhouse.Named("p_status", sglClickHouseShapedValue(status, sglClickHouseShapes[1])))
if err != nil {
return nil, err
}
defer rows.Close()
var results []BoatsNotInRow
for rows.Next() {
var row BoatsNotInRow
if err := rows.Scan(&row.ID, &row.Name, &row.Status); err != nil {
return nil, err
}
results = append(results, row)
}
if err := rows.Err(); err != nil {
return nil, err
}
return results, nil
}
const listBoatsSQL = `SELECT id, name, status FROM boats ORDER BY id;`
type ListBoatsRow struct {
ID uint64 `json:"id"`
Name string `json:"name"`
Status BoatsStatus `json:"status"`
}
func (queries *Queries) ListBoats(ctx context.Context) ([]ListBoatsRow, error) {
rows, err := queries.reader.QueryContext(ctx, listBoatsSQL)
if err != nil {
return nil, err
}
defer rows.Close()
var results []ListBoatsRow
for rows.Next() {
var row ListBoatsRow
if err := rows.Scan(&row.ID, &row.Name, &row.Status); err != nil {
return nil, err
}
results = append(results, row)
}
if err := rows.Err(); err != nil {
return nil, err
}
return results, nil
}
internal/store/clickhouse_values.go
// Code generated by sgl. DO NOT EDIT.
package store
import (
"errors"
"fmt"
"math"
"net"
"net/netip"
"reflect"
"slices"
"strconv"
"strings"
"time"
)
const (
sglClickHouseMaxDepth = 32
sglClickHouseNanosecondDigits = 9
sglClickHouseDigitGroup = 3
)
var (
sglClickHouseTextEscaper = strings.NewReplacer("\\", "\\\\", "\t", "\\t", "\n", "\\n", "\r", "\\r", "\x00", "\\0")
sglClickHouseQuotedEscaper = strings.NewReplacer("\\", "\\\\", "'", "\\'", "\t", "\\t", "\n", "\\n", "\r", "\\r", "\x00", "\\0")
sglClickHouseRefusalCleaner = strings.NewReplacer("\t", " ", "\n", " ", "\r", " ")
errSglClickHouseShape = errors.New("sgl: malformed ClickHouse parameter shape")
errSglClickHouseValue = errors.New("sgl: cannot write the value of a ClickHouse parameter")
)
type sglClickHouseShape struct {
names []string
elements []sglClickHouseShape
digits int
prepared bool
checked bool
driverMap bool
kind byte
}
var sglClickHouseShapes = []sglClickHouseShape{{kind: 110, digits: -1, prepared: true, checked: false, driverMap: false, names: []string{}, elements: []sglClickHouseShape{}}, {kind: 113, digits: -1, prepared: true, checked: false, driverMap: false, names: []string{}, elements: []sglClickHouseShape{}}}
func sglClickHouseValue(value any, shape string) string {
parsed, err := sglClickHouseParseShape(shape)
if err == nil {
return sglClickHouseShapedValue(value, parsed)
}
return sglClickHouseRefusalCleaner.Replace(err.Error()) + "\t"
}
func sglClickHouseShapedValue(value any, shape sglClickHouseShape) string {
text, err := sglClickHouseWhole(reflect.ValueOf(value), shape)
if err != nil {
return sglClickHouseRefusalCleaner.Replace(err.Error()) + "\t"
}
return text
}
func sglClickHouseWhole(value reflect.Value, shape sglClickHouseShape) (string, error) {
current, err := sglClickHouseFollow(value, 0)
if err != nil {
return "", err
}
if !current.IsValid() {
return "\\N", nil
}
shape = sglClickHouseResolve(current, shape)
switch shape.kind {
case '[', '{', '(':
return sglClickHouseComposite(current, shape, 0)
}
text, err := sglClickHouseScalar(current, shape)
if err != nil {
return "", err
}
return sglClickHouseTextEscaper.Replace(text), nil
}
func sglClickHouseAppendElement(text []byte, value reflect.Value, shape sglClickHouseShape, depth int) ([]byte, error) {
current, err := sglClickHouseFollow(value, depth)
if err != nil {
return nil, err
}
if !current.IsValid() {
return append(text, "NULL"...), nil
}
shape = sglClickHouseResolve(current, shape)
switch shape.kind {
case '[', '{', '(':
return sglClickHouseAppendComposite(text, current, shape, depth)
}
if shape.kind == 'n' && sglClickHouseIsNumber(current) {
return sglClickHouseAppendNumber(text, current), nil
}
scalar, err := sglClickHouseScalar(current, shape)
if err != nil {
return nil, err
}
if shape.kind == 'n' {
return append(text, scalar...), nil
}
text = append(text, '\'')
text = append(text, sglClickHouseQuotedEscaper.Replace(scalar)...)
return append(text, '\''), nil
}
func sglClickHouseAppendNumber(text []byte, value reflect.Value) []byte {
const decimalBase = 10
switch value.Kind() {
case reflect.Bool:
return strconv.AppendBool(text, value.Bool())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return strconv.AppendInt(text, value.Int(), decimalBase)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return strconv.AppendUint(text, value.Uint(), decimalBase)
}
number := value.Float()
switch {
case math.IsNaN(number):
return append(text, "nan"...)
case math.IsInf(number, 1):
return append(text, "inf"...)
case math.IsInf(number, -1):
return append(text, "-inf"...)
}
return strconv.AppendFloat(text, number, 'g', -1, value.Type().Bits())
}
func sglClickHouseFollow(value reflect.Value, depth int) (reflect.Value, error) {
for value.IsValid() && (value.Kind() == reflect.Pointer || value.Kind() == reflect.Interface) {
if value.IsNil() {
return reflect.Value{}, nil
}
depth++
if depth > sglClickHouseMaxDepth {
return reflect.Value{}, fmt.Errorf("%w: it nests more than %d levels deep or refers to itself", errSglClickHouseValue, sglClickHouseMaxDepth)
}
value = value.Elem()
}
return value, nil
}
func sglClickHouseResolve(value reflect.Value, shape sglClickHouseShape) sglClickHouseShape {
if shape.kind != 'a' {
return shape
}
unknown := sglClickHouseShape{names: nil, elements: nil, digits: -1, kind: 'a', checked: false, driverMap: false, prepared: false}
if _, moment := sglClickHouseMoment(value); moment {
return sglClickHouseShape{names: nil, elements: nil, digits: -1, kind: 't', checked: false, driverMap: false, prepared: false}
}
if sglClickHouseIsNumber(value) {
return sglClickHouseShape{names: nil, elements: nil, digits: -1, kind: 'n', checked: false, driverMap: false, prepared: false}
}
if sglClickHouseHasText(value) {
return sglClickHouseShape{names: nil, elements: nil, digits: -1, kind: 'q', checked: false, driverMap: false, prepared: false}
}
switch value.Kind() {
case reflect.Slice, reflect.Array:
if value.Type().Elem().Kind() != reflect.Uint8 {
return sglClickHouseShape{names: nil, elements: []sglClickHouseShape{unknown}, digits: -1, kind: '[', checked: false, driverMap: false, prepared: false}
}
case reflect.Map:
return sglClickHouseShape{names: nil, elements: []sglClickHouseShape{unknown, unknown}, digits: -1, kind: '{', checked: false, driverMap: false, prepared: false}
case reflect.Struct:
fields := make([]sglClickHouseShape, value.NumField())
for index := range fields {
fields[index] = unknown
}
return sglClickHouseShape{names: nil, elements: fields, digits: -1, kind: '(', checked: false, driverMap: false, prepared: false}
}
return sglClickHouseShape{names: nil, elements: nil, digits: -1, kind: 'q', checked: false, driverMap: false, prepared: false}
}
func sglClickHouseComposite(value reflect.Value, shape sglClickHouseShape, depth int) (string, error) {
const initialCapacity = 64
text, err := sglClickHouseAppendComposite(make([]byte, 0, initialCapacity), value, shape, depth)
return string(text), err
}
func sglClickHouseAppendComposite(text []byte, value reflect.Value, shape sglClickHouseShape, depth int) ([]byte, error) {
if depth >= sglClickHouseMaxDepth {
return nil, fmt.Errorf("%w: it nests more than %d levels deep or refers to itself", errSglClickHouseValue, sglClickHouseMaxDepth)
}
depth++
switch shape.kind {
case '[':
return sglClickHouseAppendArray(text, value, shape, depth)
case '{':
return sglClickHouseAppendMap(text, value, shape, depth)
default:
return sglClickHouseAppendTuple(text, value, shape, depth)
}
}
func sglClickHouseAppendArray(text []byte, value reflect.Value, shape sglClickHouseShape, depth int) ([]byte, error) {
if value.Kind() != reflect.Slice && value.Kind() != reflect.Array {
return nil, fmt.Errorf("%w: an array needs a slice or an array, not %s", errSglClickHouseValue, value.Type())
}
text = append(text, '[')
for index := 0; index < value.Len(); index++ {
if index > 0 {
text = append(text, ',')
}
var err error
text, err = sglClickHouseAppendElement(text, value.Index(index), shape.elements[0], depth)
if err != nil {
return nil, err
}
}
return append(text, ']'), nil
}
func sglClickHouseAppendMap(text []byte, value reflect.Value, shape sglClickHouseShape, depth int) ([]byte, error) {
if value.Kind() != reflect.Map {
return nil, fmt.Errorf("%w: a map needs a Go map, not %s", errSglClickHouseValue, value.Type())
}
parts := make([]string, 0, value.Len())
entries := value.MapRange()
for entries.Next() {
part, err := sglClickHouseAppendElement(nil, entries.Key(), shape.elements[0], depth)
if err != nil {
return nil, err
}
part = append(part, ':')
part, err = sglClickHouseAppendElement(part, entries.Value(), shape.elements[1], depth)
if err != nil {
return nil, err
}
parts = append(parts, string(part))
}
slices.Sort(parts)
text = append(text, '{')
for index, part := range parts {
if index > 0 {
text = append(text, ',')
}
text = append(text, part...)
}
return append(text, '}'), nil
}
func sglClickHouseAppendTuple(text []byte, value reflect.Value, shape sglClickHouseShape, depth int) ([]byte, error) {
elements, err := sglClickHouseTupleElements(value, shape)
if err != nil {
return nil, err
}
text = append(text, '(')
for index, element := range elements {
if index > 0 {
text = append(text, ", "...)
}
text, err = sglClickHouseAppendElement(text, element, shape.elements[index], depth)
if err != nil {
return nil, err
}
}
return append(text, ')'), nil
}
func sglClickHouseTupleElements(value reflect.Value, shape sglClickHouseShape) ([]reflect.Value, error) {
var elements []reflect.Value
switch value.Kind() {
case reflect.Struct:
for index := range value.NumField() {
if !value.Type().Field(index).IsExported() {
return nil, fmt.Errorf("%w: a tuple cannot be read from %s, which has unexported fields", errSglClickHouseValue, value.Type())
}
elements = append(elements, value.Field(index))
}
case reflect.Map:
if value.Type().Key().Kind() != reflect.String || slices.Contains(shape.names, "") {
return nil, fmt.Errorf("%w: a tuple is read from a map only by field names", errSglClickHouseValue)
}
for _, name := range shape.names {
elements = append(elements, value.MapIndex(reflect.ValueOf(name).Convert(value.Type().Key())))
}
case reflect.Slice, reflect.Array:
for index := range value.Len() {
elements = append(elements, value.Index(index))
}
default:
return nil, fmt.Errorf("%w: a tuple needs a struct, a map or a slice, not %s", errSglClickHouseValue, value.Type())
}
if len(elements) != len(shape.elements) {
return nil, fmt.Errorf("%w: the tuple has %d fields but the value holds %d", errSglClickHouseValue, len(shape.elements), len(elements))
}
return elements, nil
}
func sglClickHouseScalar(value reflect.Value, shape sglClickHouseShape) (string, error) {
if shape.kind == '4' || shape.kind == '6' {
address, isAddress, failure := sglClickHouseAddress(value, shape.kind)
if failure != "" {
return "", fmt.Errorf("%w: %s", errSglClickHouseValue, failure)
}
if isAddress {
return address.String(), nil
}
}
if moment, ok := sglClickHouseMoment(value); ok {
return sglClickHouseTime(moment, shape)
}
if shape.kind == 'n' && sglClickHouseIsNumber(value) {
return sglClickHouseNumber(value), nil
}
text, err := sglClickHouseText(value)
if err == nil && shape.kind == 'n' && !sglClickHouseIsNumberText(text) {
err = fmt.Errorf("%w: %q is not a number", errSglClickHouseValue, text)
}
return text, err
}
func sglClickHouseAddress(value reflect.Value, kind byte) (netip.Addr, bool, string) {
var address netip.Addr
switch value.Type() {
case reflect.TypeFor[netip.Addr]():
reflect.ValueOf(&address).Elem().Set(value)
if !address.IsValid() {
return address, true, "the zero netip.Addr holds no address"
}
case reflect.TypeFor[net.IP]():
bytes := value.Bytes()
if len(bytes) == 0 {
return address, true, "an empty net.IP holds no address"
}
parsed, valid := netip.AddrFromSlice(bytes)
if !valid {
return address, true, fmt.Sprintf("a net.IP of %d bytes is not an IP address", len(bytes))
}
address = parsed
default:
return address, false, ""
}
address = address.WithZone("")
if kind != '4' {
return address, true, ""
}
if address.Is6() && !address.Is4In6() {
return address, true, address.String() + " is an IPv6 address, which an IPv4 value cannot hold"
}
return address.Unmap(), true, ""
}
func sglClickHouseMoment(value reflect.Value) (time.Time, bool) {
return reflect.TypeAssert[time.Time](value)
}
func sglClickHouseTime(moment time.Time, shape sglClickHouseShape) (string, error) {
switch shape.kind {
case 'd':
return moment.Format("2006-01-02"), nil
case 't':
return sglClickHouseEpoch(moment, shape.digits), nil
case 'q':
return moment.Format(time.RFC3339Nano), nil
default:
return "", fmt.Errorf("%w: a time.Time cannot be written as a number", errSglClickHouseValue)
}
}
func sglClickHouseEpoch(moment time.Time, digits int) string {
const decimalBase = 10
nanoseconds := int64(moment.Nanosecond())
if digits < 0 {
digits = sglClickHouseNanosecondDigits
for digits > 0 && nanoseconds%int64(math.Pow10(sglClickHouseNanosecondDigits-digits+sglClickHouseDigitGroup)) == 0 {
digits -= sglClickHouseDigitGroup
}
}
seconds := moment.Unix()
if digits == 0 {
return strconv.FormatInt(seconds, decimalBase)
}
scale := int64(math.Pow10(digits))
fraction := nanoseconds / int64(math.Pow10(sglClickHouseNanosecondDigits-digits))
sign := ""
if seconds < 0 {
sign = "-"
seconds = -seconds
if fraction > 0 {
seconds--
fraction = scale - fraction
}
}
return fmt.Sprintf("%s%d.%0*d", sign, seconds, digits, fraction)
}
func sglClickHouseIsNumber(value reflect.Value) bool {
switch value.Kind() {
case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
reflect.Float32, reflect.Float64:
return true
}
return false
}
func sglClickHouseNumber(value reflect.Value) string {
const decimalBase = 10
switch value.Kind() {
case reflect.Bool:
return strconv.FormatBool(value.Bool())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
return strconv.FormatInt(value.Int(), decimalBase)
case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return strconv.FormatUint(value.Uint(), decimalBase)
}
number := value.Float()
switch {
case math.IsNaN(number):
return "nan"
case math.IsInf(number, 1):
return "inf"
case math.IsInf(number, -1):
return "-inf"
}
return strconv.FormatFloat(number, 'g', -1, value.Type().Bits())
}
func sglClickHouseMethods(value reflect.Value) []any {
if value.CanAddr() {
return []any{value.Interface(), value.Addr().Interface()}
}
return []any{value.Interface()}
}
func sglClickHouseHasText(value reflect.Value) bool {
for _, candidate := range sglClickHouseMethods(value) {
switch candidate.(type) {
case fmt.Stringer, interface{ String() (string, error) }, error:
return true
}
}
return false
}
func sglClickHouseText(value reflect.Value) (string, error) {
for _, candidate := range sglClickHouseMethods(value) {
switch typed := candidate.(type) {
case fmt.Stringer:
return typed.String(), nil
case interface{ String() (string, error) }:
text, err := typed.String()
if err != nil {
return "", fmt.Errorf("%w: its String method failed: %w", errSglClickHouseValue, err)
}
return text, nil
case error:
return "", fmt.Errorf("%w: an error is not a value", errSglClickHouseValue)
}
}
switch value.Kind() {
case reflect.String:
return value.String(), nil
case reflect.Slice, reflect.Array:
if value.Type().Elem().Kind() == reflect.Uint8 {
bytes := make([]byte, value.Len())
reflect.Copy(reflect.ValueOf(bytes), value)
return string(bytes), nil
}
}
if sglClickHouseIsNumber(value) {
return sglClickHouseNumber(value), nil
}
return "", fmt.Errorf("%w: a %s cannot be written as text", errSglClickHouseValue, value.Type())
}
func sglClickHouseIsNumberText(text string) bool {
if text == "true" || text == "false" {
return true
}
lower := strings.ToLower(sglClickHouseUnsigned(text))
if lower == "nan" || lower == "inf" {
return true
}
mantissa, exponent, scientific := strings.Cut(lower, "e")
if scientific {
exponent = sglClickHouseUnsigned(exponent)
if exponent == "" || strings.Trim(exponent, "0123456789") != "" {
return false
}
}
whole, fraction, _ := strings.Cut(mantissa, ".")
return whole+fraction != "" && strings.Trim(whole+fraction, "0123456789") == ""
}
func sglClickHouseUnsigned(text string) string {
if strings.HasPrefix(text, "+") || strings.HasPrefix(text, "-") {
return text[1:]
}
return text
}
func sglClickHouseParseShape(text string) (sglClickHouseShape, error) {
shape, rest, err := sglClickHouseReadShape(text, 0)
if err == nil && rest != "" {
err = fmt.Errorf("%w: %q has %q left over", errSglClickHouseShape, text, rest)
}
return shape, err
}
func sglClickHouseReadShape(text string, depth int) (sglClickHouseShape, string, error) {
shape := sglClickHouseShape{names: nil, elements: nil, digits: -1, kind: 0, checked: false, driverMap: false, prepared: false}
if text == "" || depth > sglClickHouseMaxDepth {
return shape, "", fmt.Errorf("%w: a shape is missing or nests too deeply", errSglClickHouseShape)
}
shape.kind, text = text[0], text[1:]
switch shape.kind {
case 'q', 'n', 'd', 'a', '4', '6':
return shape, text, nil
case 't':
shape.digits = 0
if text != "" && text[0] >= '0' && text[0] <= '9' {
shape.digits, text = int(text[0]-'0'), text[1:]
}
return shape, text, nil
case '[':
return sglClickHouseReadElements(shape, text, depth, ']')
case '{':
return sglClickHouseReadElements(shape, text, depth, '}')
case '(':
return sglClickHouseReadElements(shape, text, depth, ')')
}
return shape, "", fmt.Errorf("%w: %q is not a shape", errSglClickHouseShape, shape.kind)
}
func sglClickHouseReadElements(shape sglClickHouseShape, text string, depth int, closing byte) (sglClickHouseShape, string, error) {
for {
var err error
if shape, text, err = sglClickHouseReadElement(shape, text, depth); err != nil {
return shape, "", err
}
if text == "" {
return shape, "", fmt.Errorf("%w: %q is not closed", errSglClickHouseShape, string(shape.kind))
}
switch {
case text[0] == closing && (shape.kind != '{' || len(shape.elements) == 2):
return shape, text[1:], nil
case shape.kind == '(' && text[0] == ',', shape.kind == '{' && text[0] == ':' && len(shape.elements) == 1:
text = text[1:]
default:
return shape, "", fmt.Errorf("%w: %q is out of place", errSglClickHouseShape, text[:1])
}
}
}
func sglClickHouseReadElement(shape sglClickHouseShape, text string, depth int) (sglClickHouseShape, string, error) {
name := ""
if shape.kind == '(' && strings.HasPrefix(text, "'") {
var err error
if name, text, err = sglClickHouseReadName(text); err != nil {
return shape, "", err
}
}
element, rest, err := sglClickHouseReadShape(text, depth+1)
if err != nil {
return shape, "", err
}
shape.elements = append(shape.elements, element)
shape.names = append(shape.names, name)
return shape, rest, nil
}
func sglClickHouseReadName(text string) (name string, rest string, err error) {
var written strings.Builder
index := 1
for index < len(text) {
if text[index] != '\'' {
written.WriteByte(text[index])
index++
continue
}
if index+1 < len(text) && text[index+1] == '\'' {
written.WriteByte('\'')
index += 2
continue
}
if index+1 < len(text) && text[index+1] == '=' {
return written.String(), text[index+2:], nil
}
break
}
return "", "", fmt.Errorf("%w: a tuple field's name is not closed by '=", errSglClickHouseShape)
}
internal/store/models.go
// Code generated by sgl. DO NOT EDIT.
package store
type Boats struct {
ID uint64 `json:"id"`
Name string `json:"name"`
Status BoatsStatus `json:"status"`
}
type BoatsStatus string
const (
BoatsStatusMoored BoatsStatus = "moored"
BoatsStatusFishing BoatsStatus = "fishing"
BoatsStatusInDock BoatsStatus = "in_dock"
)
// Valid reports whether the value is one the enum declares.
func (value BoatsStatus) Valid() bool {
switch value {
case BoatsStatusMoored, BoatsStatusFishing, BoatsStatusInDock:
return true
}
return false
}
internal/store/querier.go
// Code generated by sgl. DO NOT EDIT.
package store
import (
"context"
"database/sql"
)
type DBTX interface {
ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
}
type dbtxWrapper interface {
WrapDBTX(inner any) any
}
type Queries struct {
reader DBTX
writer DBTX
wrapper dbtxWrapper
}
func New(db DBTX) *Queries {
wrapper, _ := db.(dbtxWrapper)
return &Queries{reader: db, writer: db, wrapper: wrapper}
}
func NewWithReplica(writer DBTX, reader DBTX) *Queries {
wrapper, _ := writer.(dbtxWrapper)
return &Queries{reader: reader, writer: writer, wrapper: wrapper}
}
func (queries *Queries) WithTx(transaction *sql.Tx) *Queries {
if queries == nil {
return &Queries{reader: transaction, writer: transaction, wrapper: nil}
}
db := queries.wrapDBTX(transaction)
return &Queries{reader: db, writer: db, wrapper: queries.wrapper}
}
func (queries *Queries) wrapDBTX(db DBTX) DBTX {
if queries.wrapper == nil {
return db
}
wrapped, ok := queries.wrapper.WrapDBTX(db).(DBTX)
if !ok {
return db
}
return wrapped
}
func (queries *Queries) RunInTx(ctx context.Context, db *sql.DB, fn func(*Queries) error) error {
transaction, err := db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer transaction.Rollback()
if err = fn(queries.WithTx(transaction)); err != nil {
return err
}
return transaction.Commit()
}
output.txt
all boats, status as store.BoatsStatus:
1 Kittiwake moored
2 Salty Chip fishing
3 Gull Wing in_dock
4 Driftwood fishing
not in dock, status as domain.Status:
1 Kittiwake moored at sea: false
2 Salty Chip fishing at sea: true
4 Driftwood fishing at sea: true
status "sunk" refused: not one of the Enum8 labels
Also on other engines
PostgreSQLBoats with a status from a CREATE TYPE ... AS ENUM, read as the store.BoatStatus type Seagull generates and then as a typed harbour.Status through a go_type override.CockroachDBBoats with a status from a CREATE TYPE ... AS ENUM, read as the store.BoatStatus type Seagull generates and then as a typed harbour.Status through a go_type override.TimescaleDBBoats with a status from a CREATE TYPE ... AS ENUM, read as the store.BoatStatus type Seagull generates and then as a typed harbour.Status through a go_type override.MySQLA chip shop menu with two MySQL ENUM columns, read back as the named enum types Seagull generates and, through a column override and sgl.column, as the shop's own Go types.MariaDBA chip shop menu with two MySQL ENUM columns, read back as the named enum types Seagull generates and, through a column override and sgl.column, as the shop's own Go types.DuckDBA chip shop menu with two DuckDB enum columns, read back as the named enum types Seagull generates and, through a SQL type override and sgl.column, as the shop's own Go types.