Dapper map multiple joins Sql Query

Dapper map multiple joins Sql Query

Ich habe mein Bestes versucht und es gelöst.

Hier ist die einfachere und genauere Lösung nach mir.:

var lookup = new Dictionary<int, OrderDetail>();
            var lookup2 = new Dictionary<int, OrderLine>();
            connection.Query<OrderDetail, OrderLine, OrderLineSize, OrderDetail>(@"
                    SELECT o.*, ol.*, ols.*
                    FROM orders_mstr o
                    INNER JOIN order_lines ol ON o.id = ol.order_id
                    INNER JOIN order_line_size_relations ols ON ol.id = ols.order_line_id           
                    ", (o, ol, ols) =>
            {
                OrderDetail orderDetail;
                if (!lookup.TryGetValue(o.id, out orderDetail))
                {
                    lookup.Add(o.id, orderDetail = o);
                }
                OrderLine orderLine;
                if (!lookup2.TryGetValue(ol.id, out orderLine))
                {
                    lookup2.Add(ol.id, orderLine = ol);
                    orderDetail.OrderLines.Add(orderLine);
                }
                orderLine.OrderLineSizes.Add(ols);
                return orderDetail;
            }).AsQueryable();

            var resultList = lookup.Values.ToList();

Ich weiß nicht, was die Klasse 'OrderDetail' ist, die Sie nicht bereitstellen, also habe ich die Order-Klasse verwendet.
Dies kann auch durch QueryMultiple erfolgen aber weil Ihre Frage INNER JOIN enthält, verwende ich es nicht.

public Dictionary<int, Order> GetOrderLookup()
{
    var lookup = new Dictionary<int, Order>();

    const string sql = @"   SELECT  o.id,
                                    o.order_reference,
                                    o.order_status,

                                    ol.id,
                                    ol.order_id,
                                    ol.product_number,

                                    ols.id,
                                    ols.order_line_id,
                                    ols.size_name
                            FROM    orders_mstr o
                            JOIN    order_lines ol ON o.id = ol.order_id
                            JOIN    order_line_size_relations ols ON ol.id = ols.order_line_id";

    List<Order> orders = null;
    using (var connection = OpenConnection(_connectionString))
    {
        orders = connection.Query<Order, OrderLine, OrderLineSize, Order>(sql, (order, orderLine, orderLizeSize) =>
        {
            orderLine.OrderLineSizes = new List<OrderLineSize> { orderLizeSize };
            order.OrderLines = new List<OrderLine>() { orderLine };
            return order;
        },
        null, commandType: CommandType.Text).ToList();
    }

    if (orders == null || orders.Count == 0)
    {
        return lookup;
    }

    foreach (var order in orders)
    {
        var contians = lookup.ContainsKey(order.id);
        if (contians)
        {
            var newLinesToAdd = new List<OrderLine>();
            var existsLines = lookup[order.id].OrderLines;
            foreach (var existsLine in existsLines)
            {
                foreach (var newLine in order.OrderLines)
                {
                    if (existsLine.id == newLine.id)
                    {
                        existsLine.OrderLineSizes.AddRange(newLine.OrderLineSizes);
                    }
                    else
                    {
                        newLinesToAdd.Add(newLine);
                    }
                }
            }
            existsLines.AddRange(newLinesToAdd);
        }
        else
        {
            lookup.Add(order.id, order);
        }
    }

    return lookup;
}

Ich habe mich entschieden, Dapper zu verwenden, um große Datenmengen für die Berechnung von Dingen zu erhalten. Dies ist meine elegante Erweiterungsmethode, um 3 Tabellen in der Datei _RepositoryBase.cs zu verknüpfen.

    public List<Tuple<T, T2, T3, T4>> QueryMultiple<T2, T3, T4>(string sql, object param)
        where T2 : class
        where T3 : class
    {
        using (var con = new SqlConnection(GetConnStr()))
        {
            if (con.State == ConnectionState.Closed)
                con.Open();

            var query = con.Query<T, T2, T3, T4, Tuple<T, T2, T3, T4>>(sql, (t, t2, t3, t4) => Tuple.Create(t, t2, t3, t4), param);

            //if (query.Count() == 0)
            //    return new List<T>();

            var data = query.ToList();

            con.Close();
            con.Dispose();

            return data;
        }
    }

Dann hilft Ihnen diese Funktion, SQL-verknüpfte Daten über dapper zu erhalten.

    public List<Table1> GetSqlJoinedDataViaDaper(int customerId)
    {
        var repo = new GenericRepository<T_LOOKUP>();
        var sql = @"select table1.ID Table1ID, table1.*,
                    table2.ID Table2ID, table2.*,
                    table3.ID Table3ID, table3.*
                    from dbo.Table1 table1 (nolock)
                    left outer join dbo.Table2 table2 (nolock) on table2.ID=table1.FKTable2ID
                    left outer join dbo.Table3 table3 (nolock) on table3.ID=table1.FKTable3ID
                    where [email protected] ";

        var resultWithJoin = repo.QueryMultiple<Table1, Table2, Table3>(sql,
            new { p1 = 1, splitOn = "Table1ID,Table2ID,Table3ID" }).ToList();

        var retval = new List<Table1>();
        foreach (var item in resultWithJoin)
        {
            Table1 t1 = item.Item2; //After first split
            t1.Table2 = item.Item3; //After Table2ID split
            t1.Table3 = item.Item4; //After Table3ID split

            retval.Add(t1);
        }
        return retval;
    }

Zusammenfassung:Schreiben Sie Ihre Auswahl und fügen Sie die Aufteilung zwischen den Tabellen ein. Sagen Sie Splits zu Dapper und erhalten Sie Ihre Daten. Ich habe dies verwendet und funktionierte besser als Entity Framework.