MySQL JOIN uniquement sur la ligne la plus récente?

J'ai une table client qui stocke un customer_id, un e-mail et une référence. Il existe une table supplémentaire customer_data qui stocke un enregistrement historique des modifications apportées au client, c'est-à-dire qu'une nouvelle ligne est insérée en cas de modification.

Afin d'afficher les informations client dans une table, les deux tables doivent être jointes, mais seule la ligne la plus récente de customer_data doit être jointe à la table customer.

Cela devient un peu plus compliqué dans la mesure où la requête est paginée, donc a une limite et un décalage.

Comment puis-je faire cela avec MySQL? Je pense que je veux mettre un DISTINCT là-dedans quelque part ...

La requête à la minute est comme ça-

SELECT *, CONCAT(title,' ',forename,' ',surname) AS name
FROM customer c
INNER JOIN customer_data d on c.customer_id=d.customer_id
WHERE name LIKE '%Smith%' LIMIT 10, 20

De plus, ai-je raison de penser que je peux utiliser CONCAT avec LIKE de cette manière?

(J'apprécie qu'INNER JOIN puisse être le mauvais type de JOIN à utiliser. Je n'ai en fait aucune idée de la différence entre les différents JOIN. Je vais examiner cela maintenant!)

Vous pouvez essayer ce qui suit:

SELECT    CONCAT(title, ' ', forename, ' ', surname) AS name
FROM      customer c
JOIN      (
              SELECT    MAX(id) max_id, customer_id 
              FROM      customer_data 
              GROUP BY  customer_id
          ) c_max ON (c_max.customer_id = c.customer_id)
JOIN      customer_data cd ON (cd.id = c_max.max_id)
WHERE     CONCAT(title, ' ', forename, ' ', surname) LIKE '%Smith%' 
LIMIT     10, 20;

Notez que a JOINn'est qu'un synonyme de INNER JOIN.

Cas de test:

CREATE TABLE customer (customer_id int);
CREATE TABLE customer_data (
   id int, 
   customer_id int, 
   title varchar(10),
   forename varchar(10),
   surname varchar(10)
);

INSERT INTO customer VALUES (1);
INSERT INTO customer VALUES (2);
INSERT INTO customer VALUES (3);

INSERT INTO customer_data VALUES (1, 1, 'Mr', 'Bobby', 'Smith');
INSERT INTO customer_data VALUES (2, 1, 'Mr', 'Bob', 'Smith');
INSERT INTO customer_data VALUES (3, 2, 'Mr', 'Jane', 'Green');
INSERT INTO customer_data VALUES (4, 2, 'Miss', 'Jane', 'Green');
INSERT INTO customer_data VALUES (5, 3, 'Dr', 'Jack', 'Black');

Résultat (requête sans LIMITet WHERE):

SELECT    CONCAT(title, ' ', forename, ' ', surname) AS name
FROM      customer c
JOIN      (
              SELECT    MAX(id) max_id, customer_id 
              FROM      customer_data 
              GROUP BY  customer_id
          ) c_max ON (c_max.customer_id = c.customer_id)
JOIN      customer_data cd ON (cd.id = c_max.max_id);

+-----------------+
| name            |
+-----------------+
| Mr Bob Smith    |
| Miss Jane Green |
| Dr Jack Black   |
+-----------------+
3 rows in set (0.00 sec)

Si vous travaillez avec des requêtes lourdes, il vaut mieux déplacer la demande de la dernière ligne dans la clause where. C'est beaucoup plus rapide et semble plus propre.

SELECT c.*,
FROM client AS c
LEFT JOIN client_calling_history AS cch ON cch.client_id = c.client_id
WHERE
   cch.cchid = (
      SELECT MAX(cchid)
      FROM client_calling_history
      WHERE client_id = c.client_id AND cal_event_id = c.cal_event_id
   )

En supposant que la colonne d'auto-incrémentation customer_dataest nommée Id, vous pouvez faire:

SELECT CONCAT(title,' ',forename,' ',surname) AS name *
FROM customer c
    INNER JOIN customer_data d 
        ON c.customer_id=d.customer_id
WHERE name LIKE '%Smith%'
    AND d.ID = (
                Select Max(D2.Id)
                From customer_data As D2
                Where D2.customer_id = D.customer_id
                )
LIMIT 10, 20

Pour toute personne qui doit travailler avec une ancienne version de MySQL (pré-5.0 ish), vous ne pouvez pas faire de sous-requêtes pour ce type de requête. Voici la solution que j'ai pu faire et cela a semblé très bien fonctionner.

SELECT MAX(d.id), d2.*, CONCAT(title,' ',forename,' ',surname) AS name
FROM customer AS c 
LEFT JOIN customer_data as d ON c.customer_id=d.customer_id 
LEFT JOIN customer_data as d2 ON d.id=d2.id
WHERE CONCAT(title, ' ', forename, ' ', surname) LIKE '%Smith%'
GROUP BY c.customer_id LIMIT 10, 20;

Il s'agit essentiellement de trouver l'ID maximum de votre table de données en le joignant au client, puis de joindre la table de données à l'ID maximum trouvé. La raison en est que la sélection du maximum d'un groupe ne garantit pas que le reste des données correspond à l'ID, sauf si vous le rejoignez sur lui-même.

Je n'ai pas testé cela sur les versions plus récentes de MySQL mais cela fonctionne sur 4.0.30.

Je sais que cette question est ancienne, mais elle a retenu beaucoup d'attention au fil des ans et je pense qu'il manque un concept qui pourrait aider quelqu'un dans un cas similaire. Je l'ajoute ici par souci d'exhaustivité.

Si vous ne pouvez pas modifier votre schéma de base de données d'origine, de nombreuses bonnes réponses ont été fournies et résolvent très bien le problème.

Si vous pouvez cependant modifier votre schéma, je vous conseillerais d'ajouter un champ dans votre customertable qui contient idle dernier customer_dataenregistrement de ce client:

CREATE TABLE customer (
  id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
  current_data_id INT UNSIGNED NULL DEFAULT NULL
);

CREATE TABLE customer_data (
   id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
   customer_id INT UNSIGNED NOT NULL, 
   title VARCHAR(10) NOT NULL,
   forename VARCHAR(10) NOT NULL,
   surname VARCHAR(10) NOT NULL
);

Interroger les clients

L'interrogation est aussi simple et rapide que possible:

SELECT c.*, d.title, d.forename, d.surname
FROM customer c
INNER JOIN customer_data d on d.id = c.current_data_id
WHERE ...;

L'inconvénient est la complexité supplémentaire lors de la création ou de la mise à jour d'un client.

Mettre à jour un client

Chaque fois que vous souhaitez mettre à jour un client, vous insérez un nouvel enregistrement dans la customer_datatable et mettez à jour l' customerenregistrement.

INSERT INTO customer_data (customer_id, title, forename, surname) VALUES(2, 'Mr', 'John', 'Smith');
UPDATE customer SET current_data_id = LAST_INSERT_ID() WHERE id = 2;

Créer un client

Créer un client consiste simplement à insérer l' customerentrée, puis à exécuter les mêmes instructions:

INSERT INTO customer () VALUES ();

SET @customer_id = LAST_INSERT_ID();
INSERT INTO customer_data (customer_id, title, forename, surname) VALUES(@customer_id, 'Mr', 'John', 'Smith');
UPDATE customer SET current_data_id = LAST_INSERT_ID() WHERE id = @customer_id;

Emballer

La complexité supplémentaire pour créer / mettre à jour un client peut être redoutable, mais elle peut facilement être automatisée avec des déclencheurs.

Enfin, si vous utilisez un ORM, cela peut être très facile à gérer. L'ORM peut se charger d'insérer les valeurs, de mettre à jour les identifiants et de joindre automatiquement les deux tables pour vous.

Voici à quoi Customerressemblerait votre modèle mutable :

class Customer
{
    private int id;
    private CustomerData currentData;

    public Customer(String title, String forename, String surname)
    {
        this.update(title, forename, surname);
    }

    public void update(String title, String forename, String surname)
    {
        this.currentData = new CustomerData(this, title, forename, surname);
    }

    public String getTitle()
    {
        return this.currentData.getTitle();
    }

    public String getForename()
    {
        return this.currentData.getForename();
    }

    public String getSurname()
    {
        return this.currentData.getSurname();
    }
}

Et votre CustomerDatamodèle immuable , qui ne contient que des getters:

class CustomerData
{
    private int id;
    private Customer customer;
    private String title;
    private String forename;
    private String surname;

    public CustomerData(Customer customer, String title, String forename, String surname)
    {
        this.customer = customer;
        this.title    = title;
        this.forename = forename;
        this.surname  = surname;
    }

    public String getTitle()
    {
        return this.title;
    }

    public String getForename()
    {
        return this.forename;
    }

    public String getSurname()
    {
        return this.surname;
    }
}

SELECT CONCAT(title,' ',forename,' ',surname) AS name * FROM customer c 
INNER JOIN customer_data d on c.id=d.customer_id WHERE name LIKE '%Smith%' 

je pense que vous devez changer c.customer_id en c.id

else mettre à jour la structure de la table

Vous pouvez également le faire

SELECT    CONCAT(title, ' ', forename, ' ', surname) AS name
FROM      customer c
LEFT JOIN  (
              SELECT * FROM  customer_data ORDER BY id DESC
          ) customer_data ON (customer_data.customer_id = c.customer_id)
GROUP BY  c.customer_id          
WHERE     CONCAT(title, ' ', forename, ' ', surname) LIKE '%Smith%' 
LIMIT     10, 20;

C'est une bonne idée de consigner les données réelles dans la table " customer_data ". Avec ces données, vous pouvez sélectionner toutes les données de la table "customer_data" comme vous le souhaitez.