rado 1.2.0 → 1.3.0-preview.0

package/dist/core/Virtual.js

@@ -1,8 +1,17 @@
 // src/core/Virtual.ts
+import { Field } from "./expr/Field.js";
 import { getSql, hasSql, internalTarget } from "./Internal.js";
 import { sql } from "./Sql.js";
-import { Field } from "./expr/Field.js";
-function virtual(alias, source) {
+function virtualFields(alias, source) {
+  return Object.fromEntries(
+    Object.entries(source).map(([key, value]) => {
+      if (value && typeof value === "object" && !hasSql(value))
+        return [key, virtualFields(alias, value)];
+      return [key, new Field(alias, key, getSql(value))];
+    })
+  );
+}
+function virtualTarget(alias, source) {
   const target = {
     [internalTarget]: sql.identifier(alias)
   };
@@ -14,16 +23,11 @@ function virtual(alias, source) {
     if (!name) throw new Error("Cannot alias a virtual field without a name");
     return Object.assign(new Field(alias, name, expr), target);
   }
-  const aliased = Object.fromEntries(
-    Object.entries(source).map(([key, value]) => {
-      return [key, new Field(alias, key, getSql(value))];
-    })
-  );
   return {
-    [internalTarget]: sql.identifier(alias),
-    ...aliased
+    ...target,
+    ...virtualFields(alias, source)
   };
 }
 export {
-  virtual
+  virtualTarget
 };

package/dist/core/expr/Conditions.d.ts

@@ -5,17 +5,17 @@ import { type Sql } from '../Sql.js';
 import { type Input } from './Input.js';
 export declare const eq: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
 export declare const ne: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
-export declare const gt: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
-export declare const gte: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
-export declare const lt: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
-export declare const lte: <T>(left: Input<T>, right: Input<T>) => Sql<boolean>;
+export declare const gt: (left: Input, right: Input) => Sql<boolean>;
+export declare const gte: (left: Input, right: Input) => Sql<boolean>;
+export declare const lt: (left: Input, right: Input) => Sql<boolean>;
+export declare const lte: (left: Input, right: Input) => Sql<boolean>;
 export declare const like: (left: Input<string | null>, right: Input<string>) => Sql<boolean>;
 export declare const notLike: (left: Input<string | null>, right: Input<string>) => Sql<boolean>;
 export declare const ilike: (left: Input<string | null>, right: Input<string>) => Sql<boolean>;
 export declare const notILike: (left: Input<string | null>, right: Input<string>) => Sql<boolean>;
-export declare const arrayContains: <T>(left: Input<Array<T>>, right: Input<T>) => Sql<boolean>;
-export declare const arrayContained: <T>(left: Input<Array<T>>, right: Input<Array<T>>) => Sql<boolean>;
-export declare const arrayOverlaps: <T>(left: Input<Array<T>>, right: Input<Array<T>>) => Sql<boolean>;
+export declare const arrayContains: <T>(left: Input<Array<T> | null>, right: Input<T | Array<T> | null>) => Sql<boolean>;
+export declare const arrayContained: <T>(left: Input<Array<T> | null>, right: Input<Array<T> | null>) => Sql<boolean>;
+export declare const arrayOverlaps: <T>(left: Input<Array<T> | null>, right: Input<Array<T> | null>) => Sql<boolean>;
 export declare function and(...conditions: Array<undefined | Input<boolean>>): Sql<boolean>;
 export declare function or(...conditions: Array<undefined | Input<boolean>>): Sql<boolean>;
 export declare function not(condition: Input<boolean>): Sql<boolean>;

package/dist/core/expr/Include.d.ts

@@ -1,10 +1,10 @@
 import { type HasSql, internalData, internalSql } from '../Internal.js';
 import type { QueryMeta } from '../MetaData.js';
 import type { QueryData } from '../Queries.js';
-import type { RowOfRecord } from '../Selection.js';
-import { type Sql } from '../Sql.js';
 import type { SelectQuery } from '../query/Query.js';
 import { type Select, type SelectBase } from '../query/Select.js';
+import type { RowOfRecord } from '../Selection.js';
+import { type Sql } from '../Sql.js';
 export type IncludeQuery = SelectQuery & {
     first: boolean;
 };

package/dist/core/expr/Include.js

@@ -1,10 +1,10 @@
 // src/core/expr/Include.ts
 import { getData, internalData, internalSql } from "../Internal.js";
-import { sql } from "../Sql.js";
 import {
   querySelection,
   selectQuery
 } from "../query/Select.js";
+import { sql } from "../Sql.js";
 import { jsonAggregateArray, jsonArray } from "./Json.js";
 var Include = class {
   [internalData];

package/dist/core/expr/Input.d.ts

@@ -3,4 +3,4 @@ import { type HasSql } from '../Internal.js';
 import { type Sql } from '../Sql.js';
 export type Input<T = unknown> = HasSql<T> | T;
 export declare function input<T>(value: Input<T>, maybeField?: Input<T>): Sql<T>;
-export declare function mapToColumn<T>({ mapToDriverValue }: ColumnData, expr: Input<T>): Sql<T>;
+export declare function mapToColumn<T>({ mapToDriverValue, type }: ColumnData, expr: Input<T>): Sql<T>;

package/dist/core/expr/Input.js

@@ -16,9 +16,13 @@ function input(value, maybeField) {
   const fieldSource = maybeField && typeof maybeField === "object" && hasField(maybeField) && getField(maybeField).source;
   return fieldSource && "mapToDriverValue" in fieldSource ? mapToColumn(fieldSource, value) : sql.value(value);
 }
-function mapToColumn({ mapToDriverValue }, expr) {
+function mapToColumn({ mapToDriverValue, type }, expr) {
   const isObject = expr && typeof expr === "object";
   if (isObject && hasSql(expr)) return getSql(expr);
+  if (Array.isArray(expr) && type.kind === "array") {
+    if (!mapToDriverValue) return input(expr);
+    return input(mapToDriverValue(expr));
+  }
   return input(
     expr !== null && mapToDriverValue ? mapToDriverValue(expr) : expr
   );

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

@@ -1,8 +1,6 @@
-import { type HasQuery, type HasTarget } from '../Internal.js';
-import type { SelectionInput } from '../Selection.js';
+import { type HasQuery } from '../Internal.js';
 import { type Sql } from '../Sql.js';
+import type { VirtualTarget } from '../Virtual.js';
 import type { QueryBase } from './Query.js';
-import type { UnionBase } from './Select.js';
-export type CTE<Input = unknown> = Input & HasTarget & HasQuery;
-export declare function createCTE<Input extends SelectionInput>(cteName: string, query: UnionBase<Input>): CTE<Input>;
+export type CTE<Input = unknown> = VirtualTarget<Input> & HasQuery;
 export declare function formatCTE(query: QueryBase): Sql | undefined;

package/dist/core/query/CTE.js

@@ -1,17 +1,6 @@
 // src/core/query/CTE.ts
-import {
-  getQuery,
-  getSelection,
-  getTarget,
-  internalQuery
-} from "../Internal.js";
+import { getQuery, getTarget } from "../Internal.js";
 import { sql } from "../Sql.js";
-function createCTE(cteName, query) {
-  const fields = getSelection(query).makeVirtual(cteName);
-  return Object.assign(fields, {
-    [internalQuery]: getQuery(query).nameSelf(cteName)
-  });
-}
 function formatCTE(query) {
   const isRecursive = query.withRecursive;
   const definitions = isRecursive ? query.withRecursive : query.with;
@@ -28,6 +17,5 @@ function formatCTE(query) {
   });
 }
 export {
-  createCTE,
   formatCTE
 };

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

@@ -1,23 +1,23 @@
-import { type HasQuery, type HasSql, internalData, internalQuery, internalSelection } from '../Internal.js';
+import type { Input as UserInput } from '../expr/Input.js';
+import { type HasSql, internalData, internalQuery, internalSelection } from '../Internal.js';
 import type { IsPostgres, IsSqlite, QueryMeta } from '../MetaData.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 } from '../Table.js';
-import type { Input } from '../expr/Input.js';
+import type { TableDefinition, TableFields } from '../Table.js';
 import type { DeleteQuery } from './Query.js';
-export declare class Delete<Result, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Result, Meta> implements HasQuery<Result> {
+export declare class Delete<Input, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Array<SelectionRow<Input>>, Meta> {
     readonly [internalData]: QueryData<Meta> & DeleteQuery;
     readonly [internalSelection]?: Selection;
     constructor(data: QueryData<Meta> & DeleteQuery);
-    get [internalQuery](): Sql<Result>;
-    limit(limit: Input<number>): Delete<Result, Meta>;
-    offset(offset: Input<number>): Delete<Result, Meta>;
-    orderBy(...orderBy: Array<HasSql>): Delete<Result, Meta>;
+    get [internalQuery](): Sql<Array<SelectionRow<Input>>>;
+    limit(limit: UserInput<number>): Delete<Input, Meta>;
+    offset(offset: UserInput<number>): Delete<Input, Meta>;
+    orderBy(...orderBy: Array<HasSql>): Delete<Input, Meta>;
 }
 export declare class DeleteFrom<Definition extends TableDefinition, Meta extends QueryMeta> extends Delete<void, Meta> {
     where(...where: Array<HasSql<boolean> | undefined>): DeleteFrom<Definition, Meta>;
-    returning(this: DeleteFrom<Definition, IsPostgres | IsSqlite>): Delete<Array<TableRow<Definition>>, Meta>;
-    returning<Input extends SelectionInput>(this: DeleteFrom<Definition, IsPostgres | IsSqlite>, returning: Input): Delete<Array<SelectionRow<Input>>, Meta>;
+    returning(this: DeleteFrom<Definition, IsPostgres | IsSqlite>): Delete<TableFields<Definition>, Meta>;
+    returning<Input extends SelectionInput>(this: DeleteFrom<Definition, IsPostgres | IsSqlite>, returning: Input): Delete<Input, Meta>;
 }
 export declare function deleteQuery(query: DeleteQuery): Sql;

package/dist/core/query/Delete.js

@@ -1,4 +1,5 @@
 // src/core/query/Delete.ts
+import { and } from "../expr/Conditions.js";
 import {
   getData,
   getTable,
@@ -11,7 +12,6 @@ import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
-import { and } from "../expr/Conditions.js";
 import { formatCTE } from "./CTE.js";
 import { formatModifiers } from "./Shared.js";
 var Delete = class _Delete extends SingleQuery {
@@ -52,7 +52,7 @@ function deleteQuery(query) {
   return sql.query(
     formatCTE(query),
     {
-      deleteFrom: sql.identifier(table.name),
+      deleteFrom: table.identifier(),
       where,
       returning: returning && selection(returning)
     },

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

@@ -3,17 +3,17 @@ import type { IsMysql, IsPostgres, IsSqlite, QueryMeta } from '../MetaData.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, TableInsert, TableRow } from '../Table.js';
+import type { TableDefinition, TableFields, TableInsert, TableRow } from '../Table.js';
 import type { InsertQuery, OnConflict, OnConflictSet, OnConflictUpdate } from './Query.js';
-export declare class Insert<Result, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Result, Meta> implements HasQuery<Result> {
+export declare class Insert<Input, Meta extends QueryMeta = QueryMeta> extends SingleQuery<Array<SelectionRow<Input>>, Meta> implements HasQuery<Array<SelectionRow<Input>>> {
     readonly [internalData]: QueryData<Meta> & InsertQuery;
     readonly [internalSelection]?: Selection;
     constructor(data: QueryData<Meta> & InsertQuery);
-    get [internalQuery](): Sql<Result>;
+    get [internalQuery](): Sql<Array<SelectionRow<Input>>>;
 }
 declare class InsertCanReturn<Definition extends TableDefinition, Meta extends QueryMeta> extends Insert<void, Meta> {
-    returning<Meta extends IsPostgres | IsSqlite>(this: InsertCanReturn<Definition, Meta>): Insert<Array<TableRow<Definition>>, Meta>;
-    returning<Input extends SelectionInput, Meta extends IsPostgres | IsSqlite>(this: InsertCanReturn<Definition, Meta>, returning: Input): Insert<Array<SelectionRow<Input>>, Meta>;
+    returning<Meta extends IsPostgres | IsSqlite>(this: InsertCanReturn<Definition, Meta>): Insert<TableFields<Definition>, Meta>;
+    returning<Input extends SelectionInput, Meta extends IsPostgres | IsSqlite>(this: InsertCanReturn<Definition, Meta>, returning: Input): Insert<Input, Meta>;
 }
 declare class InsertCanConflict<Definition extends TableDefinition, Meta extends QueryMeta> extends InsertCanReturn<Definition, Meta> {
     onConflictDoNothing<Meta extends IsPostgres | IsSqlite>(this: InsertCanConflict<Definition, Meta>, onConflictDoNothing?: OnConflict): InsertCanConflict<Definition, Meta>;
@@ -23,6 +23,7 @@ declare class InsertCanConflict<Definition extends TableDefinition, Meta extends
 export declare class InsertInto<Definition extends TableDefinition, Meta extends QueryMeta> {
     [internalData]: QueryData<Meta> & InsertQuery;
     constructor(data: QueryData<Meta> & InsertQuery);
+    overridingSystemValue(): InsertInto<Definition, Meta>;
     values(value: TableInsert<Definition>): InsertCanConflict<Definition, Meta>;
     values(values: Array<TableInsert<Definition>>): InsertCanConflict<Definition, Meta>;
     select(query: SingleQuery<Array<TableRow<Definition>>, Meta>): InsertCanConflict<Definition, Meta>;

package/dist/core/query/Insert.js

@@ -1,4 +1,5 @@
 // src/core/query/Insert.ts
+import { input, mapToColumn } from "../expr/Input.js";
 import {
   getData,
   getTable,
@@ -11,10 +12,8 @@ import {
   selection
 } from "../Selection.js";
 import { sql } from "../Sql.js";
-import { input, mapToColumn } from "../expr/Input.js";
 import { formatCTE } from "./CTE.js";
-import { selectQuery } from "./Select.js";
-import { formatModifiers } from "./Shared.js";
+import { querySelection, selectQuery } from "./Select.js";
 var Insert = class extends SingleQuery {
   [internalData];
   constructor(data) {
@@ -58,11 +57,17 @@ var InsertCanConflict = class _InsertCanConflict extends InsertCanReturn {
     });
   }
 };
-var InsertInto = class {
+var InsertInto = class _InsertInto {
   [internalData];
   constructor(data) {
     this[internalData] = data;
   }
+  overridingSystemValue() {
+    return new _InsertInto({
+      ...getData(this),
+      overridingSystemValue: true
+    });
+  }
   values(values) {
     return new InsertCanConflict({
       ...getData(this),
@@ -70,6 +75,15 @@ var InsertInto = class {
     });
   }
   select(query) {
+    const insert = getTable(getData(this).insert);
+    const expected = Object.keys(insert.columns);
+    const actual = querySelection(getData(query)).fieldNames();
+    if (expected.length !== actual.length)
+      throw new Error("Insert select fields must match table columns");
+    for (let i = 0; i < expected.length; i++) {
+      if (expected[i] !== actual[i])
+        throw new Error("Insert select fields must match table columns");
+    }
     return new InsertCanConflict({
       ...getData(this),
       ...getData(query)
@@ -147,21 +161,20 @@ function formatConflicts(on) {
   );
 }
 function insertQuery(query) {
-  const { insert, values, select, returning } = query;
+  const { insert, values, select, returning, overridingSystemValue } = query;
   if (!values && !select) throw new Error("No values defined");
   const table = getTable(insert);
-  const tableName = sql.identifier(table.name);
   const toInsert = values ? sql.query({
     values: formatValues(table, Array.isArray(values) ? values : [values])
   }) : selectQuery(query);
   const conflicts = query.on ? formatConflicts(query.on) : void 0;
   return sql.query(
     formatCTE(query),
-    { insertInto: sql`${tableName} (${table.listColumns()})` },
+    { insertInto: sql`${table.identifier()} (${table.listColumns()})` },
+    { overridingSystemValue },
     toInsert,
     conflicts,
-    returning && sql.query({ returning: selection(returning) }),
-    formatModifiers(query)
+    returning && sql.query({ returning: selection(returning) })
   ).inlineFields(false);
 }
 export {

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

@@ -1,18 +1,26 @@
+import type { Input } from '../expr/Input.js';
 import type { HasSql, HasTarget } from '../Internal.js';
 import type { MakeNullable, SelectionInput, SelectionRow } from '../Selection.js';
 import type { Sql } from '../Sql.js';
 import type { Table, TableDefinition, TableFields, TableInsert, TableUpdate } from '../Table.js';
 import type { Expand } from '../Types.js';
-import type { Input } from '../expr/Input.js';
 import type { CTE } from './CTE.js';
 export interface InnerJoin<Target> {
     innerJoin: Target;
     on: HasSql<boolean>;
 }
+export interface InnerJoinLateral<Target> {
+    innerJoinLateral: Target;
+    on: HasSql<boolean>;
+}
 export interface LeftJoin<Target> {
     leftJoin: Target;
     on: HasSql<boolean>;
 }
+export interface LeftJoinLateral<Target> {
+    leftJoinLateral: Target;
+    on: HasSql<boolean>;
+}
 export interface RightJoin<Target> {
     rightJoin: Target;
     on: HasSql<boolean>;
@@ -23,10 +31,14 @@ export interface FullJoin<Target> {
 }
 export interface CrossJoin<Target> {
     crossJoin: Target;
-    on: HasSql<boolean>;
+    on?: undefined;
 }
-export type Join<Target = HasTarget | Sql> = InnerJoin<Target> | LeftJoin<Target> | RightJoin<Target> | FullJoin<Target> | CrossJoin<Target>;
-export type JoinOp = 'leftJoin' | 'rightJoin' | 'innerJoin' | 'fullJoin' | 'crossJoin';
+export interface CrossJoinLateral<Target> {
+    crossJoinLateral: Target;
+    on?: undefined;
+}
+export type Join<Target = HasTarget | Sql> = InnerJoin<Target> | InnerJoinLateral<Target> | LeftJoin<Target> | LeftJoinLateral<Target> | RightJoin<Target> | FullJoin<Target> | CrossJoin<Target> | CrossJoinLateral<Target>;
+export type JoinOp = 'leftJoin' | 'leftJoinLateral' | 'rightJoin' | 'innerJoin' | 'innerJoinLateral' | 'fullJoin' | 'crossJoin' | 'crossJoinLateral';
 export interface QueryBase {
     with?: Array<CTE>;
     withRecursive?: Array<CTE>;
@@ -47,6 +59,7 @@ export type FromGuard<Target = HasTarget | Sql> = Target | [Target, ...Array<Joi
 interface SelectionBase<Returning = SelectionInput> extends SelectBase<Returning> {
     select: Returning;
     from?: FromGuard;
+    for?: HasSql;
 }
 export interface SelectionQuery<Returning = SelectionInput> extends SelectionBase<Returning>, QueryBase, ResultModifiers {
 }
@@ -58,23 +71,23 @@ export interface FromQuery<Target> extends FromBase<Target>, QueryBase, ResultMo
 type FoldJoins<T extends Array<unknown>, Result> = T extends [
     infer Join,
     ...infer Joins
-] ? FoldJoins<Joins, Join extends LeftJoin<Table<infer Definition, infer Name>> ? Result & MakeNullable<Record<Name, TableFields<Definition>>> : Join extends RightJoin<Table<infer Definition, infer Name>> ? MakeNullable<Result> & Record<Name, TableFields<Definition>> : Join extends InnerJoin<Table<infer Definition, infer Name>> ? Result & Record<Name, TableFields<Definition>> : Join extends FullJoin<Table<infer Definition, infer Name>> ? MakeNullable<Result> & MakeNullable<Record<Name, TableFields<Definition>>> : Result> : Result;
+] ? FoldJoins<Joins, Join extends LeftJoin<Table<infer Definition, infer Name>> ? Result & MakeNullable<Record<Name, TableFields<Definition>>> : Join extends LeftJoinLateral<Table<infer Definition, infer Name>> ? Result & MakeNullable<Record<Name, TableFields<Definition>>> : Join extends RightJoin<Table<infer Definition, infer Name>> ? MakeNullable<Result> & Record<Name, TableFields<Definition>> : Join extends InnerJoin<Table<infer Definition, infer Name>> ? Result & Record<Name, TableFields<Definition>> : Join extends InnerJoinLateral<Table<infer Definition, infer Name>> ? Result & Record<Name, TableFields<Definition>> : Join extends CrossJoin<Table<infer Definition, infer Name>> ? Result & Record<Name, TableFields<Definition>> : Join extends FullJoin<Table<infer Definition, infer Name>> ? MakeNullable<Result> & MakeNullable<Record<Name, TableFields<Definition>>> : Join extends CrossJoinLateral<Table<infer Definition, infer Name>> ? Result & Record<Name, TableFields<Definition>> : Result> : Result;
 export type FromRow<Target> = Target extends [
     Table<infer Definition, infer Name>,
     ...infer Joins
 ] ? Joins['length'] extends 0 ? TableFields<Definition> : Expand<FoldJoins<Joins, Record<Name, TableFields<Definition>>>> : SelectionRow<Target>;
 export type Union<Returning = SelectionInput> = {
-    union: SelectQuery<Returning>;
+    union: SelectQuery<Returning> | UnionQuery<Returning>;
 } | {
-    unionAll: SelectQuery<Returning>;
+    unionAll: SelectQuery<Returning> | UnionQuery<Returning>;
 } | {
-    intersect: SelectQuery<Returning>;
+    intersect: SelectQuery<Returning> | UnionQuery<Returning>;
 } | {
-    intersectAll: SelectQuery<Returning>;
+    intersectAll: SelectQuery<Returning> | UnionQuery<Returning>;
 } | {
-    except: SelectQuery<Returning>;
+    except: SelectQuery<Returning> | UnionQuery<Returning>;
 } | {
-    exceptAll: SelectQuery<Returning>;
+    exceptAll: SelectQuery<Returning> | UnionQuery<Returning>;
 };
 export type UnionOp = 'union' | 'unionAll' | 'intersect' | 'intersectAll' | 'except' | 'exceptAll';
 export type CompoundSelect<Returning = SelectionInput> = [
@@ -108,6 +121,7 @@ export interface InsertQuery<Returning = SelectionInput, Definition extends Tabl
     values?: TableInsert<Definition> | Array<TableInsert<Definition>>;
     returning?: Returning;
     on?: Array<Conflict<Definition>>;
+    overridingSystemValue?: boolean;
 }
 export interface DeleteQuery<Returning = SelectionInput, Definition extends TableDefinition = TableDefinition> extends QueryBase, ResultModifiers {
     delete: Table<Definition>;
@@ -117,6 +131,7 @@ export interface DeleteQuery<Returning = SelectionInput, Definition extends Tabl
 export interface UpdateQuery<Returning = SelectionInput, Definition extends TableDefinition = TableDefinition> extends QueryBase, ResultModifiers {
     update: Table<Definition>;
     set?: TableUpdate<Definition>;
+    from?: FromGuard;
     where?: HasSql<boolean>;
     returning?: Returning;
 }

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

@@ -1,3 +1,5 @@
+import type { Field, StripFieldMeta } from '../expr/Field.js';
+import type { Input as UserInput } from '../expr/Input.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';
@@ -5,9 +7,7 @@ import { type IsNullable, type MakeNullable, type Selection, type SelectionRecor
 import { Sql } from '../Sql.js';
 import type { Table, TableDefinition, TableFields } from '../Table.js';
 import type { Expand } from '../Types.js';
-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 { VirtualTarget } from '../Virtual.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>> {
@@ -32,16 +32,25 @@ export declare abstract class UnionBase<Input, Meta extends QueryMeta = QueryMet
     except(target: UnionTarget<Input, Meta>): Union<Input, Meta>;
     exceptAll<Meta extends IsPostgres | IsMysql>(this: UnionBase<Input, Meta>, target: UnionTarget<Input, Meta>): Union<Input, Meta>;
 }
+declare const forKeywords: readonly ["update", "no key update", "share", "key share"];
 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>;
+    for(keyword: (typeof forKeywords)[number], config?: {
+        of?: HasTarget | Array<HasTarget>;
+        noWait?: boolean;
+        skipLocked?: boolean;
+    }): Select<Input, Meta>;
     leftJoin(leftJoin: HasTarget | Sql, on: HasSql<boolean>): Select<Input, Meta>;
+    leftJoinLateral(leftJoinLateral: 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>;
+    innerJoinLateral(innerJoinLateral: 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>;
+    crossJoin(crossJoin: HasTarget | Sql): Select<Input, Meta>;
+    crossJoinLateral(crossJoinLateral: HasTarget | Sql): Select<Input, Meta>;
     where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
     groupBy(...groupBy: Array<HasSql>): Select<Input, Meta>;
     having(having: HasSql<boolean> | ((self: Input) => HasSql<boolean>)): Select<Input, Meta>;
@@ -54,8 +63,16 @@ export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends U
     get [internalQuery](): Sql<Array<SelectionRow<Input>>>;
     get [internalSql](): Sql<SelectionRow<Input>>;
 }
-export type SubQuery<Input, Name extends string = string> = Input & HasTarget<Name> & HasSelection;
+export type SubQuery<Input, Name extends string = string> = RetypeSubQueryInput<Input, Name> & HasTarget<Name> & HasSelection;
+type RetypeSubQueryInput<Input, TableName extends string> = Input extends HasSql<infer Value> ? Field<Value, TableName> : Input extends SelectionRecord ? Expand<{
+    [K in keyof Input]: RetypeSubQueryInput<Input[K], TableName>;
+}> : Input;
 export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends UnionBase<StripFieldMeta<Input>, Meta>, HasSql<SelectionRow<Input>> {
+    for(keyword: (typeof forKeywords)[number], config?: {
+        of?: HasTarget | Array<HasTarget>;
+        noWait?: boolean;
+        skipLocked?: boolean;
+    }): Select<Input, Meta>;
     where(...where: Array<HasSql<boolean> | undefined>): Select<Input, Meta>;
     groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
     having(having: HasSql<boolean>): Select<Input, Meta>;
@@ -67,7 +84,7 @@ export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends U
 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>;
+    from<Input>(from: VirtualTarget<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>;
@@ -78,10 +95,18 @@ export interface WithSelection<Input, Meta extends QueryMeta> extends SelectBase
 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>;
+    leftJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
+    leftJoinLateral<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>;
+    innerJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, TableFields<Definition>>>, Meta>;
+    innerJoinLateral<Input, Name extends string>(right: SubQuery<Input, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, Input>>, Meta>;
+    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): AllFrom<Expand<Tables & Record<Name, TableFields<Definition>>>, Meta>;
+    crossJoin<Input, Name extends string>(right: SubQuery<Input, Name>): AllFrom<Expand<Tables & Record<Name, Input>>, Meta>;
+    crossJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): AllFrom<Expand<Tables & Record<Name, TableFields<Definition>>>, Meta>;
+    crossJoinLateral<Input, Name extends string>(right: SubQuery<Input, Name>): 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>;
 }
@@ -90,14 +115,22 @@ type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
 }>;
 export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
     leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
+    leftJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
     leftJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    leftJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
+    leftJoinLateral<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
     rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
     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>;
+    innerJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    innerJoinLateral(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    crossJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFrom<Input, Meta>;
+    crossJoin(right: HasTarget): SelectionFrom<Input, Meta>;
+    crossJoinLateral<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>): SelectionFrom<Input, Meta>;
+    crossJoinLateral(right: HasTarget): SelectionFrom<Input, Meta>;
     fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    fullJoin<Name extends string>(right: HasTarget<Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
     fullJoin(right: HasTarget, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
 }
 export declare function querySelection({ select, from }: SelectQuery): Selection;