pqb 0.70.0 → 0.71.1

package/dist/index.d.ts

@@ -642,7 +642,7 @@ interface ColumnSchemaGetterTableClass {
 type ColumnSchemaGetterColumns<T extends ColumnSchemaGetterTableClass> = T['prototype']['columns']['shape'];
 interface ColumnTypeSchemaArg {
   __schemaType: unknown;
-  nullable<T extends Column.Pick.ForNullable>(this: T): Column.Modifiers.Nullable<T, unknown, unknown, unknown>;
+  nullable: unknown;
   encode: unknown;
   parse: unknown;
   parseNull: unknown;
@@ -714,7 +714,7 @@ declare namespace TableData {
     name?: string;
   }
   export interface ColumnIndex {
-    options: Index.ColumnArg & Index.Options;
+    options: Index.ColumnOptionsData;
   }
   export interface ColumnExclude extends ColumnIndex {
     with: string;
@@ -765,7 +765,11 @@ declare namespace TableData {
       order?: string;
       weight?: SearchWeight;
     }
-    export interface UniqueOptionsArg<Name extends string = string> {
+    /**
+     * Controls when Postgres checks a unique constraint.
+     */
+    export type UniqueDeferrable = false | 'immediate' | 'deferred';
+    export interface BaseUniqueOptionsArg<Name extends string = string> {
       name?: Name;
       nullsNotDistinct?: boolean;
       using?: string;
@@ -775,23 +779,45 @@ declare namespace TableData {
       where?: string;
       dropMode?: DropMode;
     }
-    export interface OptionsArg extends UniqueOptionsArg {
+    export interface UniqueOptionsArg<Name extends string = string> extends BaseUniqueOptionsArg<Name> {
+      /**
+       * Makes this unique definition a deferrable Postgres constraint.
+       */
+      deferrable?: UniqueDeferrable;
+    }
+    export interface NonUniqueIndexOptionsArg<Name extends string = string> extends BaseUniqueOptionsArg<Name> {
+      unique?: false;
+      deferrable?: never;
+    }
+    export interface UniqueIndexOptionsArg<Name extends string = string> extends UniqueOptionsArg<Name> {
+      unique: true;
+    }
+    export type OptionsArg<Name extends string = string> = NonUniqueIndexOptionsArg<Name> | UniqueIndexOptionsArg<Name>;
+    export type TsVectorArg = OptionsArg & TsVectorOptions;
+    export interface Options extends UniqueOptionsArg, TsVectorOptions {
       unique?: boolean;
     }
-    export interface TsVectorArg extends OptionsArg, TsVectorOptions {}
-    export type Options = TsVectorArg;
     export interface UniqueColumnArg<Name extends string = string> extends ColumnOptions, UniqueOptionsArg<Name> {
       expression?: string;
     }
-    export interface ColumnArg extends UniqueColumnArg {
-      unique?: boolean;
+    export interface NonUniqueColumnArg<Name extends string = string> extends ColumnOptions, BaseUniqueOptionsArg<Name> {
+      expression?: string;
+      unique?: false;
+      deferrable?: never;
+    }
+    export interface UniqueIndexColumnArg<Name extends string = string> extends UniqueColumnArg<Name> {
+      unique: true;
     }
+    export interface ColumnOptionsData extends ColumnOptions, Options {
+      expression?: string;
+    }
+    export type ColumnArg<Name extends string = string> = NonUniqueColumnArg<Name> | UniqueIndexColumnArg<Name>;
     interface TsVectorOptions {
       language?: string;
       languageColumn?: string;
       tsVector?: boolean;
     }
-    export interface TsVectorColumnArg extends ColumnArg, TsVectorOptions {}
+    export type TsVectorColumnArg = ColumnArg & TsVectorOptions;
     export interface ExpressionOptions extends ColumnOptions {
       expression: string;
     }
@@ -1064,7 +1090,7 @@ interface NumberColumnData extends BaseNumberData, Column.Data {
   identity?: TableData.Identity;
 }
 interface SerialColumnData extends NumberColumnData {
-  default: Expression;
+  default: true;
 }
 declare abstract class NumberBaseColumn<Schema extends ColumnSchemaConfig, SchemaType extends Schema['__schemaType']> extends Column {
   __schema: Schema;
@@ -1109,27 +1135,26 @@ declare class DecimalColumn<Schema extends ColumnSchemaConfig> extends NumberAsS
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
   toSQL(): string;
 }
-type IdentityColumn<T extends Column.Pick.Data> = Column.Modifiers.Default<T, Expression>;
 declare class SmallIntColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
   dataType: "int2";
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.Modifiers.HasDefault<T>;
 }
 declare class IntegerColumn<Schema extends ColumnSchemaConfig> extends IntegerBaseColumn<Schema> {
   dataType: "int4";
   querySchema: ReturnType<Schema['int']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.Modifiers.HasDefault<T>;
 }
 declare class BigIntColumn<Schema extends ColumnSchemaConfig> extends NumberAsStringBaseColumn<Schema, string | number | bigint> {
   dataType: "int8";
   querySchema: ReturnType<Schema['stringSchema']>;
   constructor(schema: Schema);
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
-  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): IdentityColumn<T>;
+  identity<T extends Column.Pick.Data>(this: T, options?: TableData.Identity): Column.Modifiers.HasDefault<T>;
 }
 declare class RealColumn<Schema extends ColumnSchemaConfig> extends NumberBaseColumn<Schema, ReturnType<Schema['number']>> {
   dataType: "float4";
@@ -1332,6 +1357,7 @@ declare class JSONTextColumn<T, Schema extends ColumnTypeSchemaArg, InputSchema
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 interface DefaultSchemaConfig extends ColumnSchemaConfig<Column> {
+  nullable<T extends Column.Pick.ForNullable>(this: T): Column.Modifiers.Nullable<T>;
   parse<T extends Column.Pick.ForParse, Output>(this: T, fn: (input: T['__type']) => Output): Column.Modifiers.Parse<T, unknown, Output>;
   parseNull<T extends Column.Pick.ForParseNull, Output>(this: T, fn: () => Output): Column.Modifiers.ParseNull<T, unknown, Output>;
   encode<T extends Column.Pick.Type, Input>(this: T, fn: (input: Input) => unknown): Column.Modifiers.Encode<T, unknown, Input>;
@@ -1730,7 +1756,7 @@ declare class UUIDColumn<Schema extends ColumnSchemaConfig> extends Column {
   T & {
     data: {
       primaryKey: Name;
-      default: RawSqlBase;
+      default: true;
     };
   };
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
@@ -1782,8 +1808,8 @@ declare class BooleanColumn<Schema extends ColumnSchemaConfig> extends Column {
   toCode(ctx: ColumnToCodeCtx, key: string): Code;
 }
 interface Timestamps<T extends Column.Pick.Data> {
-  createdAt: Column.Modifiers.Default<T, RawSqlBase>;
-  updatedAt: Column.Modifiers.Default<T, RawSqlBase>;
+  createdAt: Column.Modifiers.HasDefault<T>;
+  updatedAt: Column.Modifiers.HasDefault<T>;
 }
 interface TimestampHelpers {
   /**
@@ -1866,7 +1892,7 @@ interface DefaultColumnTypes<SchemaConfig extends ColumnSchemaConfig> extends Ti
   decimal: SchemaConfig['decimal'];
   real: SchemaConfig['real'];
   doublePrecision: SchemaConfig['doublePrecision'];
-  identity(options?: TableData.Identity): IdentityColumn<ReturnType<SchemaConfig['integer']>>;
+  identity(options?: TableData.Identity): Column.Modifiers.HasDefault<ReturnType<SchemaConfig['integer']>>;
   smallSerial: SchemaConfig['smallSerial'];
   serial: SchemaConfig['serial'];
   bigSerial: SchemaConfig['bigSerial'];
@@ -5038,6 +5064,10 @@ interface DbTableOptions<ColumnTypes, Table extends string | undefined, Shape ex
    * Exclude a table-like definition from migration DDL generation.
    */
   generatorIgnore?: true | undefined;
+  /**
+   * Database relation name. The public `table` name remains a query alias.
+   */
+  nameInDb?: string;
   /**
    * Computed SQL or JS columns definitions
    */
@@ -5066,7 +5096,7 @@ declare class Db<Table extends string | undefined = undefined, Shape extends Col
   } ? true : undefined;
   __hasSelect: boolean;
   __hasWhere: boolean;
-  __defaults: { [K in { [K in keyof Shape]: unknown extends Shape[K]['data']['default'] ? never : K }[keyof Shape]]: true };
+  __defaults: { [K in { [K in keyof Shape]: Shape[K]['data']['default'] extends true ? K : never }[keyof Shape]]: true };
   __scopes: { [K in keyof MapTableScopesOption<Options>]: true };
   __defaultSelect: ColumnsShape.DefaultSelectKeys<Shape>;
   baseQuery: Query;
@@ -6603,7 +6633,8 @@ declare namespace Column {
         unique: Name;
       };
     };
-    export type Nullable<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
+    export type Nullable<T extends Column.Pick.ForNullable> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends '__queryType' ? T['__queryType'] | null : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
+    export type NullableWithSchema<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema> = { [K in keyof T]: K extends '__type' ? T['__type'] | null : K extends '__inputType' ? T['__inputType'] | null : K extends 'inputSchema' ? InputSchema : K extends '__outputType' ? T['__outputType'] | (unknown extends T['__nullType'] ? null : T['__nullType']) : K extends 'outputSchema' ? OutputSchema : K extends '__queryType' ? T['__queryType'] | null : K extends 'querySchema' ? QuerySchema : K extends 'data' ? T['data'] & DataNullable : K extends 'operators' ? { [K in keyof T['operators']]: K extends 'equals' | 'not' | 'isDistinctFrom' | 'isNotDistinctFrom' ? Operator<T['__queryType'] | null, T> : T['operators'][K] } : T[K] };
     export type QueryColumnToNullable<C> = { [K in keyof C]: K extends '__outputType' | '__queryType' ? C[K] | null : C[K] };
     export type QueryColumnToOptional<C> = { [K in keyof C]: K extends '__outputType' ? C[K] | undefined : C[K] };
     interface DataNullable {
@@ -6619,8 +6650,7 @@ declare namespace Column {
     export type Encode<T, InputSchema, Input> = { [K in keyof T]: K extends '__inputType' ? Input : K extends 'inputSchema' ? InputSchema : T[K] };
     export type Parse<T extends Pick.ForParse, OutputSchema, Output> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? (Output extends null ? never : Output) | (unknown extends T['__nullType'] ? null : T['__nullType']) : Output : K extends 'outputSchema' ? null extends T['__type'] ? OutputSchema | T['nullSchema'] : OutputSchema : T[K] };
     export type ParseNull<T extends Column.Pick.ForParseNull, NullSchema, NullType> = { [K in keyof T]: K extends '__outputType' ? null extends T['__type'] ? Exclude<T['__outputType'], null> | NullType : T['__outputType'] : K extends '__nullType' ? NullType : K extends 'outputSchema' ? null extends T['__type'] ? T['outputSchema'] | NullSchema : T['outputSchema'] : K extends 'nullSchema' ? NullSchema : T[K] };
-    type DefaultData<T extends Column.Data, Value> = { [K in keyof T]: K extends 'default' ? Value extends null ? never : Value : K extends 'optional' ? true : T[K] };
-    export type Default<T extends Column.Pick.Data, Value> = { [K in keyof T]: K extends 'data' ? DefaultData<T['data'], Value> : T[K] };
+    export type HasDefault<T extends Column.Pick.Data> = T & Column.Data.Default;
     type DefaultSelectData<T extends Column.Data, Value> = { [K in keyof T]: K extends 'explicitSelect' ? Value extends true ? false : true : T[K] };
     export type DefaultSelect<T extends Column.Pick.Data, Value extends boolean> = { [K in keyof T]: K extends 'data' ? DefaultSelectData<T['data'], Value> : T[K] };
     export interface IsAppReadOnly {
@@ -6720,6 +6750,7 @@ declare namespace Column {
     interface TableParamInstance {
       schema?: string;
       table: string;
+      nameInDb?: string;
       columns: PickQueryShape;
     }
     interface TableParam {
@@ -6811,6 +6842,12 @@ declare namespace Column {
     skipValueToArray?: boolean;
   }
   export namespace Data {
+    interface Default {
+      data: {
+        default: true;
+        optional: true;
+      };
+    }
     interface Check {
       sql: RawSqlBase;
       name?: string;
@@ -6837,7 +6874,7 @@ declare namespace Column {
   export type AsTypeArg<Schema> = AsTypeArgWithType<Schema> | AsTypeArgWithoutType<Schema>;
   export {};
 }
-declare function makeColumnNullable<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema>(column: T, inputSchema: InputSchema, outputSchema: OutputSchema, querySchema: QuerySchema): Column.Modifiers.Nullable<T, InputSchema, OutputSchema, QuerySchema>;
+declare function makeColumnNullable<T extends Column.Pick.ForNullable, InputSchema, OutputSchema, QuerySchema>(column: T, inputSchema: InputSchema, outputSchema: OutputSchema, querySchema: QuerySchema): Column.Modifiers.NullableWithSchema<T, InputSchema, OutputSchema, QuerySchema>;
 declare const setColumnData: <T extends Column.Pick.Data, K extends keyof T["data"]>(q: T, key: K, value: T["data"][K]) => T;
 declare const setDataValue: <T extends Column.Pick.Data, Key extends string, Value>(item: T, key: Key, value: Value, params?: Column.Error.StringOrMessage) => T;
 declare function setCurrentColumnName(name: string): void;
@@ -6887,13 +6924,13 @@ declare abstract class Column {
    *
    * @param value - default value or a function returning a value
    */
-  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase | (() => T['__inputType'])>(this: T, value: Value): Column.Modifiers.Default<T, Value>;
+  default<T extends Column.Pick.DataAndInputType, Value extends T['__inputType'] | null | RawSqlBase | (() => T['__inputType'])>(this: T, value: Value): Column.Modifiers.HasDefault<T>;
   /**
    * Use `hasDefault` to let the column be omitted when creating records.
    *
    * It's better to use {@link default} instead so the value is explicit and serves as a hint.
    */
-  hasDefault<T extends Column.Pick.Data>(this: T): Column.Modifiers.Default<T, RawSqlBase>;
+  hasDefault<T extends Column.Pick.Data>(this: T): Column.Modifiers.HasDefault<T>;
   /**
    * Set a database-level validation check to a column. `check` accepts a raw SQL.
    *
@@ -7586,7 +7623,7 @@ declare abstract class Column {
     data: Column['data'];
     dataType: string;
   }>(this: T, ...args: [options?: TableData.Index.TsVectorColumnArg]): T;
-  unique<T extends Column.Pick.Data, const Options extends TableData.Index.ColumnArg>(this: T, ...args: [options?: Options]): T & Column.Modifiers.IsUnique<Options['name'] & string>;
+  unique<T extends Column.Pick.Data, const Options extends TableData.Index.UniqueColumnArg>(this: T, ...args: [options?: Options]): T & Column.Modifiers.IsUnique<Options['name'] & string>;
   /**
    * Add [EXCLUDE constraint](https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-EXCLUDE) to the column.
    *
@@ -8960,6 +8997,7 @@ interface QueryData extends QueryDataAliases, PickQueryDataParsers, HasHookSelec
   type: QueryType;
   adapter: Adapter;
   selectShape: ColumnsShape;
+  nameInDb?: string;
   handleResult: HandleResult;
   catch?: boolean;
   returnType: QueryReturnType;

package/dist/index.js

@@ -170,7 +170,7 @@ const toPascalCase = (str) => {
 * @param str - string to translate
 */
 const toSnakeCase = (str) => {
-	return str.replace(/[A-Z]/g, (a) => `_${a.toLowerCase()}`);
+	return str.replace(/[A-Z]/g, (a, i) => `${i ? "_" : ""}${a.toLowerCase()}`);
 };
 /**
 * Compare two values deeply.
@@ -1436,6 +1436,7 @@ const indexInnerToCode = (index, t) => {
 		"name",
 		"using",
 		"nullsNotDistinct",
+		"deferrable",
 		"include",
 		"with",
 		"tablespace",
@@ -1617,6 +1618,7 @@ const columnIndexesToCode = (items) => {
 			options.using && `using: ${singleQuote(options.using)},`,
 			options.include && `include: ${typeof options.include === "string" ? singleQuote(options.include) : `[${options.include.map(singleQuote).join(", ")}]`},`,
 			options.nullsNotDistinct && `nullsNotDistinct: true,`,
+			options.deferrable && `deferrable: ${singleQuote(options.deferrable)},`,
 			options.with && `with: ${singleQuote(options.with)},`,
 			options.tablespace && `tablespace: ${singleQuote(options.tablespace)},`,
 			options.where && `where: ${singleQuote(options.where)},`
@@ -5619,20 +5621,7 @@ const processJoinArgs = (joinTo, first, args, joinSubQuery, shape, whereExists,
 	const args0 = args.length ? args[0] : returnArg;
 	if (typeof args0 === "function") {
 		let q = first;
-		if (q.joinQueryAfterCallback) {
-			let base = q.baseQuery;
-			if (q.q.as) base = base.as(q.q.as);
-			const { q: query } = q.joinQueryAfterCallback(base, joinTo);
-			if (query.and || query.or || query.scopes) {
-				q = _clone(q);
-				if (query.and) pushQueryArrayImmutable(q, "and", query.and);
-				if (query.or) pushQueryArrayImmutable(q, "or", query.or);
-				if (query.scopes) q.q.scopes = {
-					...q.q.scopes,
-					...query.scopes
-				};
-			}
-		}
+		if (q.joinQueryAfterCallback) q = q.joinQueryAfterCallback(q, joinTo);
 		const joinedShapes = {
 			...joinTo.q.joinedShapes,
 			[joinTo.q.as || joinTo.table]: joinTo.shape
@@ -6625,12 +6614,12 @@ const processJoinItem = (ctx, table, query, args, quotedAs) => {
 		ctx.aliasValue = aliasValue;
 	} else if ("j" in args) {
 		const { j, s, r } = args;
-		const tableName = typeof j.q.from === "string" ? j.q.from : j.table;
-		const joinTable = requireTableOrStringFrom(j);
+		const joinTable = j.q.nameInDb || requireTableOrStringFrom(j);
 		target = quoteFromWithSchema(getQuerySchema$1(j), joinTable);
 		const as = j.q.as;
 		const joinAs = `"${as}"`;
-		if (as !== tableName) target += ` ${joinAs}`;
+		const alias = getQueryRelationAliasForAs(j, as);
+		if (alias) target += ` ${alias}`;
 		if (r && s) target = subJoinToSql(ctx, j, `"${joinTable}"`, !forbidLateral, joinAs, true);
 		else on = whereToSql(ctx, j, j.q, joinAs);
 	} else if ("w" in args) {
@@ -6688,16 +6677,16 @@ const getArgQueryTarget = (ctx, first, lateral, joinSubQuery, cloned) => {
 	const quotedFrom = typeof joinQuery.from === "string" ? `"${joinQuery.from}"` : void 0;
 	let joinAs = quotedFrom || `"${first.table}"`;
 	const qAs = joinQuery.as ? `"${joinQuery.as}"` : void 0;
-	const addAs = qAs && qAs !== joinAs;
+	const aliasToAdd = getQueryRelationAliasForAs(first, joinQuery.as);
 	if (joinSubQuery) return {
 		target: subJoinToSql(ctx, first, joinAs, lateral, qAs, cloned),
-		joinAs: addAs ? qAs : joinAs
+		joinAs: qAs || joinAs
 	};
 	else {
 		let target = quotedFrom || quoteTableWithSchema(first);
-		if (addAs) {
-			joinAs = qAs;
-			target += ` ${qAs}`;
+		if (aliasToAdd) {
+			joinAs = aliasToAdd;
+			target += ` ${aliasToAdd}`;
 		}
 		return {
 			target,
@@ -7455,14 +7444,18 @@ const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
 		}
 	}
 	const hasNonSelect = ctx.hasNonSelect;
+	const returningQuotedAs = query.as ? `"${query.as}"` : quotedAs;
+	const insertAlias = getQueryRelationAliasForAs(q, query.as);
+	quotedAs = insertAlias || quotedAs;
 	const sqlState = {
 		ctx,
 		q,
 		query,
 		quotedAs,
+		returningQuotedAs,
 		isSubSql,
 		returningPos: 0,
-		insertSql: `INSERT INTO ${quoteTableWithSchema(q)}${quotedColumns.length ? "(" + quotedColumns.join(", ") + ")" : ""}`
+		insertSql: `INSERT INTO ${quoteTableWithSchema(q)}${insertAlias ? ` AS ${insertAlias}` : ""}${quotedColumns.length ? "(" + quotedColumns.join(", ") + ")" : ""}`
 	};
 	ctx.sql.push(null, null);
 	const hasOnConflictWhere = pushOnConflictSql(ctx, q, query, quotedAs, columns, quotedColumns, runtimeDefaultColumns);
@@ -7575,7 +7568,7 @@ const applySqlState = (sqlState) => {
 	const insertSql = sqlState.selectFromSql ? sqlState.insertSql + sqlState.selectFromSql : sqlState.insertSql;
 	const wrapInCte = getShouldWrapMainQueryInCte(ctx, sqlState.query, "insert", sqlState.isSubSql);
 	if ("valuesSql" in sqlState) ctx.sql[1] = sqlState.valuesPrepend + sqlState.valuesSql.join(", ") + sqlState.valuesAppend;
-	const returning = makeReturningSql(ctx, sqlState.q, sqlState.query, sqlState.quotedAs, sqlState.relationSelectState, "Create", void 0, sqlState.isSubSql || !!ctx.topCtx.cteHooks);
+	const returning = makeReturningSql(ctx, sqlState.q, sqlState.query, sqlState.returningQuotedAs, sqlState.relationSelectState, "Create", void 0, sqlState.isSubSql || !!ctx.topCtx.cteHooks);
 	if (returning) ctx.sql[sqlState.returningPos] = "RETURNING " + returning;
 	ctx.sql[0] = insertSql;
 	if (wrapInCte) wrapMainQueryInCte(ctx, sqlState.query);
@@ -7736,8 +7729,9 @@ const pushUpdateSql = (ctx, query, q, quotedAs, isSubSql) => {
 	}
 };
 const pushUpdateSqlWithoutValuesJoinedAs = (ctx, query, q, quotedAs, isSubSql) => {
-	const quotedTable = `"${query.table || q.from}"`;
 	const from = quoteTableWithSchema(query);
+	const alias = getQueryRelationAliasForAs(query, q.as);
+	quotedAs = alias || quotedAs;
 	const set = [];
 	const hookSet = q.hookUpdateSet ? Object.fromEntries(q.hookUpdateSet.flatMap((item) => Object.entries(item))) : emptyObject;
 	const relationSelectState = newMutativeQueriesSelectRelationsSqlState(query);
@@ -7752,7 +7746,7 @@ const pushUpdateSqlWithoutValuesJoinedAs = (ctx, query, q, quotedAs, isSubSql) =
 	if (!set.length) pushSelectForEmptySet(ctx, query, q, quotedAs, from, isSubSql, updateManyValuesSql, relationSelectState);
 	else {
 		ctx.sql.push(`UPDATE ${from}`);
-		if (quotedTable !== quotedAs) ctx.sql.push(quotedAs);
+		if (alias) ctx.sql.push(alias);
 		ctx.sql.push("SET", set.join(", "));
 		let fromWhereSql;
 		if (updateManyValuesSql) {
@@ -7769,6 +7763,8 @@ const pushSelectForEmptySet = (ctx, query, q, quotedAs, from, isSubSql, updateMa
 	if (!q.select) q.select = countSelect;
 	pushUpdateReturning(ctx, query, q, quotedAs, "SELECT", relationSelectState, isSubSql);
 	let fromSql = `FROM ${from}`;
+	const alias = getQueryRelationAliasForAs(query, q.as);
+	if (alias) fromSql += ` ${alias}`;
 	if (updateManyValuesSql) fromSql += `, ${updateManyValuesSql}`;
 	ctx.sql.push(fromSql);
 	pushWhereStatementSql(ctx, query, q, quotedAs);
@@ -7883,7 +7879,8 @@ const throwOnDifferentColumns = (query, keysSet, row, i) => {
 const pushDeleteSql = (ctx, query, q, quotedAs, isSubSql) => {
 	const from = quoteTableWithSchema(query);
 	ctx.sql.push(`DELETE FROM ${from}`);
-	if (q.as && query.table !== q.as) ctx.sql.push(quotedAs);
+	const alias = getQueryRelationAliasForAs(query, q.as);
+	if (alias) ctx.sql.push(alias);
 	const relationSelectState = newMutativeQueriesSelectRelationsSqlState(query);
 	let returning = makeReturningSql(ctx, query, q, quotedAs, relationSelectState, "Delete", void 0, isSubSql);
 	const selectRelations = handleDeleteSelectRelationsSqlState(ctx, query, relationSelectState);
@@ -9468,7 +9465,8 @@ const getFrom = (ctx, query, data, quotedAs) => {
 		return fromToSql(ctx, query, data, from, quotedAs);
 	}
 	let sql = quoteTableWithSchema(query);
-	if (data.as && query.table !== data.as) sql += ` ${quotedAs}`;
+	const alias = getQueryRelationAliasForAs(query, data.as);
+	if (alias) sql += ` ${alias}`;
 	if (data.only) sql = `ONLY ${sql}`;
 	return sql;
 };
@@ -9480,7 +9478,7 @@ const fromToSql = (ctx, query, data, from, quotedAs) => {
 		only = from.q.only;
 		if (!from.table) sql = `(${moveMutativeQueryToCte(ctx, from)})`;
 		else if (!checkIfASimpleQuery(from)) sql = `(${moveMutativeQueryToCte(ctx, from)}) ${quotedAs || `"${getQueryAs(from)}"`}`;
-		else sql = quoteTableWithSchema(from);
+		else sql = quoteTableWithSchemaAndAlias(from);
 		fromQuery = from;
 	}
 	else sql = quoteFromWithSchema(getQuerySchema$1(query), from);
@@ -9781,7 +9779,18 @@ const requireTableOrStringFrom = (query) => {
 	if (!table) throw new OrchidOrmInternalError(query, "The query object does not have a table and doesn't define a `from` string");
 	return table;
 };
-const quoteTableWithSchema = (query) => quoteFromWithSchema(getQuerySchema$1(query), requireTableOrStringFrom(query));
+const getQueryRelationAlias = (query) => query.table && query.q.nameInDb && query.table !== query.q.nameInDb ? `"${query.table}"` : void 0;
+const getQueryRelationAliasForAs = (query, as) => {
+	if (!as) return getQueryRelationAlias(query);
+	const nameInDb = query.q.nameInDb || requireTableOrStringFrom(query);
+	return nameInDb && as !== nameInDb ? `"${as}"` : void 0;
+};
+const quoteTableWithSchema = (query) => quoteFromWithSchema(getQuerySchema$1(query), query.q.nameInDb || requireTableOrStringFrom(query));
+const quoteTableWithSchemaAndAlias = (query) => {
+	const table = quoteTableWithSchema(query);
+	const alias = getQueryRelationAlias(query);
+	return alias ? `${table} ${alias}` : table;
+};
 const quoteFromWithSchema = (schema, table) => {
 	const s = typeof schema === "function" ? schema() : schema;
 	return s ? `"${s}"."${table}"` : `"${table}"`;
@@ -10049,7 +10058,7 @@ const _joinLateral = (self, type, joinQuery, as, innerJoinLateral) => {
 		const joinedAs = getQueryAs(query);
 		setObjectValueImmutable(joinQuery.q, "joinedShapes", joinedAs, query.q.selectShape);
 	}
-	const shape = getShapeFromSelect(joinQuery, true);
+	const shape = joinQuery.table && joinQuery.q.joinedShapes?.[joinQuery.table] || joinQuery.q.joinedShapes?.[joinAs] || getShapeFromSelect(joinQuery, true);
 	setObjectValueImmutable(query.q, "joinedShapes", joinAs, shape);
 	if (joinValue) setObjectValueImmutable(query.q, "valuesJoinedAs", joinAs, joinValueAs);
 	setObjectValueImmutable(query.q, "joinedParsers", joinValueAs || joinAs, getQueryParsers(joinQuery));
@@ -10949,6 +10958,7 @@ const processNestedSelectPathEntry = (batches, path, thisKey, thisReturnType, i,
 		key: thisKey
 	});
 	else {
+		if (!data) return;
 		const { key, returnType } = path[++i];
 		if (!thisReturnType || thisReturnType === "all") for (const row of data) processNestedSelectPathEntry(batches, path, key, returnType, i, last, row);
 		else processNestedSelectPathEntry(batches, path, key, returnType, i, last, data);
@@ -13895,6 +13905,7 @@ const performQuery = async (q, args, method) => {
 		throw err;
 	}
 };
+const getTableNameInDb = (table, nameInDb, snakeCase) => table && (nameInDb || (snakeCase ? toSnakeCase(table) : table));
 var Db = class extends QueryMethods {
 	constructor(adapterNotInTransaction, qb, table = void 0, shape, columnTypes, asyncStorage, options, tableData = {}, viewData) {
 		super();
@@ -13972,6 +13983,7 @@ var Db = class extends QueryMethods {
 		this.q = {
 			adapter: adapterNotInTransaction,
 			selectShape: shape,
+			nameInDb: getTableNameInDb(table, options.nameInDb, snakeCase),
 			handleResult,
 			logger,
 			log: logParamToLogObject(logger, options.log),
@@ -14308,7 +14320,7 @@ const _initQueryBuilder = (adapter, columnTypes, asyncStorage, commonOptions, op
 const makeColumnInfoSql = (query, column) => {
 	const values = [];
 	const schema = getQuerySchema(query);
-	let text = `SELECT * FROM information_schema.columns WHERE table_name = ${addValue(values, query.table)} AND table_catalog = current_database() AND table_schema = ${schema ? addValue(values, schema) : "current_schema()"}`;
+	let text = `SELECT * FROM information_schema.columns WHERE table_name = ${addValue(values, query.q.nameInDb || query.table)} AND table_catalog = current_database() AND table_schema = ${schema ? addValue(values, schema) : "current_schema()"}`;
 	if (column) text += ` AND column_name = ${addValue(values, query.shape[column]?.data.name || column)}`;
 	return {
 		text,