top of page

Executing Raw Sql Queries using Entity Framework Core and returns result to Generic Data Model

Updated: Feb 22, 2023

Entity Framework Core is a widely used Object-Relational Mapping (ORM) tool for .NET developers. It allows developers to work with databases using high-level abstractions instead of directly interacting with the underlying SQL queries. However, sometimes it may be necessary to execute raw SQL queries against the database, for example, to perform complex operations or to optimize performance.


In this article, we will discuss how to execute raw SQL queries using Entity Framework Core and return the result to a generic data model.


Setting up the environment

Before we start, we need to set up the environment to use Entity Framework Core. We will assume that you have already created a .NET Core application and added the necessary NuGet packages for Entity Framework Core. If not, you can follow the steps outlined in the official documentation.


Executing raw SQL queries using Entity Framework Core

Entity Framework Core allows us to execute raw SQL queries using the DbContext object. The DbContext object represents a session with the database and provides access to the Database property, which in turn provides access to the ExecuteSqlRaw() method. The ExecuteSqlRaw() method executes the given SQL query against the database and returns the number of rows affected by the query.


Here's an example of how to execute a raw SQL query using Entity Framework Core:

using (var context = new MyDbContext())
{
    var result = context.Database.ExecuteSqlRaw("SELECT * FROM MyTable");
}

In the above code, we create a new instance of the MyDbContext class and call the ExecuteSqlRaw() method on its Database property, passing in a raw SQL query as a parameter. The ExecuteSqlRaw() method returns the number of rows affected by the query.


Returning results to a generic data model

Sometimes we may want to return the results of a raw SQL query to a generic data model, instead of returning a collection of DbDataReader or dynamic objects. Entity Framework Core provides a way to do this using the FromSqlRaw() method.


The FromSqlRaw() method allows us to execute a raw SQL query against the database and map the result to a given entity type. Here's an example of how to use the FromSqlRaw() method:

using (var context = new MyDbContext())
{
    var result = context.MyEntity.FromSqlRaw("SELECT * FROM MyTable").ToList();
}

In the above code, we call the FromSqlRaw() method on the MyEntity property of the MyDbContext object, passing in a raw SQL query as a parameter. The FromSqlRaw() method returns a collection of MyEntity objects that map to the result of the SQL query.


Note that the SQL query must return a result set that matches the properties of the MyEntity class for the mapping to work correctly.


Mapping the Results to a Complex Data Model

To map the results of a raw SQL query to a complex data model, we need to create a class that represents the structure of the result set. This class should contain properties that match the columns of the result set, as well as any nested objects or collections.


Let's take the example of a raw SQL query that returns data from two related tables. The query returns a list of orders and the corresponding line items for each order. Here's an example of what the result set might look like:


We can create a class that represents this structure as follows:

public class OrderData
{
    public int OrderId { get; set; }
    public DateTime OrderDate { get; set; }
    public int CustomerId { get; set; }
    public List<LineItemData> LineItems { get; set; }
}

public class LineItemData
{
    public int LineItemId { get; set; }
    public int ProductId { get; set; }
    public int Quantity { get; set; }
}

Note that we have defined a nested class LineItemData to represent the line items for each order.


To map the results of the raw SQL query to this complex data model, we can use the FromSqlRaw() method as follows:

using (var context = new MyDbContext())
{
    var orderData = context.OrderData.FromSqlRaw(@"
        SELECT o.OrderId, o.OrderDate, o.CustomerId, li.LineItemId, li.ProductId, li.Quantity
        FROM Orders o
        JOIN LineItems li ON o.OrderId = li.OrderId
    ").ToList();
}

In the above code, we call the FromSqlRaw() method on the OrderData property of the MyDbContext object, passing in the raw SQL query as a parameter. The ToList() method returns a collection of OrderData objects that map to the result of the SQL query.


Note that the SQL query must return a result set that matches the structure of the OrderData class for the mapping to work correctly. Also, we have used a multi-line string literal (@"") to format the SQL query for better readability.


Conclusion

In this article, we have discussed how to execute raw SQL queries using Entity Framework Core and return the result to a generic data model. We have seen that Entity Framework Core provides a convenient way to execute raw SQL queries and map the results to entity types. By using these techniques, we can leverage the power of raw SQL queries while still maintaining the benefits of using Entity Framework Core.

0 comments

Comments


bottom of page