Add experimental typed SQL DSL for typed builders

DynamORM.Tests/TypedSql/TypedSqlDslTests.cs

@@ -0,0 +1,119 @@
+/*
+ * DynamORM - Dynamic Object-Relational Mapping library.
+ * Copyright (c) 2012-2026, Grzegorz Russek (grzegorz.russek@gmail.com)
+ * All rights reserved.
+ */
+
+using System.Linq;
+using System.Text.RegularExpressions;
+using DynamORM.Tests.Helpers;
+using DynamORM.TypedSql;
+using NUnit.Framework;
+
+namespace DynamORM.Tests.TypedSql
+{
+    [TestFixture]
+    public class TypedSqlDslTests : TestsBase
+    {
+        private static string NormalizeSql(string sql)
+        {
+            int index = 0;
+            return Regex.Replace(sql, @"\[\$[^\]]+\]", m => string.Format("[${0}]", index++));
+        }
+
+        [SetUp]
+        public void SetUp()
+        {
+            CreateTestDatabase();
+            CreateDynamicDatabase(
+                DynamicDatabaseOptions.SingleConnection |
+                DynamicDatabaseOptions.SingleTransaction |
+                DynamicDatabaseOptions.SupportLimitOffset |
+                DynamicDatabaseOptions.SupportNoLock);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            DestroyDynamicDatabase();
+            DestroyTestDatabase();
+        }
+
+        [Test]
+        public void TestSelectSqlWithFunctionsAndOrdering()
+        {
+            var cmd = Database.FromTyped<TypedFluentUser>("u")
+                .SelectSql(
+                    u => Sql.Count().As("cnt"),
+                    u => Sql.Coalesce<string>(u.Col(x => x.Code), Sql.Val("N/A")).As("code_value"))
+                .GroupBySql(u => Sql.Coalesce<string>(u.Col(x => x.Code), Sql.Val("N/A")))
+                .HavingSql(u => Sql.Count().Gt(1))
+                .OrderBySql(u => Sql.Count().Desc());
+
+            Assert.AreEqual(
+                "SELECT COUNT(*) AS \"cnt\", COALESCE(u.\"user_code\", [$0]) AS \"code_value\" FROM \"sample_users\" AS u GROUP BY COALESCE(u.\"user_code\", [$1]) HAVING (COUNT(*) > [$2]) ORDER BY COUNT(*) DESC",
+                NormalizeSql(cmd.CommandText()));
+        }
+
+        [Test]
+        public void TestSelectSqlWithCase()
+        {
+            var cmd = Database.FromTyped<TypedFluentUser>("u")
+                .SelectSql(u => Sql.Case<string>()
+                    .When(u.Col(x => x.Code).Eq("A"), "Alpha")
+                    .When(u.Col(x => x.Code).Eq("B"), "Beta")
+                    .Else("Other")
+                    .As("category"));
+
+            Assert.AreEqual(
+                "SELECT CASE WHEN (u.\"user_code\" = [$0]) THEN [$1] WHEN (u.\"user_code\" = [$2]) THEN [$3] ELSE [$4] END AS \"category\" FROM \"sample_users\" AS u",
+                NormalizeSql(cmd.CommandText()));
+        }
+
+        [Test]
+        public void TestJoinOnSql()
+        {
+            var cmd = Database.FromTyped<TypedFluentUser>("u")
+                .Join<TypedFluentUser>(j => j.Left().As("x").OnSql((l, r) => l.Col(a => a.Id).Eq(r.Col(a => a.Id)).And(r.Col(a => a.Code).IsNotNull())))
+                .SelectSql(u => u.Col(x => x.Id));
+
+            Assert.AreEqual("SELECT u.\"id_user\" FROM \"sample_users\" AS u LEFT JOIN \"sample_users\" AS x ON ((u.\"id_user\" = x.\"id_user\") AND (x.\"user_code\" IS NOT NULL))",
+                cmd.CommandText());
+        }
+
+        [Test]
+        public void TestUpdateSetSqlAndWhereSql()
+        {
+            var cmd = Database.UpdateTyped<Users>()
+                .SetSql(u => u.Code, u => Sql.Coalesce<string>(Sql.Val("900"), u.Col(x => x.Code)))
+                .WhereSql(u => u.Col(x => x.Id).Eq(1).And(u.Col(x => x.Code).IsNotNull()));
+
+            Assert.AreEqual(
+                "UPDATE \"sample_users\" SET \"code\" = COALESCE([$0], \"code\") WHERE ((\"id\" = [$1]) AND (\"code\" IS NOT NULL))",
+                NormalizeSql(cmd.CommandText()));
+        }
+
+        [Test]
+        public void TestInsertSqlSupportsCase()
+        {
+            var cmd = Database.InsertTyped<Users>()
+                .InsertSql(u => u.Code, u => Sql.Coalesce<string>(Sql.Val("901"), Sql.Val("fallback")))
+                .InsertSql(u => u.First, u => Sql.Case<string>().When(Sql.Val(1).Eq(1), "Typed").Else("Other"));
+
+            Assert.AreEqual(
+                "INSERT INTO \"sample_users\" (\"code\", \"first\") VALUES (COALESCE([$0], [$1]), CASE WHEN ([$2] = [$3]) THEN [$4] ELSE [$5] END)",
+                NormalizeSql(cmd.CommandText()));
+        }
+
+        [Test]
+        public void TestDeleteWhereSql()
+        {
+            var cmd = Database.DeleteTyped<Users>()
+                .WhereSql(u => u.Col(x => x.Id).Eq(2).And(u.Col(x => x.Code).NotEq("X")));
+
+            Assert.AreEqual(
+                "DELETE FROM \"sample_users\" WHERE ((\"id\" = [$0]) AND (\"code\" <> [$1]))",
+                NormalizeSql(cmd.CommandText()));
+        }
+    }
+}