Joins en query's voor meerdere producten formuleren

In de volgende voorbeelden ziet u hoe u resultaten uit meerdere tabellen combineert.

Voorbeeld 1

In het volgende voorbeeld wordt gebruikgemaakt van foreign key-navigatie in de From clausule in Visual Basic (from clausule in C#) om alle orders voor klanten in Londen te selecteren.

var infoQuery =
    from cust in db.Customers
    from ord in cust.Orders
    where cust.City == "London"
    select ord;

Dim infoQuery = _
From cust In db.Customers, ord In cust.Orders _
Where cust.City = "London" _
Select ord

Voorbeeld 2

In het volgende voorbeeld wordt gebruikgemaakt van referentiesleutelnavigatie in de Where clausule in Visual Basic (where clausule in C#) om te filteren naar niet op voorraad zijnde Products waarvan de Supplier zich in de Verenigde Staten bevindt.

var infoQuery =
    from prod in db.Products
    where prod.Supplier.Country == "USA" && prod.UnitsInStock == 0
    select prod;

Dim infoQuery = _
    From prod In db.Products _
    Where prod.Supplier.Country = "USA" AndAlso _
        CShort(prod.UnitsInStock) = 0 _
    Select prod

Voorbeeld 3

In het volgende voorbeeld wordt gebruikgemaakt van foreign key navigatie in de From clausule in Visual Basic (from clausule in C#) om te filteren op werknemers in Seattle en om hun territoria weer te geven.

var infoQuery =
    from emp in db.Employees
    from empterr in emp.EmployeeTerritories
    where emp.City == "Seattle"
    select new
    {
        emp.FirstName,
        emp.LastName,
        empterr.Territory.TerritoryDescription
    };

Voorbeeld 4

In het volgende voorbeeld wordt gebruikgemaakt van buitenlandse sleutelnavigatie in de Select clausule in Visual Basic (select clausule in C#) om te filteren op paren van werknemers waarbij de ene werknemer rapporteert aan de andere en waar beide werknemers van hetzelfde City zijn.

var infoQuery =
    from emp1 in db.Employees
    from emp2 in emp1.Employees
    where emp1.City == emp2.City
    select new
    {
        FirstName1 = emp1.FirstName,
        LastName1 = emp1.LastName,
        FirstName2 = emp2.FirstName,
        LastName2 = emp2.LastName,
        emp1.City
    };

Dim infoQuery = _
    From e1 In db.Employees, e2 In e1.Employees _
    Where e1.City = e2.City _
    Select FirstName1 = e1.FirstName, _
        LastName1 = e1.LastName, FirstName2 = e2.FirstName, _
        LastName2 = e2.LastName, e1.City

Voorbeeld 5

Het volgende Visual Basic-voorbeeld zoekt naar alle klanten en orders, zorgt ervoor dat de orders overeenkomen met klanten en garandeert dat voor elke klant in die lijst een naam van een contactpersoon wordt opgegeven.

Dim q1 = From c In db.Customers, o In db.Orders _
         Where c.CustomerID = o.CustomerID _
         Select c.CompanyName, o.ShipRegion

' Note that because the O/R designer generates class
' hierarchies for database relationships for you,
' the following code has the same effect as the above
' and is shorter:

Dim q2 = From c In db.Customers, o In c.Orders _
         Select c.CompanyName, o.ShipRegion

For Each nextItem In q2
    Console.WriteLine("{0}   {1}", nextItem.CompanyName, _
        nextItem.ShipRegion)
Next

Voorbeeld 6

In het volgende voorbeeld worden twee tabellen expliciet samengevoegd en worden resultaten uit beide tabellen geprojecteerd.

var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID equals o.CustomerID
        into orders
    select new { c.ContactName, OrderCount = orders.Count() };

Dim q = From c In db.Customers _
        Group Join o In db.Orders On c.CustomerID Equals o.CustomerID _
            Into orders = Group _
        Select c.ContactName, OrderCount = orders.Count()

Voorbeeld 7

In het volgende voorbeeld worden expliciet drie tabellen samengevoegd en de resultaten van elk van hen weergegeven.

var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID equals o.CustomerID
        into ords
    join e in db.Employees on c.City equals e.City into emps
    select new
    {
        c.ContactName,
        ords = ords.Count(),
        emps = emps.Count()
    };

Dim q = From c In db.Customers _
        Group Join o In db.Orders On c.CustomerID Equals o.CustomerID _
            Into ords = Group _
        Group Join e In db.Employees On c.City Equals e.City _
            Into emps = Group _
        Select c.ContactName, ords = ords.Count(), emps = emps.Count()

Voorbeeld 8

In het volgende voorbeeld ziet u hoe u een LEFT OUTER JOIN bereikt met behulp van DefaultIfEmpty(). De DefaultIfEmpty() methode retourneert null als er geen Order is voor de Employee.

var q =
    from e in db.Employees
    join o in db.Orders on e equals o.Employee into ords
        from o in ords.DefaultIfEmpty()
        select new { e.FirstName, e.LastName, Order = o };

Dim q = From e In db.Employees() _
        Group Join o In db.Orders On e Equals o.Employee Into ords _
            = Group _
        From o In ords.DefaultIfEmpty() _
        Select e.FirstName, e.LastName, Order = o

Voorbeeld 9

In het volgende voorbeeld wordt een let expressie geprojecteert die het resultaat is van een join.

var q =
    from c in db.Customers
    join o in db.Orders on c.CustomerID equals o.CustomerID
        into ords
    let z = c.City + c.Country
        from o in ords
        select new { c.ContactName, o.OrderID, z };

Dim q = From c In db.Customers _
        Group Join o In db.Orders On c.CustomerID Equals o.CustomerID _
            Into ords = Group _
        Let z = c.City + c.Country _
        From o In ords _
        Select c.ContactName, o.OrderID, z

Voorbeeld 10

In het volgende voorbeeld ziet u een join met een samengestelde sleutel.

var q =
    from o in db.Orders
    from p in db.Products
    join d in db.OrderDetails
        on new { o.OrderID, p.ProductID } equals new
    {
        d.OrderID,
        d.ProductID
    } into details
        from d in details
        select new { o.OrderID, p.ProductID, d.UnitPrice };

Dim q = From o In db.Orders _
        From p In db.Products _
        Group Join d In db.OrderDetails On New With {o.OrderID, _
            p.ProductID} _
            Equals New With {d.OrderID, d.ProductID} Into details _
                = Group _
        From d In details _
        Select o.OrderID, p.ProductID, d.UnitPrice

Voorbeeld 11

Het volgende voorbeeld laat zien hoe u een join kunt construeren waarvan de ene zijde nullable is en de andere niet.

var q =
    from o in db.Orders
    join e in db.Employees
        on o.EmployeeID equals (int?)e.EmployeeID into emps
        from e in emps
        select new { o.OrderID, e.FirstName };

Dim q = From o In db.Orders _
        Group Join e In db.Employees On o.EmployeeID _
            Equals e.EmployeeID Into emps = Group _
        From e In emps _
        Select o.OrderID, e.FirstName

Zie ook

Queryvoorbeelden

Last updated on 2025-06-17