ddl

README

ddl

Runtime DDL over tinywasm/storage: CreateTable/DropTable/CreateDatabase/Sync/SyncSchema, plus the executable ddl/conformance contract for SQL backends. A sibling of tinywasm/orm, not a dependency of it — see docs/ARCHITECTURE.md for the design.

Documentation

Index

• func TopologicalSort(models []model.Model) ([]model.Model, error)
• type ColumnInfo
• type Compiler
• type DB
  • func New(conn storage.Conn, ddlCompiler Compiler) *DB
  • func (d *DB) CreateDatabase(name string) error
  • func (d *DB) CreateTable(m model.Model) error
  • func (d *DB) DropTable(m model.Model) error
  • func (d *DB) SetLog(fn func(...any))
  • func (d *DB) Sync(models ...model.Model) error
  • func (d *DB) SyncSchema(table string, fields []model.Field) error
• type Op
• type RenameProvider
• type SchemaInspector
• type Stmt
• type TableIntrospector

Functions

func TopologicalSort

func TopologicalSort(models []model.Model) ([]model.Model, error)

TopologicalSort returns models sorted so parents come before children (Kahn's BFS). Models not implementing SchemaExt() are treated as having no FK deps. Returns error on circular FK dependency. Moved here from tinywasm/ddlc: ordering CREATE TABLE statements by FK dependency is a DDL concern, not a generation-tool concern — see DDLC_DEPENDENCY_PROPOSAL.md in tinywasm/app-releases/docs.

Types

type ColumnInfo

type ColumnInfo struct {
	Name    string
	Type    string
	NotNull bool
	PK      bool
}

ColumnInfo describes a single column returned by SchemaInspector.

type Compiler

type Compiler interface {
	CompileDDL(s Stmt, m model.Model) (query string, args []any, err error)
}

Compiler is implemented by dialect adapters (sqlt, postgres). It renders a DDL Stmt to engine SQL. It is the DDL counterpart of storage.Compiler (which stays DML-only).

type DB

type DB struct {
	// contains filtered or unexported fields
}

DB applies schema changes through a storage.Conn: Exec for the compiled DDL, and Compile (the DML half storage.Conn already carries) for Sync's safe-drop SELECT probe. No separate DML compiler argument is needed — storage.Conn already unifies Executor+Compiler.

func New

func New(conn storage.Conn, ddlCompiler Compiler) *DB

func (*DB) CreateDatabase

func (d *DB) CreateDatabase(name string) error

CreateDatabase creates a new database. No model.Model needed — OpCreateDatabase only carries the database name.

func (*DB) CreateTable

func (d *DB) CreateTable(m model.Model) error

CreateTable creates a new table for the given model.

func (*DB) DropTable

func (d *DB) DropTable(m model.Model) error

DropTable drops the table for the given model.

func (*DB) SetLog

func (d *DB) SetLog(fn func(...any))

func (*DB) Sync

func (d *DB) Sync(models ...model.Model) error

Sync reconciles the database to match the given models.

func (*DB) SyncSchema

func (d *DB) SyncSchema(table string, fields []model.Field) error

SyncSchema reconciles one table to the given fields, with no model instance.

type Op

type Op int

Op is a DDL operation (schema), distinct from storage's DML Action.

const (
	OpCreateTable Op = iota
	OpDropTable
	OpCreateDatabase
	OpAddColumn
	OpRenameColumn
	OpDropColumn
)

type RenameProvider

type RenameProvider interface {
	OldNames() map[string]string
}

RenameProvider is implemented by generated models when db:"old_name=X" tags are present.

type SchemaInspector

type SchemaInspector interface {
	Tables() ([]string, error)
	Columns(table string) ([]ColumnInfo, error)
}

SchemaInspector is optionally implemented by storage.Conn to expose broader schema introspection. If the adapter does not implement it, the db_schema MCP tool is not registered.

type Stmt

type Stmt struct {
	Op       Op
	Table    string
	Database string
	Column   *model.Field // for AddColumn/RenameColumn — full field metadata needed to render the type
	OldName  string       // for RenameColumn
	// ColumnName carries a bare column name for operations that don't need type info —
	// currently only OpDropColumn (you can't "add" or "rename to" a column without knowing
	// its type, but dropping only needs the name). Deliberately separate from Column: giving
	// DropColumn a *model.Field would force callers to fabricate a fake Field just to carry a
	// string, which is worse than a second field that's simply unused by the other Ops.
	ColumnName string
}

Stmt is one DDL statement to run through a storage.Conn.

type TableIntrospector

type TableIntrospector interface {
	TableColumns(table string) ([]string, error)
}

TableIntrospector is optionally implemented by the injected storage.Conn to retrieve column names.