L'Instruction SQL d'Aide - Sélectionnez la dernière Commande de chaque Client

Dire que j'ai 2 tables: Clients et des Commandes. Un Client peut avoir plusieurs Commandes.

Maintenant, j'ai besoin de montrer tous les Clients avec son dernier Ordre. Cela signifie que si un Client a plus que l'on commande, montrent que l'Ordre avec la dernière Heure d'Entrée.

C'est dans quelle mesure j'ai réussi sur mon propre:

SELECT a.*, b.Id
FROM Customer a INNER JOIN Order b ON b.CustomerID = a.Id
ORDER BY b.EntryTime DESC

Bien sûr, cela renvoie tous les Clients avec un ou plusieurs Ordres, montrant les dernières Ordre d'abord, pour chaque Client, ce qui n'est pas ce que je voulais. Mon esprit a été coincé dans une ornière, à ce moment-là, j'espère que quelqu'un peut me pointer dans la bonne direction.

Pour une raison quelconque, j' pense - je besoin pour utiliser le MAX de syntaxe quelque part, mais il m'échappe en ce moment.

mise à JOUR: Après avoir traversé quelques réponses ici (il y en a beaucoup!), J'ai réalisé que j'ai fait une erreur: je voulais dire tous Client avec son dernier album. Cela signifie que si il n'a pas un Ordre, alors je n'ai pas besoin de lui la liste.

UPDATE2: le Fixe de ma propre instruction SQL, ce qui a probablement causé de la confusion pour les autres.

Votre table des clients dans cet exemple a un n ° de commande. Est ce que le droit?
Oui, implicite dans le SQL.
Si votre table Client dispose d'un n ° de commande votre question n'a aucun sens. Si c'était vrai, vous est-à-dire que chaque commande a un autre client. Êtes-vous sûr que votre Commande de table ne possède pas de code client?
aïe, vous avez raison! L'homme, Mon esprit est vraiment hors de lui aujourd'hui. :/

OriginalL'auteur alextansc | 2008-12-01

sql sql-server-2005

8

Je ne pense pas que vous voulez utiliser (MAX) que vous ne voulez pas le groupe le n ° de commande. Ce que vous avez besoin est un commandés sous-requête avec un SELECT TOP 1.
```
select * 
from Customers inner join Orders 
on Customers.CustomerID = Orders.CustomerID
and OrderID = (SELECT TOP 1 subOrders.OrderID 
                    FROM Orders subOrders 
                    WHERE subOrders.CustomerID = Orders.CustomerID 
                    ORDER BY subOrders.OrderDate DESC)
```
Oui, je pense que votre réponse est la plus correcte à ce jour, la seule erreur, c'est que vous n'avez pas de tri de la date dans l'ordre décroissant. Ne pas mentionner le plus élégant. 🙂 Merci!
J'ai fait la commande au début, puis j'ai confondu moi-même et pensais que tu voulais le plus ancien ordre. J'ai maintenant updatd mon exemple correct.

OriginalL'auteur Martin Brown
6

Alors que je vois que vous avez déjà accepté une réponse, je pense que celui-ci est un peu plus intuitive:
```
select      a.*
           ,b.Id

from       customer a

inner join Order b
on         b.CustomerID = a.Id

where      b.EntryTime = ( select max(EntryTime)
                           from   Order
                           where  Id = b.Id
                         );
```
J'aurais à exécuter quelque chose comme ceci par le biais d'un plan d'exécution pour voir la différence dans l'exécution, mais dont la première fonction est effectuée après le fait et que l'utilisation de "order by" peut être cher, je crois que l'utilisation de max(EntryTime) serait la meilleure façon de l'exécuter.

J'ai essayé ta requête, et je trouve que c'retourner le même résultat. Nice! Je ne vais pas passer ma réponse à ce moment, il y a quelques autres réponses ici, j'ai voulu tester. Mais, je vais jusqu'-voter votre réponse pour l'instant. 🙂
Sûrement que la sous-requête est là que la clause doit être CustomerId = un.Id?

OriginalL'auteur Patrick Harrington
4

Quelque chose comme ça devrait le faire:
```
SELECT X.*, Y.LatestOrderId
FROM Customer X
LEFT JOIN (
  SELECT A.Customer, MAX(A.OrderID) LatestOrderId
  FROM Order A
  JOIN (
    SELECT Customer, MAX(EntryTime) MaxEntryTime FROM Order GROUP BY Customer
  ) B ON A.Customer = B.Customer AND A.EntryTime = B.MaxEntryTime
  GROUP BY Customer
) Y ON X.Customer = Y.Customer
```
Cela suppose que les deux commandes pour le même client peut avoir le même EntryTime, c'est pourquoi MAX(OrderID) est utilisé dans la sous-requête Y pour s'assurer qu'il ne se produit qu'une seule fois par client. Le LEFT JOIN est utilisé parce que vous avez dit que vous vouliez afficher tous les clients si ils n'ont pas de toutes les commandes, puis la LatestOrderId sera NULL.

Espérons que cette aide!

--

Mise à JOUR 🙂 Cela montre seulement des clients avec des commandes:
```
SELECT A.Customer, MAX(A.OrderID) LatestOrderId
FROM Order A
JOIN (
  SELECT Customer, MAX(EntryTime) MaxEntryTime FROM Order GROUP BY Customer
) B ON A.Customer = B.Customer AND A.EntryTime = B.MaxEntryTime
GROUP BY Customer
```
Cette solution est beaucoup plus rapide que celui qui a été sélectionné par l'OP.
C'est la meilleure solution car il calcule toutes les données nécessaires à l'avant plutôt qu'individuellement, en corrélation des dossiers.

OriginalL'auteur xahtep
2

Vous pouvez utiliser une fonction de fenêtre.
```
SELECT *
  FROM (SELECT a.*, b.*,
               ROW_NUMBER () OVER (PARTITION BY a.ID ORDER BY b.orderdate DESC,
                b.ID DESC) rn
          FROM customer a, ORDER b
         WHERE a.ID = b.custid)
 WHERE rn = 1
```
Pour chaque client (un.id) il trie toutes les commandes et les rejets de tout, mais plus tard.
Clause ORDER BY comprend à la fois la date de commande et l'id d'entrée, dans le cas où il y a plusieurs commandes sur la même date.

Généralement, les fonctions de la fenêtre sont beaucoup plus rapides que n'importe quel look-ups à l'aide de MAX() sur un grand nombre d'enregistrements.

OriginalL'auteur user34850

SELECT Cust.*, Ord.*
FROM Customers cust INNER JOIN Orders ord ON cust.ID = ord.CustID
WHERE ord.OrderID = 
    (SELECT MAX(OrderID) FROM Orders WHERE Orders.CustID = cust.ID)

Vous êtes l'obtention de la commande avec le Max n ° de commande et de ne pas le Max EntryTime qui peut être différente.

OriginalL'auteur devio

Quelque chose comme:

SELECT
  a.*
FROM
  Customer a
    INNER JOIN Order b
      ON a.OrderID = b.Id
        INNER JOIN (SELECT Id, max(EntryTime) as EntryTime FROM Order b GROUP BY Id) met
          ON
            b.EntryTime = met.EntryTime and b.Id = met.Id

OriginalL'auteur Benny Wong

0

Une approche que je n'ai pas vu plus haut encore:
```
SELECT
     C.*,
     O1.ID
FROM
     dbo.Customers C
INNER JOIN dbo.Orders O1 ON
     O1.CustomerID = C.ID
LEFT OUTER JOIN dbo.Orders O2 ON
     O2.CustomerID = C.ID AND
     O2.EntryTime > O1.EntryTime
WHERE
     O2.ID IS NULL
```
Ce (ainsi que les autres solutions je crois), ce qui suppose que deux commandes pour le même client peut avoir exactement le même temps de la saisie. Si c'est une préoccupation, alors vous aurez à faire des choix quant à ce qui détermine lequel est le "plus tard". Si c'est un sujet de préoccupation poster un commentaire et je peux développer la requête si nécessaire, pour tenir compte de cela.

L'approche générale de la requête est de trouver la commande pour un client où il n'y a pas une autre commande pour le même client à une date ultérieure. C'est alors la dernière commande par définition. Cette approche permet souvent d'obtenir de meilleures performances, l'utilisation de tables dérivées ou des sous-requêtes.

J'ai testé cette requête, et ça marche, comme les deux autres réponses. Auriez-vous l'esprit en ajoutant comment vous pouvez les gérer 2 commandes, avec exactement le même temps de la saisie?
Intéressant. Ne serait-ce pas obtenir de façon exponentielle plus pour chaque commande supplémentaire d'un client que la base de données devra joindre à chaque commande, pour toute autre commande?

OriginalL'auteur Tom H

Cette requête est beaucoup plus rapide que l'on a accepté la réponse :

SELECT c.id as customer_id, 
    (SELECT co.id FROM customer_order co WHERE 
    co.customer_id=c.id 
    ORDER BY some_date_column DESC limit 1) as last_order_id
    FROM customer c

OriginalL'auteur Saad Achemlal

Vous devez vous connecter pour publier un commentaire.