StackService动态DTO

Question

I'm trying to create a dynamic DTO for use in ServiceStack. The reason is that data is queried from the database without knowing the number of columns returned and therefore no way to create a normal dto.

UPDATE: The reason for not knowing the number of columns is that a pivot is used to return the data. Quite simply turning this:

CustID | OrderDate | Qty
1      | 1/1/2008  | 100
2      | 1/2/2008  | 200
1      | 2/2/2008  | 350
2      | 2/28/2008 | 221
1      | 3/12/2008 | 250
2      | 3/15/2008 | 2150

into this.

CustID  | Jan- 2008 | Feb- 2008 | Mar - 2008 |
1       | 100       | 350       |  250
2       | 200       | 221       | 2150

the user will be able to specify the start and end date and thus determine the number of columns in the result.

UPDATE END

My code:

DTO

public class Rep_DataAvailibility
{
    public DateTime startDate { get; set; }
    public DateTime endDate { get; set; }
}

public static class Rep_DataAvailibilityData
{
    private static string _commandText = "select name,description,Constant from measurement"; // used as a test

    public static object GetData(Rep_DataAvailibility parameters)
    {
        object result = new object();
        using (IDbConnection db = DataHelper.DbProvider.OpenDbConnection())
        {
            result = db.Query<object>(_commandText).ToArray();           
        }
        return result;
    }
} 

API

public partial class Rep_DataAvailibilityService : Service
{
    //[Authenticate]
    public object Get(Rep_DataAvailibility request)
    {
        return Rep_DataAvailibilityData.GetData(request);
    } //end of GET endpoint
}//end of service class

If five items where to be returned this is what the result looks like: [{},{},{},{},{}]

I have tried using a dictionary as well but that did not work either, it seems I might have misunderstood that and thus will not elaborate as I need to read some more.

Any help is appreciated.

Thanks, Johann

Answer 1

Map a POCO class 1:1 to an RDBMS table

What you are trying to achieve goes against the aims of an ORM, such as OrmLite, which is designed to work with known types and POCOs . From the official documentation , a key aim of OrmLite is to:

Map a POCO class 1:1 to an RDBMS table, cleanly by conventions, without any attributes required.

Use of object

If you provide a plain object as your type ie db.Query<object> , then there are no public properties of that object to reflect the returned query data into hence you get [{},{},{},{},{}] .

NoSQL?

This doesn't look like a good fit for an ORM, and perhaps not even a relational database. It's unusual to query a RDBMS table and not know the columns it will return. This looks like NoSQL territory , where you need a data structure.

---

Pivot the data in your business logic:

Your issue lies ultimately in creating the pivot of your data in the database, because this is creating dynamic columns. The problem can be easily solved if you returned the list of orders and performed the pivot in your code.

So if you created an object to represent the order table:

public class Order
{
    public int CustID { get; set; }
    public DateTime OrderDate { get; set; }
    public int Qty { get; set; }
}

Then you can query the database for a List<Order> and then pivot that data into a suitable DTO, such as:

public class CustomerMonthlyOrders
{
    public int CustID { get; set; }
    public Dictionary<string, int> QuantitiesOrdered { get; set; }
}

So given a route:

[Route("/orders", "GET")]
public class GetOrderHistoryRequest : IReturn<List<CustomerMonthlyOrders>>
{
    public DateTime StartDate { get; set; }
    public DateTime EndDate { get; set; }
}

Your service can pivot the data: Note: the SQL is untested, and will need tweaked to your database.

public class OrderService : Service 
{
    public List<CustomerMonthlyOrders> Get(GetOrderHistoryRequest request)
    {
        // Perform the query to get all orders within the range
        // (NOTE: SQL is untested, and will need tweaked to your db)
        List<Order> allOrders = Db.SqlList<Order>("SELECT * FROM Orders WHERE OrderDate >= @Start AND OrderDate < @End", new {
            Start = request.StartDate,
            End = request.EndDate
        });

        // Prepare response object
        var customerMonthlyOrders = new List<CustomerMonthlyOrders>();

        // Get the distinct customer Ids
        var customers = orders.Select(o => o.CustID).OrderBy(o => o).Distinct();
        foreach(var custId in customers)
        {
            // Create a result for the customer
            var result = new CustomerMonthlyOrders { 
                CustID = custId,
                QuantitiesOrdered = new Dictionary<string, int>()
            };

            // Get the customers relevant orders
            var orders = allOrders.Where(o => o.CustID == custId);
            foreach(var order in orders)
            {
                // Determine the month the order belongs to (i.e. the key)
                var month = order.OrderDate.ToString("MMM-yyyy");

                // Add or update the quantities
                if(result.QuantitiesOrdered.ContainsKey(month))
                    result.QuantitiesOrdered[month] += order.Qty;
                else
                    result.QuantitiesOrdered.Add(month, order.Qty);
            }

            // Add the customers order to the results
            customerMonthlyOrders.Add(result);
        }

        // Return the results
        return customerMonthlyOrders;
    }
}

This then creates the dynamic DTO response you are looking for:

JSON produced:

[{
    "CustID": 1,
    "QuantitiesOrdered": {
        "Jan-2008": 100,
        "Feb-2008": 350,
        "Mar-2008": 250
    }
}, {
    "CustID": 2,
    "QuantitiesOrdered": {
        "Jan-2008": 200,
        "Feb-2008": 221,
        "Mar-2008": 2150
    }
}]