rado 1.0.15 → 1.2.1

package/dist/core/query/Select.d.ts

@@ -1,68 +1,89 @@
-import { type HasSelection, type HasSql, type HasTable, type HasTarget, internalData, internalQuery, internalSelection, internalSql } from '../Internal.js';
-import type { QueryMeta } from '../MetaData.js';
+import { type HasQuery, type HasSelection, type HasSql, type HasTarget, internalData, internalQuery, internalSelection, internalSql } from '../Internal.js';
+import type { IsMysql, IsPostgres, QueryMeta } from '../MetaData.js';
+import { type QueryData, SingleQuery } from '../Queries.js';
 import { type IsNullable, type MakeNullable, type Selection, type SelectionRecord, type SelectionRow } from '../Selection.js';
-import { type Sql } from '../Sql.js';
+import { Sql } from '../Sql.js';
 import type { Table, TableDefinition, TableFields } from '../Table.js';
 import type { Expand } from '../Types.js';
-import type { Field } from '../expr/Field.js';
-import { type Input as UserInput } from '../expr/Input.js';
-import { UnionBase, type UnionBaseData } from './Union.js';
-export type SelectionType = 'selection' | 'allFrom' | 'joinTables';
-export interface SelectData<Meta extends QueryMeta = QueryMeta> extends UnionBaseData<Meta> {
-    distinct?: boolean;
-    distinctOn?: Array<HasSql>;
-    from?: HasSql;
-    where?: HasSql;
-    groupBy?: HasSql;
-    having?: HasSql;
-    orderBy?: HasSql;
-    limit?: HasSql;
-    offset?: HasSql;
+import type { Field, StripFieldMeta } from '../expr/Field.js';
+import type { Input as UserInput } from '../expr/Input.js';
+import { type CTE } from './CTE.js';
+import type { CompoundSelect, SelectQuery, UnionQuery } from './Query.js';
+type UnionTarget<Input, Meta extends QueryMeta> = UnionBase<Input, Meta> | ((self: Input & HasTarget) => UnionBase<Input, Meta>);
+export declare class SelectFirst<Input, Meta extends QueryMeta = QueryMeta> extends SingleQuery<SelectionRow<Input>, Meta> implements HasQuery<SelectionRow<Input>> {
+    readonly [internalData]: QueryData<Meta> & SelectQuery;
+    constructor(data: QueryData<Meta> & SelectQuery);
+    get [internalSelection](): Selection;
+    get [internalQuery](): Sql<SelectionRow<Input>>;
+    get [internalSql](): Sql<SelectionRow<Input>>;
 }
-export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<Input, Meta> implements HasSelection, SelectBase<Input, Meta> {
+export declare abstract class UnionBase<Input, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Array<SelectionRow<Input>>, Meta> implements HasSelection {
     #private;
-    readonly [internalData]: SelectData<Meta>;
-    constructor(data: SelectData<Meta>);
-    as(alias: string): SubQuery<Input>;
-    from(target: HasTarget | HasSql): Select<Input, Meta>;
-    leftJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
-    rightJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
-    innerJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
-    fullJoin(right: HasTable | HasTarget, on: HasSql<boolean>): Select<Input, Meta>;
+    readonly [internalData]: QueryData<Meta>;
+    abstract [internalSelection]: Selection;
+    constructor(data: QueryData<Meta> & {
+        compound: CompoundSelect;
+    });
+    as<Name extends string>(alias: Name): SubQuery<Input, Name>;
+    union(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
+    unionAll(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
+    intersect(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
+    intersectAll<Meta extends IsPostgres | IsMysql>(this: UnionBase<Input, Meta>, target: UnionTarget<Input, Meta>): Union<Input, Meta>;
+    except(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
+    exceptAll<Meta extends IsPostgres | IsMysql>(this: UnionBase<Input, Meta>, target: UnionTarget<Input, Meta>): Union<Input, Meta>;
+}
+export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<StripFieldMeta<Input>, Meta> implements HasSelection, SelectBase<Input, Meta>, HasQuery<Array<SelectionRow<Input>>> {
+    #private;
+    readonly [internalData]: QueryData<Meta> & SelectQuery;
+    constructor(data: QueryData<Meta> & SelectQuery);
+    from(from: HasTarget | Sql): Select<Input, Meta>;
+    leftJoin(leftJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
+    rightJoin(rightJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
+    innerJoin(innerJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
+    fullJoin(fullJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
+    crossJoin(crossJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
     where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
-    groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    groupBy(...groupBy: Array<HasSql>): Select<Input, Meta>;
     having(having: HasSql<boolean> | ((self: Input) => HasSql<boolean>)): Select<Input, Meta>;
-    orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    orderBy(...orderBy: Array<HasSql>): Select<Input, Meta>;
     limit(limit: UserInput<number>): Select<Input, Meta>;
     offset(offset: UserInput<number>): Select<Input, Meta>;
+    $dynamic(): this;
+    $first(): SelectFirst<Input, Meta>;
     get [internalSelection](): Selection;
-    get [internalQuery](): Sql;
+    get [internalQuery](): Sql<Array<SelectionRow<Input>>>;
     get [internalSql](): Sql<SelectionRow<Input>>;
 }
-export type SubQuery<Input> = Input & HasTarget;
-export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<Input, Meta>, HasSelection, HasSql<SelectionRow<Input>> {
+export type SubQuery<Input, Name extends string = string> = Input & HasTarget<Name> & HasSelection;
+export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<StripFieldMeta<Input>, Meta>, HasSql<SelectionRow<Input>> {
     where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
     groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
     having(having: HasSql<boolean>): Select<Input, Meta>;
     orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
     limit(limit: UserInput<number>): Select<Input, Meta>;
     offset(offset: UserInput<number>): Select<Input, Meta>;
-    as(name: string): SubQuery<Input>;
+    $dynamic(): this;
 }
 export interface WithoutSelection<Meta extends QueryMeta> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
     from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
+    from<Input>(from: CTE<Input>): SelectionFrom<Input, Meta>;
 }
 export interface WithSelection<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta>, HasSql<SelectionRow<Input>> {
     from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
+    from(from: HasTarget): SelectionFrom<Input, Meta>;
     from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
-    from(target: HasSql): Select<Input, Meta>;
+    from(from: HasSql): Select<Input, Meta>;
 }
 export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends SelectBase<Input, Meta> {
     leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
+    leftJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & MakeNullable<Record<Name, Input>>>, Meta>;
     rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & Record<Name, TableFields<Definition>>>, Meta>;
+    rightJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & Record<Name, Input>>, Meta>;
     innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, TableFields<Definition>>>, Meta>;
+    innerJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, Input>>, Meta>;
     fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
+    fullJoin<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, Input>>>, Meta>;
 }
 type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
     [K in keyof Input]: Input[K] extends Field<infer T, TableName> ? HasSql<T | null> : Input[K] extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input[K] extends Record<string, Field<unknown, TableName> | HasSql<unknown>> ? Input[K] & IsNullable : Input[K] extends SelectionRecord ? MarkFieldsAsNullable<Input[K], TableName> : Input[K];
@@ -74,7 +95,27 @@ export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase
     rightJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     innerJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    crossJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
 }
+export declare function querySelection({ select, from }: SelectQuery): Selection;
+export declare function selectQuery(query: SelectQuery): Sql;
+export declare class Union<Result, Meta extends QueryMeta = QueryMeta> extends UnionBase<Result, Meta> implements HasSelection {
+    readonly [internalData]: QueryData<Meta> & UnionQuery;
+    constructor(data: QueryData<Meta> & UnionQuery);
+    get [internalQuery](): Sql;
+    get [internalSelection](): Selection;
+    orderBy(...orderBy: Array<HasSql>): Union<Result, Meta>;
+    limit(limit: UserInput<number>): Union<Result, Meta>;
+    offset(offset: UserInput<number>): Union<Result, Meta>;
+}
+export declare function union<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
+export declare function unionAll<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
+export declare function intersect<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
+export declare function intersectAll<Result, Meta extends IsPostgres | IsMysql>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
+export declare function except<Result, Meta extends QueryMeta>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
+export declare function exceptAll<Result, Meta extends IsPostgres | IsMysql>(left: UnionBase<Result, Meta>, right: UnionBase<Result, Meta>, ...rest: Array<UnionBase<Result, Meta>>): Union<Result, Meta>;
+export declare function unionQuery(query: UnionQuery): Sql;
 export {};

package/dist/core/query/Select.js

@@ -5,7 +5,8 @@ import {
   getSelection,
   getSql,
   getTarget,
-  hasTable,
+  hasSelection,
+  hasSql,
   hasTarget,
   internalData,
   internalQuery,
@@ -13,14 +14,32 @@ import {
   internalSql,
   internalTarget
 } from "../Internal.js";
+import { SingleQuery } from "../Queries.js";
 import {
   selection
 } from "../Selection.js";
-import { sql } from "../Sql.js";
+import { Sql, sql } from "../Sql.js";
 import { and } from "../expr/Conditions.js";
-import { input } from "../expr/Input.js";
-import { UnionBase } from "./Union.js";
-var Select = class _Select extends UnionBase {
+import { formatCTE } from "./CTE.js";
+import { formatModifiers } from "./Shared.js";
+var SelectFirst = class extends SingleQuery {
+  [internalData];
+  constructor(data) {
+    const inner = { ...data, first: true };
+    super(inner);
+    this[internalData] = inner;
+  }
+  get [internalSelection]() {
+    return querySelection(getData(this));
+  }
+  get [internalQuery]() {
+    return selectQuery(getData(this));
+  }
+  get [internalSql]() {
+    return sql`(${getQuery(this)})`;
+  }
+};
+var UnionBase = class extends SingleQuery {
   [internalData];
   constructor(data) {
     super(data);
@@ -29,89 +48,268 @@ var Select = class _Select extends UnionBase {
   as(alias) {
     const fields = getSelection(this).makeVirtual(alias);
     return Object.assign(fields, {
+      [internalSelection]: selection(fields),
       [internalTarget]: sql`(${getQuery(this)}) as ${sql.identifier(
         alias
       )}`.inlineFields(true)
     });
   }
-  from(target) {
-    const { select: current } = getData(this);
-    const from = hasTarget(target) ? getTarget(target) : getSql(target);
-    const isTable = hasTable(target);
-    const selected = current ?? (isTable ? selection.table(target) : selection(sql`*`));
-    return new _Select({
-      ...getData(this),
-      select: selected,
-      from
-    });
+  #makeSelf() {
+    const selected = getSelection(this);
+    return selected.makeVirtual(Sql.SELF_TARGET);
   }
-  #join(operator, right, on) {
-    const { from, select: current } = getData(this);
-    return new _Select({
+  #getSelect(base) {
+    const data = getData(base);
+    if (!("compound" in data)) throw new Error("No compound defined");
+    return data.compound;
+  }
+  #compound(op, target) {
+    const left = this.#getSelect(this);
+    const right = this.#getSelect(
+      typeof target === "function" ? target(this.#makeSelf()) : target
+    );
+    const [on, ...rest] = right;
+    const select = [...left, { [op]: on }, ...rest];
+    return new Union({
       ...getData(this),
-      select: hasTable(right) ? current?.join(right, operator) : current,
-      from: sql.join([
-        from,
-        sql.unsafe(`${operator} join`),
-        getTarget(right),
-        sql`on ${on}`
-      ])
+      select
     });
   }
-  leftJoin(right, on) {
-    return this.#join("left", right, on);
+  union(target) {
+    return this.#compound("union", target);
+  }
+  unionAll(target) {
+    return this.#compound("unionAll", target);
+  }
+  intersect(target) {
+    return this.#compound("intersect", target);
+  }
+  intersectAll(target) {
+    return this.#compound("intersectAll", target);
+  }
+  except(target) {
+    return this.#compound("except", target);
+  }
+  exceptAll(target) {
+    return this.#compound("exceptAll", target);
+  }
+};
+var Select = class _Select extends UnionBase {
+  [internalData];
+  constructor(data) {
+    const compound = [data];
+    const withCompound = { ...data, compound };
+    super(withCompound);
+    this[internalData] = withCompound;
+  }
+  from(from) {
+    return new _Select({ ...getData(this), from });
+  }
+  #fromTarget() {
+    const { from } = getData(this);
+    if (!from) throw new Error("No target defined");
+    if (Array.isArray(from)) return from;
+    return [from];
+  }
+  #join(join) {
+    return new _Select({ ...getData(this), from: [...this.#fromTarget(), join] });
   }
-  rightJoin(right, on) {
-    return this.#join("right", right, on);
+  leftJoin(leftJoin, on) {
+    return this.#join({ leftJoin, on });
   }
-  innerJoin(right, on) {
-    return this.#join("inner", right, on);
+  rightJoin(rightJoin, on) {
+    return this.#join({ rightJoin, on });
   }
-  fullJoin(right, on) {
-    return this.#join("full", right, on);
+  innerJoin(innerJoin, on) {
+    return this.#join({ innerJoin, on });
+  }
+  fullJoin(fullJoin, on) {
+    return this.#join({ fullJoin, on });
+  }
+  crossJoin(crossJoin, on) {
+    return this.#join({ crossJoin, on });
   }
   where(...where) {
     return new _Select({ ...getData(this), where: and(...where) });
   }
-  groupBy(...exprs) {
-    return new _Select({
-      ...getData(this),
-      groupBy: sql.join(exprs, sql.unsafe(", "))
-    });
+  groupBy(...groupBy) {
+    return new _Select({ ...getData(this), groupBy });
   }
   having(having) {
-    return new _Select({
-      ...getData(this),
-      having: typeof having === "function" ? having(getSelection(this).input) : having
-    });
+    return new _Select({ ...getData(this), having });
   }
-  orderBy(...exprs) {
-    return new _Select({
-      ...getData(this),
-      orderBy: sql.join(exprs, sql.unsafe(", "))
-    });
+  orderBy(...orderBy) {
+    return new _Select({ ...getData(this), orderBy });
   }
   limit(limit) {
-    return new _Select({ ...getData(this), limit: input(limit) });
+    return new _Select({ ...getData(this), limit });
   }
   offset(offset) {
-    return new _Select({
-      ...getData(this),
-      offset: input(offset)
-    });
+    return new _Select({ ...getData(this), offset });
+  }
+  $dynamic() {
+    return this;
+  }
+  $first() {
+    return new SelectFirst(getData(this));
   }
   get [internalSelection]() {
-    const { select } = getData(this);
-    if (!select) throw new Error("No selection defined");
-    return select;
+    return querySelection(getData(this));
   }
   get [internalQuery]() {
-    return sql.chunk("emitSelect", getData(this));
+    return selectQuery(getData(this));
   }
   get [internalSql]() {
     return sql`(${getQuery(this)})`;
   }
 };
+function querySelection({ select, from }) {
+  if (select) return selection(select);
+  if (!from) throw new Error("No selection defined");
+  if (Array.isArray(from)) {
+    const [target, ...joins] = from;
+    return joins.reduce((result, join) => {
+      const { target: target2, op } = joinOp(join);
+      return result.join(target2, op);
+    }, selection(target));
+  }
+  return hasSelection(from) ? getSelection(from) : selection(sql`*`);
+}
+function joinOp(join) {
+  const { on, ...rest } = join;
+  const op = Object.keys(rest)[0];
+  const target = rest[op];
+  return { target, op, on };
+}
+function formatFrom(from) {
+  if (!from) throw new Error("No target defined");
+  if (Array.isArray(from)) {
+    return sql.join(
+      from.map((join) => {
+        if (hasTarget(join)) return getTarget(join);
+        if (hasSql(join)) return getSql(join);
+        const { target, op, on } = joinOp(join);
+        return sql.query({
+          [op]: hasTarget(target) ? getTarget(target) : getSql(target),
+          on
+        });
+      })
+    );
+  }
+  return hasTarget(from) ? getTarget(from) : getSql(from);
+}
+function selectQuery(query) {
+  const { from, where, groupBy, having, distinct, distinctOn } = query;
+  const prefix = distinctOn ? sql`distinct on (${sql.join(distinctOn, sql`, `)})` : distinct && sql`distinct`;
+  const selected = querySelection(query);
+  const select = sql.join([prefix, selected]);
+  return sql.query(
+    formatCTE(query),
+    {
+      select,
+      from: from && formatFrom(from),
+      where,
+      groupBy: groupBy && sql.join(groupBy, sql`, `),
+      having: typeof having === "function" ? having(selected.input) : having
+    },
+    formatModifiers(query)
+  );
+}
+var Union = class _Union extends UnionBase {
+  [internalData];
+  constructor(data) {
+    const compound = data.select;
+    const withCompound = { ...data, compound };
+    super(withCompound);
+    this[internalData] = withCompound;
+  }
+  get [internalQuery]() {
+    return unionQuery(getData(this));
+  }
+  get [internalSelection]() {
+    const {
+      select: [first]
+    } = getData(this);
+    return querySelection(first);
+  }
+  orderBy(...orderBy) {
+    return new _Union({ ...getData(this), orderBy });
+  }
+  limit(limit) {
+    return new _Union({ ...getData(this), limit });
+  }
+  offset(offset) {
+    return new _Union({ ...getData(this), offset });
+  }
+};
+function union(left, right, ...rest) {
+  return [right, ...rest].reduce(
+    (acc, query) => acc.union(query),
+    left
+  );
+}
+function unionAll(left, right, ...rest) {
+  return [right, ...rest].reduce(
+    (acc, query) => acc.unionAll(query),
+    left
+  );
+}
+function intersect(left, right, ...rest) {
+  return [right, ...rest].reduce(
+    (acc, query) => acc.intersect(query),
+    left
+  );
+}
+function intersectAll(left, right, ...rest) {
+  return [right, ...rest].reduce(
+    (acc, query) => acc.intersectAll(query),
+    left
+  );
+}
+function except(left, right, ...rest) {
+  return [right, ...rest].reduce(
+    (acc, query) => acc.except(query),
+    left
+  );
+}
+function exceptAll(left, right, ...rest) {
+  return [right, ...rest].reduce(
+    (acc, query) => acc.exceptAll(query),
+    left
+  );
+}
+function unionQuery(query) {
+  const { select } = query;
+  let fields;
+  const segments = sql.join(
+    select.map((segment, i) => {
+      if (i === 0) {
+        fields = querySelection(segment).fieldNames();
+        return selectQuery(segment);
+      }
+      const op = Object.keys(segment)[0];
+      const query2 = segment[op];
+      const names = querySelection(query2).fieldNames();
+      for (let i2 = 0; i2 < fields.length; i2++)
+        if (fields[i2] !== names[i2])
+          throw new Error("Union segments must have the same fields");
+      return sql.query({ [op]: selectQuery(query2) });
+    })
+  );
+  return sql.query(formatCTE(query), segments, formatModifiers(query));
+}
 export {
-  Select
+  Select,
+  SelectFirst,
+  Union,
+  UnionBase,
+  except,
+  exceptAll,
+  intersect,
+  intersectAll,
+  querySelection,
+  selectQuery,
+  union,
+  unionAll,
+  unionQuery
 };

package/dist/core/query/Shared.d.ts

@@ -0,0 +1,3 @@
+import { type Sql } from '../Sql.js';
+import type { ResultModifiers } from './Query.js';
+export declare function formatModifiers(modifiers: ResultModifiers): Sql | undefined;

package/dist/core/query/Shared.js

@@ -0,0 +1,23 @@
+// src/core/query/Shared.ts
+import { getSql } from "../Internal.js";
+import { sql } from "../Sql.js";
+import { input } from "../expr/Input.js";
+function formatModifiers(modifiers) {
+  const { orderBy, limit, offset } = modifiers;
+  if (!orderBy && limit === void 0 && offset === void 0) return void 0;
+  return sql.query({
+    orderBy: orderBy && sql.join(
+      orderBy.map((part) => {
+        const { alias } = getSql(part);
+        if (alias) return sql.identifier(alias);
+        return part;
+      }),
+      sql`, `
+    ),
+    limit: limit !== void 0 && input(limit),
+    offset: offset !== void 0 && input(offset)
+  });
+}
+export {
+  formatModifiers
+};

package/dist/core/query/Update.d.ts

@@ -1,24 +1,24 @@
-import { type HasSql, type HasTable, internalData, internalQuery, internalSelection } from '../Internal.js';
+import { type HasQuery, type HasSql, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.js';
-import { Query, type QueryData } from '../Query.js';
+import { type QueryData, SingleQuery } from '../Queries.js';
 import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.js';
 import { type Sql } from '../Sql.js';
 import type { TableDefinition, TableRow, TableUpdate } from '../Table.js';
-export interface UpdateData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
-    table: HasTable;
-    set?: HasSql;
-    where?: HasSql;
-    returning?: Selection;
-}
-export declare class Update<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
-    readonly [internalData]: UpdateData<Meta>;
+import { type Input } from '../expr/Input.js';
+import type { UpdateQuery } from './Query.js';
+export declare class Update<Result, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Array<Result>, Meta> implements HasQuery<Result> {
+    readonly [internalData]: QueryData<Meta> & UpdateQuery;
     readonly [internalSelection]?: Selection;
-    constructor(data: UpdateData<Meta>);
-    get [internalQuery](): Sql;
+    constructor(data: QueryData<Meta> & UpdateQuery);
+    get [internalQuery](): Sql<Result>;
+    limit(limit: Input<number>): Update<Result, Meta>;
+    offset(offset: Input<number>): Update<Result, Meta>;
+    orderBy(...orderBy: Array<HasSql>): Update<Result, Meta>;
 }
 export declare class UpdateTable<Definition extends TableDefinition, Meta extends QueryMeta> extends Update<void, Meta> {
-    set(values: TableUpdate<Definition>): UpdateTable<Definition, Meta>;
+    set(set: TableUpdate<Definition>): UpdateTable<Definition, Meta>;
     where(...where: Array<HasSql<boolean> | undefined>): UpdateTable<Definition, Meta>;
     returning(this: UpdateTable<Definition, IsPostgres | IsSqlite>): Update<TableRow<Definition>, Meta>;
     returning<Input extends SelectionInput>(this: UpdateTable<Definition, IsPostgres | IsSqlite>, returning?: Input): Update<SelectionRow<Input>, Meta>;
 }
+export declare function updateQuery(query: UpdateQuery): Sql;