gizmodel/sql/ast
The SQL syntax tree. One record shape per kind of thing (expression, query, statement), each with an op naming what it is and the fields that op uses, so the planner dispatches by op through tables of functions instead of matching every case everywhere. Every dialect parses to these same nodes: the dialects differ in spelling, not in meaning, except where Dialect says.
import * as Ast from "gizmodel/sql/ast";Types
Expr
type Expr = { op: string; args: Vec<Expr>; value: Value; name: string; table: string; negated: bool; distinct: bool; star: bool; ty: string; query: Vec<Select>; filter: Vec<Expr>; window: Vec<Window>; paren: bool; at: i64; }An expression. op is one of:
lit (value), param (name: "1", "2"...), column (table, name), star (table: "" or a name),
neg, not, bitnot (args[0]); the binary operators + - * / % || = <> < <= > >= and or & | << >>
-> ->> <-> <=> <#> @@ (args[0], args[1]);
call (name, args, distinct, star for count(*), filter, window);
case (args: [operand?] whens/thens... else?; negated true when there is an operand, distinct
true when there is an else); cast (args[0], ty); in (args[0] subject, rest the list; negated);
insub (args[0], query; negated); exists (query; negated); subquery (query);
between (args[0..3]; negated); like/ilike/glob/regexp/similar (args[0], args[1], [escape]; negated);
isnull (args[0]; negated); distinctfrom (args[0], args[1]; negated: IS NOT DISTINCT FROM);
array (args), row (args), nextval (name: the sequence), currval (name), default.
op:stringargs:Vec<M151.Expr>value:M143.Valuename:stringtable:stringnegated:booldistinct:boolstar:boolty:stringquery:Vec<M151.Select>filter:Vec<M151.Expr>window:Vec<M151.Window>paren:bool— Written in parentheses: Oracle's||binds as+does, so only a parenthesized sum stays a unit.at:i64— The byte offset in the statement text of the token that starts it (an operator's own token), -1 when made by a rewrite: the position an error reports.
Window
type Window = { name: string; base: string; partition: Vec<Expr>; order: Vec<Order>; frame: string; start: Vec<Expr>; end: Vec<Expr>; startKind: string; endKind: string; exclude: string; }name names a definition or a direct OVER reference; base copies an earlier definition.
name:stringbase:stringpartition:Vec<M151.Expr>order:Vec<M151.Order>frame:stringstart:Vec<M151.Expr>end:Vec<M151.Expr>startKind:stringendKind:stringexclude:string
Order
type Order = { expr: Expr; desc: bool; nulls: i64; }An ORDER BY item: its expression, whether descending, and where nulls go.
expr:M151.Exprdesc:boolnulls:i64
Item
type Item = { expr: Expr; alias: string; text: string; quoted: bool; }text: the source of an unaliased item (Oracle labels its column with it), else "".
expr:M151.Expralias:stringtext:stringquoted:bool
From
type From = { kind: string; name: string; schema: string; alias: string; columns: Vec<string>; types: Vec<string>; query: Vec<Select>; args: Vec<Expr>; join: string; left: Vec<From>; right: Vec<From>; on: Vec<Expr>; using: Vec<string>; lateral: bool; ordinality: bool; only: bool; variadic: bool; }A FROM item. kind: table (name, schema), query (query), function (name, args), join (left, right, join: inner left right full cross, on, using, natural).
kind:stringname:stringschema:stringalias:stringcolumns:Vec<string>types:Vec<string>— A function's column definition list (AS x(a int, b text)): each column's type, or "".query:Vec<M151.Select>args:Vec<M151.Expr>join:stringleft:Vec<M151.From>right:Vec<M151.From>on:Vec<M151.Expr>using:Vec<string>lateral:boolordinality:bool— A function's WITH ORDINALITY: a last column numbering its rows from 1.only:bool— FROM ONLY t: t's rows without those of the tables that inherit from it. On a function: a select-list call (SELECT f()), whose record rows need no column definition list.variadic:bool— A function call whose last argument follows VARIADIC: that array is the variadic parameter itself.
Cte
type Cte = { name: string; columns: Vec<string>; query: Select; recursive: bool; dml: Vec<Statement>; }A CTE; a data-modifying one (WITH x AS (INSERT ... RETURNING ...)) holds its statement in dml.
name:stringcolumns:Vec<string>query:M151.Selectrecursive:booldml:Vec<M151.Statement>
Select
type Select = { with: Vec<Cte>; distinct: bool; distinctOn: Vec<Expr>; items: Vec<Item>; from: Vec<From>; where: Vec<Expr>; groupBy: Vec<Expr>; having: Vec<Expr>; windows: Vec<Window>; orderBy: Vec<Order>; limit: Vec<Expr>; offset: Vec<Expr>; values: Vec<Vec<Expr>>; setOp: string; right: Vec<Select>; lock: string; ties: bool; percent: bool; }A query: a SELECT, or VALUES (values), combined with others by setOp (union, union all,
intersect, except) on right. limit and offset hold zero or one expression.
with:Vec<M151.Cte>distinct:booldistinctOn:Vec<M151.Expr>items:Vec<M151.Item>from:Vec<M151.From>where:Vec<M151.Expr>groupBy:Vec<M151.Expr>having:Vec<M151.Expr>windows:Vec<M151.Window>orderBy:Vec<M151.Order>limit:Vec<M151.Expr>offset:Vec<M151.Expr>values:Vec<Vec<M151.Expr>>setOp:stringright:Vec<M151.Select>lock:string— SQL Server's TOP n, Oracle's FETCH FIRST n: the same as limit.ties:bool— FETCH FIRST n ROWS WITH TIES: also the rows that sort the same as the last of the n.percent:bool— FETCH FIRST n PERCENT, TOP n PERCENT:limitis a percent of the row count.
ColumnSpec
type ColumnSpec = { name: string; declared: string; nullable: bool; primary: bool; unique: bool; auto: bool; default: string; check: string; references: string; named: Vec<string>; }A column in CREATE TABLE or ALTER TABLE ADD.
name:stringdeclared:stringnullable:boolprimary:boolunique:boolauto:booldefault:stringcheck:stringreferences:stringnamed:Vec<string>— Its constraints' names, "kind:name" (n NOT NULL, p, u, c, r), "" for an unnamed one.
Constraint
type Constraint = { kind: string; name: string; columns: Vec<string>; text: string; }A table constraint: primary, unique (columns), check (text), foreign (columns, references).
kind:stringname:stringcolumns:Vec<string>text:string
Assign
type Assign = { columns: Vec<string>; value: Expr; }One SET of an UPDATE: the columns and the value.
columns:Vec<string>value:M151.Expr
Conflict
type Conflict = { columns: Vec<string>; action: string; sets: Vec<Assign>; where: Vec<Expr>; predicate: string; text: string; }ON CONFLICT: target columns (empty: any), action nothing or update (sets, where).
columns:Vec<string>action:stringsets:Vec<M151.Assign>where:Vec<M151.Expr>predicate:stringtext:string
Statement
type Statement = { op: string; query: Vec<Select>; table: string; alias: string; columns: Vec<string>; rows: Vec<Vec<Expr>>; load: Option<Batch>; defaults: bool; sets: Vec<Assign>; from: Vec<From>; where: Vec<Expr>; returning: Vec<Item>; conflict: Vec<Conflict>; or: string; specs: Vec<ColumnSpec>; constraints: Vec<Constraint>; ifNotExists: bool; ifExists: bool; name: string; what: string; unique: bool; method: string; options: string; text: string; value: Vec<Expr>; action: string; inner: Vec<Statement>; temporary: bool; orReplace: bool; asQuery: bool; inherits: Vec<string>; descending: Vec<bool>; partitionKey: string; partitionBound: Option<string>; parentIndex: string; viewChecks: Vec<Item>; named: bool; source: string; tablespace: string; indexSpaces: Vec<string>; tempNamed: bool; }A statement. op: select, insert, update, delete, create_table, create_index, create_view, create_sequence, drop (what: table, index, view, sequence), alter (action: add, drop_column, rename, rename_column), begin, commit, rollback, savepoint, release, rollback_to, pragma, set, show, explain, truncate, merge (as insert with conflict), call.
op:stringquery:Vec<M151.Select>table:stringalias:stringcolumns:Vec<string>rows:Vec<Vec<M151.Expr>>load:_gizlang_sdk_core.Option<M152.Batch>— INSERT: the rows as typed columns, one for each column, when a program gives them (a load of records). An engine stores the columns as they are, with no expression or value for a cell; SQL text has no form of it.defaults:boolsets:Vec<M151.Assign>from:Vec<M151.From>where:Vec<M151.Expr>returning:Vec<M151.Item>conflict:Vec<M151.Conflict>or:string— INSERT OR REPLACE / OR IGNORE: the action for any conflict.specs:Vec<M151.ColumnSpec>constraints:Vec<M151.Constraint>ifNotExists:boolifExists:boolname:stringwhat:stringunique:boolmethod:stringoptions:stringtext:stringvalue:Vec<M151.Expr>action:stringinner:Vec<M151.Statement>temporary:boolorReplace:boolasQuery:boolinherits:Vec<string>— CREATE TABLE ... INHERITS (parents).descending:Vec<bool>— CREATE INDEX: for each column, whether it was written DESC.partitionKey:string— PARTITION BY: "strategy\u0001key\u0002key...\u0001opclass\u0002...", "" when not given.partitionBound:_gizlang_sdk_core.Option<string>— The bound of PARTITION OF or ATTACH PARTITION, as the catalog keeps it (partbound): "default", "in\u0001v\u0002v...", "range\u0001lo\u0002...\u0001hi\u0002..." or "hash\u0001modulus\u0001remainder"; "" for DETACH PARTITION; undefined when the statement names no partition.parentIndex:string— CREATE INDEX made for a partition (ddl.giz indexStatement): the parent index it attaches to.viewChecks:Vec<M151.Item>— The conditions of the views WITH CHECK OPTION that an INSERT or UPDATE goes through, in the terms of its table: the alias of each item names its view.named:bool— A :name parameter: PostgreSQL has none (psql substitutes its variables), so its dialect refuses it.source:string— CREATE FUNCTION, PROCEDURE, TRIGGER and PACKAGE: the text from the object word to the end, as the dictionary shows it.tablespace:string— The TABLESPACE of CREATE TABLE or CREATE INDEX, or of ALTER ... SET TABLESPACE; "" when none is given.indexSpaces:Vec<string>— CREATE TABLE: the tablespaces of its USING INDEX TABLESPACE clauses.tempNamed:bool— Whether the statement names an object in pg_temp (pg_temp.x), whose qualifier the parser drops.
Functions
columnSpec
function columnSpec(name: string, declared: string, nullable: bool): ColumnSpecA column name of type declared, with no constraint but NOT NULL when not nullable.
expr
function expr(op: string): ExprA new expression node of OP with no fields set.
Effects: fail.
columnRef
function columnRef(table: string, name: string): ExprA reference to column NAME of TABLE ("" for any).
Effects: fail.
exprOf
function exprOf(op: string, args: Vec<Expr>): ExprA new expression node of OP with ARGS.
Effects: fail.
lit
function lit(v: Value): ExprA literal expression of V.
Effects: fail.
paramRef
function paramRef(n: i64): ExprThe parameter $N (from 1).
Effects: fail, alloc.
select
function select(): SelectAn empty SELECT.
newFrom
function newFrom(kind: string): FromA FROM item of kind with every other field empty.
statement
function statement(op: string): StatementAn empty statement of OP.
window
function window(): WindowAn empty window definition.
exprAny
function exprAny<F>(x: Expr, test: F): bool effects {test, fail}Whether test holds for x or for a part of it (its arguments, recursively).
keepable
function keepable(s: Select): boolWhether the answer of S depends only on the data it reads: it calls no function but an aggregate (a clock, a random draw or a function with effects gives another answer to the same data), reads no table function and locks no row. A source may keep such an answer until the data changes (model/source.giz TextClient).
Effects: fail, alloc.