Add Action<T> Set overload for assignment syntax (#33)

* Add Action<T> Set overload for assignment syntax (#32)

Add Set(Action<T>) overload to IUpdateBuilder<T> and IExecutableUpdateBuilder<T>
supporting both single-assignment expression lambdas and multi-assignment
statement lambdas. The source generator extracts property assignments from
the lambda body at compile time, producing carrier-optimized interceptors
with zero delegate allocation.

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

* Remove accidentally committed conversation log file

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

* Fix review items: captured variable safety, style, and test coverage

- Fix redundant LiteralExpressionSyntax check in IsCapturedVariable
- Restrict captured variable extraction to simple IdentifierNameSyntax
  (complex expressions like obj.Value or GetName() are inlined instead
  of attempting broken GetField lookup)
- Remove ReSharper suppress from IModificationBuilder.cs
- Remove global:: prefix from Action<T> in generated code to match
  Expression<Func<>> convention
- Add captured variable test (single and multi-assignment)
- Add type-mapped column test (Money/Balance)

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

* Add SQLite integration tests for all Update Set forms

- Add UpdateIntegrationTests with 10 end-to-end tests covering:
  Set<TValue>(Expression, TValue), Set(T entity), Set(Action<T>)
  single/multi-assignment, captured variables, chained forms, and All()
- Fix carrier terminal logging for non-nullable value types: use
  .ToString() directly instead of ?.ToString() which fails on bool/int
- Fix pre-existing CS8604 warnings in carrier logging for nullable
  reference type fields (string?) by using ?.ToString() ?? "null"
- Extract CarrierClassBuilder.IsNonNullableValueType() for shared use

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

* Fix captured variable carrier optimization, add conditional chain tests, update README

- Fix Set(Action<T>) captured variables not carrier-optimized: skip
  UpdateSetAction clauses from the direct-path check in BuildPrebuiltChainInfo,
  since they use delegate.Target + FieldInfo extraction, not expression tree paths.
- Add per-interceptor carrier-optimized label in XML remarks.
- Add ConditionalCarrierTests (19 tests): validates carrier class + bitmask
  dispatch code generation for Select, Update, and Delete conditional chains.
- Add ConditionalChainSqlTests (18 tests): validates runtime ToDiagnostics()
  SQL output for conditional chains across all operation types.
- Add carrier generation tests for Set(Action<T>) literal and captured variable.
- Update README: db.Users property -> db.Users() method, QueryBuilder<T> ->
  IEntityAccessor<T>, add Set(Action<T>) docs, add ToDiagnostics(), remove
  Set Operations (API removed in #27).

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

* Fix boolean literal formatting for non-PostgreSQL dialects in Set(Action<T>)

During discovery, inlined boolean constants were formatted using the
default PostgreSQL dialect (TRUE/FALSE). Non-PostgreSQL dialects (SQLite,
MySQL, SQL Server) require 0/1 instead. Added ReformatInlinedBooleanForDialect
to re-format boolean tokens during enrichment when the correct dialect is known.

Closes #46

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

* Inline compile-time constants in Set(Action<T>) SQL, update README

Add constant detection to TranslateSetAction: values that are compile-time
constants (literals, const fields) are inlined directly into the SQL string
instead of bound as parameters. For example, Set(u => u.IsActive = false)
now produces SET "IsActive" = 0 instead of SET "IsActive" = @p0.

- ClauseInfo.cs: Add InlinedSqlValue, InlinedCSharpExpression, IsInlined
  to SetActionAssignment for carrying inlined constant data.
- ClauseTranslator.cs: Check GetConstantValue() before creating parameters;
  use FormatConstantAsSqlLiteral for inlineable values.
- ExpressionSyntaxTranslator.cs: Make FormatConstantAsSqlLiteral internal.
- CompileTimeSqlBuilder.cs: Emit InlinedSqlValue for inlined assignments,
  track parameter offsets separately from assignment count.
- InterceptorCodeGenerator.Modifications.cs: Handle inlined assignments in
  standalone path using InlinedCSharpExpression.
- CrossDialectUpdateTests.cs: Update expected SQL to reflect inlined constants.
- README.md: Add ToDiagnostics() usage section, expand Set(Action<T>) docs
  with captured variable example.

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

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: DJGosnell

2026-03-18-043306-local-command-caveatcaveat-the-messages-below-w.txt

@@ -70,7 +70,7 @@ The Roslyn incremental source generator analyzes every query call site and emits
 
 ### Execution Interceptors
 
-All terminal methods — `ExecuteFetchAllAsync`, `ExecuteNonQueryAsync`, `ExecuteScalarAsync`, `ToAsyncEnumerable`, and `ToSql` — are intercepted at compile time. The generator emits pre-built SQL, ordinal-based readers, and pre-allocated parameter arrays directly into the interceptor, bypassing the runtime query builder entirely.
+All terminal methods — `ExecuteFetchAllAsync`, `ExecuteNonQueryAsync`, `ExecuteScalarAsync`, `ToAsyncEnumerable`, and `ToDiagnostics` — are intercepted at compile time. The generator emits pre-built SQL, ordinal-based readers, and pre-allocated parameter arrays directly into the interceptor, bypassing the runtime query builder entirely.
 
 ### Chain Analysis and Optimization Tiers
 
@@ -85,7 +85,7 @@ The generator performs dataflow analysis on query chains to determine the best o
 Queries built with `if`/`else` branching are fully supported at compile time. The generator assigns each conditional clause a bit index and enumerates all possible clause combinations as a bitmask. Each combination maps to its own pre-built SQL variant, so conditional query construction has zero runtime SQL building cost.
 
 ```csharp
-var query = db.Users.Select(u => u);
+var query = db.Users().Select(u => u);
 
 if (activeOnly)
     query = query.Where(u => u.IsActive);
@@ -160,13 +160,13 @@ public class UserSchema : Schema
 [QuarryContext(Dialect = SqlDialect.SQLite)]
 public partial class AppDb : QuarryContext
 {
-    public partial QueryBuilder<User> Users { get; }
+    public partial IEntityAccessor<User> Users();
 }
 
 // 3. Query
 await using var db = new AppDb(connection);
 
-var activeUsers = await db.Users
+var activeUsers = await db.Users()
     .Select(u => new { u.UserName, u.Email })
     .Where(u => u.IsActive)
     .OrderBy(u => u.UserName)
@@ -221,8 +221,8 @@ public class UserSchema : Schema
 [QuarryContext(Dialect = SqlDialect.SQLite, Schema = "public")]
 public partial class AppDb : QuarryContext
 {
-    public partial QueryBuilder<User> Users { get; }
-    public partial QueryBuilder<Order> Orders { get; }
+    public partial IEntityAccessor<User> Users();
+    public partial IEntityAccessor<Order> Orders();
 }
 ```
 
@@ -239,16 +239,16 @@ All query builder methods return interfaces (`IQueryBuilder<T>`, `IJoinedQueryBu
 ### Select
 
 ```csharp
-db.Users.Select(u => u);                                         // entity
-db.Users.Select(u => u.UserName);                                // single column
-db.Users.Select(u => (u.UserId, u.UserName));                    // tuple
-db.Users.Select(u => new UserDto { Name = u.UserName });         // DTO
+db.Users().Select(u => u);                                         // entity
+db.Users().Select(u => u.UserName);                                // single column
+db.Users().Select(u => (u.UserId, u.UserName));                    // tuple
+db.Users().Select(u => new UserDto { Name = u.UserName });         // DTO
 ```
 
 ### Where
 
 ```csharp
-db.Users.Where(u => u.IsActive && u.UserId > minId);
+db.Users().Where(u => u.IsActive && u.UserId > minId);
 
 // Operators: ==, !=, <, >, <=, >=, &&, ||, !
 // Null: u.Email == null, u.Email != null
@@ -260,10 +260,10 @@ db.Users.Where(u => u.IsActive && u.UserId > minId);
 ### OrderBy, GroupBy, Aggregates
 
 ```csharp
-db.Users.OrderBy(u => u.UserName);
-db.Users.OrderBy(u => u.CreatedAt, Direction.Descending);
+db.Users().OrderBy(u => u.UserName);
+db.Users().OrderBy(u => u.CreatedAt, Direction.Descending);
 
-db.Orders.GroupBy(o => o.Status)
+db.Orders().GroupBy(o => o.Status)
     .Having(o => Sql.Count() > 5)
     .Select(o => (o.Status, Sql.Count(), Sql.Sum(o.Total)));
 ```
@@ -273,24 +273,24 @@ Aggregate markers: `Sql.Count()`, `Sql.Sum()`, `Sql.Avg()`, `Sql.Min()`, `Sql.Ma
 ### Pagination and Distinct
 
 ```csharp
-db.Users.Select(u => u).Limit(10).Offset(20);
-db.Users.Select(u => u.UserName).Distinct();
+db.Users().Select(u => u).Limit(10).Offset(20);
+db.Users().Select(u => u.UserName).Distinct();
 ```
 
 ### Joins
 
 ```csharp
 // 2-table join (also LeftJoin, RightJoin)
-db.Users.Join<Order>((u, o) => u.UserId == o.UserId.Id)
+db.Users().Join<Order>((u, o) => u.UserId == o.UserId.Id)
     .Where((u, o) => o.Total > 100)
     .Select((u, o) => (u.UserName, o.Total));
 
 // Navigation-based join
-db.Users.Join(u => u.Orders)
+db.Users().Join(u => u.Orders)
     .Select((u, o) => (u.UserName, o.Total));
 
 // 3/4-table chained joins (max 4 tables)
-db.Users.Join<Order>((u, o) => u.UserId == o.UserId.Id)
+db.Users().Join<Order>((u, o) => u.UserId == o.UserId.Id)
     .Join<OrderItem>((u, o, oi) => o.OrderId == oi.OrderId.Id)
     .Select((u, o, oi) => (u.UserName, o.Total, oi.ProductName));
 ```
@@ -300,17 +300,11 @@ db.Users.Join<Order>((u, o) => u.UserId == o.UserId.Id)
 On `Many<T>` properties inside `Where`:
 
 ```csharp
-db.Users.Where(u => u.Orders.Any());                         // EXISTS
-db.Users.Where(u => u.Orders.Any(o => o.Total > 100));       // filtered EXISTS
-db.Users.Where(u => u.Orders.All(o => o.Status == "paid"));  // NOT EXISTS + negated
-db.Users.Where(u => u.Orders.Count() > 5);                   // scalar COUNT
-db.Users.Where(u => u.Orders.Count(o => o.Total > 50) > 2); // filtered COUNT
-```
-
-### Set Operations
-
-```csharp
-db.Union(query1, query2);      // also UnionAll, Except, Intersect
+db.Users().Where(u => u.Orders.Any());                         // EXISTS
+db.Users().Where(u => u.Orders.Any(o => o.Total > 100));       // filtered EXISTS
+db.Users().Where(u => u.Orders.All(o => o.Status == "paid"));  // NOT EXISTS + negated
+db.Users().Where(u => u.Orders.Count() > 5);                   // scalar COUNT
+db.Users().Where(u => u.Orders.Count(o => o.Total > 50) > 2); // filtered COUNT
 ```
 
 ---
@@ -321,24 +315,52 @@ db.Union(query1, query2);      // also UnionAll, Except, Intersect
 
 ```csharp
 // Initializer-aware — only set properties generate columns
-await db.Insert(new User { UserName = "x", IsActive = true }).ExecuteNonQueryAsync();
-var id = await db.Insert(user).ExecuteScalarAsync<int>();  // returns generated key
-await db.InsertMany(users).ExecuteNonQueryAsync();
+await db.Users().Insert(new User { UserName = "x", IsActive = true }).ExecuteNonQueryAsync();
+var id = await db.Users().Insert(user).ExecuteScalarAsync<int>();  // returns generated key
+await db.Users().InsertMany(users).ExecuteNonQueryAsync();
 ```
 
 ### Update
 
+Requires `Where()` or `All()` before execution. Three `Set` overloads:
+
 ```csharp
-// Requires Where() or All() before execution
-await db.Update<User>().Set(u => u.UserName, "New").Where(u => u.UserId == 1).ExecuteNonQueryAsync();
-await db.Update<User>().Set(new User { UserName = "New" }).Where(u => u.UserId == 1).ExecuteNonQueryAsync();
+// Column + value form
+await db.Users().Update()
+    .Set(u => u.UserName, "New")
+    .Where(u => u.UserId == 1)
+    .ExecuteNonQueryAsync();
+
+// Assignment syntax — single or multiple columns in one lambda
+await db.Users().Update()
+    .Set(u => u.UserName = "New")
+    .Where(u => u.UserId == 1)
+    .ExecuteNonQueryAsync();
+
+await db.Users().Update()
+    .Set(u => { u.UserName = "New"; u.IsActive = true; })
+    .Where(u => u.UserId == 1)
+    .ExecuteNonQueryAsync();
+
+// Captured variables work — extracted at runtime from the delegate closure
+var newName = GetNameFromInput();
+await db.Users().Update()
+    .Set(u => { u.UserName = newName; u.IsActive = true; })
+    .Where(u => u.UserId == 1)
+    .ExecuteNonQueryAsync();
+
+// Entity form — sets all initialized properties
+await db.Users().Update()
+    .Set(new User { UserName = "New" })
+    .Where(u => u.UserId == 1)
+    .ExecuteNonQueryAsync();
 ```
 
 ### Delete
 
 ```csharp
 // Requires Where() or All() before execution
-await db.Delete<User>().Where(u => u.UserId == 1).ExecuteNonQueryAsync();
+await db.Users().Delete().Where(u => u.UserId == 1).ExecuteNonQueryAsync();
 ```
 
 ### Execution Methods
@@ -352,8 +374,34 @@ await db.Delete<User>().Where(u => u.UserId == 1).ExecuteNonQueryAsync();
 | `ExecuteScalarAsync<T>()` | `Task<T>` |
 | `ExecuteNonQueryAsync()` | `Task<int>` |
 | `ToAsyncEnumerable()` | `IAsyncEnumerable<T>` |
+| `ToDiagnostics()` | `QueryDiagnostics` (SQL, parameters, optimization tier, clause breakdown) |
 | `ToSql()` | `string` (preview SQL) |
 
+### Query Diagnostics
+
+`ToDiagnostics()` returns a `QueryDiagnostics` object with the generated SQL, bound parameters, optimization metadata, and a per-clause breakdown. Available on all builder types.
+
+```csharp
+var diag = db.Users()
+    .Where(u => u.IsActive)
+    .OrderBy(u => u.UserName)
+    .Select(u => u)
+    .ToDiagnostics();
+
+Console.WriteLine(diag.Sql);               // SELECT ... FROM "users" WHERE ...
+Console.WriteLine(diag.Dialect);           // SQLite
+Console.WriteLine(diag.Tier);             // PrebuiltDispatch
+Console.WriteLine(diag.IsCarrierOptimized); // True
+
+foreach (var p in diag.Parameters)
+    Console.WriteLine($"{p.Name} = {p.Value}");
+
+foreach (var clause in diag.Clauses)
+    Console.WriteLine($"{clause.ClauseType}: {clause.SqlFragment} (active={clause.IsActive})");
+```
+
+For conditional chains, each clause reports `IsConditional` and `IsActive` so you can inspect which branches were taken and verify the generated SQL for each path.
+
 ---
 
 ## Raw SQL
@@ -446,7 +494,7 @@ quarry scaffold -c "Server=localhost;Database=mydb" -d sqlserver -o Schemas --ni
 ### What It Generates
 
 - One schema class per table with `Key<T>`, `Col<T>`, `Ref<T, TKey>`, and `Many<T>` properties
-- A `QuarryContext` subclass with `QueryBuilder<T>` properties for each table
+- A `QuarryContext` subclass with `IEntityAccessor<T>` methods for each table
 - Automatic detection of junction tables (many-to-many), implicit foreign keys by naming convention, and naming style inference
 
 ---

README.md

@@ -138,6 +138,22 @@ private static string SelectBaseClass(PrebuiltChainInfo chain)
         };
     }
 
+    /// <summary>
+    /// Checks if the given CLR type name is a non-nullable value type.
+    /// Used by the logging emitter to decide between .ToString() and ?.ToString() ?? "null".
+    /// </summary>
+    internal static bool IsNonNullableValueType(string typeName)
+    {
+        if (typeName.EndsWith("?"))
+            return false;
+        if (ValueTypes.Contains(typeName))
+            return true;
+        // Enum types (PascalCase, no dots/generics) are value types
+        if (!typeName.Contains('<') && !typeName.Contains('[') && !typeName.Contains('.'))
+            return false; // Could be a class name — treat conservatively as reference
+        return false;
+    }
+
     /// <summary>
     /// Known value types that don't need nullable annotation.
     /// </summary>

src/Quarry.Generator/Generation/CarrierClassBuilder.cs

@@ -815,10 +815,13 @@ private static void EmitInlineParameterLogging(StringBuilder sb, PrebuiltChainIn
             }
             else
             {
-                // Entity-sourced params read from Entity field, not P{n}.
-                // Box to object? to handle value types (bool, int, etc.) that can't use ?.ToString().
+                // Non-nullable value types use .ToString() directly.
+                // Nullable/reference types use ?.ToString() ?? "null" since carrier fields
+                // are declared as T? by NormalizeFieldType.
                 if (param.EntityPropertyExpression != null)
                     sb.AppendLine($"            ParameterLog.Bound(__opId, {i}, ((object?){param.EntityPropertyExpression})?.ToString() ?? \"null\");");
+                else if (CarrierClassBuilder.IsNonNullableValueType(param.TypeName))
+                    sb.AppendLine($"            ParameterLog.Bound(__opId, {i}, __c.P{i}.ToString());");
                 else
                     sb.AppendLine($"            ParameterLog.Bound(__opId, {i}, __c.P{i}?.ToString() ?? \"null\");");
             }