@simplysm/orm-common 13.0.69 → 13.0.71

package/tests/expr/string.expected.ts

@@ -0,0 +1,218 @@
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+export const concat: ExpectedSql = {
+  mysql: mysql`
+    SELECT CONCAT(IFNULL(\`T1\`.\`name\`, ''), IFNULL('@', ''), IFNULL(\`T1\`.\`email\`, '')) AS \`fullName\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT CONCAT([T1].[name], N'@', [T1].[email]) AS [fullName]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT COALESCE("T1"."name", '') || COALESCE('@', '') || COALESCE("T1"."email", '') AS "fullName"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const length: ExpectedSql = {
+  mysql: mysql`
+    SELECT CHAR_LENGTH(IFNULL(\`T1\`.\`name\`, '')) AS \`nameLength\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT LEN(ISNULL([T1].[name], N'')) AS [nameLength]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT LENGTH(COALESCE("T1"."name", '')) AS "nameLength"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const byteLength: ExpectedSql = {
+  mysql: mysql`
+    SELECT LENGTH(IFNULL(\`T1\`.\`name\`, '')) AS \`byteLen\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT DATALENGTH(ISNULL([T1].[name], N'')) AS [byteLen]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT OCTET_LENGTH(COALESCE("T1"."name", '')) AS "byteLen"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const left: ExpectedSql = {
+  mysql: mysql`
+    SELECT LEFT(\`T1\`.\`name\`, 3) AS \`prefix\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT LEFT([T1].[name], 3) AS [prefix]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT LEFT("T1"."name", 3) AS "prefix"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const right: ExpectedSql = {
+  mysql: mysql`
+    SELECT RIGHT(\`T1\`.\`name\`, 3) AS \`suffix\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT RIGHT([T1].[name], 3) AS [suffix]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT RIGHT("T1"."name", 3) AS "suffix"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const trim: ExpectedSql = {
+  mysql: mysql`
+    SELECT TRIM(\`T1\`.\`name\`) AS \`trimmed\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT RTRIM(LTRIM([T1].[name])) AS [trimmed]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT TRIM("T1"."name") AS "trimmed"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const padStart: ExpectedSql = {
+  mysql: mysql`
+    SELECT LPAD(\`T1\`.\`name\`, 10, '0') AS \`padded\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT RIGHT(REPLICATE(N'0', 10) + [T1].[name], 10) AS [padded]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT LPAD("T1"."name", 10, '0') AS "padded"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const replace: ExpectedSql = {
+  mysql: mysql`
+    SELECT REPLACE(\`T1\`.\`name\`, 'a', 'A') AS \`replaced\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT REPLACE([T1].[name], N'a', N'A') AS [replaced]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT REPLACE("T1"."name", 'a', 'A') AS "replaced"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const upper: ExpectedSql = {
+  mysql: mysql`
+    SELECT UPPER(\`T1\`.\`name\`) AS \`upper\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT UPPER([T1].[name]) AS [upper]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT UPPER("T1"."name") AS "upper"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const lower: ExpectedSql = {
+  mysql: mysql`
+    SELECT LOWER(\`T1\`.\`name\`) AS \`lower\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT LOWER([T1].[name]) AS [lower]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT LOWER("T1"."name") AS "lower"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const substring: ExpectedSql = {
+  mysql: mysql`
+    SELECT SUBSTRING(\`T1\`.\`name\`, 1, 5) AS \`sub\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT SUBSTRING([T1].[name], 1, 5) AS [sub]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT SUBSTRING("T1"."name", 1, 5) AS "sub"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const indexOf: ExpectedSql = {
+  mysql: mysql`
+    SELECT LOCATE('test', \`T1\`.\`name\`) AS \`pos\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT CHARINDEX(N'test', [T1].[name]) AS [pos]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT POSITION('test' IN "T1"."name") AS "pos"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const like: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`name\` LIKE '%test%' ESCAPE '\\\\'
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[name] LIKE N'%test%' ESCAPE '\\'
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."name" LIKE '%test%' ESCAPE '\\'
+  `,
+};
+
+export const likeEscape: ExpectedSql = {
+  mysql: mysql`
+    SELECT *
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+    WHERE \`T1\`.\`name\` LIKE '%\\\\%%' ESCAPE '\\\\'
+  `,
+  mssql: tsql`
+    SELECT *
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+    WHERE [T1].[name] LIKE N'%\\%%' ESCAPE '\\'
+  `,
+  postgresql: pgsql`
+    SELECT *
+    FROM "TestSchema"."User" AS "T1"
+    WHERE "T1"."name" LIKE '%\\%%' ESCAPE '\\'
+  `,
+};

package/tests/expr/string.spec.ts

@@ -0,0 +1,356 @@
+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 "./string.expected";
+
+describe("Expr - String functions", () => {
+  describe("concat - string concatenation (null processing)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        fullName: expr.concat(item.name, "@", item.email),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        fullName: {
+          type: "concat",
+          args: expect.arrayContaining([
+            { type: "column", path: ["T1", "name"] },
+            { type: "value", value: "@" },
+            { type: "column", path: ["T1", "email"] },
+          ]),
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.concat[dialect]);
+    });
+  });
+
+  describe("length - character length", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        nameLength: expr.length(item.name),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        nameLength: {
+          type: "length",
+          arg: { type: "column", path: ["T1", "name"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.length[dialect]);
+    });
+  });
+
+  describe("byteLength - byte length", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        byteLen: expr.byteLength(item.name),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        byteLen: {
+          type: "byteLength",
+          arg: { type: "column", path: ["T1", "name"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.byteLength[dialect]);
+    });
+  });
+
+  describe("left - extract left string", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        prefix: expr.left(item.name, 3),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        prefix: {
+          type: "left",
+          source: { type: "column", path: ["T1", "name"] },
+          length: { type: "value", value: 3 },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.left[dialect]);
+    });
+  });
+
+  describe("right - extract right string", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        suffix: expr.right(item.name, 3),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        suffix: {
+          type: "right",
+          source: { type: "column", path: ["T1", "name"] },
+          length: { type: "value", value: 3 },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.right[dialect]);
+    });
+  });
+
+  describe("trim - remove whitespace", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        trimmed: expr.trim(item.name),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        trimmed: {
+          type: "trim",
+          arg: { type: "column", path: ["T1", "name"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.trim[dialect]);
+    });
+  });
+
+  describe("padStart - left padding", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        padded: expr.padStart(item.name, 10, "0"),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        padded: {
+          type: "padStart",
+          source: { type: "column", path: ["T1", "name"] },
+          length: { type: "value", value: 10 },
+          fillString: { type: "value", value: "0" },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.padStart[dialect]);
+    });
+  });
+
+  describe("replace - character replacement", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        replaced: expr.replace(item.name, "a", "A"),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        replaced: {
+          type: "replace",
+          source: { type: "column", path: ["T1", "name"] },
+          from: { type: "value", value: "a" },
+          to: { type: "value", value: "A" },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.replace[dialect]);
+    });
+  });
+
+  describe("upper - convert to uppercase", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        upper: expr.upper(item.name),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        upper: {
+          type: "upper",
+          arg: { type: "column", path: ["T1", "name"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.upper[dialect]);
+    });
+  });
+
+  describe("lower - convert to lowercase", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        lower: expr.lower(item.name),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        lower: {
+          type: "lower",
+          arg: { type: "column", path: ["T1", "name"] },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.lower[dialect]);
+    });
+  });
+
+  describe("substring - substring", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        sub: expr.substring(item.name, 1, 5),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        sub: {
+          type: "substring",
+          source: { type: "column", path: ["T1", "name"] },
+          start: { type: "value", value: 1 },
+          length: { type: "value", value: 5 },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.substring[dialect]);
+    });
+  });
+
+  describe("indexOf - character position (0-based)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .select((item) => ({
+        pos: expr.indexOf(item.name, "test"),
+      }))
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.select).toMatchObject({
+        pos: {
+          type: "indexOf",
+          source: { type: "column", path: ["T1", "name"] },
+          search: { type: "value", value: "test" },
+        },
+      });
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.indexOf[dialect]);
+    });
+  });
+
+  describe("like - LIKE pattern matching", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.like(item.name, "%test%")])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.where).toEqual([
+        {
+          type: "like",
+          source: { type: "column", path: ["T1", "name"] },
+          pattern: { type: "value", value: "%test%" },
+        },
+      ]);
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.like[dialect]);
+    });
+  });
+
+  describe("like - escape processing (%)", () => {
+    const db = createTestDb();
+    const def = db
+      .user()
+      .where((item) => [expr.like(item.name, "%\\%%")])
+      .getSelectQueryDef();
+
+    it("Verify QueryDef", () => {
+      expect(def.where).toEqual([
+        {
+          type: "like",
+          source: { type: "column", path: ["T1", "name"] },
+          pattern: { type: "value", value: "%\\%%" },
+        },
+      ]);
+    });
+
+    it.each(dialects)("[%s] Verify SQL", (dialect) => {
+      const builder = createQueryBuilder(dialect);
+      expect(builder.build(def)).toMatchSql(expected.likeEscape[dialect]);
+    });
+  });
+});

package/tests/expr/utility.expected.ts

@@ -0,0 +1,147 @@
+/**
+ * Expr - utility function test expected SQL
+ */
+import { mysql, pgsql, tsql } from "@simplysm/core-common";
+import type { ExpectedSql } from "../setup/test-utils";
+
+//#region ========== ROW_NUM ==========
+
+export const rowNum: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      ROW_NUMBER() OVER () AS \`rowNum\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[id] AS [id],
+      ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS [rowNum]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."id" AS "id",
+      ROW_NUMBER() OVER () AS "rowNum"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+//#endregion
+
+//#region ========== RANDOM ==========
+
+export const random: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      RAND() AS \`randomVal\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[id] AS [id],
+      NEWID() AS [randomVal]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."id" AS "id",
+      RANDOM() AS "randomVal"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+//#endregion
+
+//#region ========== CAST ==========
+
+export const castToInt: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      CAST(\`T1\`.\`age\` AS INT) AS \`ageInt\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[id] AS [id],
+      CAST([T1].[age] AS INT) AS [ageInt]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."id" AS "id",
+      CAST("T1"."age" AS INTEGER) AS "ageInt"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const castToVarchar: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      CAST(\`T1\`.\`age\` AS VARCHAR(50)) AS \`ageStr\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[id] AS [id],
+      CAST([T1].[age] AS NVARCHAR(50)) AS [ageStr]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."id" AS "id",
+      CAST("T1"."age" AS VARCHAR(50)) AS "ageStr"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+//#endregion
+
+//#region ========== RAW ==========
+
+export const rawBasic: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      NOW() AS \`serverTime\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[id] AS [id],
+      NOW() AS [serverTime]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."id" AS "id",
+      NOW() AS "serverTime"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+export const rawWithParam: ExpectedSql = {
+  mysql: mysql`
+    SELECT
+      \`T1\`.\`id\` AS \`id\`,
+      CONCAT(\`T1\`.\`name\`, ' - ', \`T1\`.\`email\`) AS \`combined\`
+    FROM \`TestDb\`.\`User\` AS \`T1\`
+  `,
+  mssql: tsql`
+    SELECT
+      [T1].[id] AS [id],
+      CONCAT([T1].[name], ' - ', [T1].[email]) AS [combined]
+    FROM [TestDb].[TestSchema].[User] AS [T1]
+  `,
+  postgresql: pgsql`
+    SELECT
+      "T1"."id" AS "id",
+      CONCAT("T1"."name", ' - ', "T1"."email") AS "combined"
+    FROM "TestSchema"."User" AS "T1"
+  `,
+};
+
+//#endregion