All Classes and Interfaces
Class
Description
The running state of one aggregate over one group.
Represents an aggregate function in an aggregation operation.
One aggregate a library supplies: its form plus the
Accumulator that reduces a group.Aggregate function operators used in
AggregateFunction.A contract an aggregate makes with the optimizer, in the way
FunctionProperty does for scalar functions.The form of an aggregate — what the engine needs to plan a grouping before any row
is read.
Represents an aggregation operation (γ) in relational algebra.
Allen's interval algebra relations used in
IntervalJoinNode.Specifies the continuous LP (linear-programming) allocation mode for the
OPTIMIZE ALLOCATE operator.Logical conjunction (∧) — true when both
left and right are
true.A tuple paired with its provenance annotation — the side-channel carrier of the
K-relation model.
A K-relation: a relation in which every distinct tuple carries an annotation
drawn from a
Semiring (after Green, Karvounarakis & Tannen,
PODS 2007).Represents an anti-join operation (▷).
API-key authentication: the connector sends a named key either as a request
header or as a URL query parameter.
Where an
ApiKeyAuth key is placed in the request.One argument of a
LazyScalarFunction call, not yet evaluated.Binary arithmetic operators used in
BinaryArithmeticExpression.How many arguments a function accepts — an inclusive range, with
Arity.UNBOUNDED standing for "no upper limit".Constructs a nested array value in a projection —
[ expr, expr, … ].A nested array type — an ordered collection of elements of a single
element type (which may itself be nested).A runtime array value — an ordered list of
Value elements.One downloadable JAR — a URL and its expected SHA-256 (lower-case hex) — shared by
the connector-plugin catalog (
ConnectorCatalog) and the JDBC driver catalog
a connector provider keeps (DriverCatalog, in relix-connectors-std).AS-OF join (
ASOF) — a temporal "pick the nearest right row by time"
join.Sealed interface for the right-hand side of an assignment statement.
An assignment statement — gives a name to a relational algebra expression or
an inline table.
The AST authoring surface — one factory per node kind, for tests and embedders that
build a tree directly rather than parsing one.
A column reference operand, optionally relation-qualified.
Sealed root for an HTTP source's authentication shorthand.
A base tuple as a
Semiring can read it — the engine's row reduced to the two
things an annotation can be built from: which tuple this is, and what it
weighs.HTTP basic authentication: the connector sends
Authorization: Basic <base64(username:password)>.Bearer-token authentication: the connector sends
Authorization: Bearer <token>.A binary arithmetic expression (
left op right) used in projections
and predicates.A two-argument function's promise about which pairs of values a comparison of its
result could accept, in a form a join can index.
How a call's result is compared with its threshold, read with the call on the
left:
F(a, b) >= t is Blocking.Bound.AT_LEAST.A boolean literal operand (
true or false).The boolean semiring
(𝔹, ∨, ∧, false, true) — plain set semantics
(a tuple is present or absent).A runtime boolean value.
Supplies table metadata for database connections during semantic analysis.
Table metadata captured once and replayed later, so a session composes and
costs a query with no database in reach.
One observation of one table.
Where one entry's knowledge came from.
Transitive closure (least fixpoint) of a binary relation — the recursive
"reachability" operator.
Connected-components labelling of an undirected graph — the entity-resolution /
network-island operator.
A string compared under a named collation:
s COLLATE NOCASE.Sealed interface describing how a column maps to the underlying transport.
A single column in a relation schema — its name,
Type, and optional
source-relation ColumnProvenance.Indicates whether a column spec describes an input parameter or an output value.
The source-relation origin of a schema
ColumnDefinition — which
relation a column came from, and under what name, so that a
relation-qualified reference (rooms.name) can be resolved
precisely even after a join has renamed the physical column to disambiguate a
collision.One entry of a
references: block on a database or connection-table
source — a foreign-key style arrow from columns of the declaring
source to columns of another relation:Describes one column in a source declaration's schema.
Per-column statistics used by the cost model to refine cardinality estimates.
A comment as it was written in a script, and where.
Binary comparison operators used in
ComparisonPredicate.A binary comparison predicate (
left op right).Relational composition (∘) — composes two relations on their shared columns,
like function composition.
The uniform shape shared by every condition-carrying binary join:
(left, right, condition, location).A boolean-valued operand: a
Predicate used in operand position.A top-level
connection NAME from <type> { … } declaration.Configuration for a source bound to a table within a named
connection, e.g.A catalog of downloadable connector plugins — the SPI-side analogue of the JDBC
DriverCatalog.A connector plugin: the type token it provides and the artifacts to download.
The raw, type-agnostic configuration for one connector-backed relation —
the key/value pairs from a
connection or source declaration,
already environment-substituted.Provisions a connector plugin on demand: when a connection names a
connectorType for which no RelixConnector is registered, this
looks the plugin up in the ConnectorCatalog, downloads its artifacts
(the connector JAR + its driver/runtime JARs, each checksum-verified) into the
connector directory, and reports the outcome — the caller then rebuilds its
ConnectorRegistry to pick up the new plugin.The result of a provisioning attempt (the caller checks the registry for "already present").
A provisioning outcome plus a human-readable explanation.
Consolidation functions for the
DownsampleNode time-series aggregation operator.The counting semiring
(ℕ, +, ×, 0, 1) — bag semantics (row
multiplicity) and, over a weighted closure, path counting.Covering-reduction node —
COVER [EXACT] t (R).Extracts tabular data from a CSV response body.
Configuration for a local CSV file source.
An inline table in comma-delimited CSV format.
Configuration for a named database connection — the JDBC coordinates
shared by every table referenced through it.
A relation symbol backed by an external data store — typically a database table
or view.
Configuration for a database-backed source (JDBC table or view).
A typed calendar-date literal operand, written
DATE '2026-06-15'.A runtime calendar-date value with no time zone, backed by
LocalDate (e.g.A
def … : relation statement — defines a table-valued (relation-returning)
user-defined function.A
def statement — defines a scalar user-defined function.One thing wrong with a query, as data rather than as an exception.
Set difference (−) — returns tuples that appear in
left but not in
right.Distinct (δ) — eliminates duplicate tuples from
input.Relational division (÷) — returns tuples from
left that are associated
with every tuple in right (the relational analogue of "for all").Time-series downsampling (DOWNSAMPLE) — groups input rows into fixed-width time
buckets and consolidates numeric columns within each bucket using the chosen
ConsolidationFunction.A catalog of downloadable JDBC drivers — the manifest that lets relix fetch a
driver it does not have locally, complementing the external driver directory.
A driver: a JDBC scheme prefix it satisfies and the artifacts to download.
Provisions a JDBC driver on demand: when a connection references a database for
which no driver is registered, this looks the driver up in the
DriverCatalog, downloads it (with checksum verification) into the driver
directory, and registers it — so a database relix has never seen before just
works.The result of a provisioning attempt.
A provisioning outcome plus a human-readable explanation.
A typed duration literal operand, written
DURATION 'PT30M', or with
calendar months DURATION 'P1M' or INTERVAL '1 month'.How a
Relationship entered the schema graph.Represents element-of predicates: element ∈ set_expression or element ∉ set_expression
Used for set membership testing (equivalent to SQL IN/NOT IN).
The relation with no rows and the heading of another expression — the
∅ that a provably-unsatisfiable query collapses to.One side of a
Relationship: a relation plus the ordered columns
joined at this side, carrying numeric multiplicity bounds.One endpoint of a
RelateStatement — a relation reference plus the
ordered columns joined at this side, with optional multiplicity bounds.An
env statement — declares the environment file and active profile
used for credential and configuration variable resolution.Thrown when a query cannot be evaluated at run time.
The numbers an observed decision can carry — what a
QueryEvent's text cannot say.EXISTS (relation): true when the relation has a row, false when it has none, and
never UNKNOWN.The readable spelling of
AstBuilders — comparisons by name, n-ary
connectives, and literals built from Java values rather than
from their source spelling.A query target that holds an inline relational algebra expression.
Binds an
OUT column to a JSONPath expression within the response body.Sealed interface describing how to extract tabular data from an HTTP response.
Fetches the bytes at a URI — the network seam for
DriverDownloader.General monotone recursion — the least-fixpoint binder
FIX.Full outer join (⟗) — returns all tuples from both
left and
right; unmatched tuples on either side are padded with nulls.Represents a function call in an expression.
Every function available to a run, indexed by name.
The ambient state a function implementation may read while it runs.
A collection of functions offered to the engine — the unit that is installed,
discovered and versioned.
Optimizer hint flags that may be attached to a function symbol.
The form of a scalar function — everything the engine reasons about
before anything is evaluated.
Sealed sub-interface of
Symbol for all function-typed symbols.Configuration for a generator source — a leaf relation whose rows are
produced by engine code rather than read from a file or database.
A single grouping key of an aggregation (
γ): the Operand
expression the rows are grouped by, with an optional alias for the output
column.Binds an
IN column to an HTTP request header.The production
Fetcher: an HTTPS-only download over
HttpClient.HTTP request method for an
HttpSourceConfig.What a
PhysicalNode.Scan over an HTTP source has folded into its request — a
query λ bound to the source's declared paginate limit, and σ
equalities bound to the source's IN columns (a query parameter or a path
segment).Configuration for an HTTP/REST API source.
Classifies the kind of symbol being imported in an
ImportStatement.An
import statement — brings symbols from another .relix
file into the current namespace.A relation whose rows are declared inline in a
.relix source file,
typically as a Markdown table.Sealed root interface for inline relation data embedded in a script.
An assignment body that holds an inline data table (Markdown or CSV format).
Rows arriving as text — a file, a pipe, a socket, standard input — for
Relix.input(String, Input) to name as a relation.How the text of an
Input is written.Set intersection (∩) — returns tuples that appear in both
left and
right.Interval join (
IJOIN) — a temporal join over two interval-valued
relations using an Allen's interval algebra relation.Replace-each-round iteration — the binder
ITERATE.When an
IterateNode stops.UNTIL c, … WITHIN ε PER k, … MAX n ROUNDS — stop when, for every key,
every named column changed by at most tolerance since the previous
round, and no key appeared or disappeared.ROUNDS n — apply the step exactly n times; ROUNDS 0
is the base unchanged.UNTIL STABLE MAX n ROUNDS — stop at the first round whose output
equals its input.What resolving the joins in an expression over a
SchemaGraph came to: the
engine's own assembly of the join from the relationships the graph records, rather
than the conditions the expression was written with.One enumerated join, distinguished by relationship name — the ambiguity is
speakable only because edges are named.
Several equally minimal paths; each
JoinResolution.Alternative is a runnable program.Multiplicity facts of a chosen path: whether the join fans
out (an endpoint admits more than one match, repeating rows) and whether an
inner join may drop rows (an endpoint's
min is zero).The graph could not improve on the model's program; it stands unchanged.
A unique path was assembled into
program with its bounds.Extracts tabular data from a JSON response body.
Transport configuration for a local JSON file source.
A lateral join: its right side is evaluated once per row of its left input, and may read
that row's columns.
What a
LateralJoinNode does with a left row for which its right side yields no
rows.A scalar function that decides which of its arguments to evaluate — a special form.
Left outer join (⟕) — returns all tuples from
left, paired with
matching tuples from right; unmatched left tuples are padded with
nulls.Represents a limit operation (λ) in relational algebra.
An inline table in pipe-delimited Markdown format.
Describes the output materialisation strategy of a relational algebra node.
A monomial in the polynomial-lineage semiring
ℕ[X] — a
product of provenance variables with positive integer
exponents (a multiset of variables).A query target that references a previously declared symbol by name.
A
Semiring together with the names it answers to and a line describing it —
one entry in the registry a relix provenance request is resolved against.Natural join (⋈) — joins two relations on all attributes with the same name,
projecting away the duplicate join columns.
Logical negation (¬) — true when
predicate is false.The NULL literal (
NULL or ⊥) written as a value: the missing value
itself, as in IIf(late, NULL, fee) or COUNT(IIf(ok, id, NULL)).Where
NULL values land when a column is used as a sort key.Represents a null predicate (IS NULL or IS NOT NULL) in relational algebra.
The absent (SQL
NULL) value, compatible with all scalar types.A numeric literal operand, stored as its original string representation.
A runtime numeric value, stored as an arbitrary-precision
BigDecimal.The optimisation direction of an
OptimizeNode: whether the objective is
to be maximised or minimised.The offset window functions carried by a
WindowFunction.OffsetWindow.Root sealed interface for scalar value expressions used in projections and
predicates.
Visitor over the
Operand sealed hierarchy.Enumeration of every transformation rule the query optimizer can apply.
A single linear constraint of an
OptimizeNode:
SUM(expr) op bound.Declarative optimisation (OPTIMIZE) — the goal-seeking sibling of
γ.A sort ordering — the sequence of (column, direction) keys by which a relation's
rows are ordered.
Logical disjunction (∨) — true when at least one of
left or
right is true.Outer-union (⊔) — a schema-reconciling merge of two relations that need
not be union-compatible.
Maps a logical pagination concept to a URL query parameter.
Declares how an HTTP source's pagination maps to URL parameters.
Represents a pairwise universal semi-join (USEMI), the ∀ dual of semi-join (⋉).
A single parameter in a function signature: a scalar, or — for a table-valued
function only — a relation.
A bound query parameter,
$name: a scalar whose value is supplied from outside
the query text when it runs.A slip the parser accepted in a script, and says what to write instead.
An element of the cheapest-route semiring
PathCostSemiring — a path's
minimum cost and the set of co-cheapest routes
that achieve it.The cheapest-route semiring
((ℝ ∪ {+∞}) × ℘(Route), ⊕, ⊗, (+∞, ∅), (0, {ε}))
— the combined cost-and-witness algebra: a single weighted
closure run carries both a path's
cheapest cost and the route(s) achieving it.Bounded variable-length path reachability — the RA-native graph-traversal
operator.
Binds an
IN column to a URL path segment.Represents a pattern-matching predicate:
operand LIKE pattern or
operand NOT LIKE pattern.A node in a physical query plan — the executable form of a logical
RelNode tree, produced by the
Planner.Aggregation (γ) — groups by
groupingKeys and reduces each group
with aggregates.AS-OF join — a temporal "pick the nearest right row by time" join.
Bernoulli sampling (SAMPLE p [SEED n]): keeps each row of
input
independently with probability probability.Which input a join materialises (hashes, or buffers for nested-loop).
Transitive closure (least fixpoint) of the
input edge relation over
PhysicalNode.Closure.fromColumn()/PhysicalNode.Closure.toColumn().Connected-components labelling (CLUSTER) of the
input edge relation,
read as undirected edges over PhysicalNode.Cluster.fromColumn()/PhysicalNode.Cluster.toColumn().Constructive covering reduction (COVER, constructive mode): builds
candidate rows value-by-value over the
PhysicalNode.ConstructiveCover.factors domains, using PhysicalNode.ConstructiveCover.conjuncts as a validity oracle,
never materialising the full Cartesian product.Covering reduction (COVER): keeps a near-minimal subset of
input rows
such that every distinct t-column value combination (PhysicalNode.Cover.strength-way tuple)
occurring in the input occurs in the output.Distinct (δ) — eliminates duplicate rows.
Time-series downsampling (DOWNSAMPLE): groups input rows into fixed-width
time buckets and consolidates numeric columns using the chosen
ConsolidationFunction.Produces no rows at all, under
schema's heading — the physical form of
EmptyRelationNode, planted by the
optimizer where a sub-tree was proved unsatisfiable.General monotone recursion (FIX): computes the semi-naïve least-fixpoint of
PhysicalNode.Fixpoint.step() seeded by PhysicalNode.Fixpoint.base(), with the relation named
PhysicalNode.Fixpoint.name() bound to the current delta during each step evaluation.Interval join — tests each pair of rows against an Allen interval
algebra relation.
Replace-each-round iteration (ITERATE): evaluates
PhysicalNode.Iterate.base(), then
evaluates PhysicalNode.Iterate.step() with the relation named PhysicalNode.Iterate.name() bound to the
previous round's whole output, replacing it each round, until PhysicalNode.Iterate.stop()
is satisfied.A join of any kind, carrying the chosen physical strategy.
How a join is executed.
Equi-join key columns:
left.get(i) and right.get(i) are the
positions, in the left and right inputs, of the i-th equated column
pair.The join flavour.
Lateral / correlated table-valued function join: for each row of
PhysicalNode.LateralJoin.left(),
evaluates the PhysicalNode.LateralJoin.arguments() in that row's context, binds them into the
function body via PhysicalNode.LateralJoin.bodyBuilder(), plans the instantiated body, and
concatenates the left row with each row the body produces.Limit (λ) — takes a prefix of the input; preserves the input's delivered ordering.
Declarative optimisation (OPTIMIZE): within each group (by
groupingKeys) either selects the optimal subset (MIP, when
allocation is empty) or assigns continuous allocations (LP, when
allocation is present).Bounded variable-length path reachability (PATH) over the
input edge
relation, read over PhysicalNode.Path.fromColumn()/PhysicalNode.Path.toColumn() as directed edges, or
as undirected ones when PhysicalNode.Path.undirected().Rows-to-columns rotation (PIVOT): groups the input by the optional
groupKeys,
then turns each distinct value of keyColumn into a new output column whose
cell is the corresponding valueColumn cell (NULL when the group has no row
for that key).Projection (π) — computes
attributes from each row, streaming.A leaf that pushes a relational sub-expression down to a connector as a
single native query.
A reference to the relation bound by an enclosing
PhysicalNode.Fixpoint or PhysicalNode.Iterate.Relation/column rename — a metadata-only relabel to
PhysicalNode.Rename.schema().Reservoir (fixed-count) sampling (SAMPLE … ROWS [SEED n]): keeps exactly
count rows of input, chosen uniformly at random without
replacement (or the whole input when it has fewer rows).Endless uniform draw with replacement (ROLL): buffers the finite face set
input and then emits an unbounded stream of independent uniform
draws from it (a die roll).Reads a base relation: inline rows, or an external source/database via the connector.
Selection (σ) — streaming row filter; preserves the input's delivered ordering.
Gap-and-island / sessionization (SESSIONIZE): within each partition (by
partitionKeys) orders rows ascending by orderColumn and
appends a 1-based session-id column (sessionColumn), incremented
whenever the gap to the prior row exceeds threshold.The set-operation flavour.
Random permutation (SHUFFLE): buffers the input and returns every row exactly
once in a uniformly random order (Fisher–Yates).
Similarity join — an inner theta join whose condition bounds a two-argument
function's result by a constant,
F(left.x, right.y) >= t, executed by
indexing one input under the keys the function's
Blocking gives and probing it with the
other, rather than calling F on every pair.Goal-seek (SOLVE): for each row of
input, fills the NULL columns
participating in equations — one equation by inverting its arithmetic,
several linear ones by elimination, anything else by Newton's method.Sort (τ) — establishes ordering on its sort keys.
Marks a sub-plan whose rows are computed once and read by more than one
consumer.
Top-k per group: within each partition (by
groupingAttributes) keeps
the count rows highest by sortSpecs, after skipping
offset, and with withTies every further row tied with the last of
them on all the sort keys.Optimal-path extraction (TRACE) over the
input weighted edge relation, read
as directed edges or, when PhysicalNode.Trace.undirected(), as undirected ones.Adjacency-to-forest nesting (TREE): folds the adjacency relation
input (with node key keyColumn and parent key
parentColumn) into a forest of nested documents — one output row per
root, each carrying its subtree in the appended childrenColumn array
(siblings ordered by orderSpecs, empty = input order).Group-wise universal quantification (∀): keeps the grouping-key tuple of
each group in which every row of
input satisfies predicate
(strict NULL semantics — an UNKNOWN row disqualifies its group).Unnest (μ) — explodes the array-valued
column into one row per
element; outer keeps a NULL-bound row when the array is empty/missing.Column-to-rows rotation (UNPIVOT): folds the listed columns into rows — each
input row fans out to one output row per listed column, with the column name
placed in
nameColumn (STRING) and the cell value in valueColumn
(ANY).Lineage reification (WHY): emits every result tuple of its input
unchanged plus the reserved
provenance:ANY column holding that tuple's
lineage polynomial as a nested document.Window (ROLLING / WINDOW): adds one computed column (
outputColumn) to
every input row, partitioned by partitionKeys and ordered within each
partition by sortSpecs.Row-pivoting operator (PIVOT) — spreads distinct values of a key column into
new columns.
The estimated row count the planner computed for each node of a physical plan —
the numbers behind
Planner.buildSide and the merge-versus-hash choice,
kept so :explain can show them.A physical plan together with the row estimates the planner computed for it.
A provenance polynomial — an element of the lineage semiring
ℕ[X].The provenance-polynomial semiring
ℕ[X] — full why-provenance
(which input tuples produced a result, and how they were combined), after Green,
Karvounarakis & Tannen (PODS 2007).Root sealed interface for boolean filter conditions.
Visitor over the
Predicate sealed hierarchy.A production stop folded into a monotone generator leaf by the optimizer's
SelectionIntoGeneratorPass (GEN-001).Cartesian product (×) — returns every combination of a tuple from
left
with a tuple from right.Represents a projected attribute in a projection operation.
Projection (π) — selects a subset of attributes from
input,
optionally computing new expressions or renaming columns.Records whether a symbol was provided by the runtime or declared by a user.
A provenance variable — the token identifying one base-tuple occurrence in the
polynomial-lineage semiring
ℕ[X] (after Green,
Karvounarakis & Tannen, PODS 2007).How a function call is written in a backend that could evaluate it itself.
The backend a call is being rendered for, named in a way the SPI can carry without
knowing anything about query planning.
A comparison with every value of a one-column relation:
x > ALL (π v (S)),
x = ANY (π v (S)).Which comparisons a
QuantifiedPredicate needs to hold: x > ANY (…) holds
when some row's comparison does, x > ALL (…) when every row's does.An assignment body that holds a parsed relational algebra expression.
One observed decision in the query pipeline — a rule that fired in the
optimizer, or a physical choice the planner made.
Which part of the pipeline an event came from.
Receives
QueryEvents as the optimizer and planner make decisions.Thrown when a query started and did not finish.
Binds an
IN column to a URL query parameter.A named relational algebra expression — essentially a stored view.
A
query statement — produces output from a named symbol or an
inline relational algebra expression.Sealed interface for the argument of a
query statement.The ranking window functions carried by a
WindowFunction.RankingWindow.An occurrence of a
FIX-bound recursive relation name inside the body of
its enclosing FixpointNode.The outcome of a
SymbolTable.register(com.darkcollective.relix.symbol.Symbol)
call.A standalone schema relationship declaration:
A relation — an expression together with the analysis it resolves against.
A reference to a table-valued (relation-returning) user-defined function, used
wherever a relation is expected — a leaf node in the relational algebra tree.
A table-valued function symbol — a relation-returning user-defined function.
Fluent builder for
RelationFunctionSymbol.A base relation (table) reference — a leaf node in the relational algebra tree.
A named relationship edge of the
SchemaGraph.Optimizer-facing statistics about a relation — cardinality and structural
metadata gathered from a data source (e.g.
Sealed sub-interface of
Symbol for all relation-typed symbols.A Relix session — the environment relations resolve against, and the entry point to
the embedding API.
Assembles a
Relix session.The plug-in boundary for an external data source — the open seam that replaces
the closed CSV/JSON/JDBC dispatch.
Thrown when text will not parse, or a relation will not analyse against its session.
Root sealed interface for all relational algebra operation nodes.
Visitor over the
RelNode sealed hierarchy.Rename (ρ) — renames a relation and optionally reassigns its attribute names.
A single
old → new column rename within the pair form.Reservoir (fixed-count) sampling (SAMPLE … ROWS) — keeps exactly
count
rows of input, chosen uniformly at random without replacement.Right outer join (⟖) — returns all tuples from
right, paired with
matching tuples from left; unmatched right tuples are padded with
nulls.Endless uniform draw with replacement (ROLL) — a die roll.
One derivation (path) carried by the cheapest-route semiring
PathCostSemiring — the set of edge tokens traversed.The result of one run — the rows, their heading, and what the engine did to produce
them.
Bernoulli sampling (SAMPLE) — independently keeps each row of
input
with probability probability (a fraction in [0, 1]).What a session lets its users reach, and how much work one query may do.
Assembles a closed sandbox.
A closed
Sandbox refused what a session was given: an external declaration
the sandbox does not permit, or text longer than its input limit.One scalar function a library supplies: its form plus
the processing behind it.
A scalar function symbol — a function that accepts zero or more scalar arguments
and returns a single scalar value.
Fluent builder for
ScalarFunctionSymbol.A relation used as a value:
(γ COUNT(*) → n (σ customer_id = Customers.customer_id (Orders))).The scalar-value type lattice used for column types, function parameter types,
and function return types.
The structural description of a relation — an ordered list of named, typed columns.
The schema graph: an immutable set of
Relationship edges between
relations.The root AST node for a parsed
.relix script file.The
Script authoring surface — the statement-level half of the AST contract,
for tests and embedders that assemble a whole script without the .relix grammar.The comments a parsed script carried, each placed by the code it was written next to,
so that
ScriptPrinter can put it back there.The comments placed by one statement, and whether a blank line came before it.
Strategy for resolving a path to a
Script — the engine's pluggable
"where does a Script come from" seam.Thrown when a frontend cannot turn its input into a
Script.The security / access-control lattice semiring over
SecurityLevel
(min, max) — propagates a confidentiality (clearance) level through a
query so each output tuple carries the level at which it may be released.A confidentiality / clearance level, ordered from least to most restrictive —
the carrier of the
SecurityLattice semiring.Selection (σ) — filters the tuples of
input to those satisfying
predicate.A single diagnostic produced during semantic analysis of a
.relix script.The validated in-memory representation produced by a successful (or
partially-successful) semantic analysis run.
Represents a semi-join operation (⋉).
A commutative semiring
(K, ⊕, ⊗, 0, 1) — the pluggable extension point
of the provenance / K-relation framework.Which semirings are installed — the bundled six plus every one a discovered
SemiringLibrary offers, resolved by name.A provider of semirings — the extension point through which an
annotation algebra the engine has never heard of becomes something a query can ask for
by name.
Resolves a
Semiring by name — the lookup the surfacing layer uses to turn a
relix provenance --semiring=<name> request into a concrete semiring without the caller
hard-wiring the singletons.Gap-and-island / sessionization operator — groups an ordered stream
into sessions separated by an idle gap, the famous SQL
LAG/running-sum incantation expressed as a single algebraic operator.Represents a set literal like {1, 2, 3} or {"active", "pending"}
Used in element-of predicates for set membership testing.
Severity level of a
SemanticError.Governs what happens when a new symbol is registered under a name that is
already occupied in the same namespace.
Random permutation (SHUFFLE) — returns every row of
input exactly once,
in a uniformly random order.One equation of a
SolveNode: left = right.Goal-seek (SOLVE) — fills the unknown columns of a row by solving one or more
declared arithmetic equations
left = right.Where a
SolveNode's iterative search starts for one unknown:
START column = value.Sort direction used in a
SortSpecification.Represents a sort operation (τ) in relational algebra.
A single sort key: the
Operand expression to order by, the direction
(SortDirection.ASC / SortDirection.DESC), and where its
NULLs go.Sealed root interface for the transport configuration of a source declaration.
A
source declaration — names a virtual relation backed by an
external data source.The source location of an AST node — file path, 1-based line, and 1-based
column of the first character of the construct.
A structured, machine-readable identity for one base-tuple occurrence — the
data a
ProvenanceVariable carries so a consuming tool can pinpoint
which row of which relation a lineage variable stands for.A relation symbol backed by an external data source whose transport details
(HTTP, CSV file, etc.) are held outside the symbol table.
Which of an operator's two spellings printed text uses.
Sealed root interface for every top-level declaration in a
.relix script.A scalar function whose arguments are all evaluated before it is called — the
ordinary kind.
A string literal operand.
A runtime string value.
Constructs a nested struct value in a projection —
{ name: expr, … }.A single struct field: a name paired with its value expression.
A nested struct type — an ordered set of named, typed
StructType.Fields.A single named, typed field of a
StructType.A runtime struct (nested object) value — an ordered map of field name to
Value.Root sealed interface for every named entity registered in a
SymbolTable.A non-fatal diagnostic produced during symbol registration.
Classification of symbol registration errors.
A mutable, namespace-scoped registry of
Symbol instances.Symmetric difference (∆) — returns tuples that appear in exactly one of
left or right, but not in both, eliminating duplicates.A read-only system catalog relation in the reserved
relix.* namespace.Theta join (⨝) — inner join that keeps only tuples satisfying
condition.Tie-break rule for AS-OF join (
ASOF) when multiple right rows
share the nearest match value.A typed wall-clock time-of-day literal operand, written
TIME '13:40:00'.A typed timestamp literal operand, written
TIMESTAMP '2026-06-15T13:40:00Z'.A runtime timestamp value — an absolute point on the timeline, UTC-normalised,
backed by
Instant (e.g.A runtime wall-clock time-of-day value with no time zone, backed by
LocalTime (e.g.A run of
.relix text and what kind of token it is, as Relix.tokens(java.lang.String)
reports it.What a
Token is, in the handful of categories a syntax highlighter colours.Top-k per group (TOP) — partitions
input by groupingAttributes
and, within each group, keeps the first count rows in sortSpecs
order (after skipping offset rows).Physical algorithm choice for a
PhysicalNode.Trace optimal-path operator.Optimal-path extraction over a directed, weighted graph — the cheapest (or longest)
path finder.
An immutable record of a single optimization transformation applied during
query planning.
Adjacency-to-forest nesting operator — folds a
self-referential adjacency relation into a forest of nested
documents, one output row per root, each carrying its whole subtree as a
nested
ANY document.The tropical (min-plus) semiring
(ℝ ∪ {+∞}, min, +, +∞, 0) — the
cheapest-derivation algebra, i.e.A nullary truth relation literal — a leaf node denoting one of the two
relations whose heading is the empty (closed, zero-column) schema.
One row of a result, read as Java types.
The type of a value in relix — a scalar, a nested struct, or an array.
Represents a unary operation applied to an operand.
Thrown when a terminal that must collect every row is asked for one that never ends.
Multiset union (⊎) — returns all tuples from both
left and
right, preserving duplicates (equivalent to SQL UNION ALL).Set union (∪) — returns tuples that appear in
left, right,
or both, eliminating duplicates.Group-wise universal quantification (∀) — partitions
input by the
groupingAttributes and keeps the grouping-key tuple of each group in
which every row satisfies predicate.Unnest (μ) — explodes an array-valued column into one row per element,
carrying the other columns through (≈ SQL
LATERAL UNNEST, Mongo
$unwind).Column-folding operator (UNPIVOT) — transforms selected columns into rows.
A join on named shared columns — SQL's
JOIN … USING (a, b) — in its inner,
left, right and full forms.Which unmatched rows the join keeps, as SQL's
[INNER | LEFT | RIGHT | FULL] JOIN.A runtime scalar value produced or consumed during query execution.
Why (ω) — reifies the lineage provenance of
input as queryable data.The scope of rows fed to a
WindowFunction within a partition.SQL's frame clause,
ROWS | RANGE BETWEEN start AND end.One end of a
WindowFrame.Between frame.The kinds of bound, from the partition's start to its end.
A trailing
n-row sliding window — OVER n ROWS — equivalent to
SQL's ROWS BETWEEN n-1 PRECEDING AND CURRENT ROW.The cumulative (running) frame —
OVER ALL ROWS — equivalent to SQL's
ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW.The full-partition frame — equivalent to SQL's
ROWS BETWEEN UNBOUNDED
PRECEDING AND UNBOUNDED FOLLOWING.What a
WindowFrame.Between frame's offsets count.The computation a
WindowNode performs per row.A sliding / cumulative aggregate over an
Operand argument — the same
AggregateOperator + Operand pair used by γ.An offset function (slice 4).
A ranking function (slice 3).
Window operator — a non-collapsing per-partition computation that
adds one column to every input row without removing or merging any.
A runtime
TIMESTAMPTZ value: a point on the timeline with the UTC offset it was
recorded at, backed by OffsetDateTime (e.g.