Cosmos FromSql (#25525)

Closes #17311

src/EFCore.Cosmos/Extensions/CosmosQueryableExtensions.cs

@@ -5,6 +5,8 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Cosmos.Query.Internal;
 using Microsoft.EntityFrameworkCore.Query;
 using Microsoft.EntityFrameworkCore.Query.Internal;
 using Microsoft.EntityFrameworkCore.Utilities;
@@ -13,7 +15,7 @@
 namespace Microsoft.EntityFrameworkCore
 {
     /// <summary>
-    ///     Cosmos DB specific extension methods for LINQ queries.
+    ///     Cosmos-specific extension methods for LINQ queries.
     /// </summary>
     public static class CosmosQueryableExtensions
     {
@@ -46,5 +48,56 @@ source.Provider is EntityQueryProvider
                             Expression.Constant(partitionKey)))
                     : source;
         }
+
+        /// <summary>
+        ///     <para>
+        ///         Creates a LINQ query based on a raw SQL query.
+        ///     </para>
+        ///     <para>
+        ///         You can compose on top of the raw SQL query using LINQ operators:
+        ///     </para>
+        ///     <code>context.Blogs.FromSqlRaw("SELECT * FROM root c).OrderBy(b => b.Name)</code>
+        ///     <para>
+        ///         As with any API that accepts SQL it is important to parameterize any user input to protect against a SQL injection
+        ///         attack. You can include parameter place holders in the SQL query string and then supply parameter values as additional
+        ///         arguments. Any parameter values you supply will automatically be converted to a Cosmos parameter:
+        ///     </para>
+        ///     <code>context.Blogs.FromSqlRaw(""SELECT * FROM root c WHERE c["Name"] = {0})", userSuppliedSearchTerm)</code>
+        /// </summary>
+        /// <typeparam name="TEntity"> The type of the elements of <paramref name="source" />. </typeparam>
+        /// <param name="source">
+        ///     An <see cref="IQueryable{T}" /> to use as the base of the raw SQL query (typically a <see cref="DbSet{TEntity}" />).
+        /// </param>
+        /// <param name="sql"> The raw SQL query. </param>
+        /// <param name="parameters"> The values to be assigned to parameters. </param>
+        /// <returns> An <see cref="IQueryable{T}" /> representing the raw SQL query. </returns>
+        [StringFormatMethod("sql")]
+        public static IQueryable<TEntity> FromSqlRaw<TEntity>(
+            this IQueryable<TEntity> source,
+            [NotParameterized] string sql,
+            params object[] parameters)
+            where TEntity : class
+        {
+            Check.NotNull(source, nameof(source));
+            Check.NotEmpty(sql, nameof(sql));
+            Check.NotNull(parameters, nameof(parameters));
+
+            var queryRootExpression = (QueryRootExpression)source.Expression;
+
+            var entityType = queryRootExpression.EntityType;
+
+            Check.DebugAssert(
+                (entityType.BaseType is null && !entityType.GetDirectlyDerivedTypes().Any())
+                || entityType.FindDiscriminatorProperty() is not null,
+                "Found FromSql on a TPT entity type, but TPT isn't supported on Cosmos");
+
+            var fromSqlQueryRootExpression = new FromSqlQueryRootExpression(
+                queryRootExpression.QueryProvider!,
+                entityType,
+                sql,
+                Expression.Constant(parameters));
+
+            return source.Provider.CreateQuery<TEntity>(fromSqlQueryRootExpression);
+        }
     }
 }

src/EFCore.Cosmos/Metadata/Conventions/CosmosDiscriminatorConvention.cs

@@ -102,14 +102,14 @@ private void ProcessEntityType(IConventionEntityTypeBuilder entityTypeBuilder)
                 return;
             }
 
-            if (!entityType.IsDocumentRoot())
+            if (entityType.IsDocumentRoot())
             {
-                entityTypeBuilder.HasNoDiscriminator();
+                entityTypeBuilder.HasDiscriminator(typeof(string))
+                    ?.HasValue(entityType, entityType.ShortName());
             }
             else
             {
-                entityTypeBuilder.HasDiscriminator(typeof(string))
-                    ?.HasValue(entityType, entityType.ShortName());
+                entityTypeBuilder.HasNoDiscriminator();
             }
         }
 

src/EFCore.Cosmos/Properties/CosmosStrings.resx

@@ -144,6 +144,9 @@
   <data name="InvalidDerivedTypeInEntityProjection" xml:space="preserve">
     <value>The specified entity type '{derivedType}' is not derived from '{entityType}'.</value>
   </data>
+  <data name="InvalidFromSqlArguments" xml:space="preserve">
+    <value>A FromSqlExpression has an invalid arguments expression type '{expressionType}' or value type '{valueType}'.</value>
+  </data>
   <data name="InvalidResourceId" xml:space="preserve">
     <value>Unable to generate a valid 'id' value to execute a 'ReadItem' query. This usually happens when the value provided for one of the properties is 'null' or an empty string. Please supply a value that's not 'null' or an empty string.</value>
   </data>

src/EFCore.Cosmos/Query/Internal/CosmosQueryTranslationPostprocessor.cs

@@ -44,8 +44,7 @@ public override Expression Process(Expression query)
         {
             query = base.Process(query);
 
-            if (query is ShapedQueryExpression shapedQueryExpression
-                && shapedQueryExpression.QueryExpression is SelectExpression selectExpression)
+            if (query is ShapedQueryExpression { QueryExpression: SelectExpression selectExpression })
             {
                 // Cosmos does not have nested select expression so this should be safe.
                 selectExpression.ApplyProjection();

src/EFCore.Cosmos/Query/Internal/CosmosQueryableMethodTranslatingExpressionVisitor.cs

@@ -128,7 +128,7 @@ public override Expression Visit(Expression expression)
 
                                     var readItemExpression = new ReadItemExpression(entityType, propertyParameterList);
 
-                                    return CreateShapedQueryExpression(readItemExpression, entityType)
+                                    return CreateShapedQueryExpression(entityType, readItemExpression)
                                         .UpdateResultCardinality(ResultCardinality.Single);
                                 }
                             }
@@ -187,6 +187,24 @@ static bool TryGetPartitionKeyProperty(IEntityType entityType, out IProperty par
             }
         }
 
+        /// <inheritdoc />
+        protected override Expression VisitExtension(Expression extensionExpression)
+        {
+            switch (extensionExpression)
+            {
+                case FromSqlQueryRootExpression fromSqlQueryRootExpression:
+                    return CreateShapedQueryExpression(
+                        fromSqlQueryRootExpression.EntityType,
+                        _sqlExpressionFactory.Select(
+                            fromSqlQueryRootExpression.EntityType,
+                            fromSqlQueryRootExpression.Sql,
+                            fromSqlQueryRootExpression.Argument));
+
+                default:
+                    return base.VisitExtension(extensionExpression);
+            }
+        }
+
         /// <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
@@ -246,10 +264,10 @@ protected override ShapedQueryExpression CreateShapedQueryExpression(IEntityType
 
             var selectExpression = _sqlExpressionFactory.Select(entityType);
 
-            return CreateShapedQueryExpression(selectExpression, entityType);
+            return CreateShapedQueryExpression(entityType, selectExpression);
         }
 
-        private ShapedQueryExpression CreateShapedQueryExpression(Expression queryExpression, IEntityType entityType)
+        private ShapedQueryExpression CreateShapedQueryExpression(IEntityType entityType, Expression queryExpression)
             => new(
                 queryExpression,
                 new EntityShaperExpression(

src/EFCore.Cosmos/Query/Internal/CosmosShapedQueryCompilingExpressionVisitor.cs

@@ -65,7 +65,6 @@ protected override Expression VisitShapedQuery(ShapedQueryExpression shapedQuery
             switch (shapedQueryExpression.QueryExpression)
             {
                 case SelectExpression selectExpression:
-
                     shaperBody = new CosmosProjectionBindingRemovingExpressionVisitor(
                             selectExpression, jObjectParameter,
                             QueryCompilationContext.QueryTrackingBehavior == QueryTrackingBehavior.TrackAll)
@@ -92,7 +91,6 @@ protected override Expression VisitShapedQuery(ShapedQueryExpression shapedQuery
                         Expression.Constant(_threadSafetyChecksEnabled));
 
                 case ReadItemExpression readItemExpression:
-
                     shaperBody = new CosmosProjectionBindingRemovingReadItemExpressionVisitor(
                             readItemExpression, jObjectParameter,
                             QueryCompilationContext.QueryTrackingBehavior == QueryTrackingBehavior.TrackAll)

src/EFCore.Cosmos/Query/Internal/FromSqlExpression.cs

@@ -0,0 +1,108 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.Utilities;
+
+#nullable disable
+
+namespace Microsoft.EntityFrameworkCore.Cosmos.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 FromSqlExpression : RootReferenceExpression, IPrintableExpression
+    {
+        /// <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 FromSqlExpression(IEntityType entityType, string alias, string sql, Expression arguments) : base(entityType, alias)
+        {
+            Check.NotEmpty(sql, nameof(sql));
+            Check.NotNull(arguments, nameof(arguments));
+
+            Sql = sql;
+            Arguments = arguments;
+        }
+
+        /// <inheritdoc />
+        public override string Alias => base.Alias!;
+
+        /// <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 string Sql { get; }
+
+        /// <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 Expression Arguments { get; }
+
+        /// <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 FromSqlExpression Update(Expression arguments)
+        {
+            Check.NotNull(arguments, nameof(arguments));
+
+            return arguments != Arguments
+                ? new FromSqlExpression(EntityType, Alias, Sql, arguments)
+                : this;
+        }
+
+        /// <inheritdoc />
+        protected override Expression VisitChildren(ExpressionVisitor visitor)
+        {
+            Check.NotNull(visitor, nameof(visitor));
+
+            return this;
+        }
+
+        /// <inheritdoc />
+        public override Type Type
+            => typeof(object);
+
+        /// <inheritdoc />
+        void IPrintableExpression.Print(ExpressionPrinter expressionPrinter)
+        {
+            Check.NotNull(expressionPrinter, nameof(expressionPrinter));
+
+            expressionPrinter.Append(Sql);
+        }
+
+        /// <inheritdoc />
+        public override bool Equals(object obj)
+            => obj != null
+                && (ReferenceEquals(this, obj)
+                    || obj is FromSqlExpression fromSqlExpression
+                    && Equals(fromSqlExpression));
+
+        private bool Equals(FromSqlExpression fromSqlExpression)
+            => base.Equals(fromSqlExpression)
+                && Sql == fromSqlExpression.Sql
+                && ExpressionEqualityComparer.Instance.Equals(Arguments, fromSqlExpression.Arguments);
+
+        /// <inheritdoc />
+        public override int GetHashCode()
+            => HashCode.Combine(base.GetHashCode(), Sql);
+    }
+}