release: 2.4.0 — CASE WHEN + function-call DEFAULT

Closes the two gaps that forced CosmoMailServer's Phase D to work around
the driver: CASE WHEN derivation in INSERT/SELECT/WHERE, and non-literal
DEFAULT clauses (GETUTCDATE(), NEWID(), …) that round-trip through the
catalog as canonical SQL text. Adds NEWID() to the scalar dispatch.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: vkuttyp

Directory.Build.props

@@ -7,6 +7,6 @@
     <Authors>vkuttyp</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RepositoryUrl>https://github.com/vkuttyp/CosmoSQLClient-Dotnet</RepositoryUrl>
-    <Version>2.3.0</Version>
+    <Version>2.4.0</Version>
   </PropertyGroup>
 </Project>

src/CosmoSQLClient.CosmoKv/Ast/Statement.cs

@@ -181,6 +181,18 @@ internal sealed record CountStarExpression : Expression;
 /// </summary>
 internal sealed record CastExpression(Expression Operand, Schema.SqlColumnType TargetType) : Expression;
 
+/// <summary>
+/// Searched <c>CASE WHEN pred THEN val [WHEN pred THEN val …] [ELSE val] END</c>.
+/// The simple form (<c>CASE expr WHEN val THEN …</c>) isn't supported — the
+/// migration consumer's flag-bit derivation uses only the searched form, and
+/// nothing else surfaced a need.
+/// </summary>
+internal sealed record CaseExpression(
+    IReadOnlyList<CaseBranch> Branches,
+    Expression? Else) : Expression;
+
+internal sealed record CaseBranch(Expression When, Expression Then);
+
 internal enum BinaryOperator
 {
     And, Or,
@@ -192,3 +204,65 @@ internal enum UnaryOperator
 {
     Not, Negate,
 }
+
+/// <summary>
+/// Render a subset of the <see cref="Expression"/> AST back to T-SQL text.
+/// Currently used by the parser to capture non-literal <c>DEFAULT</c>
+/// clauses (v2.4 task #34) — those need to round-trip through the catalog's
+/// JSON serialization but the AST itself is polymorphic and doesn't
+/// serialize cleanly. Producing a canonical SQL string sidesteps the
+/// problem; we re-parse on INSERT.
+/// </summary>
+internal static class ExpressionToSql
+{
+    /// <summary>Render an expression to canonical T-SQL. Throws for forms
+    /// that aren't valid in <c>DEFAULT</c> position (column refs, *, etc).</summary>
+    public static string Render(Expression e) => e switch
+    {
+        LiteralExpression l        => RenderLiteral(l.Value),
+        FunctionCallExpression fc  => $"{fc.Name}({string.Join(", ", fc.Args.Select(Render))})",
+        CastExpression c           => $"CAST({Render(c.Operand)} AS {c.TargetType})",
+        UnaryExpression u when u.Op == UnaryOperator.Negate => $"-{Render(u.Operand)}",
+        UnaryExpression u when u.Op == UnaryOperator.Not    => $"NOT {Render(u.Operand)}",
+        BinaryExpression b         => $"({Render(b.Left)} {OpToSql(b.Op)} {Render(b.Right)})",
+        ParameterExpression p      => p.Name.StartsWith('@') ? p.Name : "@" + p.Name,
+        _ => throw new InvalidOperationException(
+                $"Cannot render {e.GetType().Name} to SQL text (not valid in DEFAULT)."),
+    };
+
+    private static string RenderLiteral(Core.SqlValue v)
+    {
+        if (v.IsNull) return "NULL";
+        return v.Kind switch
+        {
+            Core.SqlValueKind.Bool          => v.BoolValue ? "1" : "0",
+            Core.SqlValueKind.Int8 or Core.SqlValueKind.Int16 or
+            Core.SqlValueKind.Int32 or Core.SqlValueKind.Int64
+                                             => v.AsInt()!.Value.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            Core.SqlValueKind.Float or
+            Core.SqlValueKind.Double         => (v.AsDouble() ?? 0).ToString("R", System.Globalization.CultureInfo.InvariantCulture),
+            Core.SqlValueKind.Decimal        => (v.AsDecimal() ?? 0).ToString(System.Globalization.CultureInfo.InvariantCulture),
+            Core.SqlValueKind.Text or
+            Core.SqlValueKind.EmptyString    => "'" + (v.AsString() ?? "").Replace("'", "''") + "'",
+            _ => throw new InvalidOperationException($"Cannot render SqlValue kind {v.Kind} as a SQL literal."),
+        };
+    }
+
+    private static string OpToSql(BinaryOperator op) => op switch
+    {
+        BinaryOperator.And => "AND",
+        BinaryOperator.Or  => "OR",
+        BinaryOperator.Eq  => "=",
+        BinaryOperator.Ne  => "<>",
+        BinaryOperator.Lt  => "<",
+        BinaryOperator.Le  => "<=",
+        BinaryOperator.Gt  => ">",
+        BinaryOperator.Ge  => ">=",
+        BinaryOperator.Add => "+",
+        BinaryOperator.Sub => "-",
+        BinaryOperator.Mul => "*",
+        BinaryOperator.Div => "/",
+        BinaryOperator.Mod => "%",
+        _ => throw new InvalidOperationException($"Unknown operator {op}"),
+    };
+}

src/CosmoSQLClient.CosmoKv/Execution/Executor.cs

@@ -51,6 +51,35 @@ public void SetActiveAccess(IKvAccess? kv)
     /// </summary>
     public bool IdentityInsertEnabled { get; set; }
 
+    // Cache of parsed DEFAULT expressions keyed by source SQL — the same
+    // string fires once per row inserted, parser is cheap but constant
+    // overhead adds up under bulk loads.
+    private readonly Dictionary<string, Ast.Expression> _defaultExprCache = new();
+
+    /// <summary>
+    /// Evaluate a column's <c>DefaultExpressionSql</c> (v2.4 non-literal
+    /// DEFAULT). Cached on first use; the expression has no row context
+    /// (DEFAULT can't reference columns) so we evaluate against an empty
+    /// dummy table.
+    /// </summary>
+    private SqlValue EvalDefaultExpression(string defExprSql)
+    {
+        if (!_defaultExprCache.TryGetValue(defExprSql, out var expr))
+        {
+            expr = Parsing.TSqlParser.ParseExpressionString(defExprSql);
+            _defaultExprCache[defExprSql] = expr;
+        }
+        var dummyTable = new TableSchema(
+            Name: "(default-expr)",
+            Columns: Array.Empty<ColumnSchema>(),
+            PrimaryKeyColumnIndex: null,
+            IdentityColumnIndex: null);
+        var ctx = new ExpressionEvaluator.RowContext(
+            dummyTable, ReadOnlySpan<SqlValue>.Empty,
+            new Dictionary<string, SqlValue>());
+        return ExpressionEvaluator.Evaluate(expr, ctx);
+    }
+
     // ── Public entry points ─────────────────────────────────────────────────
 
     public async Task<int> ExecuteAsync(
@@ -225,7 +254,12 @@ private async Task<InsertResult> ExecuteInsertCore(
             for (int i = 0; i < table.Columns.Count; i++)
             {
                 var col = table.Columns[i];
-                record[i] = col.DefaultValue ?? SqlValue.Null_;
+                // v2.4: non-literal DEFAULT (e.g. GETUTCDATE()) is stored
+                // as a SQL string; parse + evaluate at INSERT time.
+                if (col.DefaultExpressionSql is { } defExprSql)
+                    record[i] = EvalDefaultExpression(defExprSql);
+                else
+                    record[i] = col.DefaultValue ?? SqlValue.Null_;
             }
 
             // Track whether the caller supplied an explicit IDENTITY value
@@ -1387,17 +1421,30 @@ private async Task<DeleteResult> ExecuteDeleteCore(
     private static SqlValue EvalLiteralOrBound(
         Expression expr, IReadOnlyDictionary<string, SqlValue> bound)
     {
-        return expr switch
+        // Fast paths for the overwhelmingly common cases — literal and
+        // parameter dispatch without building a RowContext.
+        switch (expr)
         {
-            LiteralExpression l   => l.Value,
-            ParameterExpression p => bound.TryGetValue(p.Name, out var v)
-                ? v
-                : throw new InvalidOperationException(
-                    $"Parameter '{p.Name}' was not bound."),
-            UnaryExpression { Op: UnaryOperator.Negate } u => NegateLiteral(u.Operand, bound),
-            _ => throw new InvalidOperationException(
-                $"Expression {expr.GetType().Name} is not a constant — INSERT supports only literals and parameters."),
-        };
+            case LiteralExpression l:
+                return l.Value;
+            case ParameterExpression p:
+                return bound.TryGetValue(p.Name, out var v)
+                    ? v
+                    : throw new InvalidOperationException($"Parameter '{p.Name}' was not bound.");
+            case UnaryExpression { Op: UnaryOperator.Negate } u:
+                return NegateLiteral(u.Operand, bound);
+        }
+        // General expression in INSERT VALUES position — CASE WHEN, function
+        // calls, arithmetic. Evaluate against a dummy empty-row context so
+        // column refs throw cleanly (no source row at INSERT time).
+        var dummyTable = new TableSchema(
+            Name: "(insert-values)",
+            Columns: Array.Empty<ColumnSchema>(),
+            PrimaryKeyColumnIndex: null,
+            IdentityColumnIndex: null);
+        var ctx = new ExpressionEvaluator.RowContext(
+            dummyTable, ReadOnlySpan<SqlValue>.Empty, bound);
+        return ExpressionEvaluator.Evaluate(expr, ctx);
     }
 
     private static SqlValue NegateLiteral(

src/CosmoSQLClient.CosmoKv/Execution/ExpressionEvaluator.cs

@@ -92,6 +92,7 @@ public static SqlValue Evaluate(Expression expr, in RowContext ctx)
             case InExpression i:         return EvalIn(i, ctx);
             case FunctionCallExpression fc: return EvalFunctionCall(fc, ctx);
             case CastExpression cast:    return EvalCast(cast, ctx);
+            case CaseExpression ce:      return EvalCase(ce, ctx);
             case CountStarExpression:
                 throw new InvalidOperationException(
                     "COUNT(*) is only valid in an aggregating SELECT.");
@@ -453,6 +454,25 @@ private static SqlValue EvalIsNull(IsNullExpression n, in RowContext ctx)
         return SqlValue.From(n.Negated ? !v.IsNull : v.IsNull);
     }
 
+    // ── CASE WHEN ───────────────────────────────────────────────────────────
+
+    /// <summary>
+    /// Evaluate a searched <c>CASE WHEN p1 THEN v1 [WHEN p2 THEN v2 …]
+    /// [ELSE ve] END</c>. Branches are tested in declaration order; the
+    /// first branch whose predicate evaluates to TRUE wins. UNKNOWN /
+    /// FALSE branches fall through. With no winning branch, the ELSE
+    /// value is returned; with no ELSE, the result is NULL.
+    /// </summary>
+    private static SqlValue EvalCase(CaseExpression ce, in RowContext ctx)
+    {
+        foreach (var branch in ce.Branches)
+        {
+            if (EvaluatePredicate(branch.When, ctx))
+                return Evaluate(branch.Then, ctx);
+        }
+        return ce.Else is null ? SqlValue.Null_ : Evaluate(ce.Else, ctx);
+    }
+
     // ── LIKE ────────────────────────────────────────────────────────────────
 
     private static SqlValue EvalLike(LikeExpression lk, in RowContext ctx)

src/CosmoSQLClient.CosmoKv/Execution/ScalarFunctions.cs

@@ -43,6 +43,12 @@ private static SqlValue Fn_GETDATE(SqlValue[] args)
         return SqlValue.From(DateTime.Now);
     }
 
+    private static SqlValue Fn_NEWID(SqlValue[] args)
+    {
+        if (args.Length != 0) throw new InvalidOperationException("NEWID takes no arguments.");
+        return SqlValue.From(Guid.NewGuid());
+    }
+
     private static SqlValue Fn_DATEADD(SqlValue[] args)
     {
         if (args.Length != 3)
@@ -353,6 +359,7 @@ private static long DiffPart(DateTime a, DateTime b, DatePart part)
         {
             ["GETUTCDATE"]  = Fn_GETUTCDATE,
             ["GETDATE"]     = Fn_GETDATE,
+            ["NEWID"]       = Fn_NEWID,
             ["DATEADD"]     = Fn_DATEADD,
             ["DATEDIFF"]    = Fn_DATEDIFF,
             ["DATEPART"]    = Fn_DATEPART,

src/CosmoSQLClient.CosmoKv/Parsing/TSqlParser.cs

@@ -51,6 +51,21 @@ internal static Statement Parse(string sql)
         return stmt;
     }
 
+    /// <summary>
+    /// Parse a single expression (no surrounding statement). Used by the
+    /// executor to re-parse <see cref="Schema.ColumnSchema.DefaultExpressionSql"/>
+    /// at INSERT time for non-literal column defaults (v2.4 task #34).
+    /// </summary>
+    internal static Expression ParseExpressionString(string sql)
+    {
+        var lexer  = new TSqlLexer(sql);
+        var tokens = lexer.Tokenize();
+        var parser = new TSqlParser(tokens);
+        var expr   = parser.ParseExpression();
+        parser.Expect(TokenKind.EndOfInput);
+        return expr;
+    }
+
     // ── Statement dispatch ──────────────────────────────────────────────────
 
     internal Statement ParseStatement()
@@ -172,6 +187,7 @@ private ColumnSchema ParseColumnDef(int columnIndex, ref int? pkIndex, ref int?
         bool isPk = false;
         bool isUnique = false;
         SqlValue? defaultVal = null;
+        string? defaultExprSql = null;
 
         while (true)
         {
@@ -220,7 +236,12 @@ private ColumnSchema ParseColumnDef(int columnIndex, ref int? pkIndex, ref int?
             if (t.Kind == TokenKind.Default)
             {
                 Advance();
-                defaultVal = ParseLiteralExpr().Value;
+                // v2.4: DEFAULT accepts any expression, not just literals.
+                // Literals → SqlValue?, function calls / arithmetic →
+                // canonical SQL string that round-trips through the catalog.
+                var expr = ParseExpression();
+                if (expr is LiteralExpression lit) defaultVal = lit.Value;
+                else                               defaultExprSql = ExpressionToSql.Render(expr);
                 continue;
             }
             if (t.Kind == TokenKind.Unique)
@@ -233,7 +254,8 @@ private ColumnSchema ParseColumnDef(int columnIndex, ref int? pkIndex, ref int?
         }
 
         return new ColumnSchema(
-            colName, type, nullable, isIdentity, seed, inc, isPk, defaultVal, isUnique);
+            colName, type, nullable, isIdentity, seed, inc, isPk, defaultVal, isUnique,
+            DefaultExpressionSql: defaultExprSql);
     }
 
     private SqlColumnType ParseTypeName()
@@ -956,6 +978,33 @@ private Expression ParseAtom()
             Advance();
             return new ParameterExpression(t.Text);
         }
+        // CASE WHEN <pred> THEN <val> [WHEN <pred> THEN <val> …] [ELSE <val>] END
+        // Searched form only — the simple form `CASE expr WHEN val THEN …`
+        // isn't accepted; reach for nested CASE WHEN expr = val THEN … instead.
+        if (t.Kind == TokenKind.Case)
+        {
+            Advance();
+            var branches = new List<CaseBranch>();
+            while (Current().Kind == TokenKind.When)
+            {
+                Advance();
+                var when = ParseExpression();
+                Expect(TokenKind.Then);
+                var then = ParseExpression();
+                branches.Add(new CaseBranch(when, then));
+            }
+            if (branches.Count == 0)
+                throw new InvalidOperationException("CASE expression requires at least one WHEN branch.");
+            Expression? elseExpr = null;
+            if (Current().Kind == TokenKind.Else)
+            {
+                Advance();
+                elseExpr = ParseExpression();
+            }
+            Expect(TokenKind.End);
+            return new CaseExpression(branches, elseExpr);
+        }
+
         // Special-form keyword functions: CAST(expr AS type), CONVERT(type, expr [, style]).
         if (t.Kind == TokenKind.Cast)
         {

src/CosmoSQLClient.CosmoKv/Schema/ColumnSchema.cs

@@ -16,4 +16,13 @@ internal sealed record ColumnSchema(
     long IdentityIncrement,
     bool IsPrimaryKey,
     SqlValue? DefaultValue,
-    bool IsUnique = false);
+    bool IsUnique = false,
+    /// <summary>
+    /// Non-literal DEFAULT expression as canonical SQL text, e.g.
+    /// <c>"GETUTCDATE()"</c>. Persisted alongside the literal
+    /// <see cref="DefaultValue"/>; exactly one is set per column. Evaluated
+    /// at INSERT time by re-parsing the small expression; cost is
+    /// negligible next to the row write. Pre-v2.4 catalogs only have
+    /// DefaultValue set; everything keeps working.
+    /// </summary>
+    string? DefaultExpressionSql = null);

src/CosmoSQLClient.CosmoKv/Storage/Catalog.cs

@@ -167,19 +167,21 @@ private sealed record ColumnSchemaDto(
         bool Nullable,
         bool IsIdentity, long IdentitySeed, long IdentityIncrement,
         bool IsPrimaryKey,
-        SqlValue? DefaultValue)
+        SqlValue? DefaultValue,
+        bool IsUnique = false,
+        string? DefaultExpressionSql = null)
     {
         public ColumnSchema ToColumn()
             => new(Name,
                    new SqlColumnType(Family, Length, Precision, Scale, LengthMax),
                    Nullable, IsIdentity, IdentitySeed, IdentityIncrement,
-                   IsPrimaryKey, DefaultValue);
+                   IsPrimaryKey, DefaultValue, IsUnique, DefaultExpressionSql);
 
         public static ColumnSchemaDto From(ColumnSchema c)
             => new(c.Name, c.Type.Family, c.Type.Length, c.Type.Precision,
                    c.Type.Scale, c.Type.LengthMax, c.Nullable,
                    c.IsIdentity, c.IdentitySeed, c.IdentityIncrement,
-                   c.IsPrimaryKey, c.DefaultValue);
+                   c.IsPrimaryKey, c.DefaultValue, c.IsUnique, c.DefaultExpressionSql);
     }
 
     /// <summary>