kysely 0.19.4 → 0.19.7

package/dist/cjs/dialect/database-introspector.d.ts

@@ -1,4 +1,3 @@
-import { ColumnDataType } from '../operation-node/data-type-node.js';
 /**
  * An interface for getting the database metadata (names of the tables and columns etc.)
  */
@@ -41,6 +40,16 @@ export interface TableMetadata {
 }
 export interface ColumnMetadata {
     readonly name: string;
-    readonly dataType: ColumnDataType;
+    /**
+     * The data type of the column as reported by the database.
+     *
+     * NOTE: This value is whatever the database engine returns and it will be
+     *       different on different dialects even if you run the same migrations.
+     *       For example `integer` datatype in a migration will produce `int4`
+     *       on PostgreSQL, `INTEGER` on SQLite and `int` on MySQL.
+     */
+    readonly dataType: string;
+    readonly isAutoIncrementing: boolean;
     readonly isNullable: boolean;
+    readonly hasDefaultValue: boolean;
 }

package/dist/cjs/dialect/mysql/mysql-introspector.js

@@ -22,10 +22,12 @@ class MysqlIntrospector {
             .selectFrom('information_schema.columns')
             .select([
             'column_name',
+            'column_default',
             'table_name',
             'table_schema',
             'is_nullable',
             'data_type',
+            'extra',
         ])
             .where('table_schema', '=', (0, sql_js_1.sql) `database()`)
             .castTo();
@@ -57,6 +59,8 @@ class MysqlIntrospector {
                 name: it.COLUMN_NAME,
                 dataType: it.DATA_TYPE,
                 isNullable: it.IS_NULLABLE === 'YES',
+                isAutoIncrementing: it.EXTRA.toLowerCase().includes('auto_increment'),
+                hasDefaultValue: it.COLUMN_DEFAULT !== null,
             }));
             return tables;
         }, []);

package/dist/cjs/dialect/postgres/postgres-introspector.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresIntrospector = void 0;
 const migrator_js_1 = require("../../migration/migrator.js");
 const object_utils_js_1 = require("../../util/object-utils.js");
+const sql_js_1 = require("../../raw-builder/sql.js");
 class PostgresIntrospector {
     #db;
     constructor(db) {
@@ -25,9 +26,18 @@ class PostgresIntrospector {
             .select([
             'a.attname as column',
             'a.attnotnull as not_null',
+            'a.atthasdef as has_default',
             't.tablename as table',
             't.schemaname as schema',
             'typ.typname as type',
+            // Detect if the column is auto incrementing by finding the sequence
+            // that is created for `serial` and `bigserial` columns.
+            this.#db
+                .selectFrom('pg_class')
+                .select((0, sql_js_1.sql) `true`.as('auto_incrementing'))
+                .where('relkind', '=', 'S')
+                .where('relname', '=', (0, sql_js_1.sql) `t.tablename || '_' || a.attname || '_seq'`)
+                .as('auto_incrementing'),
         ])
             .where('t.schemaname', '!~', '^pg_')
             .where('t.schemaname', '!=', 'information_schema')
@@ -62,6 +72,8 @@ class PostgresIntrospector {
                 name: it.column,
                 dataType: it.type,
                 isNullable: !it.not_null,
+                isAutoIncrementing: !!it.auto_incrementing,
+                hasDefaultValue: it.has_default,
             }));
             return tables;
         }, []);

package/dist/cjs/dialect/sqlite/sqlite-introspector.js

@@ -34,9 +34,22 @@ class SqliteIntrospector {
     }
     async #getTableMetadata(table) {
         const db = this.#db;
+        // Get the SQL that was used to create the table.
+        const createSql = await db
+            .selectFrom('sqlite_master')
+            .where('name', '=', table)
+            .select('sql')
+            .castTo()
+            .execute();
+        // Try to find the name of the column that has `autoincrement` 🤦
+        const autoIncrementCol = createSql[0]?.sql
+            ?.split(/[\(\),]/)
+            ?.find((it) => it.toLowerCase().includes('autoincrement'))
+            ?.split(/\s+/)?.[0]
+            ?.replace(/["`]/g, '');
         const columns = await db
-            .selectFrom((0, sql_js_1.sql) `PRAGMA_TABLE_INFO(${table})`.as('table_info'))
-            .select(['name', 'type', 'notnull'])
+            .selectFrom((0, sql_js_1.sql) `pragma_table_info(${table})`.as('table_info'))
+            .select(['name', 'type', 'notnull', 'dflt_value'])
             .execute();
         return {
             name: table,
@@ -44,6 +57,8 @@ class SqliteIntrospector {
                 name: col.name,
                 dataType: col.type,
                 isNullable: !col.notnull,
+                isAutoIncrementing: col.name === autoIncrementCol,
+                hasDefaultValue: !!col.dflt_value,
             })),
         };
     }

package/dist/cjs/operation-node/join-node.d.ts

@@ -4,7 +4,7 @@ import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export declare type JoinTableNode = TableNode | AliasNode;
-export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin';
+export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;

package/dist/cjs/operation-node/operation-node-transformer.js

@@ -256,6 +256,8 @@ class OperationNodeTransformer {
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
+            orderBy: this.transformNode(node.orderBy),
+            limit: this.transformNode(node.limit),
         };
     }
     transformReturning(node) {
@@ -480,6 +482,7 @@ class OperationNodeTransformer {
         return {
             kind: 'CreateSchemaNode',
             schema: this.transformNode(node.schema),
+            ifNotExists: node.ifNotExists,
         };
     }
     transformDropSchema(node) {

package/dist/cjs/parser/join-parser.d.ts

@@ -1,10 +1,10 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
-import { TableExpressionDatabase, TableExpressionTables } from './table-parser.js';
+import { From, FromTables } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 export declare type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>) => JoinBuilder<any, any>;
-declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
+declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
+declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
 export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
 export {};

package/dist/cjs/parser/table-parser.d.ts

@@ -7,12 +7,12 @@ import { AliasedComplexExpression } from './complex-expression-parser.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedComplexExpression<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AnyAliasedRawBuilder;
-export declare type TableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
-    [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
+export declare type From<DB, TE> = {
+    [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
-export declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;
-export declare type TableExpressionTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
-export declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
+export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
+declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;
+declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
 declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): TableExpressionNode[];

package/dist/cjs/query-builder/expression-builder.d.ts

@@ -1,5 +1,5 @@
 import { SelectQueryBuilder } from './select-query-builder.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
+import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { FunctionBuilder } from './function-builder.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
@@ -83,8 +83,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * that case Kysely typings wouldn't allow you to reference `pet.owner_id`
      * because `pet` is not joined to that query.
      */
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
     /**
      * See {@link QueryCreator.withSchema}
      */

package/dist/cjs/query-builder/join-builder.d.ts

@@ -66,6 +66,10 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      * See {@link WhereInterface.orWhereNotExists} for documentation and examples.
      */
     orOnNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
+    /**
+     * Adds `on true`.
+     */
+    onTrue(): JoinBuilder<DB, TB>;
     toOperationNode(): JoinNode;
 }
 export interface JoinBuilderProps {

package/dist/cjs/query-builder/join-builder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinBuilder = void 0;
 const join_node_js_1 = require("../operation-node/join-node.js");
+const raw_node_js_1 = require("../operation-node/raw-node.js");
 const filter_parser_js_1 = require("../parser/filter-parser.js");
 const object_utils_js_1 = require("../util/object-utils.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
@@ -94,6 +95,15 @@ class JoinBuilder {
             joinNode: join_node_js_1.JoinNode.cloneWithOrOn(this.#props.joinNode, (0, filter_parser_js_1.parseNotExistFilter)(arg)),
         });
     }
+    /**
+     * Adds `on true`.
+     */
+    onTrue() {
+        return new JoinBuilder({
+            ...this.#props,
+            joinNode: join_node_js_1.JoinNode.cloneWithOn(this.#props.joinNode, raw_node_js_1.RawNode.createWithSql('true')),
+        });
+    }
     toOperationNode() {
         return this.#props.joinNode;
     }

package/dist/cjs/query-builder/select-query-builder.d.ts

@@ -873,6 +873,46 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
     fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral join instead of an inner join.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .innerJoinLateral(
+     *     (eb) =>
+     *       eb.selectFrom('pet')
+     *         .select('name')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *         .as('p'),
+     *     (join) => join.onTrue()
+     *   )
+     *   .select(['first_name', 'p.name'])
+     *   .orderBy('first_name')
+     */
+    innerJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    innerJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral left join instead of an inner join.
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .leftJoinLateral(
+     *     (eb) =>
+     *       eb.selectFrom('pet')
+     *         .select('name')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *         .as('p'),
+     *     (join) => join.onTrue()
+     *   )
+     *   .select(['first_name', 'p.name'])
+     *   .orderBy('first_name')
+     * ```
+     */
+    leftJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Adds an `order by` clause to the query.
      *

package/dist/cjs/query-builder/select-query-builder.js

@@ -237,6 +237,18 @@ class SelectQueryBuilder {
             queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('FullJoin', args)),
         });
     }
+    innerJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('LateralInnerJoin', args)),
+        });
+    }
+    leftJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: query_node_js_1.QueryNode.cloneWithJoin(this.#props.queryNode, (0, join_parser_js_1.parseJoin)('LateralLeftJoin', args)),
+        });
+    }
     /**
      * Adds an `order by` clause to the query.
      *

package/dist/cjs/query-builder/update-query-builder.d.ts

@@ -1,7 +1,7 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
+import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
@@ -434,8 +434,8 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * where "pet"."owner_id" = "person"."id"
      * ```
      */
-    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -839,4 +839,6 @@ const JOIN_TYPE_SQL = (0, object_utils_js_1.freeze)({
     LeftJoin: 'left join',
     RightJoin: 'right join',
     FullJoin: 'full join',
+    LateralInnerJoin: 'inner join lateral',
+    LateralLeftJoin: 'left join lateral',
 });

package/dist/cjs/query-creator.d.ts

@@ -2,7 +2,7 @@ import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
 import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
+import { TableExpression, From, FromTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
@@ -120,8 +120,8 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     /**
      * Creates an insert query.
      *
@@ -180,7 +180,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numDeletedRows)
      * ```
      */
-    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, DeleteResult>;
+    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.
      *
@@ -204,7 +204,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/esm/dialect/database-introspector.d.ts

@@ -1,4 +1,3 @@
-import { ColumnDataType } from '../operation-node/data-type-node.js';
 /**
  * An interface for getting the database metadata (names of the tables and columns etc.)
  */
@@ -41,6 +40,16 @@ export interface TableMetadata {
 }
 export interface ColumnMetadata {
     readonly name: string;
-    readonly dataType: ColumnDataType;
+    /**
+     * The data type of the column as reported by the database.
+     *
+     * NOTE: This value is whatever the database engine returns and it will be
+     *       different on different dialects even if you run the same migrations.
+     *       For example `integer` datatype in a migration will produce `int4`
+     *       on PostgreSQL, `INTEGER` on SQLite and `int` on MySQL.
+     */
+    readonly dataType: string;
+    readonly isAutoIncrementing: boolean;
     readonly isNullable: boolean;
+    readonly hasDefaultValue: boolean;
 }

package/dist/esm/dialect/mysql/mysql-introspector.js

@@ -20,10 +20,12 @@ export class MysqlIntrospector {
             .selectFrom('information_schema.columns')
             .select([
             'column_name',
+            'column_default',
             'table_name',
             'table_schema',
             'is_nullable',
             'data_type',
+            'extra',
         ])
             .where('table_schema', '=', sql `database()`)
             .castTo();
@@ -55,6 +57,8 @@ export class MysqlIntrospector {
                 name: it.COLUMN_NAME,
                 dataType: it.DATA_TYPE,
                 isNullable: it.IS_NULLABLE === 'YES',
+                isAutoIncrementing: it.EXTRA.toLowerCase().includes('auto_increment'),
+                hasDefaultValue: it.COLUMN_DEFAULT !== null,
             }));
             return tables;
         }, []);

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -1,6 +1,7 @@
 /// <reference types="./postgres-introspector.d.ts" />
 import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
 import { freeze } from '../../util/object-utils.js';
+import { sql } from '../../raw-builder/sql.js';
 export class PostgresIntrospector {
     #db;
     constructor(db) {
@@ -23,9 +24,18 @@ export class PostgresIntrospector {
             .select([
             'a.attname as column',
             'a.attnotnull as not_null',
+            'a.atthasdef as has_default',
             't.tablename as table',
             't.schemaname as schema',
             'typ.typname as type',
+            // Detect if the column is auto incrementing by finding the sequence
+            // that is created for `serial` and `bigserial` columns.
+            this.#db
+                .selectFrom('pg_class')
+                .select(sql `true`.as('auto_incrementing'))
+                .where('relkind', '=', 'S')
+                .where('relname', '=', sql `t.tablename || '_' || a.attname || '_seq'`)
+                .as('auto_incrementing'),
         ])
             .where('t.schemaname', '!~', '^pg_')
             .where('t.schemaname', '!=', 'information_schema')
@@ -60,6 +70,8 @@ export class PostgresIntrospector {
                 name: it.column,
                 dataType: it.type,
                 isNullable: !it.not_null,
+                isAutoIncrementing: !!it.auto_incrementing,
+                hasDefaultValue: it.has_default,
             }));
             return tables;
         }, []);

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -32,9 +32,22 @@ export class SqliteIntrospector {
     }
     async #getTableMetadata(table) {
         const db = this.#db;
+        // Get the SQL that was used to create the table.
+        const createSql = await db
+            .selectFrom('sqlite_master')
+            .where('name', '=', table)
+            .select('sql')
+            .castTo()
+            .execute();
+        // Try to find the name of the column that has `autoincrement` 🤦
+        const autoIncrementCol = createSql[0]?.sql
+            ?.split(/[\(\),]/)
+            ?.find((it) => it.toLowerCase().includes('autoincrement'))
+            ?.split(/\s+/)?.[0]
+            ?.replace(/["`]/g, '');
         const columns = await db
-            .selectFrom(sql `PRAGMA_TABLE_INFO(${table})`.as('table_info'))
-            .select(['name', 'type', 'notnull'])
+            .selectFrom(sql `pragma_table_info(${table})`.as('table_info'))
+            .select(['name', 'type', 'notnull', 'dflt_value'])
             .execute();
         return {
             name: table,
@@ -42,6 +55,8 @@ export class SqliteIntrospector {
                 name: col.name,
                 dataType: col.type,
                 isNullable: !col.notnull,
+                isAutoIncrementing: col.name === autoIncrementCol,
+                hasDefaultValue: !!col.dflt_value,
             })),
         };
     }

package/dist/esm/operation-node/join-node.d.ts

@@ -4,7 +4,7 @@ import { FilterExpressionNode } from './operation-node-utils.js';
 import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 export declare type JoinTableNode = TableNode | AliasNode;
-export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin';
+export declare type JoinType = 'InnerJoin' | 'LeftJoin' | 'RightJoin' | 'FullJoin' | 'LateralInnerJoin' | 'LateralLeftJoin';
 export interface JoinNode extends OperationNode {
     readonly kind: 'JoinNode';
     readonly joinType: JoinType;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -254,6 +254,8 @@ export class OperationNodeTransformer {
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
+            orderBy: this.transformNode(node.orderBy),
+            limit: this.transformNode(node.limit),
         };
     }
     transformReturning(node) {
@@ -478,6 +480,7 @@ export class OperationNodeTransformer {
         return {
             kind: 'CreateSchemaNode',
             schema: this.transformNode(node.schema),
+            ifNotExists: node.ifNotExists,
         };
     }
     transformDropSchema(node) {

package/dist/esm/parser/join-parser.d.ts

@@ -1,10 +1,10 @@
 import { JoinNode, JoinType } from '../operation-node/join-node.js';
 import { AnyColumn, AnyColumnWithTable } from '../util/type-utils.js';
-import { TableExpressionDatabase, TableExpressionTables } from './table-parser.js';
+import { From, FromTables } from './table-parser.js';
 import { JoinBuilder } from '../query-builder/join-builder.js';
 export declare type JoinReferenceExpression<DB, TB extends keyof DB, TE> = AnyJoinColumn<DB, TB, TE> | AnyJoinColumnWithTable<DB, TB, TE>;
-export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>) => JoinBuilder<any, any>;
-declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
-declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>>;
+export declare type JoinCallbackExpression<DB, TB extends keyof DB, TE> = (join: JoinBuilder<From<DB, TE>, FromTables<DB, TB, TE>>) => JoinBuilder<any, any>;
+declare type AnyJoinColumn<DB, TB extends keyof DB, TE> = AnyColumn<From<DB, TE>, FromTables<DB, TB, TE>>;
+declare type AnyJoinColumnWithTable<DB, TB extends keyof DB, TE> = AnyColumnWithTable<From<DB, TE>, FromTables<DB, TB, TE>>;
 export declare function parseJoin(joinType: JoinType, args: any[]): JoinNode;
 export {};

package/dist/esm/parser/table-parser.d.ts

@@ -7,12 +7,12 @@ import { AliasedComplexExpression } from './complex-expression-parser.js';
 export declare type TableExpression<DB, TB extends keyof DB> = TableReference<DB> | AliasedComplexExpression<DB, TB>;
 export declare type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
 export declare type TableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB> | AnyAliasedRawBuilder;
-export declare type TableExpressionDatabase<DB, TE, A extends keyof any = ExtractAliasFromTableExpression<DB, TE>> = {
-    [C in keyof DB | A]: C extends A ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
+export declare type From<DB, TE> = {
+    [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
 };
-export declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;
-export declare type TableExpressionTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
-export declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
+export declare type FromTables<DB, TB extends keyof DB, TE> = TB | ExtractAliasFromTableExpression<DB, TE>;
+declare type ExtractAliasFromTableExpression<DB, TE> = TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : TE extends AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends (qb: any) => AliasedQueryBuilder<any, any, any, infer QA> ? QA : TE extends AliasedRawBuilder<any, infer RA> ? RA : TE extends (qb: any) => AliasedRawBuilder<any, infer RA> ? RA : never;
+declare type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedQueryBuilder<any, any, infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : TE extends (qb: any) => AliasedRawBuilder<infer O, infer RA> ? RA extends A ? O : never : never;
 declare type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
 declare type AnyTable<DB> = keyof DB & string;
 export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): TableExpressionNode[];

package/dist/esm/query-builder/expression-builder.d.ts

@@ -1,5 +1,5 @@
 import { SelectQueryBuilder } from './select-query-builder.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
+import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { FunctionBuilder } from './function-builder.js';
 import { ExtractTypeFromReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { RawBuilder } from '../raw-builder/raw-builder.js';
@@ -83,8 +83,8 @@ export declare class ExpressionBuilder<DB, TB extends keyof DB> {
      * that case Kysely typings wouldn't allow you to reference `pet.owner_id`
      * because `pet` is not joined to that query.
      */
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
     /**
      * See {@link QueryCreator.withSchema}
      */

package/dist/esm/query-builder/join-builder.d.ts

@@ -66,6 +66,10 @@ export declare class JoinBuilder<DB, TB extends keyof DB> implements OperationNo
      * See {@link WhereInterface.orWhereNotExists} for documentation and examples.
      */
     orOnNotExists(arg: ExistsExpression<DB, TB>): JoinBuilder<DB, TB>;
+    /**
+     * Adds `on true`.
+     */
+    onTrue(): JoinBuilder<DB, TB>;
     toOperationNode(): JoinNode;
 }
 export interface JoinBuilderProps {

package/dist/esm/query-builder/join-builder.js

@@ -1,5 +1,6 @@
 /// <reference types="./join-builder.d.ts" />
 import { JoinNode } from '../operation-node/join-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
 import { parseExistFilter, parseNotExistFilter, parseOnFilter, parseReferenceFilter, } from '../parser/filter-parser.js';
 import { freeze } from '../util/object-utils.js';
 import { preventAwait } from '../util/prevent-await.js';
@@ -92,6 +93,15 @@ export class JoinBuilder {
             joinNode: JoinNode.cloneWithOrOn(this.#props.joinNode, parseNotExistFilter(arg)),
         });
     }
+    /**
+     * Adds `on true`.
+     */
+    onTrue() {
+        return new JoinBuilder({
+            ...this.#props,
+            joinNode: JoinNode.cloneWithOn(this.#props.joinNode, RawNode.createWithSql('true')),
+        });
+    }
     toOperationNode() {
         return this.#props.joinNode;
     }

package/dist/esm/query-builder/select-query-builder.d.ts

@@ -873,6 +873,46 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     fullJoin<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
     fullJoin<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithFullJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral join instead of an inner join.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .innerJoinLateral(
+     *     (eb) =>
+     *       eb.selectFrom('pet')
+     *         .select('name')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *         .as('p'),
+     *     (join) => join.onTrue()
+     *   )
+     *   .select(['first_name', 'p.name'])
+     *   .orderBy('first_name')
+     */
+    innerJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    innerJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithInnerJoin<DB, TB, O, TE>;
+    /**
+     * Just like {@link innerJoin} but adds a lateral left join instead of an inner join.
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .leftJoinLateral(
+     *     (eb) =>
+     *       eb.selectFrom('pet')
+     *         .select('name')
+     *         .whereRef('pet.owner_id', '=', 'person.id')
+     *         .as('p'),
+     *     (join) => join.onTrue()
+     *   )
+     *   .select(['first_name', 'p.name'])
+     *   .orderBy('first_name')
+     * ```
+     */
+    leftJoinLateral<TE extends TableExpression<DB, TB>, K1 extends JoinReferenceExpression<DB, TB, TE>, K2 extends JoinReferenceExpression<DB, TB, TE>>(table: TE, k1: K1, k2: K2): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
+    leftJoinLateral<TE extends TableExpression<DB, TB>, FN extends JoinCallbackExpression<DB, TB, TE>>(table: TE, callback: FN): SelectQueryBuilderWithLeftJoin<DB, TB, O, TE>;
     /**
      * Adds an `order by` clause to the query.
      *

package/dist/esm/query-builder/select-query-builder.js

@@ -235,6 +235,18 @@ export class SelectQueryBuilder {
             queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('FullJoin', args)),
         });
     }
+    innerJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralInnerJoin', args)),
+        });
+    }
+    leftJoinLateral(...args) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: QueryNode.cloneWithJoin(this.#props.queryNode, parseJoin('LateralLeftJoin', args)),
+        });
+    }
     /**
      * Adds an `order by` clause to the query.
      *

package/dist/esm/query-builder/update-query-builder.d.ts

@@ -1,7 +1,7 @@
 import { OperationNodeSource } from '../operation-node/operation-node-source.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { JoinCallbackExpression, JoinReferenceExpression } from '../parser/join-parser.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables } from '../parser/table-parser.js';
+import { TableExpression, From, FromTables } from '../parser/table-parser.js';
 import { SelectExpression } from '../parser/select-parser.js';
 import { ExistsExpression, FilterOperator, FilterValueExpressionOrList, WhereGrouper } from '../parser/filter-parser.js';
 import { ReturningRow } from '../parser/returning-parser.js';
@@ -434,8 +434,8 @@ export declare class UpdateQueryBuilder<DB, UT extends keyof DB, TB extends keyo
      * where "pet"."owner_id" = "person"."id"
      * ```
      */
-    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
-    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<TableExpressionDatabase<DB, TE>, UT, TableExpressionTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
+    from<TE extends TableExpression<DB, TB>>(table: TE[]): UpdateQueryBuilder<From<DB, TE>, UT, FromTables<DB, TB, TE>, O>;
     /**
      * Joins another table to the query using an inner join.
      *

package/dist/esm/query-compiler/default-query-compiler.js

@@ -836,4 +836,6 @@ const JOIN_TYPE_SQL = freeze({
     LeftJoin: 'left join',
     RightJoin: 'right join',
     FullJoin: 'full join',
+    LateralInnerJoin: 'inner join lateral',
+    LateralLeftJoin: 'left join lateral',
 });

package/dist/esm/query-creator.d.ts

@@ -2,7 +2,7 @@ import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
 import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
 import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
-import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
+import { TableExpression, From, FromTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
@@ -120,8 +120,8 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<TableExpressionDatabase<DB, TE>, TableExpressionTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpression<DB, keyof DB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
     /**
      * Creates an insert query.
      *
@@ -180,7 +180,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numDeletedRows)
      * ```
      */
-    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, DeleteResult>;
+    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
     /**
      * Creates an update query.
      *
@@ -204,7 +204,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
+    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.19.4",
+  "version": "0.19.7",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",