kysely 0.19.11 → 0.20.1

package/dist/cjs/raw-builder/sql.d.ts

@@ -1,5 +1,101 @@
 import { RawBuilder } from './raw-builder.js';
 export interface Sql {
+    /**
+     * Template tag for creating raw SQL snippets and queries.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const id = 123
+     *
+     * const snippet = sql<Person[]>`select * from person where id = ${id}`
+     * ```
+     *
+     * Substitutions (the things inside `${}`) are automatically passed to the database
+     * as parameters and are NOT interpolated to the SQL string. There's no need to worry
+     * about SQL injection vulnerabilities.
+     *
+     * If you need your substitutions to be interpreted as identifiers, value literals or
+     * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
+     * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
+     *
+     * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
+     * something can't be done using the Kysely API, you should be able to drop down to
+     * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
+     * of methods:
+     *
+     * ```ts
+     * const persons = await db
+     *   .selectFrom('person')
+     *   .select(
+     *     // If you use `sql` in a select statement, remember to call the `as`
+     *     // method to give it an alias. Otherwise Kysely is not able to add
+     *     // the column to the result type.
+     *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
+     *   )
+     *   .where(sql`birthdate between ${date1} and ${date2}`)
+     *   // Here we assume we have list of nicknames for the person
+     *   // (a list of strings) and we use the PostgreSQL `@>` operator
+     *   // to test if all of them are valid nicknames for the user.
+     *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
+     *   .orderBy(sql`concat(first_name, ' ', last_name)`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select concat(first_name, ' ', last_name) as "full_name"
+     * from "person"
+     * where birthdate between $1 and $2
+     * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
+     * order by concat(first_name, ' ', last_name)
+     * ```
+     *
+     * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
+     * instance as the only argument:
+     *
+     * ```ts
+     * const result = await sql<Person[]>`select * from person`.execute(db)
+     * ```
+     *
+     * You can merge other `sql` expressions and queries using substitutions:
+     *
+     * ```ts
+     * const petName = db.selectFrom('pet').select('name').limit(1)
+     * const fullName = sql`concat(first_name, ' ', last_name)`
+     *
+     * sql`
+     *   select ${fullName} as full_name, ${petName} as pet_name
+     *   from person
+     * `
+     * ```
+     *
+     * Substitutions also handle {@link ExpressionBuilder.ref},
+     * {@link DynamicModule.ref} and pretty much anything else you
+     * throw at it. Here's an example of calling a function in a
+     * type-safe way:
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select([
+     *     'first_name',
+     *     'last_name',
+     *     (eb) => {
+     *       // The `eb.ref` method is type-safe and only accepts
+     *       // column references that are possible.
+     *       const firstName = eb.ref('first_name')
+     *       const lastName = eb.ref('last_name')
+     *
+     *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
+     *       return fullName.as('full_name')
+     *     }
+     *   ])
+     * ```
+     *
+     * don't know if that amount of ceremony is worth the small increase in
+     * type-safety though... But it's possible.
+     */
     <T = unknown>(sqlFragments: TemplateStringsArray, ...parameters: unknown[]): RawBuilder<T>;
     /**
      * This can be used to add runtime column references to SQL snippets.
@@ -232,100 +328,4 @@ export interface Sql {
      */
     join(array: unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
 }
-/**
- * Template tag for creating raw SQL snippets and queries.
- *
- * ```ts
- * import { sql } from 'kysely'
- *
- * const id = 123
- *
- * const snippet = sql<Person[]>`select * from person where id = ${id}`
- * ```
- *
- * Substitutions (the things inside `${}`) are automatically passed to the database
- * as parameters and are NOT interpolated to the SQL string. There's no need to worry
- * about SQL injection vulnerabilities.
- *
- * If you need your substitutions to be interpreted as identifiers, value literals or
- * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
- * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
- *
- * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
- * something can't be done using the Kysely API, you should be able to drop down to
- * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
- * of methods:
- *
- * ```ts
- * const persons = await db
- *   .selectFrom('person')
- *   .select(
- *     // If you use `sql` in a select statement, remember to call the `as`
- *     // method to give it an alias. Otherwise Kysely is not able to add
- *     // the column to the result type.
- *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
- *   )
- *   .where(sql`birthdate between ${date1} and ${date2}`)
- *   // Here we assume we have list of nicknames for the person
- *   // (a list of strings) and we use the PostgreSQL `@>` operator
- *   // to test if all of them are valid nicknames for the user.
- *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
- *   .orderBy(sql`concat(first_name, ' ', last_name)`)
- *   .execute()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select concat(first_name, ' ', last_name) as "full_name"
- * from "person"
- * where birthdate between $1 and $2
- * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concat(first_name, ' ', last_name)
- * ```
- *
- * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
- * instance as the only argument:
- *
- * ```ts
- * const result = await sql<Person[]>`select * from person`.execute(db)
- * ```
- *
- * You can merge other `sql` expressions and queries using substitutions:
- *
- * ```ts
- * const petName = db.selectFrom('pet').select('name').limit(1)
- * const fullName = sql`concat(first_name, ' ', last_name)`
- *
- * sql`
- *   select ${fullName} as full_name, ${petName} as pet_name
- *   from person
- * `
- * ```
- *
- * Substitutions also handle {@link ExpressionBuilder.ref},
- * {@link DynamicModule.ref} and pretty much anything else you
- * throw at it. Here's an example of calling a function in a
- * type-safe way:
- *
- * ```ts
- * db.selectFrom('person')
- *   .select([
- *     'first_name',
- *     'last_name',
- *     (eb) => {
- *       // The `eb.ref` method is type-safe and only accepts
- *       // column references that are possible.
- *       const firstName = eb.ref('first_name')
- *       const lastName = eb.ref('last_name')
- *
- *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
- *       return fullName.as('full_name')
- *     }
- *   ])
- * ```
- *
- * don't know if that amount of ceremony is worth the small increase in
- * type-safety though... But it's possible.
- */
 export declare const sql: Sql;

package/dist/cjs/raw-builder/sql.js

@@ -9,102 +9,6 @@ const table_parser_js_1 = require("../parser/table-parser.js");
 const value_parser_js_1 = require("../parser/value-parser.js");
 const query_id_js_1 = require("../util/query-id.js");
 const raw_builder_js_1 = require("./raw-builder.js");
-/**
- * Template tag for creating raw SQL snippets and queries.
- *
- * ```ts
- * import { sql } from 'kysely'
- *
- * const id = 123
- *
- * const snippet = sql<Person[]>`select * from person where id = ${id}`
- * ```
- *
- * Substitutions (the things inside `${}`) are automatically passed to the database
- * as parameters and are NOT interpolated to the SQL string. There's no need to worry
- * about SQL injection vulnerabilities.
- *
- * If you need your substitutions to be interpreted as identifiers, value literals or
- * lists of things, see the {@link Sql.ref}, {@link Sql.table}, {@link Sql.id},
- * {@link Sql.literal}, {@link Sql.raw} and {@link Sql.join} functions.
- *
- * You can pass sql snippets returned by the `sql` tag pretty much anywhere. Whenever
- * something can't be done using the Kysely API, you should be able to drop down to
- * raw SQL using the `sql` tag. Here's an example query that uses raw sql in a bunch
- * of methods:
- *
- * ```ts
- * const persons = await db
- *   .selectFrom('person')
- *   .select(
- *     // If you use `sql` in a select statement, remember to call the `as`
- *     // method to give it an alias. Otherwise Kysely is not able to add
- *     // the column to the result type.
- *     sql<string>`concat(first_name, ' ', last_name)`.as('full_name')
- *   )
- *   .where(sql`birthdate between ${date1} and ${date2}`)
- *   // Here we assume we have list of nicknames for the person
- *   // (a list of strings) and we use the PostgreSQL `@>` operator
- *   // to test if all of them are valid nicknames for the user.
- *   .where('nicknames', '@>', sql`ARRAY[${sql.join(nicknames)}]`)
- *   .orderBy(sql`concat(first_name, ' ', last_name)`)
- *   .execute()
- * ```
- *
- * The generated SQL (PostgreSQL):
- *
- * ```sql
- * select concat(first_name, ' ', last_name) as "full_name"
- * from "person"
- * where birthdate between $1 and $2
- * and "nicknames" @> ARRAY[$3, $4, $5, $6, $7, $8, $9, $10]
- * order by concat(first_name, ' ', last_name)
- * ```
- *
- * SQL snippets can be executed by calling the `execute` method and passing a `Kysely`
- * instance as the only argument:
- *
- * ```ts
- * const result = await sql<Person[]>`select * from person`.execute(db)
- * ```
- *
- * You can merge other `sql` expressions and queries using substitutions:
- *
- * ```ts
- * const petName = db.selectFrom('pet').select('name').limit(1)
- * const fullName = sql`concat(first_name, ' ', last_name)`
- *
- * sql`
- *   select ${fullName} as full_name, ${petName} as pet_name
- *   from person
- * `
- * ```
- *
- * Substitutions also handle {@link ExpressionBuilder.ref},
- * {@link DynamicModule.ref} and pretty much anything else you
- * throw at it. Here's an example of calling a function in a
- * type-safe way:
- *
- * ```ts
- * db.selectFrom('person')
- *   .select([
- *     'first_name',
- *     'last_name',
- *     (eb) => {
- *       // The `eb.ref` method is type-safe and only accepts
- *       // column references that are possible.
- *       const firstName = eb.ref('first_name')
- *       const lastName = eb.ref('last_name')
- *
- *       const fullName = sql<string>`concat(${firstName}, ' ', ${lastName})`
- *       return fullName.as('full_name')
- *     }
- *   ])
- * ```
- *
- * don't know if that amount of ceremony is worth the small increase in
- * type-safety though... But it's possible.
- */
 exports.sql = Object.assign((sqlFragments, ...parameters) => {
     return new raw_builder_js_1.RawBuilder({
         queryId: (0, query_id_js_1.createQueryId)(),

package/dist/cjs/schema/column-definition-builder.js

@@ -11,6 +11,7 @@ const column_definition_node_js_1 = require("../operation-node/column-definition
 const default_value_parser_js_1 = require("../parser/default-value-parser.js");
 const generated_node_js_1 = require("../operation-node/generated-node.js");
 const default_value_node_js_1 = require("../operation-node/default-value-node.js");
+const on_modify_action_parser_js_1 = require("../parser/on-modify-action-parser.js");
 class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
@@ -38,7 +39,7 @@ class ColumnDefinitionBuilder {
             throw new Error('on delete constraint can only be added for foreign keys');
         }
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {
-            references: references_node_js_1.ReferencesNode.cloneWithOnDelete(this.#node.references, onDelete),
+            references: references_node_js_1.ReferencesNode.cloneWithOnDelete(this.#node.references, (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onDelete)),
         }));
     }
     onUpdate(onUpdate) {
@@ -46,7 +47,7 @@ class ColumnDefinitionBuilder {
             throw new Error('on update constraint can only be added for foreign keys');
         }
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {
-            references: references_node_js_1.ReferencesNode.cloneWithOnUpdate(this.#node.references, onUpdate),
+            references: references_node_js_1.ReferencesNode.cloneWithOnUpdate(this.#node.references, (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onUpdate)),
         }));
     }
     unique() {

package/dist/cjs/schema/create-table-builder.d.ts

@@ -149,6 +149,60 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      */
     addForeignKeyConstraint(constraintName: string, columns: C[], targetTable: string, targetColumns: string[], build?: ForeignKeyConstraintBuilderCallback): CreateTableBuilder<TB, C>;
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `create` keyword.
+     *
+     * Also see {@link temporary}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .modifyFront(sql`global temporary`)
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (Postgres):
+     *
+     * ```sql
+     * create global temporary table "person" (
+     *   "id" integer primary key,
+     *   "first_name" varchar(64) not null,
+     *   "last_name" varchar(64) not null
+     * )
+     * ```
+     */
+    modifyFront(modifier: AnyRawBuilder): CreateTableBuilder<TB, C>;
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link onCommit}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .modifyEnd(sql`collate utf8_unicode_ci`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `first_name` varchar(64) not null,
+     *   `last_name` varchar(64) not null
+     * ) collate utf8_unicode_ci
+     * ```
+     */
+    modifyEnd(modifier: AnyRawBuilder): CreateTableBuilder<TB, C>;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

package/dist/cjs/schema/create-table-builder.js

@@ -14,6 +14,7 @@ const primary_constraint_node_js_1 = require("../operation-node/primary-constrai
 const unique_constraint_node_js_1 = require("../operation-node/unique-constraint-node.js");
 const check_constraint_node_js_1 = require("../operation-node/check-constraint-node.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
+const on_commit_action_parse_js_1 = require("../parser/on-commit-action-parse.js");
 /**
  * This builder can be used to create a `create table` query.
  */
@@ -45,7 +46,7 @@ class CreateTableBuilder {
         return new CreateTableBuilder({
             ...this.#props,
             createTableNode: create_table_node_js_1.CreateTableNode.cloneWith(this.#props.createTableNode, {
-                onCommit,
+                onCommit: (0, on_commit_action_parse_js_1.parseOnCommitAction)(onCommit),
             }),
         });
     }
@@ -205,6 +206,70 @@ class CreateTableBuilder {
             createTableNode: create_table_node_js_1.CreateTableNode.cloneWithConstraint(this.#props.createTableNode, builder.toOperationNode()),
         });
     }
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `create` keyword.
+     *
+     * Also see {@link temporary}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .modifyFront(sql`global temporary`)
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (Postgres):
+     *
+     * ```sql
+     * create global temporary table "person" (
+     *   "id" integer primary key,
+     *   "first_name" varchar(64) not null,
+     *   "last_name" varchar(64) not null
+     * )
+     * ```
+     */
+    modifyFront(modifier) {
+        return new CreateTableBuilder({
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithFrontModifier(this.#props.createTableNode, modifier.toOperationNode()),
+        });
+    }
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link onCommit}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createTable('person')
+     *   .addColumn('id', 'integer', col => col => primaryKey())
+     *   .addColumn('first_name', 'varchar(64)', col => col.notNull())
+     *   .addColumn('last_name', 'varchar(64), col => col.notNull())
+     *   .modifyEnd(sql`collate utf8_unicode_ci`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * create table `person` (
+     *   `id` integer primary key,
+     *   `first_name` varchar(64) not null,
+     *   `last_name` varchar(64) not null
+     * ) collate utf8_unicode_ci
+     * ```
+     */
+    modifyEnd(modifier) {
+        return new CreateTableBuilder({
+            ...this.#props,
+            createTableNode: create_table_node_js_1.CreateTableNode.cloneWithEndModifier(this.#props.createTableNode, modifier.toOperationNode()),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.createTableNode, this.#props.queryId);
     }

package/dist/cjs/schema/foreign-key-constraint-builder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForeignKeyConstraintBuilder = void 0;
 const foreign_key_constraint_node_js_1 = require("../operation-node/foreign-key-constraint-node.js");
+const on_modify_action_parser_js_1 = require("../parser/on-modify-action-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 class ForeignKeyConstraintBuilder {
     #node;
@@ -10,12 +11,12 @@ class ForeignKeyConstraintBuilder {
     }
     onDelete(onDelete) {
         return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
-            onDelete,
+            onDelete: (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onDelete),
         }));
     }
     onUpdate(onUpdate) {
         return new ForeignKeyConstraintBuilder(foreign_key_constraint_node_js_1.ForeignKeyConstraintNode.cloneWith(this.#node, {
-            onUpdate,
+            onUpdate: (0, on_modify_action_parser_js_1.parseOnModifyForeignAction)(onUpdate),
         }));
     }
     toOperationNode() {

package/dist/cjs/util/explainable.d.ts

@@ -0,0 +1,5 @@
+import { AnyRawBuilder } from './type-utils.js';
+export declare type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
+export interface Explainable {
+    explain<O extends Record<string, any> = Record<string, any>>(format?: ExplainFormat, options?: AnyRawBuilder): Promise<O[]>;
+}

package/dist/cjs/util/explainable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -28,6 +28,8 @@ export class MysqlIntrospector {
             'extra',
         ])
             .where('table_schema', '=', sql `database()`)
+            .orderBy('table_name')
+            .orderBy('column_name')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query

package/dist/esm/dialect/mysql/mysql-query-compiler.d.ts

@@ -1,6 +1,11 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class MysqlQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
+    protected getLeftExplainOptionsWrapper(): string;
+    protected getExplainOptionAssignment(): string;
+    protected getExplainOptionsDelimiter(): string;
+    protected getRightExplainOptionsWrapper(): string;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
+    protected sanitizeIdentifier(identifier: string): string;
 }

package/dist/esm/dialect/mysql/mysql-query-compiler.js

@@ -1,13 +1,29 @@
 /// <reference types="./mysql-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const ID_WRAP_REGEX = /`/g;
 export class MysqlQueryCompiler extends DefaultQueryCompiler {
     getCurrentParameterPlaceholder() {
         return '?';
     }
+    getLeftExplainOptionsWrapper() {
+        return '';
+    }
+    getExplainOptionAssignment() {
+        return '=';
+    }
+    getExplainOptionsDelimiter() {
+        return ' ';
+    }
+    getRightExplainOptionsWrapper() {
+        return '';
+    }
     getLeftIdentifierWrapper() {
         return '`';
     }
     getRightIdentifierWrapper() {
         return '`';
     }
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '``');
+    }
 }

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

@@ -19,33 +19,41 @@ export class PostgresIntrospector {
         let query = this.#db
             .selectFrom('pg_catalog.pg_attribute as a')
             .innerJoin('pg_catalog.pg_class as c', 'a.attrelid', 'c.oid')
-            .innerJoin('pg_catalog.pg_tables as t', 't.tablename', 'c.relname')
+            .innerJoin('pg_catalog.pg_namespace as ns', 'c.relnamespace', 'ns.oid')
             .innerJoin('pg_catalog.pg_type as typ', 'a.atttypid', 'typ.oid')
             .select([
             'a.attname as column',
             'a.attnotnull as not_null',
             'a.atthasdef as has_default',
-            't.tablename as table',
-            't.schemaname as schema',
+            'c.relname as table',
+            'ns.nspname 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'))
+                // Make sure the sequence is in the same schema as the table.
+                .whereRef('relnamespace', '=', 'c.relnamespace')
                 .where('relkind', '=', 'S')
-                .where('relname', '=', sql `t.tablename || '_' || a.attname || '_seq'`)
+                .where('relname', '=', sql `c.relname || '_' || a.attname || '_seq'`)
                 .as('auto_incrementing'),
         ])
-            .where('t.schemaname', '!~', '^pg_')
-            .where('t.schemaname', '!=', 'information_schema')
-            .where('a.attnum', '>=', 0) // No system columns
+            // r == normal table
+            .where('c.relkind', '=', 'r')
+            .where('ns.nspname', '!~', '^pg_')
+            .where('ns.nspname', '!=', 'information_schema')
+            // No system columns
+            .where('a.attnum', '>=', 0)
             .where('a.attisdropped', '!=', true)
+            .orderBy('ns.nspname')
+            .orderBy('c.relname')
+            .orderBy('a.attname')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
-                .where('t.tablename', '!=', DEFAULT_MIGRATION_TABLE)
-                .where('t.tablename', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
+                .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)
+                .where('c.relname', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);

package/dist/esm/dialect/postgres/postgres-query-compiler.d.ts

@@ -1,6 +1,4 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class PostgresQueryCompiler extends DefaultQueryCompiler {
-    protected getCurrentParameterPlaceholder(): string;
-    protected getLeftIdentifierWrapper(): string;
-    protected getRightIdentifierWrapper(): string;
+    protected sanitizeIdentifier(identifier: string): string;
 }

package/dist/esm/dialect/postgres/postgres-query-compiler.js

@@ -1,13 +1,8 @@
 /// <reference types="./postgres-query-compiler.d.ts" />
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
+const ID_WRAP_REGEX = /"/g;
 export class PostgresQueryCompiler extends DefaultQueryCompiler {
-    getCurrentParameterPlaceholder() {
-        return '$' + this.numParameters;
-    }
-    getLeftIdentifierWrapper() {
-        return '"';
-    }
-    getRightIdentifierWrapper() {
-        return '"';
+    sanitizeIdentifier(identifier) {
+        return identifier.replace(ID_WRAP_REGEX, '""');
     }
 }

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

@@ -16,6 +16,7 @@ export class SqliteIntrospector {
             .where('type', '=', 'table')
             .where('name', 'not like', 'sqlite_%')
             .select('name')
+            .orderBy('name')
             .castTo();
         if (!options.withInternalKyselyTables) {
             query = query
@@ -48,6 +49,7 @@ export class SqliteIntrospector {
         const columns = await db
             .selectFrom(sql `pragma_table_info(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull', 'dflt_value'])
+            .orderBy('name')
             .execute();
         return {
             name: table,

package/dist/esm/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -1,7 +1,10 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
     protected getCurrentParameterPlaceholder(): string;
+    protected getLeftExplainOptionsWrapper(): string;
+    protected getRightExplainOptionsWrapper(): string;
     protected getLeftIdentifierWrapper(): string;
     protected getRightIdentifierWrapper(): string;
     protected getAutoIncrement(): string;
+    protected sanitizeIdentifier(identifier: string): string;
 }