@leuduan/block 0.0.0-stage → 2.0.0

package/dist/pipe.d.ts

@@ -0,0 +1,39 @@
+import { type LineOrStr } from './line.js';
+import { Pipe, TableExpression, type QueryExpression, type MapOrRecord } from './sql.js';
+export declare function aggregate(aggregates: readonly LineOrStr[], groupBy?: readonly LineOrStr[]): Pipe;
+export declare function as(alias: string): Pipe;
+export declare function comment(text: string): Pipe;
+/** COUNT(*) AS count aggregate pipe. */
+export declare function count(): Pipe;
+export declare function distinct(): Pipe;
+export declare function drop(columns: readonly string[]): Pipe;
+export declare function extend(exprs: readonly LineOrStr[], windows?: MapOrRecord<LineOrStr>): Pipe;
+/** `on` and `using` are the whole clause, keyword included; a join takes at most one of them. */
+export type JoinOptions = {
+    alias?: string;
+} & ({
+    on?: LineOrStr;
+    using?: never;
+} | {
+    using?: LineOrStr;
+    on?: never;
+});
+export declare function join(joinOp: LineOrStr, fromItem: TableExpression, options?: JoinOptions): Pipe;
+export declare function limit(lim: number, offset?: number): Pipe;
+export declare function orderBy(orders: readonly LineOrStr[]): Pipe;
+export declare function raw(content: LineOrStr): Pipe;
+export declare function rename(renames: MapOrRecord<string>): Pipe;
+export declare function select(expressions: readonly LineOrStr[], windows?: MapOrRecord<LineOrStr>): Pipe;
+export declare function set(exprs: readonly LineOrStr[]): Pipe;
+export declare function union({ unionType, queries, }: {
+    unionType?: string;
+    queries: readonly QueryExpression[];
+}): Pipe;
+export declare function where(condition: LineOrStr | LineOrStr[]): Pipe;
+export declare function with_(ctes: MapOrRecord<QueryExpression>): Pipe;
+/** |> [CROSS|LEFT] JOIN UNNEST(expr) [AS alias] */
+export declare function unnest(expr: TableExpression | LineOrStr, { alias, left }?: {
+    alias?: string;
+    left?: boolean;
+}): Pipe;
+//# sourceMappingURL=pipe.d.ts.map

package/dist/pipe.js

@@ -0,0 +1,106 @@
+// Port of py/dbox/dbox/block/pipe.py
+// GoogleSQL pipe steps: each factory builds its line directly.
+import * as l from './line.js';
+import {} from './line.js';
+import { and, call as eCall, star as eStar } from './expr.js';
+import * as h from './helpers.js';
+import { Pipe, TableExpression, mapEntries } from './sql.js';
+/** Mirrors Python textwrap.indent: prefix non-whitespace-only lines. */
+function textwrapIndent(text, prefix) {
+    return text
+        .split('\n')
+        .map((line) => (/\S/.test(line) ? prefix + line : line))
+        .join('\n');
+}
+function listWithWindows(keyword, expressions, windows) {
+    const hasWindows = mapEntries(windows).length > 0;
+    return new Pipe(l.indentNext([
+        l.lit(keyword),
+        l.stackComma(expressions.map((e) => l.ensure(e))),
+        hasWindows ? h.windows(windows) : null,
+    ]));
+}
+export function aggregate(aggregates, groupBy = []) {
+    const groupingExpr = groupBy.length > 0 ? l.stackComma(groupBy.map((g) => l.ensure(g))) : null;
+    return new Pipe(l.stack([
+        l.indentNext([l.lit('|> AGGREGATE'), l.stackComma(aggregates.map((a) => l.ensure(a)))]),
+        groupingExpr ? l.indentNext([l.lit('GROUP BY'), groupingExpr]) : null,
+    ]));
+}
+export function as(alias) {
+    return new Pipe(l.indentNext([l.keyword('|> AS'), l.lit(alias)]));
+}
+export function comment(text) {
+    return raw(textwrapIndent(text, '-- '));
+}
+/** COUNT(*) AS count aggregate pipe. */
+export function count() {
+    return aggregate([h.expression(eCall('COUNT', [eStar()]), 'count')]);
+}
+export function distinct() {
+    return new Pipe(l.keyword('|> DISTINCT'));
+}
+export function drop(columns) {
+    return new Pipe(l.indentNext([l.lit('|> DROP'), l.stackComma(columns.map((c) => l.lit(c)))]));
+}
+export function extend(exprs, windows = {}) {
+    return listWithWindows('|> EXTEND', exprs, windows);
+}
+export function join(joinOp, fromItem, options = {}) {
+    const { alias, on, using } = options;
+    if (!(fromItem instanceof TableExpression)) {
+        throw new Error('p.join: fromItem must be a TableExpression');
+    }
+    if (on !== undefined && using !== undefined) {
+        throw new Error('p.join cannot have both ON and USING clause.');
+    }
+    const joinLine = l.stack([l.lit('|>'), l.ensure(joinOp)]);
+    return new Pipe(l.indentNext([
+        l.indentNext([
+            joinLine,
+            fromItem.toLine(),
+            alias !== undefined ? l.stack([l.keyword('AS'), l.lit(alias)]) : null,
+        ]),
+        on !== undefined ? l.ensure(on) : null,
+        using !== undefined ? l.ensure(using) : null,
+    ]));
+}
+export function limit(lim, offset) {
+    const parts = [l.lit('|> LIMIT'), l.lit(String(lim))];
+    if (offset !== undefined)
+        parts.push(l.lit('OFFSET'), l.lit(String(offset)));
+    return new Pipe(l.indentNext(parts));
+}
+export function orderBy(orders) {
+    return new Pipe(l.indentNext([l.lit('|> ORDER BY'), l.stackComma(orders.map((o) => l.ensure(o)))]));
+}
+export function raw(content) {
+    return new Pipe(l.ensure(content));
+}
+export function rename(renames) {
+    const renameLines = l.stackComma(mapEntries(renames).map(([old, next]) => l.lit(`${old} AS ${next}`)));
+    return new Pipe(l.indentNext([l.lit('|> RENAME'), renameLines]));
+}
+export function select(expressions, windows = {}) {
+    return listWithWindows('|> SELECT', expressions, windows);
+}
+export function set(exprs) {
+    return new Pipe(l.indentNext([l.lit('|> SET'), l.stackComma(exprs.map((e) => l.ensure(e)))]));
+}
+export function union({ unionType = 'all', queries, }) {
+    const unionLine = l.keyword(unionType === 'all' ? '|> UNION ALL' : `|> ${unionType.toUpperCase()}`);
+    const queryLines = queries.map((query) => l.paren(query.toLine()));
+    return new Pipe(l.indentNext([unionLine, l.stackComma(queryLines)]));
+}
+export function where(condition) {
+    const cond = Array.isArray(condition) ? and(condition.map((c) => l.ensure(c))) : l.ensure(condition);
+    return new Pipe(l.indentNext([l.lit('|> WHERE'), cond]));
+}
+export function with_(ctes) {
+    return new Pipe(h.ctes(ctes, { withPipe: true }));
+}
+/** |> [CROSS|LEFT] JOIN UNNEST(expr) [AS alias] */
+export function unnest(expr, { alias, left = false } = {}) {
+    const source = expr instanceof TableExpression ? expr.toLine() : l.ensure(expr);
+    return join(l.keyword(left ? 'LEFT JOIN' : 'CROSS JOIN'), new TableExpression(h.unnest(source)), { alias });
+}

package/dist/problems.d.ts

@@ -0,0 +1,7 @@
+export interface Problem {
+    message: string;
+    /** The dataset cannot be built until this is fixed. */
+    blocks: boolean;
+}
+export declare function problemsOf(def: unknown): Problem[];
+//# sourceMappingURL=problems.d.ts.map

package/dist/problems.js

@@ -0,0 +1,128 @@
+// What a definition must declare, judged on the object `define(...)` received, so it does not trust the types. The
+// builder refuses a dataset with a blocking problem; callers report the rest as they see fit.
+import { PARAM_TYPES } from './descriptor.js';
+const PARAM_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const TABLE_NAME = /^[\p{L}\p{M}\p{N}_-]{1,1024}$/u;
+const DATE = /^\d{4}-\d{2}-\d{2}$/;
+const TIME = /^\d{2}:\d{2}:\d{2}(\.\d+)?$/;
+const DATETIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?$/;
+const TIMESTAMP = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}(:?\d{2})?)$/;
+function validValue(type, value) {
+    switch (type) {
+        case 'STRING':
+            return typeof value === 'string';
+        case 'INT64':
+            return typeof value === 'number' && Number.isSafeInteger(value);
+        case 'FLOAT64':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'BOOL':
+            return typeof value === 'boolean';
+        case 'DATE':
+            return typeof value === 'string' && DATE.test(value) && !Number.isNaN(Date.parse(value));
+        case 'TIME':
+            return typeof value === 'string' && TIME.test(value);
+        case 'DATETIME':
+            return typeof value === 'string' && DATETIME.test(value);
+        case 'TIMESTAMP':
+            return typeof value === 'string' && TIMESTAMP.test(value);
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() !== '';
+}
+function notes(field, value, out) {
+    if (value === undefined)
+        return;
+    if (!isRecord(value) || !Object.values(value).every((note) => typeof note === 'string')) {
+        out.push({ message: `\`${field}\` is a record of name → note (string)`, blocks: false });
+    }
+}
+export function problemsOf(def) {
+    if (!isRecord(def) || (def.kind !== 'table' && def.kind !== 'query')) {
+        return [{ message: "define takes an object with kind 'table' or 'query'", blocks: true }];
+    }
+    const out = [];
+    const flag = (message, blocks = false) => out.push({ message, blocks });
+    if (!nonEmpty(def.description))
+        flag('`description` is missing or empty');
+    if (!nonEmpty(def.grain))
+        flag('`grain` is missing or empty');
+    notes('columns', def.columns, out);
+    notes('relations', def.relations, out);
+    if (def.kind === 'table') {
+        for (const field of ['build', 'params', 'cases', 'role']) {
+            if (def[field] !== undefined)
+                flag(`\`${field}\` belongs to queries, not tables`, true);
+        }
+        if (def.table !== undefined && !(typeof def.table === 'string' && TABLE_NAME.test(def.table))) {
+            flag('`table` is not a valid table name', true);
+        }
+        if (def.partitionedBy !== undefined && !nonEmpty(def.partitionedBy))
+            flag('`partitionedBy` is a column name');
+        const clustered = def.clusteredBy;
+        if (clustered !== undefined && !(Array.isArray(clustered) && clustered.every(nonEmpty))) {
+            flag('`clusteredBy` is a list of column names');
+        }
+        return out;
+    }
+    for (const field of ['table', 'partitionedBy', 'clusteredBy']) {
+        if (def[field] !== undefined)
+            flag(`\`${field}\` belongs to tables, not queries`, true);
+    }
+    if (typeof def.build !== 'function')
+        flag('`build` is missing', true);
+    if (def.role !== undefined && def.role !== 'metric')
+        flag("`role` can only be 'metric'");
+    const params = def.params === undefined ? {} : def.params;
+    const declared = new Map();
+    if (!isRecord(params)) {
+        flag('`params` is a record of name → { type, default? }', true);
+    }
+    else {
+        for (const [name, spec] of Object.entries(params)) {
+            if (!PARAM_NAME.test(name))
+                flag(`parameter "${name}" is not a valid name`, true);
+            if (!isRecord(spec) || !PARAM_TYPES.includes(spec.type)) {
+                flag(`parameter "${name}" needs a type (${PARAM_TYPES.join(', ')})`, true);
+                continue;
+            }
+            const type = spec.type;
+            if (spec.default !== undefined && !validValue(type, spec.default)) {
+                flag(`the default of parameter "${name}" is not a ${type}`, true);
+            }
+            declared.set(name, { type, hasDefault: spec.default !== undefined });
+        }
+    }
+    const cases = def.cases === undefined ? {} : def.cases;
+    if (!isRecord(cases)) {
+        flag('`cases` is a record of case name → parameter values', true);
+        return out;
+    }
+    const unbound = [...declared].filter(([, spec]) => !spec.hasDefault).map(([name]) => name);
+    if (unbound.length > 0 && Object.keys(cases).length === 0) {
+        flag(`parameter ${unbound.map((name) => `"${name}"`).join(', ')} has no default and the dataset declares no cases`, true);
+    }
+    for (const [caseName, bindings] of Object.entries(cases)) {
+        if (caseName === '')
+            flag('a case needs a name', true);
+        if (!isRecord(bindings)) {
+            flag(`case "${caseName}" is a record of parameter values`, true);
+            continue;
+        }
+        for (const [name, value] of Object.entries(bindings)) {
+            const spec = declared.get(name);
+            if (!spec)
+                flag(`case "${caseName}" binds "${name}", which is not a parameter`, true);
+            else if (!validValue(spec.type, value))
+                flag(`case "${caseName}" binds "${name}" to a value that is not a ${spec.type}`, true);
+        }
+        for (const name of unbound) {
+            if (!(name in bindings))
+                flag(`case "${caseName}" does not bind "${name}", which has no default`, true);
+        }
+    }
+    return out;
+}

package/dist/query.d.ts

@@ -0,0 +1,37 @@
+import * as l from './line.js';
+import { type LineOrStr } from './line.js';
+import { QueryExpression, GoogleSqlQuery, TableExpression, Pipe, type MapOrRecord } from './sql.js';
+export declare function raw(sql: LineOrStr): QueryExpression;
+export declare function named(name: string): QueryExpression;
+/**
+ * A GoogleSqlQuery around `queryExpression`: optional WITH, then the conventional ORDER BY / LIMIT suffix lines,
+ * then the `|>` pipes. A query that is already a GoogleSqlQuery is nested in parentheses, not merged.
+ */
+export declare function googleQuery({ ctes, queryExpression, orderBy, limitOffset, pipes, }: {
+    ctes?: MapOrRecord<QueryExpression>;
+    queryExpression: QueryExpression;
+    orderBy?: l.Line;
+    limitOffset?: l.Line;
+    pipes?: readonly Pipe[];
+}): GoogleSqlQuery;
+export declare function exceptQueries(...queries: QueryExpression[]): QueryExpression;
+export declare function standardSelect({ distinct, selectList, tableExpr, whereClause, groupBy, having, qualify, windows, ctes, }: {
+    distinct?: boolean;
+    selectList: readonly LineOrStr[];
+    tableExpr?: TableExpression;
+    whereClause?: LineOrStr;
+    groupBy?: LineOrStr;
+    having?: LineOrStr;
+    qualify?: LineOrStr;
+    windows?: MapOrRecord<LineOrStr>;
+    ctes?: MapOrRecord<QueryExpression>;
+}): QueryExpression;
+export declare function combineQueries(queries: MapOrRecord<QueryExpression>, marker?: string): QueryExpression;
+export declare function stackQueries(queries: QueryExpression[], opts: {
+    keys: string[];
+    hashColumns: string[];
+}): QueryExpression;
+type DictRow = Record<string, LineOrStr | number> | Map<string, LineOrStr | number>;
+export declare function data(schemaFields: readonly LineOrStr[] | MapOrRecord<LineOrStr>, rows: readonly LineOrStr[] | DictRow[]): QueryExpression;
+export {};
+//# sourceMappingURL=query.d.ts.map

package/dist/query.js

@@ -0,0 +1,164 @@
+// Port of py/dbox/dbox/block/query.py
+// GoogleSQL query builders.
+import * as l from './line.js';
+import {} from './line.js';
+import * as e from './expr.js';
+import * as h from './helpers.js';
+import * as p from './pipe.js';
+import { QueryExpression, GoogleSqlQuery, RawQuery, NamedQueryExpression, TableExpression, Pipe, mapEntries, pipe, } from './sql.js';
+// ---------------------------------------------------------------------------
+// SelectQuery (Python query.py:46-103): the standard SELECT form
+// ---------------------------------------------------------------------------
+class SelectQuery extends QueryExpression {
+    ctes;
+    isDistinct;
+    selectList;
+    tableExpr;
+    whereClause;
+    groupBy;
+    having;
+    qualify;
+    windows;
+    constructor(props) {
+        super();
+        this.isDistinct = props.distinct;
+        this.selectList = props.selectList;
+        this.tableExpr = props.tableExpr;
+        this.ctes = props.ctes;
+        this.whereClause = props.whereClause;
+        this.groupBy = props.groupBy;
+        this.having = props.having;
+        this.qualify = props.qualify;
+        this.windows = props.windows;
+    }
+    toLine() {
+        const selectKeyword = this.isDistinct ? l.stack([l.keyword('SELECT'), l.keyword('DISTINCT')]) : l.keyword('SELECT');
+        return l.stack([
+            this.ctes.size > 0 ? h.ctes(this.ctes) : null,
+            l.indentNext([selectKeyword, l.stackComma(this.selectList)]),
+            this.tableExpr ? l.indentNext([l.keyword('FROM'), this.tableExpr.toLine()]) : null,
+            this.whereClause ? l.indentNext([l.keyword('WHERE'), this.whereClause]) : null,
+            this.groupBy,
+            this.having ? l.indentNext([l.keyword('HAVING'), this.having]) : null,
+            this.qualify ? l.indentNext([l.keyword('QUALIFY'), this.qualify]) : null,
+            this.windows.size > 0 ? h.windows(this.windows) : null,
+        ]);
+    }
+}
+// ---------------------------------------------------------------------------
+// Public query builders
+// ---------------------------------------------------------------------------
+export function raw(sql) {
+    return new RawQuery(l.ensure(sql));
+}
+export function named(name) {
+    return new NamedQueryExpression(name);
+}
+/**
+ * A GoogleSqlQuery around `queryExpression`: optional WITH, then the conventional ORDER BY / LIMIT suffix lines,
+ * then the `|>` pipes. A query that is already a GoogleSqlQuery is nested in parentheses, not merged.
+ */
+export function googleQuery({ ctes = {}, queryExpression, orderBy, limitOffset, pipes = [], }) {
+    return new GoogleSqlQuery({
+        ctes: new Map(mapEntries(ctes)),
+        queryExpression,
+        orderByLine: orderBy,
+        limitOffset,
+        pipes,
+    });
+}
+export function exceptQueries(...queries) {
+    const lines = queries.map((q) => l.paren(q.toLine()));
+    const line = l.stackWithSep(lines, l.keyword('EXCEPT DISTINCT'));
+    return raw(line);
+}
+export function standardSelect({ distinct = false, selectList, tableExpr, whereClause, groupBy, having, qualify, windows = {}, ctes = {}, }) {
+    return new SelectQuery({
+        distinct,
+        selectList: selectList.map((s) => l.ensure(s)),
+        tableExpr,
+        ctes: new Map(mapEntries(ctes)),
+        whereClause: whereClause !== undefined ? l.ensure(whereClause) : undefined,
+        groupBy: groupBy !== undefined ? l.ensure(groupBy) : undefined,
+        having: having !== undefined ? l.ensure(having) : undefined,
+        qualify: qualify !== undefined ? l.ensure(qualify) : undefined,
+        windows: new Map(mapEntries(windows).map(([k, v]) => [k, l.ensure(v)])),
+    });
+}
+// ---------------------------------------------------------------------------
+// combineQueries (query.py:217-228)
+// ---------------------------------------------------------------------------
+export function combineQueries(queries, marker = '__combined__') {
+    const entries = mapEntries(queries);
+    if (entries.length === 0)
+        throw new Error('combineQueries requires at least one query');
+    const lMarker = l.lit(`1 AS ${marker}`);
+    let query = null;
+    for (const [name, queryExpr] of entries) {
+        if (query === null) {
+            query = pipe(queryExpr, p.extend([lMarker]), p.as(name), p.select([name]));
+        }
+        else {
+            query = pipe(query, p.union({
+                unionType: 'outer union all by name',
+                queries: [pipe(queryExpr, p.extend([lMarker]), p.as(name), p.select([name]))],
+            }));
+        }
+    }
+    return query;
+}
+// ---------------------------------------------------------------------------
+// stackQueries (query.py:231-268)
+// ---------------------------------------------------------------------------
+export function stackQueries(queries, opts) {
+    const { keys, hashColumns } = opts;
+    // Copy to avoid mutating caller's array (Python mutates in-place; we don't).
+    const qs = [...queries];
+    if (hashColumns && hashColumns.length > 0) {
+        for (let i = 0; i < qs.length; i++) {
+            const calcJsonValue = e.call('to_json_string', [e.struct(hashColumns)]);
+            const hashExpr = e.call('farm_fingerprint', [calcJsonValue]);
+            qs[i] = pipe(qs[i], p.extend([h.expression(hashExpr, '__hash')]));
+        }
+    }
+    for (let i = 0; i < qs.length; i++) {
+        qs[i] = pipe(qs[i], p.select([h.expression('*'), h.expression(`'${i}' as lineage_index`)]));
+    }
+    let query = pipe(qs[0], p.union({ unionType: 'outer union all by name', queries: qs.slice(1) }));
+    const fn = (q) => {
+        const selectValues = l.paren(h.selectAsStruct([`t.* except (${keys.join(', ')})`]));
+        return pipe(q, p.as('t'), p.select([...keys, h.expression(selectValues, 'values')]));
+    };
+    query = fn(query);
+    const calcRow = e.call('array_agg', [h.expression('values order by values.lineage_index')]);
+    query = pipe(query, p.aggregate([h.expression(calcRow, 'row'), h.expression('count(distinct values.__hash) > 1 or count(*) < 2', 'is_different')], keys));
+    return query;
+}
+function ensureData(v) {
+    if (typeof v === 'number')
+        return l.ensure(String(v));
+    return l.ensure(v);
+}
+export function data(schemaFields, rows) {
+    let rowLineOrStrs;
+    const isDict = !Array.isArray(schemaFields);
+    if (isDict) {
+        const schema = schemaFields;
+        const keys = mapEntries(schema).map(([k]) => k);
+        rowLineOrStrs = rows.map((row) => {
+            const get = (k) => row instanceof Map ? row.get(k) : row[k];
+            return l.paren(l.stackComma(keys.map((k) => ensureData(get(k)))), l.BLANK);
+        });
+    }
+    else {
+        rowLineOrStrs = [...rows];
+    }
+    const schemaForStruct = isDict ? schemaFields : schemaFields;
+    const rowLines = [
+        l.indentNext([h.structType(schemaForStruct), l.ensure(rowLineOrStrs[0])]),
+        ...rowLineOrStrs.slice(1).map((r) => l.ensure(r)),
+    ];
+    const source = h.array(rowLines);
+    const sqlLines = [l.keyword('select *'), l.indentNext([l.keyword('from'), h.unnest(source)])];
+    return raw(l.stack(sqlLines));
+}

package/dist/sql.d.ts

@@ -0,0 +1,72 @@
+import { type Line, type Options } from './line.js';
+export type MapOrRecord<V> = Map<string, V> | Record<string, V>;
+export declare function mapEntries<V>(m: MapOrRecord<V>): [string, V][];
+export declare abstract class SqlSegment {
+    abstract toLine(): Line;
+    format(options?: Options): string;
+    toString(): string;
+}
+/** One `|>` step. Built by the `p` factories. */
+export declare class Pipe extends SqlSegment {
+    readonly line: Line;
+    constructor(line: Line);
+    toLine(): Line;
+}
+/** Something that goes after FROM or JOIN. Built by the `t` factories. */
+export declare class TableExpression extends SqlSegment {
+    readonly line: Line;
+    constructor(line: Line);
+    toLine(): Line;
+}
+export declare abstract class QueryExpression extends SqlSegment {
+    /** Default toTableExpression wraps in a parenthesized subquery. */
+    toTableExpression(): TableExpression;
+}
+export declare class RawQuery extends QueryExpression {
+    readonly sql: Line;
+    constructor(sql: Line);
+    toLine(): Line;
+}
+export declare class NamedQueryExpression extends QueryExpression {
+    readonly name: string;
+    constructor(name: string);
+    toLine(): Line;
+    /** Named expressions refer to CTEs/tables — no subquery wrapping. */
+    toTableExpression(): TableExpression;
+}
+/** `FROM table`; a string is emitted as given, so quote identifiers with `t.path(id, true)` or `e.ident`. */
+export declare function from(tableExpression: TableExpression | string): QueryExpression;
+export interface GoogleSqlQueryProps {
+    ctes?: Map<string, QueryExpression>;
+    queryExpression: QueryExpression;
+    /** orderByLine avoids collision with the p.orderBy pipe. */
+    orderByLine?: Line;
+    limitOffset?: Line;
+    pipes?: readonly Pipe[];
+}
+export declare class GoogleSqlQuery extends QueryExpression {
+    readonly ctes: Map<string, QueryExpression>;
+    readonly queryExpression: QueryExpression;
+    readonly orderByLine: Line | undefined;
+    readonly limitOffset: Line | undefined;
+    readonly pipes: readonly Pipe[];
+    constructor({ ctes, queryExpression, orderByLine, limitOffset, pipes }: GoogleSqlQueryProps);
+    toLine(): Line;
+}
+/**
+ * Apply `|>` steps to a query. Pipe syntax is GoogleSQL's, so the result is a GoogleSqlQuery. A GoogleSqlQuery takes
+ * the steps on its own pipe list (only its outer wrapper is flattened); anything else is wrapped. The input is not
+ * changed.
+ */
+export declare function pipe(query: QueryExpression, ...steps: Pipe[]): GoogleSqlQuery;
+type SqlInterp = string | number | Line | SqlSegment;
+/**
+ * Tagged template for raw SQL fragments.
+ * - string/number interpolations inline as raw SQL text (no quoting).
+ * - Line interpolations embed structurally (breaker recurses into them).
+ * - SqlSegment (QueryExpression etc.) interpolations use .toLine().
+ * For quoted identifiers use ident(name); for string literals use e.literalString(x).
+ */
+export declare function sql(strings: TemplateStringsArray, ...values: SqlInterp[]): Line;
+export {};
+//# sourceMappingURL=sql.d.ts.map