Improve SQL Server insertion logic and other update pipeline optimiza…

…tions (#27573)

Also make RETURNING the default INSERT strategy for retrieving
db-generated values (for other providers).

Fixes #27372
Fixes #27503

src/EFCore.Design/Migrations/Design/CSharpSnapshotGenerator.cs

@@ -715,30 +715,55 @@ protected virtual void GenerateEntityTypeAnnotations(
  }
 
  var isExcludedAnnotation = annotations.Find(RelationalAnnotationNames.IsTableExcludedFromMigrations);
+ var isExcludedFromMigrations = (isExcludedAnnotation?.Value as bool?) == true;
+ if (isExcludedAnnotation is not null)
+ {
+ annotations.Remove(isExcludedAnnotation.Name);
+ }
+
+ var hasTriggers = entityType.GetTriggers().Any();
+ var requiresTableBuilder = isExcludedFromMigrations || hasTriggers;
+
  if (schema != null
  || (schemaAnnotation != null && tableName != null))
  {
  stringBuilder
  .Append(", ");
 
- if (schema == null
- && ((bool?)isExcludedAnnotation?.Value) != true)
+ if (schema == null && !requiresTableBuilder)
  {
  stringBuilder.Append("(string)");
  }
 
  stringBuilder.Append(Code.UnknownLiteral(schema));
  }
 
- if (isExcludedAnnotation != null)
+ if (requiresTableBuilder)
  {
- if (((bool?)isExcludedAnnotation.Value) == true)
+ if (isExcludedFromMigrations && !hasTriggers)
  {
- stringBuilder
- .Append(", t => t.ExcludeFromMigrations()");
+ stringBuilder.Append(", t => t.ExcludeFromMigrations()");
  }
+ else
+ {
+ stringBuilder
+ .AppendLine(", t =>")
+ .AppendLine("{");
 
- annotations.Remove(isExcludedAnnotation.Name);
+ using (stringBuilder.Indent())
+ {
+ if (isExcludedFromMigrations)
+ {
+ stringBuilder
+ .AppendLine("t.ExcludeFromMigrations();")
+ .AppendLine();
+ }
+
+ GenerateTriggers("t", entityType, stringBuilder);
+ }
+
+ stringBuilder.Append("}");
+ }
  }
 
  stringBuilder.AppendLine(");");
@@ -943,6 +968,64 @@ protected virtual void GenerateCheckConstraint(
  stringBuilder.AppendLine(");");
  }
 
+ /// <summary>
+ /// Generates code for <see cref="ITrigger" /> objects.
+ /// </summary>
+ /// <param name="tableBuilderName">The name of the table builder variable.</param>
+ /// <param name="entityType">The entity type.</param>
+ /// <param name="stringBuilder">The builder code is added to.</param>
+ protected virtual void GenerateTriggers(
+ string tableBuilderName,
+ IEntityType entityType,
+ IndentedStringBuilder stringBuilder)
+ {
+ foreach (var trigger in entityType.GetTriggers())
+ {
+ GenerateTrigger(tableBuilderName, trigger, stringBuilder);
+ }
+ }
+
+ /// <summary>
+ /// Generates code for an <see cref="ITrigger" />.
+ /// </summary>
+ /// <param name="tableBuilderName">The name of the table builder variable.</param>
+ /// <param name="trigger">The check constraint.</param>
+ /// <param name="stringBuilder">The builder code is added to.</param>
+ protected virtual void GenerateTrigger(
+ string tableBuilderName,
+ ITrigger trigger,
+ IndentedStringBuilder stringBuilder)
+ {
+ var triggerBuilderNameStringBuilder = new StringBuilder();
+ triggerBuilderNameStringBuilder
+ .Append(tableBuilderName)
+ .Append(".HasTrigger(")
+ .Append(Code.Literal(trigger.ModelName))
+ .Append(")");
+ var triggerBuilderName = triggerBuilderNameStringBuilder.ToString();
+
+ stringBuilder.Append(triggerBuilderName);
+
+ // Note that GenerateAnnotations below does the corresponding decrement
+ stringBuilder.IncrementIndent();
+
+ if (trigger.Name != null
+ && trigger.Name != (trigger.GetDefaultName() ?? trigger.ModelName))
+ {
+ stringBuilder
+ .AppendLine()
+ .Append(".HasName(")
+ .Append(Code.Literal(trigger.Name))
+ .Append(")");
+ }
+
+ var annotations = Dependencies.AnnotationCodeGenerator
+ .FilterIgnoredAnnotations(trigger.GetAnnotations())
+ .ToDictionary(a => a.Name, a => a);
+
+ GenerateAnnotations(triggerBuilderName, trigger, stringBuilder, annotations, inChainedCall: true);
+ }
+
  /// <summary>
  /// Generates code for <see cref="IForeignKey" /> objects.
  /// </summary>

src/EFCore.Relational/Design/AnnotationCodeGenerator.cs

@@ -28,6 +28,7 @@ public class AnnotationCodeGenerator : IAnnotationCodeGenerator
  private static readonly ISet<string> IgnoredRelationalAnnotations = new HashSet<string>
  {
  RelationalAnnotationNames.CheckConstraints,
+ RelationalAnnotationNames.Triggers,
  RelationalAnnotationNames.Sequences,
  RelationalAnnotationNames.DbFunctions,
  RelationalAnnotationNames.RelationalOverrides

src/EFCore.Relational/Design/IAnnotationCodeGenerator.cs

@@ -223,6 +223,17 @@ IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(
  IDictionary<string, IAnnotation> annotations)
  => Array.Empty<MethodCallCodeFragment>();
 
+ /// <summary>
+ /// For the given annotations which have corresponding fluent API calls, returns those fluent API calls
+ /// and removes the annotations.
+ /// </summary>
+ /// <param name="trigger">The trigger to which the annotations are applied.</param>
+ /// <param name="annotations">The set of annotations from which to generate fluent API calls.</param>
+ IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(
+ ITrigger trigger,
+ IDictionary<string, IAnnotation> annotations)
+ => Array.Empty<MethodCallCodeFragment>();
+
  /// <summary>
  /// For the given annotations which have corresponding fluent API calls, returns those fluent API calls
  /// and removes the annotations.
@@ -240,6 +251,8 @@ IReadOnlyList<MethodCallCodeFragment> GenerateFluentApiCalls(IAnnotatable annota
  INavigation navigation => GenerateFluentApiCalls(navigation, annotations),
  ISkipNavigation skipNavigation => GenerateFluentApiCalls(skipNavigation, annotations),
  IIndex index => GenerateFluentApiCalls(index, annotations),
+ ITrigger trigger => GenerateFluentApiCalls(trigger, annotations),
+
  _ => throw new ArgumentException(RelationalStrings.UnhandledAnnotatableType(annotatable.GetType()))
  };
 

src/EFCore.Relational/Design/Internal/RelationalCSharpRuntimeAnnotationCodeGenerator.cs

@@ -325,11 +325,63 @@ public override void Generate(IEntityType entityType, CSharpRuntimeAnnotationCod
  annotations[RelationalAnnotationNames.ViewSchema] = entityType.GetViewSchema();
  annotations[RelationalAnnotationNames.SqlQuery] = entityType.GetSqlQuery();
  annotations[RelationalAnnotationNames.FunctionName] = entityType.GetFunctionName();
+
+ if (annotations.TryGetAndRemove(
+ RelationalAnnotationNames.Triggers,
+ out SortedDictionary<string, ITrigger> triggers))
+ {
+ parameters.Namespaces.Add(typeof(SortedDictionary<,>).Namespace!);
+ var triggersVariable = Dependencies.CSharpHelper.Identifier("triggers", parameters.ScopeVariables, capitalize: false);
+ parameters.MainBuilder
+ .Append("var ").Append(triggersVariable).AppendLine(" = new SortedDictionary<string, ITrigger>();").AppendLine();
+
+ foreach (var (_, trigger) in triggers)
+ {
+ Create(trigger, triggersVariable, parameters);
+ }
+
+ GenerateSimpleAnnotation(RelationalAnnotationNames.Triggers, triggersVariable, parameters);
+ }
  }
 
  base.Generate(entityType, parameters);
  }
 
+ private void Create(ITrigger trigger, string triggersVariable, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+ {
+ var code = Dependencies.CSharpHelper;
+ var triggerVariable = code.Identifier(trigger.ModelName, parameters.ScopeVariables, capitalize: false);
+ var mainBuilder = parameters.MainBuilder;
+ mainBuilder
+ .Append("var ").Append(triggerVariable).AppendLine(" = new RuntimeTrigger(").IncrementIndent()
+ .Append(parameters.TargetName).AppendLine(",")
+ .Append(code.Literal(trigger.ModelName)).AppendLine(",")
+ .Append(code.UnknownLiteral(trigger.Name)).AppendLine(",")
+ .Append(code.Literal(trigger.TableName)).AppendLine(",")
+ .Append(code.UnknownLiteral(trigger.TableSchema))
+ .AppendLine(");")
+ .DecrementIndent()
+ .AppendLine();
+
+ CreateAnnotations(
+ trigger,
+ Generate,
+ parameters with { TargetName = triggerVariable });
+
+ mainBuilder
+ .Append(triggersVariable).Append("[").Append(code.Literal(trigger.ModelName)).Append("] = ")
+ .Append(triggerVariable).AppendLine(";")
+ .AppendLine();
+ }
+
+ /// <summary>
+ /// Generates code to create the given annotations.
+ /// </summary>
+ /// <param name="trigger">The trigger to which the annotations are applied.</param>
+ /// <param name="parameters">Additional parameters used during code generation.</param>
+ public virtual void Generate(ITrigger trigger, CSharpRuntimeAnnotationCodeGeneratorParameters parameters)
+ => GenerateSimpleAnnotations(parameters);
+
  /// <summary>
  /// Generates code to create the given annotations.
  /// </summary>

src/EFCore.Relational/Extensions/RelationalEntityTypeBuilderExtensions.cs

@@ -1846,4 +1846,55 @@ public static bool CanSetComment(
  RelationalAnnotationNames.Comment,
  comment,
  fromDataAnnotation);
+
+ /// <summary>
+ /// Configures a database trigger when targeting a relational database.
+ /// </summary>
+ /// <remarks>
+ /// See <see href="https://aka.ms/efcore-docs-triggers">Database triggers</see> for more information and examples.
+ /// </remarks>
+ /// <param name="entityTypeBuilder">The entity type builder.</param>
+ /// <param name="name">The name of the trigger.</param>
+ /// <param name="tableName">The name of the table on which this trigger is defined.</param>
+ /// <param name="tableSchema">The schema of the table on which this trigger is defined.</param>
+ /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+ /// <returns>The same builder instance if the check constraint was configured, <see langword="null" /> otherwise.</returns>
+ public static IConventionTriggerBuilder? HasTrigger(
+ this IConventionEntityTypeBuilder entityTypeBuilder,
+ string name,
+ string? tableName,
+ string? tableSchema,
+ bool fromDataAnnotation = false)
+ => InternalTriggerBuilder.HasTrigger(
+ entityTypeBuilder.Metadata,
+ name,
+ tableName,
+ tableSchema,
+ fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention)
+ ?.Builder;
+
+ /// <summary>
+ /// Returns a value indicating whether the trigger can be configured.
+ /// </summary>
+ /// <remarks>
+ /// See <see href="https://aka.ms/efcore-docs-triggers">Database triggers</see> for more information and examples.
+ /// </remarks>
+ /// <param name="entityTypeBuilder">The builder for the entity type being configured.</param>
+ /// <param name="name">The name of the trigger.</param>
+ /// <param name="tableName">The name of the table on which this trigger is defined.</param>
+ /// <param name="tableSchema">The schema of the table on which this trigger is defined.</param>
+ /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
+ /// <returns><see langword="true" /> if the configuration can be applied.</returns>
+ public static bool CanHaveTrigger(
+ this IConventionEntityTypeBuilder entityTypeBuilder,
+ string name,
+ string? tableName,
+ string? tableSchema,
+ bool fromDataAnnotation = false)
+ => InternalTriggerBuilder.CanHaveTrigger(
+ entityTypeBuilder.Metadata,
+ name,
+ tableName,
+ tableSchema,
+ fromDataAnnotation ? ConfigurationSource.DataAnnotation : ConfigurationSource.Convention);
 }