sqlcomplete

type Catalog struct {
	Databases ItemsFn
	// Tables answers a named database's tables, views and table functions, or
	// the buffer's default database when the argument is empty.
	Tables ItemsOfFn
	// Columns answers a table's columns, or the statement's own sources' when
	// the argument is empty.
	Columns ItemsOfFn
	// ColumnType answers one column's type, for the typer. table may be
	// empty, meaning the buffer's single source.
	ColumnType func(table string, column string) (t chtype.Type, ok bool)

	Functions            ItemsFn
	Settings             ItemsFn
	TypeNames            ItemsFn
	TimeZones            ItemsFn
	Dictionaries         ItemsFn
	DictionaryAttributes ItemsOfFn
	Formats              ItemsFn
	// EnumValues answers a column's Enum members, derived from its type
	// string (§SD12 B11).
	EnumValues ItemsOfFn
}

type Engine struct {
	// Vocab is the host's function registry — what the rosters declare.
	Vocab *sqlvocab.Registry
	// Builtins is the curated ClickHouse table; nil means [sqlvocab.Builtins].
	Builtins []sqlvocab.Function
	// Providers resolve a domain to candidates.
	Providers Providers
	// Typer answers the type-dependent domains; nil means one is built on
	// first use over Providers.
	Typer *Typer
	// NamedTupleAccess reports that the buffer's pipeline accepts `expr.name`
	// on a named tuple (ADR-0190 §SD11). Until it does, offering the fields of
	// a call receiver would offer a spelling that does not parse, so §SD7 gates
	// that one receiver on this.
	NamedTupleAccess bool
	// contains filtered or unexported fields
}

type Finding struct {
	// Range is the literal's content, quotes excluded — what a tint covers.
	Range highlight.Range
	// Text is the content.
	Text string
	// Domain is the domain the position declares.
	Domain sqlvocab.Domain
	// Resolved is true when the domain has a member equal to Text.
	Resolved bool
	// Callee is the enclosing call, for a message.
	Callee string
}

type Item struct {
	// Text is the candidate's identity — the value, unquoted: `SysMem`,
	// `TotalBytes`, `system.parts`. It is what a match compares against and
	// what the pane's first column shows.
	Text string
	// Insert is the spelling that names it at the caret's position. It equals
	// Text inside a string literal, and carries the quotes when the position
	// takes a literal and none has been opened. Filled by the engine, not by
	// the provider, because only the engine knows where the caret is.
	Insert string
	Kind   ItemKindE
	// Type is the candidate's ClickHouse type where it has one — a component
	// field, a column. Empty otherwise.
	Type string
	// Doc is one line, for the pane's last column.
	Doc string
	// Source names the provider, so a row can say where it came from (§SD1's
	// provenance requirement).
	Source string
	// Marks are the provisioning marks the Vocabulary tab shows — `✓`,
	// `MISSING`, a dependency note. Carried through rather than filtered on:
	// hiding a MISSING function would hide the provisioning fact (§SD8).
	Marks []string
}

type ItemKindE uint8

type ItemsFn func() (items []Item, ready bool)

type ItemsOfFn func(of string) (items []Item, ready bool)

type MatchE uint8

type Providers struct {
	ComponentKinds ItemsFn
	// ComponentType answers the whole named Tuple a kind projects.
	//
	// A type rather than a list of rows, because that is what composes: the
	// typer needs the element's own type for
	// `tupleElement(tupleElement(LW_COMPONENT(k),'a'),'b')`, and the field
	// list falls out of the type. A provider keyed on a kind and answering
	// rows would serve the LW_COMPONENT spelling and nothing else.
	ComponentType func(kind string) (t chtype.Type, ok bool)

	IntrospectionTables ItemsFn
	Sections            ItemsFn
	SectionColumns      ItemsOfFn
	ExtractionTokens    ItemsOfFn
	Memberships         ItemsFn
	Channels            ItemsFn
	SupportRoles        ItemsFn
	Aspects             ItemsFn
	CanonicalTypes      ItemsFn
	Glosses             ItemsFn
	GlossKeys           ItemsOfFn
	IdentityTags        ItemsFn
	StatementParams     ItemsFn
	// Expressions answers a free expression position — the columns of the
	// statement's single source, the functions the endpoint has, the names
	// this build's vocabulary declares. Its argument is that source, qualified,
	// or empty when the statement has none or more than one.
	//
	// It exists because "any expression" is not one catalogue: a column and a
	// function are both valid at a SELECT position, and a provider returning
	// only one of them would be exactly as wrong as returning neither.
	Expressions ItemsOfFn

	// Catalog is the server's own vocabulary for this buffer's endpoint —
	// every entry an ADR-0147 §SD6 probe. Empty until M2.
	Catalog Catalog
}

type Request struct {
	// Site is the per-frame answer from the lex tier.
	Site highlight.CaretSite
	// Scope is the sentinel parse's answer, nil until it arrives.
	Scope *Scope
	// Statement is the buffer the site's ranges index.
	Statement string
	// Caret is the caret's byte offset into Statement.
	Caret int
}

type Result struct {
	// Domain is the argument domain the engine resolved, zero when it
	// resolved none.
	Domain sqlvocab.Domain
	// Items are the candidates, in the provider's own order.
	Items []Item
	// Partial is the byte range in Statement a completion replaces.
	Partial highlight.Range
	// Match is the state of what was typed against Items.
	Match MatchE
	// Exact is the index in Items of the candidate equal to the token's whole
	// text, or -1.
	Exact int
	// Prefix are the indices of the candidates extending the typed text — all
	// of them when nothing has been typed.
	Prefix []int
	// Silent says why there is nothing to offer, for the pane to show instead
	// of an empty table. Empty when Items is non-empty.
	//
	// Every path that offers nothing sets it: ADR-0190 §SD1 commits to silence
	// over guessing, and a silence with no reason is indistinguishable from a
	// bug.
	Silent string
	// Callee is the enclosing call the domain came from, for the pane's
	// heading. Empty when the domain came from the clause or a member access.
	Callee string
	// Ordinal is the argument position within Callee, or -1.
	Ordinal int
}

type Scope struct {
	// Frame is the tree's own view of the caret's call. For a comma-separated
	// call it must agree with the site's; for a keyword-syntax call
	// (`CAST(x AS T)`) it is the only one there is.
	Frame *highlight.CallFrame
	// Aliases maps an alias to the source text of the expression it names, so
	// the typer can recurse into it.
	Aliases map[string]string
	CTEs    []string
	Tables  []TableRef
	Windows []string
	// Clause is the clause the sentinel landed in, spelled as
	// [highlight.CaretSite.Clause] spells it so the two tiers do not disagree
	// about the same word.
	Clause string
}

type TableRef struct {
	Database string
	Name     string
	Alias    string
}

type Typer struct {
	// Providers is where the registry answers come from — the component
	// registry, the column probe.
	Providers *Providers
	// Scope is the statement's alias map, nil until the scope tier answers.
	Scope *Scope
	// contains filtered or unexported fields
}