Translate spatial aggregates

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

@@ -610,7 +610,7 @@ private static void AppendLiteral(StoreObjectIdentifier storeObject, IndentedStr
  .Append("DbFunction(").Append(code.Literal(storeObject.Name)).Append(")");
  break;
  default:
- Check.DebugAssert(false, "Unexpected StoreObjectType: " + storeObject.StoreObjectType);
+ Check.DebugFail("Unexpected StoreObjectType: " + storeObject.StoreObjectType);
  break;
  }
  }

src/EFCore.Relational/Infrastructure/EntityFrameworkRelationalServicesBuilder.cs

@@ -90,6 +90,7 @@ public static readonly IDictionary<Type, ServiceCharacteristics> RelationalServi
  new ServiceCharacteristics(ServiceLifetime.Singleton, multipleRegistrations: true)
  },
  { typeof(IMethodCallTranslatorPlugin), new ServiceCharacteristics(ServiceLifetime.Scoped, multipleRegistrations: true) },
+ { typeof(IAggregateMethodCallTranslatorPlugin), new ServiceCharacteristics(ServiceLifetime.Scoped, multipleRegistrations: true) },
  { typeof(IMemberTranslatorPlugin), new ServiceCharacteristics(ServiceLifetime.Scoped, multipleRegistrations: true) }
  };
 

src/EFCore.Relational/Migrations/Internal/MigrationsModelDiffer.cs

@@ -237,7 +237,7 @@ protected virtual IReadOnlyList<MigrationOperation> Sort(
  else
  {
  leftovers.Add(operation);
- Check.DebugAssert(false, "Unexpected operation type: " + operation.GetType());
+ Check.DebugFail("Unexpected operation type: " + operation.GetType());
  }
  }
 
@@ -275,7 +275,7 @@ protected virtual IReadOnlyList<MigrationOperation> Sort(
  }
  else
  {
- Check.DebugAssert(false, "Operation removed twice: " + cyclicAddForeignKeyOperation);
+ Check.DebugFail("Operation removed twice: " + cyclicAddForeignKeyOperation);
  }
  }
 
@@ -2189,7 +2189,7 @@ private IEnumerable<MigrationOperation> GetDataOperations(
 
  if (forSource)
  {
- Check.DebugAssert(false, "Insert using the source model");
+ Check.DebugFail("Insert using the source model");
  break;
  }
 
@@ -2212,7 +2212,7 @@ private IEnumerable<MigrationOperation> GetDataOperations(
 
  if (forSource)
  {
- Check.DebugAssert(false, "Update using the source model");
+ Check.DebugFail("Update using the source model");
  break;
  }
 

src/EFCore.Relational/Query/Internal/FromSqlParameterExpandingExpressionVisitor.cs

@@ -160,7 +160,7 @@ public virtual Expression Expand(
  return _visitedFromSqlExpressions[fromSql] = fromSql.Update(Expression.Constant(constantValues, typeof(object[])));
 
  default:
- Check.DebugAssert(false, "FromSql.Arguments must be Constant/ParameterExpression");
+ Check.DebugFail("FromSql.Arguments must be Constant/ParameterExpression");
  return null;
  }
  }

src/EFCore.SqlServer.NTS/Extensions/SqlServerNetTopologySuiteServiceCollectionExtensions.cs

@@ -31,6 +31,7 @@ public static IServiceCollection AddEntityFrameworkSqlServerNetTopologySuite(
  new EntityFrameworkRelationalServicesBuilder(serviceCollection)
  .TryAdd<IRelationalTypeMappingSourcePlugin, SqlServerNetTopologySuiteTypeMappingSourcePlugin>()
  .TryAdd<IMethodCallTranslatorPlugin, SqlServerNetTopologySuiteMethodCallTranslatorPlugin>()
+ .TryAdd<IAggregateMethodCallTranslatorPlugin, SqlServerNetTopologySuiteAggregateMethodCallTranslatorPlugin>()
  .TryAdd<IMemberTranslatorPlugin, SqlServerNetTopologySuiteMemberTranslatorPlugin>()
  .TryAdd<IEvaluatableExpressionFilterPlugin, SqlServerNetTopologySuiteEvaluatableExpressionFilterPlugin>();
 

src/EFCore.SqlServer.NTS/Query/Internal/SqlServerGeometryMethodTranslator.cs

@@ -85,7 +85,12 @@ public SqlServerGeometryMethodTranslator(
  arguments.Where(e => typeof(Geometry).IsAssignableFrom(e.Type)));
  var typeMapping = ExpressionExtensions.InferTypeMapping(geometryExpressions.ToArray());
 
- Check.DebugAssert(typeMapping != null, "At least one argument must have typeMapping.");
+ if (typeMapping is null)
+ {
+ Check.DebugFail("At least one argument must have typeMapping.");
+ return null;
+ }
+
  var storeType = typeMapping.StoreType;
  var isGeography = string.Equals(storeType, "geography", StringComparison.OrdinalIgnoreCase);
 

src/EFCore.SqlServer.NTS/Query/Internal/SqlServerNetTopologySuiteAggregateMethodCallTranslatorPlugin.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.SqlServer.Query.Internal;
+
+/// <summary>
+/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+/// the same compatibility standards as public APIs. It may be changed or removed without notice in
+/// any release. You should only use it directly in your code with extreme caution and knowing that
+/// doing so can result in application failures when updating to a new Entity Framework Core release.
+/// </summary>
+public class SqlServerNetTopologySuiteAggregateMethodCallTranslatorPlugin : IAggregateMethodCallTranslatorPlugin
+{
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public SqlServerNetTopologySuiteAggregateMethodCallTranslatorPlugin(
+ IRelationalTypeMappingSource typeMappingSource,
+ ISqlExpressionFactory sqlExpressionFactory)
+ {
+ Translators = new IAggregateMethodCallTranslator[]
+ {
+ new SqlServerNetTopologySuiteAggregateMethodTranslator(sqlExpressionFactory, typeMappingSource)
+ };
+ }
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual IEnumerable<IAggregateMethodCallTranslator> Translators { get; }
+}

src/EFCore.SqlServer.NTS/Query/Internal/SqlServerNetTopologySuiteAggregateMethodTranslator.cs

@@ -0,0 +1,102 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+using NetTopologySuite.Algorithm;
+using NetTopologySuite.Geometries;
+using NetTopologySuite.Geometries.Utilities;
+using NetTopologySuite.Operation.Union;
+
+namespace Microsoft.EntityFrameworkCore.SqlServer.Query.Internal;
+
+/// <summary>
+/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+/// the same compatibility standards as public APIs. It may be changed or removed without notice in
+/// any release. You should only use it directly in your code with extreme caution and knowing that
+/// doing so can result in application failures when updating to a new Entity Framework Core release.
+/// </summary>
+public class SqlServerNetTopologySuiteAggregateMethodTranslator : IAggregateMethodCallTranslator
+{
+ private static readonly MethodInfo GeometryCombineMethod
+ = typeof(GeometryCombiner).GetRuntimeMethod(nameof(GeometryCombiner.Combine), new[] { typeof(IEnumerable<Geometry>) })!;
+
+ private static readonly MethodInfo ConvexHullMethod
+ = typeof(ConvexHull).GetRuntimeMethod(nameof(ConvexHull.Create), new[] { typeof(IEnumerable<Geometry>) })!;
+
+ private static readonly MethodInfo UnionMethod
+ = typeof(UnaryUnionOp).GetRuntimeMethod(nameof(UnaryUnionOp.Union), new[] { typeof(IEnumerable<Geometry>) })!;
+
+ private readonly ISqlExpressionFactory _sqlExpressionFactory;
+ private readonly IRelationalTypeMappingSource _typeMappingSource;
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public SqlServerNetTopologySuiteAggregateMethodTranslator(
+ ISqlExpressionFactory sqlExpressionFactory,
+ IRelationalTypeMappingSource typeMappingSource)
+ {
+ _sqlExpressionFactory = sqlExpressionFactory;
+ _typeMappingSource = typeMappingSource;
+ }
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual SqlExpression? Translate(
+ MethodInfo method, EnumerableExpression source, IReadOnlyList<SqlExpression> arguments,
+ IDiagnosticsLogger<DbLoggerCategory.Query> logger)
+ {
+ // Docs: https://docs.microsoft.com/sql/t-sql/spatial-geometry/static-aggregate-geometry-methods
+
+ if (source.Selector is not SqlExpression sqlExpression)
+ {
+ return null;
+ }
+
+ if (sqlExpression.TypeMapping is not { } typeMapping)
+ {
+ Check.DebugFail("SQL expression is missing a type mapping.");
+ return null;
+ }
+
+ var functionName = method == GeometryCombineMethod
+ ? "CollectionAggregate"
+ : method == UnionMethod
+ ? "UnionAggregate"
+ : method == ConvexHullMethod
+ ? "ConvexHullAggregate"
+ : null;
+
+ if (functionName is null)
+ {
+ return null;
+ }
+
+ if (source.Predicate != null)
+ {
+ sqlExpression = _sqlExpressionFactory.Case(
+ new List<CaseWhenClause> { new(source.Predicate, sqlExpression) },
+ elseResult: null);
+ }
+
+ if (source.IsDistinct)
+ {
+ sqlExpression = new DistinctExpression(sqlExpression);
+ }
+
+ return _sqlExpressionFactory.Function(
+ $"{typeMapping.StoreType}::{functionName}",
+ new[] { sqlExpression },
+ nullable: true,
+ argumentsPropagateNullability: new[] { false },
+ method.ReturnType,
+ _typeMappingSource.FindMapping(method.ReturnType, typeMapping.StoreType));
+ }
+}

src/EFCore.Sqlite.NTS/Extensions/SqliteNetTopologySuiteServiceCollectionExtensions.cs

@@ -30,6 +30,7 @@ public static IServiceCollection AddEntityFrameworkSqliteNetTopologySuite(
  new EntityFrameworkRelationalServicesBuilder(serviceCollection)
  .TryAdd<IRelationalTypeMappingSourcePlugin, SqliteNetTopologySuiteTypeMappingSourcePlugin>()
  .TryAdd<IMethodCallTranslatorPlugin, SqliteNetTopologySuiteMethodCallTranslatorPlugin>()
+ .TryAdd<IAggregateMethodCallTranslatorPlugin, SqliteNetTopologySuiteAggregateMethodCallTranslatorPlugin>()
  .TryAdd<IMemberTranslatorPlugin, SqliteNetTopologySuiteMemberTranslatorPlugin>();
 
  return serviceCollection;

src/EFCore.Sqlite.NTS/Query/Internal/SqliteNetTopologySuiteAggregateMethodCallTranslatorPlugin.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.EntityFrameworkCore.Sqlite.Query.Internal;
+
+/// <summary>
+/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+/// the same compatibility standards as public APIs. It may be changed or removed without notice in
+/// any release. You should only use it directly in your code with extreme caution and knowing that
+/// doing so can result in application failures when updating to a new Entity Framework Core release.
+/// </summary>
+public class SqliteNetTopologySuiteAggregateMethodCallTranslatorPlugin : IAggregateMethodCallTranslatorPlugin
+{
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public SqliteNetTopologySuiteAggregateMethodCallTranslatorPlugin(
+ ISqlExpressionFactory sqlExpressionFactory,
+ IRelationalTypeMappingSource typeMappingSource)
+ {
+ Translators = new IAggregateMethodCallTranslator[]
+ {
+ new SqliteNetTopologySuiteAggregateMethodTranslator(sqlExpressionFactory, typeMappingSource)
+ };
+ }
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual IEnumerable<IAggregateMethodCallTranslator> Translators { get; }
+}

src/EFCore.Sqlite.NTS/Query/Internal/SqliteNetTopologySuiteAggregateMethodTranslator.cs

@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+using NetTopologySuite.Algorithm;
+using NetTopologySuite.Geometries;
+using NetTopologySuite.Geometries.Utilities;
+using NetTopologySuite.Operation.Union;
+
+namespace Microsoft.EntityFrameworkCore.Sqlite.Query.Internal;
+
+/// <summary>
+/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+/// the same compatibility standards as public APIs. It may be changed or removed without notice in
+/// any release. You should only use it directly in your code with extreme caution and knowing that
+/// doing so can result in application failures when updating to a new Entity Framework Core release.
+/// </summary>
+public class SqliteNetTopologySuiteAggregateMethodTranslator : IAggregateMethodCallTranslator
+{
+ private static readonly MethodInfo GeometryCombineMethod
+ = typeof(GeometryCombiner).GetRuntimeMethod(nameof(GeometryCombiner.Combine), new[] { typeof(IEnumerable<Geometry>) })!;
+
+ private static readonly MethodInfo ConvexHullMethod
+ = typeof(ConvexHull).GetRuntimeMethod(nameof(ConvexHull.Create), new[] { typeof(IEnumerable<Geometry>) })!;
+
+ private static readonly MethodInfo UnionMethod
+ = typeof(UnaryUnionOp).GetRuntimeMethod(nameof(UnaryUnionOp.Union), new[] { typeof(IEnumerable<Geometry>) })!;
+
+ private readonly ISqlExpressionFactory _sqlExpressionFactory;
+ private readonly IRelationalTypeMappingSource _typeMappingSource;
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public SqliteNetTopologySuiteAggregateMethodTranslator(
+ ISqlExpressionFactory sqlExpressionFactory,
+ IRelationalTypeMappingSource typeMappingSource)
+ {
+ _sqlExpressionFactory = sqlExpressionFactory;
+ _typeMappingSource = typeMappingSource;
+ }
+
+ /// <summary>
+ /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+ /// the same compatibility standards as public APIs. It may be changed or removed without notice in
+ /// any release. You should only use it directly in your code with extreme caution and knowing that
+ /// doing so can result in application failures when updating to a new Entity Framework Core release.
+ /// </summary>
+ public virtual SqlExpression? Translate(
+ MethodInfo method, EnumerableExpression source, IReadOnlyList<SqlExpression> arguments,
+ IDiagnosticsLogger<DbLoggerCategory.Query> logger)
+ {
+ if (source.Selector is not SqlExpression sqlExpression
+ || (method != GeometryCombineMethod && method != UnionMethod && method != ConvexHullMethod))
+ {
+ return null;
+ }
+
+ if (source.Predicate != null)
+ {
+ sqlExpression = _sqlExpressionFactory.Case(
+ new List<CaseWhenClause> { new(source.Predicate, sqlExpression) },
+ elseResult: null);
+ }
+
+ if (source.IsDistinct)
+ {
+ sqlExpression = new DistinctExpression(sqlExpression);
+ }
+
+ if (method == GeometryCombineMethod || method == UnionMethod)
+ {
+ return _sqlExpressionFactory.Function(
+ method == GeometryCombineMethod ? "Collect" : "GUnion",
+ new[] { sqlExpression },
+ nullable: true,
+ argumentsPropagateNullability: new[] { false },
+ typeof(Geometry));
+ }
+
+ // Spatialite has no built-in aggregate convex hull, but we can simply apply Collect beforehand
+ return _sqlExpressionFactory.Function(
+ "ConvexHull",
+ new[]
+ {
+ _sqlExpressionFactory.Function(
+ "Collect",
+ new[] { sqlExpression },
+ nullable: true,
+ argumentsPropagateNullability: new[] { false },
+ typeof(Geometry))
+ },
+ nullable: true,
+ argumentsPropagateNullability: new[] { true },
+ typeof(Geometry));
+ }
+}