Merge remote-tracking branch 'upstream/master' into nulls-not-distinct

src/operation-node/create-table-node.ts

@@ -28,6 +28,7 @@ export interface CreateTableNode extends OperationNode {
   readonly onCommit?: OnCommitAction
   readonly frontModifiers?: ReadonlyArray<OperationNode>
   readonly endModifiers?: ReadonlyArray<OperationNode>
+  readonly selectQuery?: OperationNode
 }
 
 /**

src/operation-node/operation-node-transformer.ts

@@ -411,6 +411,7 @@ export class OperationNodeTransformer {
       onCommit: node.onCommit,
       frontModifiers: this.transformNodeList(node.frontModifiers),
       endModifiers: this.transformNodeList(node.endModifiers),
+      selectQuery: this.transformNode(node.selectQuery),
     })
   }
 

src/query-compiler/default-query-compiler.ts

@@ -138,6 +138,7 @@ export class DefaultQueryCompiler
       this.parentNode !== undefined &&
       !ParensNode.is(this.parentNode) &&
       !InsertQueryNode.is(this.parentNode) &&
+      !CreateTableNode.is(this.parentNode) &&
       !CreateViewNode.is(this.parentNode) &&
       !SetOperationNode.is(this.parentNode)
 
@@ -549,18 +550,24 @@ export class DefaultQueryCompiler
     }
 
     this.visitNode(node.table)
-    this.append(' (')
-    this.compileList([...node.columns, ...(node.constraints ?? [])])
-    this.append(')')
 
-    if (node.onCommit) {
-      this.append(' on commit ')
-      this.append(node.onCommit)
-    }
+    if (node.selectQuery) {
+      this.append(' as ')
+      this.visitNode(node.selectQuery)
+    } else {
+      this.append(' (')
+      this.compileList([...node.columns, ...(node.constraints ?? [])])
+      this.append(')')
 
-    if (node.endModifiers && node.endModifiers.length > 0) {
-      this.append(' ')
-      this.compileList(node.endModifiers, ' ')
+      if (node.onCommit) {
+        this.append(' on commit ')
+        this.append(node.onCommit)
+      }
+
+      if (node.endModifiers && node.endModifiers.length > 0) {
+        this.append(' ')
+        this.compileList(node.endModifiers, ' ')
+      }
     }
   }
 

src/schema/create-table-builder.ts

@@ -28,6 +28,7 @@ import {
   UniqueConstraintNodeBuilder,
   UniqueConstraintNodeBuilderCallback,
 } from './unique-constraint-builder.js'
+import { parseExpression } from '../parser/expression-parser.js'
 
 /**
  * This builder can be used to create a `create table` query.
@@ -375,6 +376,34 @@ export class CreateTableBuilder<TB extends string, C extends string = never>
     })
   }
 
+  /**
+   * Allows to create table from `select` query.
+   *
+   * ### Examples
+   *
+   * ```ts
+   * db.schema.createTable('copy')
+   *   .temporary()
+   *   .as(db.selectFrom('person').select(['first_name', 'last_name']))
+   *   .execute()
+   * ```
+   *
+   * The generated SQL (PostgreSQL):
+   *
+   * ```sql
+   * create temporary table "copy" as
+   * select "first_name", "last_name" from "person"
+   * ```
+   */
+  as(expression: Expression<unknown>) {
+    return new CreateTableBuilder({
+      ...this.#props,
+      node: CreateTableNode.cloneWith(this.#props.node, {
+        selectQuery: parseExpression(expression),
+      }),
+    })
+  }
+
   /**
    * Calls the given function passing `this` as the only argument.
    *

test/node/src/schema.test.ts

@@ -757,6 +757,113 @@ for (const dialect of DIALECTS) {
 
           await builder.execute()
         })
+
+        it('should create a table with as expression', async () => {
+          const builder = ctx.db.schema
+            .createTable('test')
+            .as(ctx.db.selectFrom('person').select(['first_name', 'last_name']))
+
+          testSql(builder, dialect, {
+            postgres: {
+              sql: 'create table "test" as select "first_name", "last_name" from "person"',
+              parameters: [],
+            },
+            mysql: {
+              sql: 'create table `test` as select `first_name`, `last_name` from `person`',
+              parameters: [],
+            },
+            mssql: NOT_SUPPORTED,
+            sqlite: {
+              sql: 'create table "test" as select "first_name", "last_name" from "person"',
+              parameters: [],
+            },
+          })
+
+          await builder.execute()
+        })
+
+        it('should create a temporary table if not exists with as expression', async () => {
+          const builder = ctx.db.schema
+            .createTable('test')
+            .temporary()
+            .ifNotExists()
+            .as(
+              ctx.db
+                .selectFrom('person')
+                .select(['first_name', 'last_name'])
+                .where('first_name', '=', 'Jennifer')
+            )
+
+          testSql(builder, dialect, {
+            postgres: {
+              sql: 'create temporary table if not exists "test" as select "first_name", "last_name" from "person" where "first_name" = $1',
+              parameters: ['Jennifer'],
+            },
+            mysql: {
+              sql: 'create temporary table if not exists `test` as select `first_name`, `last_name` from `person` where `first_name` = ?',
+              parameters: ['Jennifer'],
+            },
+            mssql: NOT_SUPPORTED,
+            sqlite: {
+              sql: 'create temporary table if not exists "test" as select "first_name", "last_name" from "person" where "first_name" = ?',
+              parameters: ['Jennifer'],
+            },
+          })
+
+          await builder.execute()
+        })
+
+        it('should create a table with as expression and raw sql', async () => {
+          let rawSql = sql`select "first_name", "last_name" from "person"`
+          if (dialect === 'mysql') {
+            rawSql = sql`select \`first_name\`, \`last_name\` from \`person\``
+          }
+
+          const builder = ctx.db.schema.createTable('test').as(rawSql)
+
+          testSql(builder, dialect, {
+            postgres: {
+              sql: 'create table "test" as select "first_name", "last_name" from "person"',
+              parameters: [],
+            },
+            mysql: {
+              sql: 'create table `test` as select `first_name`, `last_name` from `person`',
+              parameters: [],
+            },
+            mssql: NOT_SUPPORTED,
+            sqlite: {
+              sql: 'create table "test" as select "first_name", "last_name" from "person"',
+              parameters: [],
+            },
+          })
+
+          await builder.execute()
+        })
+
+        it('should create a table with as expression and ignore addColumn', async () => {
+          const builder = ctx.db.schema
+            .createTable('test')
+            .as(ctx.db.selectFrom('person').select(['first_name', 'last_name']))
+            .addColumn('first_name', 'varchar(20)')
+
+          testSql(builder, dialect, {
+            postgres: {
+              sql: 'create table "test" as select "first_name", "last_name" from "person"',
+              parameters: [],
+            },
+            mysql: {
+              sql: 'create table `test` as select `first_name`, `last_name` from `person`',
+              parameters: [],
+            },
+            mssql: NOT_SUPPORTED,
+            sqlite: {
+              sql: 'create table "test" as select "first_name", "last_name" from "person"',
+              parameters: [],
+            },
+          })
+
+          await builder.execute()
+        })
       }
 
       if (dialect === 'mssql') {

test/typings/test-d/create-table.test-d.ts

@@ -22,3 +22,8 @@ async function testCreateTableWithAddUniqueConstraint(db: Kysely<Database>) {
       .addUniqueConstraint('a_unique', ['a'], 'wrong option')
   )
 }
+
+async function testCreateTableWithAsStatement(db: Kysely<Database>) {
+  expectError(db.schema.createTable('test').as())
+  expectError(db.schema.createTable('test').as('test'))
+}