@simplysm/orm-common 13.0.100 → 14.0.1

package/tests/select/subquery.spec.ts

@@ -1,441 +0,0 @@
-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("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]);
-    });
-  });
-
-});
-
-//#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

@@ -1,155 +0,0 @@
-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 - View With 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