feat: add support for translation of static members

Author: PawelGerr

.claude/CLAUDE.md

@@ -253,8 +253,10 @@ private NpgsqlBulkOperationExecutor SUT => field ??= ActDbContext.GetService<Npg
 - PostgreSQL resolves `NpgsqlDbType` per column via `INpgsqlTypeMapping` for correct type handling (e.g., `jsonb`/`json` from `string`)
 - Table/schema override via options; property selection via `IEntityPropertiesProvider`
 - PostgreSQL temp table collation: strings with `.` split into schema+name by default; set `SplitCollationComponents = false` to escape as single identifier
-- **Query-based bulk update** (all providers): `DbSet<TTarget>.BulkUpdateAsync(sourceQuery, targetKey, sourceKey, setBuilder, filter?, options?)`. SQL Server generates `UPDATE t SET ... FROM target INNER JOIN (sourceQuerySql) AS s ON ... [WHERE filterCondition]`; PostgreSQL/SQLite generate `UPDATE target AS t SET ... FROM (sourceQuerySql) AS s WHERE ... [AND filterCondition]`. Uses `SetPropertyBuilder<TTarget, TSource>` for fluent property assignment. Key selectors support single and composite keys (anonymous types). Source SQL and parameters extracted via `CreateDbCommand()`. Optional `filter` (`Expression<Func<TTarget, TSource, bool>>`) restricts which rows are updated; filter can reference both target and source properties (e.g., `(e, f) => e.Count < f.Count`); filter is translated via `ValueExpressionTranslator` (same instance as SET values), with unified `@__ev_N` parameters. Shared expression analysis logic in `BulkUpdateFromQueryHelper`. Table/schema override via `SqlServerBulkUpdateFromQueryOptions`, `NpgsqlBulkUpdateFromQueryOptions`, or `SqliteBulkUpdateFromQueryOptions`. Value expressions support constants and captured variables (e.g., `.Set(e => e.Count, (e, f) => 42)` or `.Set(e => e.Name, (e, f) => myVar)`), complex arithmetic expressions referencing target and/or source properties (e.g., `.Set(e => e.Count, (e, f) => e.Count + f.Count * 2)` or `.Set(e => e.Count, (e, f) => f.Count + 10)`), in addition to simple property access and `EF.Property` calls; constant values are emitted as SQL parameters (`@__bv_N`); complex expressions are translated to SQL via `ValueExpressionTranslator` with expression-value parameters (`@__ev_N`).
-- **Query-based bulk insert** (all providers): `DbSet<TTarget>.BulkInsertAsync(sourceQuery, mapBuilder)`. Generates `INSERT INTO target (cols) SELECT s.cols FROM (sourceQuerySql) AS s` — identical structure across all three providers (only identifier quoting differs). Uses `InsertPropertyBuilder<TTarget, TSource>` for fluent column mapping via `Map(target => target.Prop, source => source.Prop)` with single-parameter value selector. No key selectors needed (insert, not join). Table/schema override via `SqlServerBulkInsertFromQueryOptions`, `NpgsqlBulkInsertFromQueryOptions`, or `SqliteBulkInsertFromQueryOptions`. Value selectors support constants and captured variables (e.g., `.Map(e => e.Count, f => 42)` or `.Map(e => e.Name, f => myVar)`), complex arithmetic expressions referencing source properties (e.g., `.Map(e => e.Count, f => f.Count * 2 + 1)`), in addition to simple property access and `EF.Property` calls; constant values are emitted as SQL parameters (`@__bv_N`); complex expressions are translated to SQL via `ValueExpressionTranslator` with expression-value parameters (`@__ev_N`).
+- **Query-based bulk update** (all providers): `DbSet<TTarget>.BulkUpdateAsync(sourceQuery, targetKey, sourceKey, setBuilder, filter?, options?)`. SQL Server generates `UPDATE t SET ... FROM target INNER JOIN (sourceQuerySql) AS s ON ... [WHERE filterCondition]`; PostgreSQL/SQLite generate `UPDATE target AS t SET ... FROM (sourceQuerySql) AS s WHERE ... [AND filterCondition]`. Uses `SetPropertyBuilder<TTarget, TSource>` for fluent property assignment. Key selectors support single and composite keys (anonymous types). Source SQL and parameters extracted via `CreateDbCommand()`. Optional `filter` (`Expression<Func<TTarget, TSource, bool>>`) restricts which rows are updated; filter can reference both target and source properties (e.g., `(e, f) => e.Count < f.Count`); filter is translated via `ValueExpressionTranslator` (same instance as SET values), with unified `@__ev_N` parameters. Shared expression analysis logic in `BulkUpdateFromQueryHelper`. Table/schema override via `SqlServerBulkUpdateFromQueryOptions`, `NpgsqlBulkUpdateFromQueryOptions`, or `SqliteBulkUpdateFromQueryOptions`. Value expressions support constants, captured variables, and static members (e.g., `.Set(e => e.Count, (e, f) => 42)`, `.Set(e => e.Name, (e, f) => myVar)`, or `.Set(e => e.Status, (e, f) => Status.Published)`), complex arithmetic expressions referencing target and/or source properties (e.g., `.Set(e => e.Count, (e, f) => e.Count + f.Count * 2)` or `.Set(e => e.Count, (e, f) => f.Count + 10)`), in addition to simple property access and `EF.Property` calls; constant values are emitted as SQL parameters (`@__bv_N`); complex expressions are translated to SQL via `ValueExpressionTranslator` with expression-value parameters (`@__ev_N`).
+- **Query-based bulk insert** (all providers): `DbSet<TTarget>.BulkInsertAsync(sourceQuery, mapBuilder)`. Generates `INSERT INTO target (cols) SELECT s.cols FROM (sourceQuerySql) AS s` — identical structure across all three providers (only identifier quoting differs). Uses `InsertPropertyBuilder<TTarget, TSource>` for fluent column mapping via `Map(target => target.Prop, source => source.Prop)` with single-parameter value selector. No key selectors needed (insert, not join). Table/schema override via `SqlServerBulkInsertFromQueryOptions`, `NpgsqlBulkInsertFromQueryOptions`, or `SqliteBulkInsertFromQueryOptions`. Value selectors support constants, captured variables, and static members (e.g., `.Map(e => e.Count, f => 42)` or `.Map(e => e.Name, f => myVar)`), complex arithmetic expressions referencing source properties (e.g., `.Map(e => e.Count, f => f.Count * 2 + 1)`), in addition to simple property access and `EF.Property` calls; constant values are emitted as SQL parameters (`@__bv_N`); complex expressions are translated to SQL via `ValueExpressionTranslator` with expression-value parameters (`@__ev_N`).
+
+- **Value expression evaluation** (query-based bulk update/insert): `ClosureFlatteningVisitor` in `EfCoreValueExpressionTranslator` evaluates closure fields **and static members** (e.g. smart-enum values like `Status.Published`) to constants, guarded by `IEvaluatableExpressionFilter` so server-translatable members (e.g. `DateTime.Now`) stay untouched. Resulting `ConstantExpression`s bypass EF's SQL translator (which fails for types without a built-in type mapping) and are emitted directly with the target column's type mapping, so value-converter-typed values work; in the insert path, the converter is applied via `ConvertToProvider` before the value is bound as a raw parameter.
 
 - **Source entity type resolution** (query-based bulk update/insert): Source entity type is resolved via `FindEntityType(typeof(TSource))` first (regular CLR-type lookup), then falls back to `FindEntityType(EntityNameProvider.GetTempTableName(typeof(TSource)))` for temp-table-only entities registered via `ConfigureTempTableEntity<T>()`. Without the fallback, column name resolution uses property names instead of mapped column names, causing SQL errors.
 

docs

@@ -94,17 +94,9 @@ public EfCoreValueExpressionTranslator(
             throw new ArgumentException($"Update value expression must have exactly 2 parameters. Expression: {valueExpr}");
 
          var remapped = RemapTwoParameterLambda(valueExpr, targetShaper, sourceShaper);
-         var flattenedRemapped = FlattenClosures(_logger, remapped);
+         var flattenedRemapped = FlattenClosures(remapped);
 
-         var sqlValue = sqlTranslator.TranslateProjection(flattenedRemapped)
-                        ?? throw new InvalidOperationException($"Could not translate value expression: {valueExpr}");
-
-         if (sqlValue is not SqlExpression sqlExpr)
-            throw new InvalidOperationException($"Translated expression is not a SqlExpression: {sqlValue.GetType().Name}");
-
-         // Apply type mapping from target column
-         var typeMapping = targetProp.GetRelationalTypeMapping();
-         sqlExpr = sqlExprFactory.ApplyTypeMapping(sqlExpr, typeMapping);
+         var sqlExpr = TranslateValueExpression(valueExpr, flattenedRemapped, sqlTranslator, sqlExprFactory, targetProp.GetRelationalTypeMapping());
 
          setters.Add(new ColumnValueSetter(targetColumn, sqlExpr));
       }
@@ -116,7 +108,7 @@ public EfCoreValueExpressionTranslator(
             throw new ArgumentException($"Filter expression must have exactly 2 parameters. Expression: {filter}");
 
          var remappedFilter = RemapTwoParameterLambda(filter, targetShaper, sourceShaper);
-         var flattenedFilter = FlattenClosures(_logger, remappedFilter);
+         var flattenedFilter = FlattenClosures(remappedFilter);
 
          var sqlFilter = sqlTranslator.TranslateProjection(flattenedFilter)
                          ?? throw new InvalidOperationException($"Could not translate filter expression: {filter}");
@@ -225,17 +217,9 @@ private string ApplyTableSchemaAndNameOverride(
             throw new ArgumentException($"Insert value expression must have exactly 1 parameter. Expression: {valueExpr}");
 
          var remapped = RemapSingleParameterLambda(valueExpr, sourceShaper);
-         var flattenedRemapped = FlattenClosures(_logger, remapped);
-
-         var sqlValue = sqlTranslator.TranslateProjection(flattenedRemapped)
-                        ?? throw new InvalidOperationException($"Could not translate value expression: {valueExpr}");
+         var flattenedRemapped = FlattenClosures(remapped);
 
-         if (sqlValue is not SqlExpression sqlExpr)
-            throw new InvalidOperationException($"Translated expression is not a SqlExpression: {sqlValue.GetType().Name}");
-
-         // Apply type mapping from target column
-         var typeMapping = targetProp.GetRelationalTypeMapping();
-         sqlExpr = sqlExprFactory.ApplyTypeMapping(sqlExpr, typeMapping);
+         var sqlExpr = TranslateValueExpression(valueExpr, flattenedRemapped, sqlTranslator, sqlExprFactory, targetProp.GetRelationalTypeMapping());
 
          valueExpressions.Add(sqlExpr);
       }
@@ -251,7 +235,9 @@ private string ApplyTableSchemaAndNameOverride(
          if (valExpr is SqlConstantExpression constExpr)
          {
             var paramName = $"__insert_const_{constParamIndex++}";
-            parameterValues[paramName] = constExpr.Value;
+            // The parameter value is bound as-is by the executors, so the value converter (if any) must be applied here.
+            var converter = constExpr.TypeMapping?.Converter;
+            parameterValues[paramName] = converter is null ? constExpr.Value : converter.ConvertToProvider(constExpr.Value);
             projectionExpressions.Add(new SqlParameterExpression(paramName, valExpr.Type, constExpr.TypeMapping));
          }
          else
@@ -420,9 +406,31 @@ private static Expression RemapSingleParameterLambda(LambdaExpression lambda, Ex
       return ReplacingExpressionVisitor.Replace(lambda.Parameters[0], sourceShaper, lambda.Body);
    }
 
-   private static Expression FlattenClosures(ILogger logger, Expression expression)
+   private Expression FlattenClosures(Expression expression)
    {
-      return new ClosureFlatteningVisitor(logger).Visit(expression);
+      return new ClosureFlatteningVisitor(_logger, _ctx.GetService<IEvaluatableExpressionFilter>(), _ctx.Model).Visit(expression);
+   }
+
+   private static SqlExpression TranslateValueExpression(
+      LambdaExpression valueExpr,
+      Expression flattenedValue,
+      RelationalSqlTranslatingExpressionVisitor sqlTranslator,
+      ISqlExpressionFactory sqlExprFactory,
+      RelationalTypeMapping targetTypeMapping)
+   {
+      // Constants of types without a built-in type mapping (e.g. properties with a value converter)
+      // cannot be translated by EF Core; create the constant with the target column's type mapping directly.
+      if (flattenedValue is ConstantExpression constant)
+         return sqlExprFactory.Constant(constant.Value, constant.Type, targetTypeMapping);
+
+      var sqlValue = sqlTranslator.TranslateProjection(flattenedValue)
+                     ?? throw new InvalidOperationException($"Could not translate value expression: {valueExpr}");
+
+      if (sqlValue is not SqlExpression sqlExpr)
+         throw new InvalidOperationException($"Translated expression is not a SqlExpression: {sqlValue.GetType().Name}");
+
+      // Apply type mapping from target column
+      return sqlExprFactory.ApplyTypeMapping(sqlExpr, targetTypeMapping);
    }
 
    private static string GetTargetTableAlias(SelectExpression selectExpression)
@@ -444,21 +452,38 @@ private static ColumnExpression CreateColumnExpression(
                                   property.IsNullable);
    }
 
-   private sealed partial class ClosureFlatteningVisitor(ILogger logger) : ExpressionVisitor
+   private sealed partial class ClosureFlatteningVisitor(
+      ILogger logger,
+      IEvaluatableExpressionFilter evaluatableExpressionFilter,
+      IModel model) : ExpressionVisitor
    {
       protected override Expression VisitMember(MemberExpression node)
       {
+         // Static member access (e.g. MyType.StaticValue) — evaluate it to a constant
+         // unless EF Core translates it server-side (e.g. DateTime.Now).
+         if (node.Expression is null)
+         {
+            return evaluatableExpressionFilter.IsEvaluatableExpression(node, model)
+                      ? Evaluate(node, null) ?? node
+                      : node;
+         }
+
          var expression = Visit(node.Expression);
 
          if (expression is not ConstantExpression constant)
             return node.Update(expression);
 
+         return Evaluate(node, constant.Value) ?? node.Update(expression);
+      }
+
+      private Expression? Evaluate(MemberExpression node, object? instance)
+      {
          try
          {
             var value = node.Member switch
             {
-               FieldInfo fi => fi.GetValue(constant.Value),
-               PropertyInfo pi => pi.GetValue(constant.Value),
+               FieldInfo fi => fi.GetValue(instance),
+               PropertyInfo pi => pi.GetValue(instance),
                _ => throw new NotSupportedException($"Unsupported member type: {node.Member.GetType().Name}")
             };
 
@@ -469,7 +494,7 @@ protected override Expression VisitMember(MemberExpression node)
             LogClosureFlatteningFailed(logger, ex, node.Member.Name, node.Member.DeclaringType?.Name);
          }
 
-         return node.Update(expression);
+         return null;
       }
 
       [LoggerMessage(Level = LogLevel.Warning,

src/Thinktecture.EntityFrameworkCore.BulkOperations/EntityFrameworkCore/BulkOperations/Internal/EfCoreValueExpressionTranslator.cs

@@ -628,6 +628,126 @@ public async Task Should_update_with_captured_variable()
       loaded.Name.Should().Be("CapturedValue");
    }
 
+   public static string StaticName => "StaticValue";
+   private static readonly ConvertibleClass _staticConvertibleClass = new(42);
+
+   [Fact]
+   public async Task Should_update_with_static_member_value()
+   {
+      var entity = new TestEntity { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), Name = "Original", RequiredName = "RequiredName", Count = 0 };
+      ArrangeDbContext.Add(entity);
+      await ArrangeDbContext.SaveChangesAsync();
+
+      var updatedEntities = new List<TestEntity>
+      {
+         new() { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), RequiredName = "RequiredName" }
+      };
+
+      await using var tempTable = await SUT.BulkInsertIntoTempTableAsync(updatedEntities, new NpgsqlTempTableBulkInsertOptions());
+
+      var sourceQuery = tempTable.Query;
+
+      var affectedRows = await ActDbContext.Set<TestEntity>().BulkUpdateAsync(
+         sourceQuery,
+         e => e.Id,
+         f => f.Id,
+         builder => builder.Set(e => e.Name, (e, f) => StaticName));
+
+      affectedRows.Should().Be(1);
+
+      var loaded = await AssertDbContext.TestEntities.SingleAsync();
+      loaded.Name.Should().Be("StaticValue");
+   }
+
+   [Fact]
+   public async Task Should_update_with_static_member_of_converted_type()
+   {
+      var entity = new TestEntity { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), Name = "Original", RequiredName = "RequiredName", ConvertibleClass = new ConvertibleClass(1) };
+      ArrangeDbContext.Add(entity);
+      await ArrangeDbContext.SaveChangesAsync();
+
+      var updatedEntities = new List<TestEntity>
+      {
+         new() { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), RequiredName = "RequiredName" }
+      };
+
+      await using var tempTable = await SUT.BulkInsertIntoTempTableAsync(updatedEntities, new NpgsqlTempTableBulkInsertOptions());
+
+      var sourceQuery = tempTable.Query;
+
+      var affectedRows = await ActDbContext.Set<TestEntity>().BulkUpdateAsync(
+         sourceQuery,
+         e => e.Id,
+         f => f.Id,
+         builder => builder.Set(e => e.ConvertibleClass, (e, f) => _staticConvertibleClass));
+
+      affectedRows.Should().Be(1);
+
+      var loaded = await AssertDbContext.TestEntities.SingleAsync();
+      loaded.ConvertibleClass.Should().Be(new ConvertibleClass(42));
+   }
+
+   [Fact]
+   public async Task Should_update_with_captured_variable_of_converted_type()
+   {
+      var entity = new TestEntity { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), Name = "Original", RequiredName = "RequiredName", ConvertibleClass = new ConvertibleClass(1) };
+      ArrangeDbContext.Add(entity);
+      await ArrangeDbContext.SaveChangesAsync();
+
+      var updatedEntities = new List<TestEntity>
+      {
+         new() { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), RequiredName = "RequiredName" }
+      };
+
+      await using var tempTable = await SUT.BulkInsertIntoTempTableAsync(updatedEntities, new NpgsqlTempTableBulkInsertOptions());
+
+      var sourceQuery = tempTable.Query;
+
+      var newValue = new ConvertibleClass(43);
+
+      var affectedRows = await ActDbContext.Set<TestEntity>().BulkUpdateAsync(
+         sourceQuery,
+         e => e.Id,
+         f => f.Id,
+         builder => builder.Set(e => e.ConvertibleClass, (e, f) => newValue));
+
+      affectedRows.Should().Be(1);
+
+      var loaded = await AssertDbContext.TestEntities.SingleAsync();
+      loaded.ConvertibleClass.Should().Be(new ConvertibleClass(43));
+   }
+
+   [Fact]
+   public async Task Should_translate_datetime_now_server_side_instead_of_evaluating_it()
+   {
+      var entity = new TestEntity { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), Name = "Original", RequiredName = "RequiredName", Count = 0 };
+      ArrangeDbContext.Add(entity);
+      await ArrangeDbContext.SaveChangesAsync();
+
+      var updatedEntities = new List<TestEntity>
+      {
+         new() { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), RequiredName = "RequiredName" }
+      };
+
+      await using var tempTable = await SUT.BulkInsertIntoTempTableAsync(updatedEntities, new NpgsqlTempTableBulkInsertOptions());
+
+      var sourceQuery = tempTable.Query;
+
+      var affectedRows = await ActDbContext.Set<TestEntity>().BulkUpdateAsync(
+         sourceQuery,
+         e => e.Id,
+         f => f.Id,
+         builder => builder.Set(e => e.Count, (e, f) => DateTime.Now.Year));
+
+      affectedRows.Should().Be(1);
+
+      // DateTime.Now must not be evaluated to a constant at translation time but be translated server-side.
+      ExecutedCommands.Last().Should().Contain("now()");
+
+      var loaded = await AssertDbContext.TestEntities.SingleAsync();
+      loaded.Count.Should().Be(DateTime.Now.Year);
+   }
+
    [Fact]
    public async Task Should_update_with_source_arithmetic_expression()
    {