使用QueryMultiple时如何确定返回哪些记录？

Question

I'm retrieving records by doing the following:

using (var multi = await connection.QueryMultipleAsync(procedureName, param, commandType: CommandType.StoredProcedure))
{
    var results = new List<dynamic>();

    while (!multi.IsConsumed)
    {
        results.Add(multi.Read().ToList());
    }

    return results;
}

So far so good. The stored procedure returns the data by doing:

SELECT * FROM @Orders;
SELECT * FROM @OrderDetails;

Is it possible to change the List<dynamic> to a Dictionary<string, IEnumerable<dynamic>> and set the key automatically when reading the GridReader , so that in the above example, the dictionary will have two entries with the keys Orders and OrderDetails .

Using Read<T> is not a solution for this question because the method is quite generic and doesn't known what is coming back.

Answer 1

If you don't mind aggregating the data first in a query, you can create a JOIN query and a matching Data Transfer Object class for Dapper to map to.

So say you have these tables:

Orders table:

orders.id
orders.customerid
orders.date

OrderDetails table:

orderdetails.id
orderdetails.orderid
orderdetails.productid
orderdetails.quantity
orderdetails.cost

You can then create a joining query to return related data like this:

SELECT 
  orders.id AS OrderId,
  orders.customer AS CustomerId,
  orders.date AS OrderDate,
  orderdetails.productid AS ProductId,
  orderdetails.quantity AS Quantity,
  orderdetails.cost AS Cost
FROM orders
LEFT JOIN orderdetails ON orders.id = orderdetails.orderid

And a matching DTO like this:

public class CustomerOrderDto : BaseDto
{
    public int OrderId { get; set; }
    public int CustomerId { get; set; }
    public DateTime OrderDate { get; set; }
    public int ProductId { get; set; }
    public double Quantity { get; set; }
    public double Cost { get; set; }
}

CustomerOrder retrieval methods:

// get single order and its details
public CustomerOrder GetCustomerOrder(int id)
{
    string sql = @"SELECT 
                     orders.id AS OrderId,
                     orders.customer AS CustomerId,
                     orders.date AS OrderDate,
                     orderdetails.productid AS ProductId,
                     orderdetails.quantity AS Quantity,
                     orderdetails.cost AS Cost
                   FROM orders
                   LEFT JOIN orderdetails ON orderdetails.orderid = orders.id
                   WHERE orders.id = @Id";

    using (connection...)
    {
        return connection.Query<CustomerOrder>(sql, new { Id = id }).SingleOrDefault();
    }
}


// get all orders and their details
public IEnumerable<CustomerOrder> GetCustomerOrders()
{
    string sql = @"SELECT 
                     orders.id AS OrderId,
                     orders.customer AS CustomerId,
                     orders.date AS OrderDate,
                     orderdetails.productid AS ProductId,
                     orderdetails.quantity AS Quantity,
                     orderdetails.cost AS Cost
                   FROM orders
                   LEFT JOIN orderdetails ON orderdetails.orderid = orders.id";

    using (connection...)
    {
        return connection.Query<CustomerOrder>(sql);
    }
}

In our applications we'll actually have a static SELECT body string and create the sql WHERE clauses dynamically so that we don't have to repeat a bunch of code.