Raw SQL Query without DbSet - Entity Framework Core

后端 未结 17 1193
眼角桃花
眼角桃花 2020-11-22 13:27

With Entity Framework Core removing dbData.Database.SqlQuery I can\'t find a solution to build a raw SQL Query for my full-text search query th

相关标签:
17条回答
  • 2020-11-22 13:37

    I know it's an old question, but maybe it helps someone to call stored procedures without adding DTOs as DbSets.

    https://stackoverflow.com/a/62058345/3300944

    0 讨论(0)
  • 2020-11-22 13:37

    With Entity Framework 6 you can execute something like below

    Create Modal Class as

    Public class User
    {
            public int Id { get; set; }
            public string fname { get; set; }
            public string lname { get; set; }
            public string username { get; set; }
    }
    

    Execute Raw DQL SQl command as below:

    var userList = datacontext.Database.SqlQuery<User>(@"SELECT u.Id ,fname , lname ,username FROM dbo.Users").ToList<User>();
    
    0 讨论(0)
  • 2020-11-22 13:38

    Building on the other answers I've written this helper that accomplishes the task, including example usage:

    public static class Helper
    {
        public static List<T> RawSqlQuery<T>(string query, Func<DbDataReader, T> map)
        {
            using (var context = new DbContext())
            {
                using (var command = context.Database.GetDbConnection().CreateCommand())
                {
                    command.CommandText = query;
                    command.CommandType = CommandType.Text;
    
                    context.Database.OpenConnection();
    
                    using (var result = command.ExecuteReader())
                    {
                        var entities = new List<T>();
    
                        while (result.Read())
                        {
                            entities.Add(map(result));
                        }
    
                        return entities;
                    }
                }
            }
        }
    

    Usage:

    public class TopUser
    {
        public string Name { get; set; }
    
        public int Count { get; set; }
    }
    
    var result = Helper.RawSqlQuery(
        "SELECT TOP 10 Name, COUNT(*) FROM Users U"
        + " INNER JOIN Signups S ON U.UserId = S.UserId"
        + " GROUP BY U.Name ORDER BY COUNT(*) DESC",
        x => new TopUser { Name = (string)x[0], Count = (int)x[1] });
    
    result.ForEach(x => Console.WriteLine($"{x.Name,-25}{x.Count}"));
    

    I plan to get rid of it as soon as built-in support is added. According to a statement by Arthur Vickers from the EF Core team it is a high priority for post 2.0. The issue is being tracked here.

    0 讨论(0)
  • 2020-11-22 13:38

    Actually you can create a generic repository and do something like this

    public class GenericRepository<TEntity> : IGenericRepository<TEntity> where TEntity : BaseEntity
    {
        private readonly DataContext context;
        private readonly DbSet<TEntity> dbSet;
    
        public GenericRepository(DataContext context)
        {
            this.context = context;
            this.dbSet = context.Set<TEntity>();
        }
    
       
        public IEnumerable<TEntity> ExecuteCommandQuery(string command)
            => dbSet.FromSqlRaw(command);
    
    }
    
    0 讨论(0)
  • 2020-11-22 13:41

    You can execute raw sql in EF Core - Add this class to your project. This will allow you to execute raw SQL and get the raw results without having to define a POCO and a DBSet. See https://github.com/aspnet/EntityFramework/issues/1862#issuecomment-220787464 for original example.

    using Microsoft.EntityFrameworkCore.Infrastructure;
    using Microsoft.EntityFrameworkCore.Internal;
    using Microsoft.EntityFrameworkCore.Storage;
    using System.Threading;
    using System.Threading.Tasks;
    
    namespace Microsoft.EntityFrameworkCore
    {
        public static class RDFacadeExtensions
        {
            public static RelationalDataReader ExecuteSqlQuery(this DatabaseFacade databaseFacade, string sql, params object[] parameters)
            {
                var concurrencyDetector = databaseFacade.GetService<IConcurrencyDetector>();
    
                using (concurrencyDetector.EnterCriticalSection())
                {
                    var rawSqlCommand = databaseFacade
                        .GetService<IRawSqlCommandBuilder>()
                        .Build(sql, parameters);
    
                    return rawSqlCommand
                        .RelationalCommand
                        .ExecuteReader(
                            databaseFacade.GetService<IRelationalConnection>(),
                            parameterValues: rawSqlCommand.ParameterValues);
                }
            }
    
            public static async Task<RelationalDataReader> ExecuteSqlQueryAsync(this DatabaseFacade databaseFacade, 
                                                                 string sql, 
                                                                 CancellationToken cancellationToken = default(CancellationToken),
                                                                 params object[] parameters)
            {
    
                var concurrencyDetector = databaseFacade.GetService<IConcurrencyDetector>();
    
                using (concurrencyDetector.EnterCriticalSection())
                {
                    var rawSqlCommand = databaseFacade
                        .GetService<IRawSqlCommandBuilder>()
                        .Build(sql, parameters);
    
                    return await rawSqlCommand
                        .RelationalCommand
                        .ExecuteReaderAsync(
                            databaseFacade.GetService<IRelationalConnection>(),
                            parameterValues: rawSqlCommand.ParameterValues,
                            cancellationToken: cancellationToken);
                }
            }
        }
    }
    

    Here's an example of how to use it:

    // Execute a query.
    using(var dr = await db.Database.ExecuteSqlQueryAsync("SELECT ID, Credits, LoginDate FROM SamplePlayer WHERE " +
                                                              "Name IN ('Electro', 'Nitro')"))
    {
        // Output rows.
        var reader = dr.DbDataReader;
        while (reader.Read())
        {
            Console.Write("{0}\t{1}\t{2} \n", reader[0], reader[1], reader[2]);
        }
    }
    
    0 讨论(0)
  • 2020-11-22 13:42

    It depends if you're using EF Core 2.1 or EF Core 3 and higher versions.

    If you're using EF Core 2.1

    If you're using EF Core 2.1 Release Candidate 1 available since 7 may 2018, you can take advantage of the proposed new feature which is Query type.

    What is query type?

    In addition to entity types, an EF Core model can contain query types, which can be used to carry out database queries against data that isn't mapped to entity types.

    When to use query type?

    Serving as the return type for ad hoc FromSql() queries.

    Mapping to database views.

    Mapping to tables that do not have a primary key defined.

    Mapping to queries defined in the model.

    So you no longer need to do all the hacks or workarounds proposed as answers to your question. Just follow these steps:

    First you defined a new property of type DbQuery<T> where T is the type of the class that will carry the column values of your SQL query. So in your DbContext you'll have this:

    public DbQuery<SomeModel> SomeModels { get; set; }
    

    Secondly use FromSql method like you do with DbSet<T>:

    var result = context.SomeModels.FromSql("SQL_SCRIPT").ToList();
    var result = await context.SomeModels.FromSql("SQL_SCRIPT").ToListAsync();
    

    Also note that DdContexts are partial classes, so you can create one or more separate files to organize your 'raw SQL DbQuery' definitions as best suits you.


    If you're using EF Core 3.0 and higher versions

    Query type is now known as Keyless entity type. As said above query types were introduced in EF Core 2.1. If you're using EF Core 3.0 or higher version you should now condider using keyless tntity types because query types are now marked obsolete.

    This feature was added in EF Core 2.1 under the name of query types. In EF Core 3.0 the concept was renamed to keyless entity types. The [Keyless] Data Annotation became available in EFCore 5.0.

    We still have the same scenarios as for query types for when to use keyless entity type.

    So to use it you need to first mark your class SomeModel with [Keyless] data annotation or through fluent configuration with .HasNoKey() method call like below:

    public DbSet<SomeModel> SomeModels { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<SomeModel>().HasNoKey();
    }
    

    After that configuration, you can use one of the methods explained here to execute your SQL query. For example you can use this one:

    var result = context.SomeModels.FromSqlRaw("SQL SCRIPT").ToList();
    
    0 讨论(0)
提交回复
热议问题