@simplysm/orm-common 13.0.99 → 14.0.1

package/tests/expr/comparison.expected.ts

@@ -1,282 +0,0 @@
-import { mysql, pgsql, tsql, DateTime, DateOnly, Time, Uuid } from "@simplysm/core-common";
-import type { ExpectedSql } from "../setup/test-utils";
-
-// For DateTime value tests
-export const testDateTime = new DateTime(2024, 1, 15, 10, 30, 0);
-export const testDateOnly = new DateOnly(2024, 1, 15);
-export const testTime = new Time(10, 30, 0);
-export const testUuid = new Uuid("12345678-1234-1234-1234-123456789012");
-
-export const eqNull: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`email\` <=> NULL
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE (([T1].[email] IS NULL AND NULL IS NULL) OR [T1].[email] = NULL)
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."email" IS NOT DISTINCT FROM NULL
-  `,
-};
-
-export const eqValue: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`id\` <=> 1
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE (([T1].[id] IS NULL AND 1 IS NULL) OR [T1].[id] = 1)
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."id" IS NOT DISTINCT FROM 1
-  `,
-};
-
-export const gt: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`age\` > 20
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[age] > 20
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."age" > 20
-  `,
-};
-
-export const lt: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`age\` < 30
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[age] < 30
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."age" < 30
-  `,
-};
-
-export const gte: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`age\` >= 18
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[age] >= 18
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."age" >= 18
-  `,
-};
-
-export const lte: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`age\` <= 65
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[age] <= 65
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."age" <= 65
-  `,
-};
-
-export const between: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`age\` BETWEEN 20 AND 30
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[age] BETWEEN 20 AND 30
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."age" BETWEEN 20 AND 30
-  `,
-};
-
-export const betweenFromOnly: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`age\` >= 20
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[age] >= 20
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."age" >= 20
-  `,
-};
-
-export const betweenToOnly: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`age\` <= 30
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[age] <= 30
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."age" <= 30
-  `,
-};
-
-export const betweenNone: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE 1=1
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE 1=1
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE TRUE
-  `,
-};
-
-export const betweenColumns: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`MonthlySales\` AS \`T1\`
-    WHERE \`T1\`.\`feb\` BETWEEN \`T1\`.\`jan\` AND \`T1\`.\`mar\`
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[MonthlySales] AS [T1]
-    WHERE [T1].[feb] BETWEEN [T1].[jan] AND [T1].[mar]
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."MonthlySales" AS "T1"
-    WHERE "T1"."feb" BETWEEN "T1"."jan" AND "T1"."mar"
-  `,
-};
-
-export const regexpMysqlPostgresql: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`name\` REGEXP '^test.*'
-  `,
-  mssql: tsql``,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."name" ~ '^test.*'
-  `,
-};
-
-export const inEmpty: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE 1=0
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE 1=0
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE FALSE
-  `,
-};
-
-//#region ========== DateTime/DateOnly/Time Value Tests ==========
-
-export const eqDateTime: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`createdAt\` <=> '2024-01-15 10:30:00'
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE (([T1].[createdAt] IS NULL AND '2024-01-15 10:30:00' IS NULL) OR [T1].[createdAt] = '2024-01-15 10:30:00')
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."createdAt" IS NOT DISTINCT FROM '2024-01-15 10:30:00'::timestamp
-  `,
-};
-
-//#endregion
-
-//#region ========== inQuery Tests ==========
-
-export const inQuery: ExpectedSql = {
-  mysql: mysql`
-    SELECT *
-    FROM \`TestDb\`.\`User\` AS \`T1\`
-    WHERE \`T1\`.\`id\` IN (SELECT \`T2\`.\`userId\` AS \`userId\` FROM \`TestDb\`.\`Post\` AS \`T2\`)
-  `,
-  mssql: tsql`
-    SELECT *
-    FROM [TestDb].[TestSchema].[User] AS [T1]
-    WHERE [T1].[id] IN (SELECT [T2].[userId] AS [userId] FROM [TestDb].[TestSchema].[Post] AS [T2])
-  `,
-  postgresql: pgsql`
-    SELECT *
-    FROM "TestSchema"."User" AS "T1"
-    WHERE "T1"."id" IN (SELECT "T2"."userId" AS "userId" FROM "TestSchema"."Post" AS "T2")
-  `,
-};
-
-//#endregion

package/tests/expr/comparison.spec.ts

@@ -1,334 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createTestDb } from "../setup/TestDbContext";
-import { expr } from "../../src/expr/expr";
-import { createQueryBuilder } from "../../src/query-builder/query-builder";
-import { dialects } from "../setup/test-utils";
-import "../setup/test-utils"; // toMatchSql matcher
-import * as expected from "./comparison.expected";
-import { DateTime } from "@simplysm/core-common";
-
-describe("Expr - Comparison operators (null-safe)", () => {
-  describe("eq - equality comparison (null == null → true)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.eq(item.email, undefined)])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        as: "T1",
-        from: { database: "TestDb", schema: "TestSchema", name: "User" },
-        where: [
-          {
-            type: "eq",
-            source: { type: "column", path: ["T1", "email"] },
-            target: { type: "value", value: undefined },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.eqNull[dialect]);
-    });
-  });
-
-  describe("eq - value comparison (1 == 1 → true)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.eq(item.id, 1)])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "eq",
-            source: { type: "column", path: ["T1", "id"] },
-            target: { type: "value", value: 1 },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.eqValue[dialect]);
-    });
-  });
-
-  describe("gt - greater than comparison", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.gt(item.age, 20)])
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.gt[dialect]);
-    });
-  });
-
-  describe("lt - less than comparison", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.lt(item.age, 30)])
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.lt[dialect]);
-    });
-  });
-
-  describe("gte - greater than or equal comparison", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.gte(item.age, 18)])
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.gte[dialect]);
-    });
-  });
-
-  describe("lte - less than or equal comparison", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.lte(item.age, 65)])
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.lte[dialect]);
-    });
-  });
-
-  describe("between - range comparison", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.between(item.age, 20, 30)])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "between",
-            source: { type: "column", path: ["T1", "age"] },
-            from: { type: "value", value: 20 },
-            to: { type: "value", value: 30 },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.between[dialect]);
-    });
-  });
-
-  describe("between - only from present (>= handling)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.between(item.age, 20, undefined)])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "between",
-            source: { type: "column", path: ["T1", "age"] },
-            from: { type: "value", value: 20 },
-            to: undefined,
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.betweenFromOnly[dialect]);
-    });
-  });
-
-  describe("between - only to present (<= handling)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.between(item.age, undefined, 30)])
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.betweenToOnly[dialect]);
-    });
-  });
-
-  describe("between - both absent (always true)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.between(item.age, undefined, undefined)])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "between",
-            source: { type: "column", path: ["T1", "age"] },
-            from: undefined,
-            to: undefined,
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.betweenNone[dialect]);
-    });
-  });
-
-  describe("between - using column references for from/to", () => {
-    const db = createTestDb();
-    const def = db
-      .monthlySales()
-      .where((item) => [expr.between(item.feb, item.jan, item.mar)])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "between",
-            source: { type: "column", path: ["T1", "feb"] },
-            from: { type: "column", path: ["T1", "jan"] },
-            to: { type: "column", path: ["T1", "mar"] },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.betweenColumns[dialect]);
-    });
-  });
-
-  describe("regexp - regex comparison (MySQL/PostgreSQL)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.regexp(item.name, "^test.*")])
-      .getSelectQueryDef();
-
-    it.each(["mysql", "postgresql"] as const)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.regexpMysqlPostgresql[dialect]);
-    });
-  });
-
-  describe("in - empty array (always false)", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((item) => [expr.in(item.id, [])])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "in",
-            source: { type: "column", path: ["T1", "id"] },
-            values: [],
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.inEmpty[dialect]);
-    });
-  });
-
-  //#region ========== DateTime value tests ==========
-
-  describe("eq - DateTime value comparison", () => {
-    const db = createTestDb();
-    const testDateTime = new DateTime(2024, 1, 15, 10, 30, 0);
-    const def = db
-      .user()
-      .where((item) => [expr.eq(item.createdAt, testDateTime)])
-      .getSelectQueryDef();
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.eqDateTime[dialect]);
-    });
-  });
-
-  //#endregion
-
-  //#region ========== inQuery tests ==========
-
-  describe("inQuery - subquery IN condition", () => {
-    const db = createTestDb();
-    const def = db
-      .user()
-      .where((u) => [
-        expr.inQuery(
-          u.id,
-          db.post().select((p) => ({ userId: p.userId })),
-        ),
-      ])
-      .getSelectQueryDef();
-
-    it("Verify QueryDef", () => {
-      expect(def).toMatchObject({
-        type: "select",
-        where: [
-          {
-            type: "inQuery",
-            source: { type: "column", path: ["T1", "id"] },
-            query: {
-              type: "select",
-              select: {
-                userId: { type: "column", path: ["T2", "userId"] },
-              },
-            },
-          },
-        ],
-      });
-    });
-
-    it.each(dialects)("[%s] Verify SQL", (dialect) => {
-      const builder = createQueryBuilder(dialect);
-      expect(builder.build(def)).toMatchSql(expected.inQuery[dialect]);
-    });
-  });
-
-  //#endregion
-});