@simplysm/orm-common 13.0.69 → 13.0.70

package/tests/select/subquery.spec.ts

@@ -0,0 +1,537 @@
+import { describe, expect, it } from "vitest";
+import { createTestDb } from "../setup/TestDbContext";
+import { expr } from "../../src/expr/expr";
+import { Queryable } from "../../src/exec/queryable";
+import { createQueryBuilder } from "../../src/query-builder/query-builder";
+import { dialects } from "../setup/test-utils";
+import "../setup/test-utils"; // toMatchSql matcher
+import * as expected from "./subquery.expected";
+
+describe("SELECT - WRAP (subquery)", () => {
+  describe("Basic", () => {
+    const db = createTestDb();
+    const def = db.user().wrap().getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T2",
+        from: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.wrapBasic[dialect]);
+    });
+  });
+
+  describe("WRAP -> SELECT", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .wrap()
+      .select((item) => ({ id: item.id, name: item.name }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T2",
+        from: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        },
+        select: {
+          id: { type: "column", path: ["T2", "id"] },
+          name: { type: "column", path: ["T2", "name"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.wrapThenSelect[dialect]);
+    });
+  });
+
+  describe("SELECT -> WRAP", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({ id: item.id, name: item.name }))
+      .wrap()
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T2",
+        from: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "User" },
+          select: {
+            id: { type: "column", path: ["T1", "id"] },
+            name: { type: "column", path: ["T1", "name"] },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.selectThenWrap[dialect]);
+    });
+  });
+
+  describe("WHERE -> WRAP -> WHERE", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.eq(item.isActive, true)])
+      .wrap()
+      .where((item) => [expr.gt(item.age, 20)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T2",
+        from: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "User" },
+          where: [
+            {
+              type: "eq",
+              source: { type: "column", path: ["T1", "isActive"] },
+              target: { type: "value", value: true },
+            },
+          ],
+        },
+        where: [
+          {
+            type: "gt",
+            source: { type: "column", path: ["T2", "age"] },
+            target: { type: "value", value: 20 },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.whereThenWrapThenWhere[dialect]);
+    });
+  });
+
+  describe("INCLUDE -> WRAP -> SELECT", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .include((item) => item.posts)
+      .wrap()
+      .select((item) => ({ postUserId: item.posts![0].userId }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T2",
+        from: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "User" },
+          select: {
+            "id": { type: "column", path: ["T1", "id"] },
+            "name": { type: "column", path: ["T1", "name"] },
+            "email": { type: "column", path: ["T1", "email"] },
+            "age": { type: "column", path: ["T1", "age"] },
+            "isActive": { type: "column", path: ["T1", "isActive"] },
+            "companyId": { type: "column", path: ["T1", "companyId"] },
+            "createdAt": { type: "column", path: ["T1", "createdAt"] },
+            "posts.id": { type: "column", path: ["T1.posts", "id"] },
+            "posts.userId": { type: "column", path: ["T1.posts", "userId"] },
+            "posts.title": { type: "column", path: ["T1.posts", "title"] },
+            "posts.content": { type: "column", path: ["T1.posts", "content"] },
+            "posts.viewCount": { type: "column", path: ["T1.posts", "viewCount"] },
+            "posts.publishedAt": { type: "column", path: ["T1.posts", "publishedAt"] },
+          },
+          joins: [
+            {
+              type: "select",
+              as: "T1.posts",
+              from: { database: "TestDb", schema: "TestSchema", name: "Post" },
+              isSingle: false,
+              where: [
+                {
+                  type: "eq",
+                  source: { type: "column", path: ["T1.posts", "userId"] },
+                  target: { type: "column", path: ["T1", "id"] },
+                },
+              ],
+            },
+          ],
+        },
+        select: {
+          postUserId: { type: "column", path: ["T2", "posts.userId"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.includeThenWrapThenSelect[dialect]);
+    });
+  });
+
+  describe("GROUP BY -> WRAP -> ORDER BY", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        name: item.name,
+        cnt: expr.count(item.id),
+      }))
+      .groupBy((item) => [item.name])
+      .wrap()
+      .orderBy((item) => item.cnt, "DESC")
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T2",
+        from: {
+          type: "select",
+          as: "T1",
+          from: { database: "TestDb", schema: "TestSchema", name: "User" },
+          select: {
+            name: { type: "column", path: ["T1", "name"] },
+            cnt: {
+              type: "count",
+              arg: { type: "column", path: ["T1", "id"] },
+              distinct: undefined,
+            },
+          },
+          groupBy: [{ type: "column", path: ["T1", "name"] }],
+        },
+        orderBy: [[{ type: "column", path: ["T2", "cnt"] }, "DESC"]],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.groupByThenWrapThenOrderBy[dialect]);
+    });
+  });
+});
+
+describe("SELECT - UNION", () => {
+  describe("Basic (2 items)", () => {
+    const db = createTestDb();
+    const qr1 = db.user().where((item) => [expr.eq(item.isActive, true)]);
+    const qr2 = db.user().where((item) => [expr.gt(item.age, 30)]);
+    const def = Queryable.union(qr1, qr2).getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T3",
+        from: [
+          {
+            type: "select",
+            as: "T1",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            where: [
+              {
+                type: "eq",
+                source: { type: "column", path: ["T1", "isActive"] },
+                target: { type: "value", value: true },
+              },
+            ],
+          },
+          {
+            type: "select",
+            as: "T2",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            where: [
+              {
+                type: "gt",
+                source: { type: "column", path: ["T2", "age"] },
+                target: { type: "value", value: 30 },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unionBasic[dialect]);
+    });
+  });
+
+  describe("3 or more", () => {
+    const db = createTestDb();
+    const qr1 = db.user().where((item) => [expr.eq(item.age, 20)]);
+    const qr2 = db.user().where((item) => [expr.eq(item.age, 30)]);
+    const qr3 = db.user().where((item) => [expr.eq(item.age, 40)]);
+    const def = Queryable.union(qr1, qr2, qr3).getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T4",
+        from: [
+          {
+            type: "select",
+            as: "T1",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            where: [
+              {
+                type: "eq",
+                source: { type: "column", path: ["T1", "age"] },
+                target: { type: "value", value: 20 },
+              },
+            ],
+          },
+          {
+            type: "select",
+            as: "T2",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            where: [
+              {
+                type: "eq",
+                source: { type: "column", path: ["T2", "age"] },
+                target: { type: "value", value: 30 },
+              },
+            ],
+          },
+          {
+            type: "select",
+            as: "T3",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            where: [
+              {
+                type: "eq",
+                source: { type: "column", path: ["T3", "age"] },
+                target: { type: "value", value: 40 },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unionThree[dialect]);
+    });
+  });
+
+  describe("UNION -> WHERE (apply to each query)", () => {
+    const db = createTestDb();
+    const qr1 = db.user();
+    const qr2 = db.user();
+    const def = Queryable.union(qr1, qr2)
+      .where((item) => [expr.eq(item.isActive, true)])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T3",
+        from: [
+          {
+            type: "select",
+            as: "T1",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            where: [
+              {
+                type: "eq",
+                source: { type: "column", path: ["T1", "isActive"] },
+                target: { type: "value", value: true },
+              },
+            ],
+          },
+          {
+            type: "select",
+            as: "T2",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            where: [
+              {
+                type: "eq",
+                source: { type: "column", path: ["T2", "isActive"] },
+                target: { type: "value", value: true },
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unionThenWhere[dialect]);
+    });
+  });
+
+  describe("UNION -> WRAP -> ORDER BY + LIMIT", () => {
+    const db = createTestDb();
+    const qr1 = db.user().where((item) => [expr.eq(item.isActive, true)]);
+    const qr2 = db.user().where((item) => [expr.gt(item.age, 30)]);
+    const def = Queryable.union(qr1, qr2)
+      .wrap()
+      .orderBy((item) => item.id, "DESC")
+      .limit(0, 10)
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T4",
+        from: {
+          type: "select",
+          as: "T3",
+          from: [
+            {
+              type: "select",
+              as: "T1",
+              from: { database: "TestDb", schema: "TestSchema", name: "User" },
+              where: [
+                {
+                  type: "eq",
+                  source: { type: "column", path: ["T1", "isActive"] },
+                  target: { type: "value", value: true },
+                },
+              ],
+            },
+            {
+              type: "select",
+              as: "T2",
+              from: { database: "TestDb", schema: "TestSchema", name: "User" },
+              where: [
+                {
+                  type: "gt",
+                  source: { type: "column", path: ["T2", "age"] },
+                  target: { type: "value", value: 30 },
+                },
+              ],
+            },
+          ],
+        },
+        orderBy: [[{ type: "column", path: ["T4", "id"] }, "DESC"]],
+        limit: [0, 10],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unionThenWrapThenOrderByLimit[dialect]);
+    });
+  });
+
+  describe("UNION -> SELECT", () => {
+    const db = createTestDb();
+    const qr1 = db.user().select((item) => ({ id: item.id, name: item.name }));
+    const qr2 = db.user().select((item) => ({ id: item.id, name: item.name }));
+    const def = Queryable.union(qr1, qr2).getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T3",
+        from: [
+          {
+            type: "select",
+            as: "T1",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            select: {
+              id: { type: "column", path: ["T1", "id"] },
+              name: { type: "column", path: ["T1", "name"] },
+            },
+          },
+          {
+            type: "select",
+            as: "T2",
+            from: { database: "TestDb", schema: "TestSchema", name: "User" },
+            select: {
+              id: { type: "column", path: ["T2", "id"] },
+              name: { type: "column", path: ["T2", "name"] },
+            },
+          },
+        ],
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.unionThenSelect[dialect]);
+    });
+  });
+});
+
+//#region ========== SCALAR SUBQUERY ==========
+
+describe("SELECT - SCALAR SUBQUERY (expr.subquery)", () => {
+  describe("Basic (COUNT)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((u) => ({
+        id: u.id,
+        postCount: expr.subquery(
+          "number",
+          db
+            .post()
+            .where((p) => [expr.eq(p.userId, u.id)])
+            .select(() => ({ cnt: expr.count() })),
+        ),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def).toEqual({
+        type: "select",
+        as: "T1",
+        from: { database: "TestDb", schema: "TestSchema", name: "User" },
+        select: {
+          id: { type: "column", path: ["T1", "id"] },
+          postCount: {
+            type: "subquery",
+            queryDef: {
+              type: "select",
+              as: "T2",
+              from: { database: "TestDb", schema: "TestSchema", name: "Post" },
+              where: [
+                {
+                  type: "eq",
+                  source: { type: "column", path: ["T2", "userId"] },
+                  target: { type: "column", path: ["T1", "id"] },
+                },
+              ],
+              select: {
+                cnt: { type: "count" },
+              },
+            },
+          },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.scalarSubquery[dialect]);
+    });
+  });
+});
+
+//#endregion

package/tests/select/view.expected.ts

@@ -0,0 +1,155 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== View - Basic ==========
+
+export const viewSelect: ExpectedSql = {
+  mysql: mysql`SELECT * FROM \`TestDb\`.\`ActiveUsers\` AS \`T1\``,
+  mssql: tsql`SELECT * FROM [TestDb].[TestSchema].[ActiveUsers] AS [T1]`,
+  postgresql: pgsql`SELECT * FROM "TestSchema"."ActiveUsers" AS "T1"`,
+};
+
+export const viewSelectWhere: ExpectedSql = {
+  mysql: mysql`
+    SELECT * FROM \`TestDb\`.\`ActiveUsers\` AS \`T1\`
+    WHERE \`T1\`.\`age\` > 20
+  `,
+  mssql: tsql`
+    SELECT * FROM [TestDb].[TestSchema].[ActiveUsers] AS [T1]
+    WHERE [T1].[age] > 20
+  `,
+  postgresql: pgsql`
+    SELECT * FROM "TestSchema"."ActiveUsers" AS "T1"
+    WHERE "T1"."age" > 20
+  `,
+};
+
+export const viewSelectColumns: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      \`T1\`.\`name\` AS \`name\`
+    FROM \`TestDb\`.\`ActiveUsers\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[id] AS [id],
+      [T1].[name] AS [name]
+    FROM [TestDb].[TestSchema].[ActiveUsers] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."id" AS "id",
+      "T1"."name" AS "name"
+    FROM "TestSchema"."ActiveUsers" AS "T1"
+  `,
+};
+
+export const viewSelectOrderBy: ExpectedSql = {
+  mysql: mysql`
+    SELECT * FROM \`TestDb\`.\`ActiveUsers\` AS \`T1\`
+    ORDER BY \`T1\`.\`name\` ASC
+  `,
+  mssql: tsql`
+    SELECT * FROM [TestDb].[TestSchema].[ActiveUsers] AS [T1]
+    ORDER BY [T1].[name] ASC
+  `,
+  postgresql: pgsql`
+    SELECT * FROM "TestSchema"."ActiveUsers" AS "T1"
+    ORDER BY "T1"."name" ASC
+  `,
+};
+
+export const viewSelectOrderByLimit: ExpectedSql = {
+  mysql: mysql`
+    SELECT * FROM \`TestDb\`.\`ActiveUsers\` AS \`T1\`
+    ORDER BY \`T1\`.\`id\`
+    LIMIT 0, 10
+  `,
+  mssql: tsql`
+    SELECT * FROM [TestDb].[TestSchema].[ActiveUsers] AS [T1]
+    ORDER BY [T1].[id]
+    OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY
+  `,
+  postgresql: pgsql`
+    SELECT * FROM "TestSchema"."ActiveUsers" AS "T1"
+    ORDER BY "T1"."id"
+    LIMIT 10 OFFSET 0
+  `,
+};
+
+//#endregion
+
+//#region ========== View - SELECT가 있는 뷰 ==========
+
+export const userSummarySelect: ExpectedSql = {
+  mysql: mysql`SELECT * FROM \`TestDb\`.\`UserSummary\` AS \`T1\``,
+  mssql: tsql`SELECT * FROM [TestDb].[TestSchema].[UserSummary] AS [T1]`,
+  postgresql: pgsql`SELECT * FROM "TestSchema"."UserSummary" AS "T1"`,
+};
+
+export const userSummarySelectColumn: ExpectedSql = {
+  mysql: mysql`
+    SELECT \`T1\`.\`name\` AS \`userName\`
+    FROM \`TestDb\`.\`UserSummary\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT [T1].[name] AS [userName]
+    FROM [TestDb].[TestSchema].[UserSummary] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT "T1"."name" AS "userName"
+    FROM "TestSchema"."UserSummary" AS "T1"
+  `,
+};
+
+//#endregion
+
+//#region ========== View - DDL ==========
+
+export const createActiveUsersView: ExpectedSql = {
+  mysql: mysql`
+    CREATE OR REPLACE VIEW \`TestDb\`.\`ActiveUsers\` AS
+    SELECT * FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`isActive\` <=> TRUE
+  `,
+  mssql: tsql`
+    CREATE OR ALTER VIEW [TestDb].[TestSchema].[ActiveUsers] AS
+    SELECT * FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE (([T1].[isActive] IS NULL AND 1 IS NULL) OR [T1].[isActive] = 1)
+  `,
+  postgresql: pgsql`
+    CREATE OR REPLACE VIEW "TestSchema"."ActiveUsers" AS
+    SELECT * FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."isActive" IS NOT DISTINCT FROM TRUE
+  `,
+};
+
+export const createUserSummaryView: ExpectedSql = {
+  mysql: mysql`
+    CREATE OR REPLACE VIEW \`TestDb\`.\`UserSummary\` AS
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      \`T1\`.\`name\` AS \`name\`,
+      \`T1\`.\`email\` AS \`email\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    CREATE OR ALTER VIEW [TestDb].[TestSchema].[UserSummary] AS
+    SELECT
+      [T1].[id] AS [id],
+      [T1].[name] AS [name],
+      [T1].[email] AS [email]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    CREATE OR REPLACE VIEW "TestSchema"."UserSummary" AS
+    SELECT
+      "T1"."id" AS "id",
+      "T1"."name" AS "name",
+      "T1"."email" AS "email"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+//#endregion