formula

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

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

type BindOptions struct {
	Mode Mode
	// Sources are the explicit tables LOOKUP may read (ADR-0016); nil
	// means none, and every LOOKUP is an unknown source.
	Sources Sources
}

type BindingSuite struct {
	Suite       string                       `json:"suite"`
	Description string                       `json:"description,omitempty"`
	Variables   map[string]string            `json:"variables,omitempty"`
	Schemas     map[string]map[string]string `json:"schemas,omitempty"`
	// Sources declares the tables LOOKUP may read, as in an evaluation
	// suite; their rows are not needed to bind.
	Sources map[string]*SuiteSource `json:"sources,omitempty"`
	// Mode is "any" (the default), "auto" (ADR-0015) or "pure" (ADR-0018).
	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),
	// state and id.
	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"`
	State  string   `json:"state,omitempty"`
	ID     string   `json:"id,omitempty"`
}

type Class string

type Column struct {
	Name  string
	Kind  Kind
	Scale int8
}

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
	// State is the state of the document the formula runs over, for
	// STATE(); empty for a class without states and in a preview of a
	// stateless application (ADR-0040).
	State string
	// ID is the id of the document the formula runs over, for ID(); empty
	// when there is no document.
	ID string
}

type DecConst struct {
	Mant  int64
	Scale int8
}

type Dialect interface {
	Name() string
	NumberLit(f float64) string
	// IntLit spells an integer literal as the engine's 64-bit integer.
	IntLit(m int64) 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
	// Mant reads an exact expression's mantissa as a non-null integer in
	// the type the dialect does exact arithmetic in: a blank is 0, a bool
	// 1 or 0. RawMant reads it with a blank kept NULL, for the functions
	// that skip blanks.
	Mant(e SQLExpr) string
	RawMant(e SQLExpr) string
	// Narrow brings an exact arithmetic result back to a 64-bit integer,
	// NULL when it does not fit, and OverflowErr is the matching check.
	Narrow(val string) string
	OverflowErr(val string) 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
	// ColumnType is the SQL type of a column that stores values of the
	// kind, as the engine's tables declare it.
	ColumnType(k Kind) 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 Field struct {
	Name string
	Type Type
}

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
	Path []string
	P    int
}

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

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     int32
	Len   int32
}

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
	Decs    []DecConst
	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 QueryExecutor interface {
	// Lookup returns the slot's column of the first row of its source, in
	// the source's key order, on which the condition holds for the
	// arguments, or blank when no row does. A row on which the condition
	// stops with an error does not match. ctx is the context the formula
	// runs in, for a condition that reads it.
	Lookup(q *QuerySlot, args []Value, ctx *Context) (Value, *EvalError)
}

type QuerySlot struct {
	Source string
	Column string
	// Type is the column's type, which is the type of the lookup.
	Type Type
	// Order lists the source's key columns: "first row" is first in this
	// order.
	Order []string
	// Args are the slots of the enclosing program whose values the
	// condition reads as THIS.name, and ArgNames those variables' names,
	// so that a slot "THIS.<name>" of Cond or Key maps to Args[i].
	Args     []int32
	ArgNames []string
	// Cond is the condition; a row matches when it is TRUE, and a row on
	// which it stops with an error does not match.
	Cond *Program
	// Key is the compared expression of an equality condition, nil for
	// any other shape, and IndexColumn the column it is compared with.
	Key         *Program
	IndexColumn string
}

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. A
	// KindDecimal position receives a raw mantissa, scale 0.
	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
	// Currency is the currency expression of a money result, "" otherwise.
	Currency string
	// Kind is the kind of the value expression.
	Kind Kind
	// Scale is the scale of an exact value expression.
	Scale int8
	// 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 SQLBinding struct {
	// Column gives the column expression that holds each slot's value; for
	// a money slot it is asked again for the currency column, a text slot
	// named with CurrencySuffix. Column expressions must be qualified when
	// the program has a lookup, since they are referenced inside its
	// subquery.
	Column func(Slot) string
	// Table gives the table expression of each source a LOOKUP reads; nil
	// refers to the source by its quoted name.
	Table func(source string) string
	// Row gives the column that holds a system value of the document row
	// the statement runs over, asked for "state" and "id", which STATE()
	// and ID() read (ADR-0040); nil binds them to parameters, as USER().
	Row func(name string) string
}

type SQLExpr struct {
	// Val is the value expression: the mantissa for an exact kind.
	Val string
	// Err is the error expression, or "" when the expression cannot fail.
	Err string
	// Cur is the currency expression of a money value, NULL for a blank.
	Cur string
	// Kind is the static kind of Val.
	Kind Kind
	// Scale is the scale of an exact Val.
	Scale int8
	// Sure reports that Val is never NULL, so no COALESCE is needed.
	Sure bool
	// IsConst and Const carry a number literal, which a dialect reads for
	// an argument that must be written in the formula, such as places.
	IsConst bool
	Const   float64
}

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 Source struct {
	Name    string
	Columns []Field
	// Key lists the columns that order the source. LOOKUP returns the
	// first matching row in this order (ADR-0020).
	Key []string
	// Binding is sqlite, duckdb or external (ADR-0016); "" is the
	// store's default.
	Binding string
}

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

type Sources interface {
	Source(name string) (*Source, bool)
}

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, or
	// object<Name> for a schema of Schemas.
	Variables map[string]string `json:"variables,omitempty"`
	// Schemas declares object schemas by name: field name to type, where
	// a type may be object<Name> of another schema (ADR-0031). A case sets
	// an object's leaf by its path, "shipping.city".
	Schemas map[string]map[string]string `json:"schemas,omitempty"`
	// Sources declares the explicit tables LOOKUP may read (ADR-0020),
	// with their rows.
	Sources map[string]*SuiteSource `json:"sources,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 SuiteSource struct {
	Columns map[string]string            `json:"columns"`
	Key     []string                     `json:"key"`
	Rows    []map[string]json.RawMessage `json:"rows,omitempty"`
}

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
	// Scale is the number of digits after the point of a decimal or money
	// type, 0 to MaxScale. For an array it is the element's scale.
	Scale int8
	// Elem is the element kind of an array.
	Elem Kind
	// contains filtered or unexported fields
}

type Unary struct {
	Op    TokenKind
	Const bool
	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
	// Executor answers LOOKUP (ADR-0020). A program with a lookup and no
	// executor stops with query_failed.
	Executor QueryExecutor
	// contains filtered or unexported fields
}

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

type Variable struct {
	Name string
	Type Type
}