formula

type Array struct {
	Elem  Kind
	Nums  []float64
	Strs  []string
	Nulls []bool
}

type Binary struct {
	Op   TokenKind
	L, R Node
	P    int
}

type BindOptions struct {
	Mode Mode
}

type BindingSuite struct {
	Suite       string            `json:"suite"`
	Description string            `json:"description,omitempty"`
	Variables   map[string]string `json:"variables,omitempty"`
	// Mode is "any" (the default) or "auto" (ADR-0015).
	Mode   string       `json:"mode,omitempty"`
	Accept []string     `json:"accept"`
	Reject []RejectCase `json:"reject"`
	File   string       `json:"-"`
}

type BlankLit struct {
	P int
}

type BoolLit struct {
	Value bool
	P     int
}

type Call struct {
	Name string
	Args []Node
	P    int
}

type Case struct {
	Name    string `json:"name,omitempty"`
	Formula string `json:"formula"`
	// Inputs are values for declared variables; an absent variable is blank.
	// Dates are written as YYYY-MM-DD or YYYY-MM-DD HH:MM:SS.
	Inputs map[string]json.RawMessage `json:"inputs,omitempty"`
	// Context sets the context functions: user, groups, now (a date).
	Context *CaseContext `json:"context,omitempty"`
	// Type is the static type the formula must have, when the case pins it.
	// A date result must declare it so that Expected can be written as text.
	Type string `json:"type,omitempty"`
	// Expected is the value, in the same notation as Inputs. Exactly one of
	// Expected and Error is set; Expected may be null for a blank result.
	Expected json.RawMessage `json:"expected,omitempty"`
	// Error is the error code the evaluation must stop with.
	Error string `json:"error,omitempty"`
}

type CaseContext struct {
	User   string   `json:"user,omitempty"`
	Groups []string `json:"groups,omitempty"`
	Now    string   `json:"now,omitempty"`
}

type Class string

type Column struct {
	Name string
	Kind Kind
}

type Context struct {
	// User is the id of the user the formula runs for; empty for a system
	// recompute.
	User string
	// Groups are the groups the user belongs to.
	Groups []string
	// Now is the current time in seconds since the epoch, UTC. Zero means
	// the wall clock.
	Now int64
}

type Dialect interface {
	Name() string
	NumberLit(f float64) string
	TextLit(s string) string
	True() string
	False() string
	// Load references a column holding a variable of the kind, cast to the
	// SQL type the dialect computes with.
	Load(column string, k Kind) string
	// Num, Cond and Text read an expression as a number, a condition or
	// text with the blank rules of ADR-0005: a blank is 0, FALSE or "".
	Num(e SQLExpr) string
	Cond(e SQLExpr) string
	Text(e SQLExpr) string
	// NotFinite is the condition that a numeric value is not a finite
	// number, the overflow check of ADR-0019.
	NotFinite(val string) string
	// Pow spells x to the power y as the VM computes it.
	Pow(x, y string) string
	// Render applies the TEXT rule of ADR-0019 to a scalar.
	Render(e SQLExpr) string
	// Call translates a builtin by canonical name. Args are translated
	// already; the dialect reads their kinds.
	Call(name string, args []SQLExpr, params *Params) (SQLExpr, error)
	// Param references a context parameter by name.
	Param(name string) string
	// ContextArgs binds the context parameters for database/sql, in the
	// form the dialect's SQL expects.
	ContextArgs(ctx *Context) []any
	// Setup lists statements to run on a connection before the generated
	// SQL can be used: the DuckDB macros, nothing for SQLite.
	Setup() []string
	// Limits are the size limits the generated SQL enforces (ADR-0021).
	Limits() Limits
	// WithLimits returns the dialect under other limits.
	WithLimits(l Limits) Dialect
}

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

type Error struct {
	// Pos is the byte offset of the error in the formula.
	Pos int
	// Col is the 1-based column in characters, for people.
	Col int
	Msg string
}

type EvalError struct {
	Code string
	Pos  int
	Msg  string
}

type Function struct {
	Name     string   `json:"name"`
	Aliases  []string `json:"aliases,omitempty"`
	Class    Class    `json:"class"`
	Category string   `json:"category"`
	Params   []Param  `json:"params"`
	Returns  string   `json:"returns"`
	Summary  string   `json:"summary"`
}

type Ident struct {
	Name string
	P    int
}

type If struct {
	Cond, Then, Else Node
	P                int
}

type Instr struct {
	Op  Op
	Arg int32
}

type Kind uint8

type Limits struct {
	// MaxText is the longest text a formula may produce or a document may
	// store, in code points. A longer result is the error out_of_range,
	// decided before the text is built.
	MaxText int
}

type Member struct {
	Base string
	Name string
	P    int
}

type Mode uint8

type Node interface {
	// Pos is the byte offset of the node in the formula: the operator for
	// operators, the start otherwise.
	Pos() int
}

type NumberLit struct {
	Value float64
	P     int
}

type Op uint8

type Param struct {
	Name string `json:"name"`
	// Type names the argument's static type, or a shape such as "numbers"
	// (a number or an array of numbers), "source" or "condition" for the
	// query functions.
	Type string `json:"type"`
	// Optional: this argument and every one after it may be left out.
	Optional bool `json:"optional,omitempty"`
	// Repeat: the argument may be given any number of times.
	Repeat bool `json:"repeat,omitempty"`
}

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

type Program struct {
	Nums    []float64
	Texts   []string
	Slots   []Slot
	Code    []Instr
	Pos     []int32 // byte offset in the source per instruction, for messages
	Result  Type
	Classes []Class // function classes used, in catalog order
	Queries []QuerySlot
	// MaxStack is the stack depth the program needs.
	MaxStack int
}

type QuerySlot struct {
	Source string
	Args   []int32
}

type RegisteredFunc struct {
	// Name is the SQL function name.
	Name string
	// NArgs is the argument count, the limit included when Limited, or -1
	// for variadic.
	NArgs int
	// Kinds gives the kind expected at each position; the last repeats.
	Kinds []Kind
	// Fn is the implementation, the VM's own.
	Fn func(vm *VM, args []Value) (Value, *EvalError)
	// Limited: the last argument is the text limit, and Fn reads it from
	// the VM it is called with.
	Limited bool
}

type RejectCase struct {
	Formula string `json:"formula"`
	Reason  string `json:"reason,omitempty"`
}

type Rows struct {
	Cols []Column
	Data []Array
	N    int
}

type SQL struct {
	// Value is the value expression.
	Value string
	// Error is the error expression, or "" when the formula cannot fail.
	Error string
	// Kind is the kind of the value expression.
	Kind Kind
	// Params lists the context parameters the expressions reference, by
	// name: now (seconds since the epoch, always bound, never NULL), user
	// (the user id or NULL) and groups (the user's groups or NULL, in the
	// form the dialect's ContextArgs binds).
	Params []string
}

type SQLExpr struct {
	// Val is the value expression.
	Val string
	// Err is the error expression, or "" when the expression cannot fail.
	Err string
	// Kind is the static kind of Val.
	Kind Kind
	// Sure reports that Val is never NULL, so no COALESCE is needed.
	Sure bool
}

type SQLResult struct {
	// Query is the statement that ran, for messages.
	Query string
	// Value is the value column as a Value of the program's result kind.
	Value Value
	// Code is the error column, or "" when NULL.
	Code string
}

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

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

type Slot struct {
	Name string
	Type Type
}

type Suite struct {
	// Suite is the short name, unique across files.
	Suite       string `json:"suite"`
	Description string `json:"description,omitempty"`
	// Variables declares the input variables the cases may set, by type:
	// bool, number, text, date, ref, json, array<scalar>, rows.
	Variables map[string]string `json:"variables,omitempty"`
	// Limits sets the size limits the cases evaluate under (ADR-0021);
	// absent, the defaults. A suite at a small limit reaches the boundary
	// with short texts.
	Limits *SuiteLimits `json:"limits,omitempty"`
	Cases  []Case       `json:"cases"`
	// File is where the suite was loaded from, for messages.
	File string `json:"-"`
}

type SuiteLimits struct {
	MaxText int `json:"max_text"`
}

type SyntaxSuite struct {
	Suite       string            `json:"suite"`
	Description string            `json:"description,omitempty"`
	Variables   map[string]string `json:"variables,omitempty"`
	Accept      []string          `json:"accept"`
	Reject      []RejectCase      `json:"reject"`
	File        string            `json:"-"`
}

type TextLit struct {
	Value string
	P     int
}

type ThisRef struct {
	Name string
	P    int
}

type Token struct {
	Kind TokenKind
	// Text is the name as written for a name, the unescaped value for a
	// text literal, and the source text otherwise.
	Text string
	// Num is the value of a number literal.
	Num float64
	// Pos is the byte offset of the token in the formula.
	Pos int
}

type TokenKind uint8

type Type struct {
	Kind Kind
	// Elem is the element kind of an array.
	Elem Kind
	// Cols is the schema of rows; nil when unknown.
	Cols []Column
}

type Unary struct {
	Op TokenKind
	X  Node
	P  int
}

type VM struct {
	// Limits are the size limits of the database the programs belong to
	// (ADR-0021). NewVM sets the defaults; set others before Run.
	Limits Limits
	// contains filtered or unexported fields
}

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

type Variable struct {
	Name string
	Type Type
}