@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Algebra-uGsIEOUA.d.mts

@@ -0,0 +1,446 @@
+import { O as Triple, d as NamedNode, j as Variable, l as Literal, t as BlankNode } from "./Term-B_4ezyXq.mjs";
+import { A as Operator, N as Path$1, Q as TermPattern, d as DatasetClause, et as TriplePattern, n as AggregateName, w as GroupPattern } from "./Ast-vcw2W-lf.mjs";
+import { t as Bindings } from "./Bindings-DiKpBd7f.mjs";
+declare namespace Algebra_d_exports {
+  export { Aggregate, Bgp, Distinct, ExistsExpression, Expression, Extend, Filter, FunctionCallExpression, Graph, Group, GroupKey, Join, LeftJoin, Minus, Operation, OperationExpression, OrderBy, OrderCondition, Path, Project, Query, Reduced, Service, Slice, Union, Values, bgp, certainVariables, containsExists, expressionVariables, extend, filter, format, formatExpression, internalVariable, isInternalVariable, join, leftJoin, mapChildren, mapExpressionPatterns, minus, prebind, project, transform, union, unit, variables };
+}
+/**
+ * An algebra expression: like `Ast.Expression`, but `EXISTS` patterns are
+ * translated to algebra and aggregates have been replaced by variables.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Expression = Variable | NamedNode | Literal | BlankNode | Triple<any, any, any> | OperationExpression | FunctionCallExpression | ExistsExpression;
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface OperationExpression {
+  readonly _tag: 'Operation';
+  readonly operator: Operator;
+  readonly args: ReadonlyArray<Expression>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface FunctionCallExpression {
+  readonly _tag: 'FunctionCall';
+  readonly function: NamedNode;
+  readonly args: ReadonlyArray<Expression>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface ExistsExpression {
+  readonly _tag: 'Exists';
+  readonly negated: boolean;
+  readonly input: Operation;
+}
+/**
+ * An aggregate computed by a `Group` operator.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Aggregate {
+  readonly name: AggregateName;
+  readonly distinct: boolean;
+  readonly expression: Expression | '*';
+  readonly separator?: string | undefined;
+}
+/**
+ * An algebra operator.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Operation = Bgp | Path | Join | LeftJoin | Filter | Union | Graph | Extend | Minus | Group | OrderBy | Project | Distinct | Reduced | Slice | Values | Service;
+/**
+ * A basic graph pattern. The empty BGP is the join identity (one empty
+ * solution).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Bgp {
+  readonly _tag: 'Bgp';
+  readonly patterns: ReadonlyArray<TriplePattern>;
+}
+/**
+ * A property path pattern that could not be expanded to triple patterns.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Path {
+  readonly _tag: 'Path';
+  readonly subject: TermPattern;
+  readonly path: Path$1;
+  readonly object: TermPattern;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Join {
+  readonly _tag: 'Join';
+  readonly left: Operation;
+  readonly right: Operation;
+}
+/**
+ * `OPTIONAL`, with the filter of the optional group as `expression`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface LeftJoin {
+  readonly _tag: 'LeftJoin';
+  readonly left: Operation;
+  readonly right: Operation;
+  readonly expression?: Expression | undefined;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Filter {
+  readonly _tag: 'Filter';
+  readonly expression: Expression;
+  readonly input: Operation;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Union {
+  readonly _tag: 'Union';
+  readonly left: Operation;
+  readonly right: Operation;
+}
+/**
+ * Evaluates `input` against a named graph (`GRAPH`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Graph {
+  readonly _tag: 'Graph';
+  readonly name: NamedNode | Variable;
+  readonly input: Operation;
+}
+/**
+ * Binds `variable` to the value of `expression` (`BIND` and select
+ * expressions).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Extend {
+  readonly _tag: 'Extend';
+  readonly input: Operation;
+  readonly variable: Variable;
+  readonly expression: Expression;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Minus {
+  readonly _tag: 'Minus';
+  readonly left: Operation;
+  readonly right: Operation;
+}
+/**
+ * A group key: the grouping expression and the variable it is bound to.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface GroupKey {
+  readonly expression: Expression;
+  readonly variable: Variable;
+}
+/**
+ * Grouping and aggregation (`Group` + `AggregateJoin`). Each output solution
+ * binds the key variables and the aggregate variables of one group. With no
+ * keys, all solutions form one group (which exists even if there are no
+ * solutions).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Group {
+  readonly _tag: 'Group';
+  readonly input: Operation;
+  readonly keys: ReadonlyArray<GroupKey>;
+  readonly aggregates: ReadonlyArray<{
+    readonly variable: Variable;
+    readonly aggregate: Aggregate;
+  }>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface OrderCondition {
+  readonly expression: Expression;
+  readonly descending: boolean;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface OrderBy {
+  readonly _tag: 'OrderBy';
+  readonly input: Operation;
+  readonly conditions: ReadonlyArray<OrderCondition>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Project {
+  readonly _tag: 'Project';
+  readonly input: Operation;
+  readonly variables: ReadonlyArray<Variable>;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Distinct {
+  readonly _tag: 'Distinct';
+  readonly input: Operation;
+}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Reduced {
+  readonly _tag: 'Reduced';
+  readonly input: Operation;
+}
+/**
+ * `OFFSET` / `LIMIT`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Slice {
+  readonly _tag: 'Slice';
+  readonly input: Operation;
+  readonly offset: number;
+  readonly limit?: number | undefined;
+}
+/**
+ * Inline data (`VALUES`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Values {
+  readonly _tag: 'Values';
+  readonly variables: ReadonlyArray<Variable>;
+  readonly bindings: ReadonlyArray<Bindings>;
+}
+/**
+ * A federated `SERVICE` pattern. `pattern` keeps the original syntax so that
+ * the pattern can be sent to the remote endpoint.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Service {
+  readonly _tag: 'Service';
+  readonly name: NamedNode | Variable;
+  readonly silent: boolean;
+  readonly input: Operation;
+  readonly pattern: GroupPattern;
+  readonly prefixes: Readonly<Record<string, string>>;
+}
+/**
+ * A translated query: the algebra of the WHERE clause plus solution
+ * modifiers, the query form and the dataset clause.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type Query = {
+  readonly _tag: 'Select';
+  readonly input: Operation;
+  readonly variables: ReadonlyArray<Variable>;
+  readonly dataset?: DatasetClause | undefined;
+} | {
+  readonly _tag: 'Construct';
+  readonly input: Operation;
+  readonly template: ReadonlyArray<TriplePattern>;
+  readonly dataset?: DatasetClause | undefined;
+} | {
+  readonly _tag: 'Ask';
+  readonly input: Operation;
+  readonly dataset?: DatasetClause | undefined;
+} | {
+  readonly _tag: 'Describe';
+  readonly input: Operation;
+  readonly terms: ReadonlyArray<NamedNode | Variable>;
+  readonly dataset?: DatasetClause | undefined;
+};
+/**
+ * The empty BGP: the join identity.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const unit: Bgp;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const bgp: (patterns: ReadonlyArray<TriplePattern>) => Bgp;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const join: (left: Operation, right: Operation) => Join;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const leftJoin: (left: Operation, right: Operation, expression?: Expression) => LeftJoin;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const filter: (expression: Expression, input: Operation) => Filter;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const union: (left: Operation, right: Operation) => Union;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const minus: (left: Operation, right: Operation) => Minus;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const extend: (input: Operation, variable: Variable, expression: Expression) => Extend;
+/**
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const project: (input: Operation, variables: ReadonlyArray<Variable>) => Project;
+/**
+ * Whether a variable name is internal (introduced by translation for blank
+ * nodes, property path sequences, group keys and aggregates).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const isInternalVariable: (name: string) => boolean;
+/**
+ * The variables that may be bound by solutions of an operator ("in-scope"
+ * variables, including internal ones).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const variables: (op: Operation) => ReadonlySet<string>;
+/**
+ * The variables that are bound in every solution of an operator (as far as
+ * can be determined statically).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const certainVariables: (op: Operation) => ReadonlySet<string>;
+/**
+ * The variables mentioned by an expression (not looking into `EXISTS`).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const expressionVariables: (expression: Expression) => ReadonlySet<string>;
+/**
+ * Whether an expression contains `EXISTS` / `NOT EXISTS`.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const containsExists: (expression: Expression) => boolean;
+/**
+ * Rewrites an operator tree bottom-up: `f` is applied to every node after
+ * its children have been rewritten.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const transform: (op: Operation, f: (op: Operation) => Operation) => Operation;
+/**
+ * Applies `f` to the direct children of an operator.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const mapChildren: (op: Operation, f: (op: Operation) => Operation) => Operation;
+/**
+ * Formats an expression as an S-expression (for debugging and logging).
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const formatExpression: (e: Expression) => string;
+/**
+ * Formats an operator tree as an S-expression in the style of the SPARQL
+ * Algebra notation (for debugging and logging).
+ *
+ * @since 0.1.0
+ * @category formatting
+ */
+declare const format: (op: Operation, indent?: string) => string;
+/**
+ * Creates an internal variable.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+declare const internalVariable: (name: string) => Variable;
+/**
+ * Applies `f` to every graph pattern nested in an expression (the patterns
+ * of `EXISTS` / `NOT EXISTS`).
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const mapExpressionPatterns: (expression: Expression, f: (op: Operation) => Operation) => Expression;
+/**
+ * Pre-binds variables in an algebra expression, following the "values
+ * insertion" definition of SHACL-SPARQL (Appendix "Pre-binding of
+ * Variables", aligned with the SPARQL `EXISTS` errata): every basic graph
+ * pattern, property path and `GRAPH ?var` pattern `Y` — including those
+ * nested in `EXISTS` — is replaced by `Join(Table(μ), Y)`, where `Table(μ)`
+ * is a one-row `VALUES` table holding the pre-bound solution `μ`.
+ *
+ * The pre-bound values are also substituted into the replaced patterns,
+ * which does not change the result (the join restores the bindings) but lets
+ * the optimizer and the store use them as constants.
+ *
+ * Unlike a trailing `VALUES` clause, pre-bound values are visible to every
+ * `FILTER` and `BIND`, including those of groups that never match the
+ * variable: `SELECT $this WHERE { FILTER ($this = ex:a) }` has one solution
+ * when `this` is pre-bound to `ex:a`. Queries using `MINUS`, `VALUES` or
+ * `SERVICE`, rebinding a pre-bound variable with `AS`, or with sub-queries
+ * that do not project the pre-bound variables, have no well-defined meaning
+ * under pre-binding.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+declare const prebind: (op: Operation, bindings: Bindings) => Operation;
+export { containsExists as A, mapChildren as B, Reduced as C, Values as D, Union as E, formatExpression as F, transform as G, minus as H, internalVariable as I, variables as J, union as K, isInternalVariable as L, extend as M, filter as N, bgp as O, format as P, join as R, Query as S, Slice as T, prebind as U, mapExpressionPatterns as V, project as W, OperationExpression as _, ExistsExpression as a, Path as b, Filter as c, Group as d, GroupKey as f, Operation as g, Minus as h, Distinct as i, expressionVariables as j, certainVariables as k, FunctionCallExpression as l, LeftJoin as m, Algebra_d_exports as n, Expression as o, Join as p, unit as q, Bgp as r, Extend as s, Aggregate as t, Graph as u, OrderBy as v, Service as w, Project as x, OrderCondition as y, leftJoin as z };
+//# sourceMappingURL=Algebra-uGsIEOUA.d.mts.map