MySQL JOIN solo en la fila más reciente?

Tengo un cliente de mesa que almacena un customer_id, un correo electrónico y una referencia. Hay una tabla adicional customer_data que almacena un registro histórico de los cambios realizados al cliente, es decir, cuando se realiza un cambio, se inserta una nueva fila.

Para mostrar la información del cliente en una tabla, las dos tablas deben unirse; sin embargo, solo la fila más reciente de customer_data debe unirse a la tabla de clientes.

Se vuelve un poco más complicado porque la consulta está paginada, por lo que tiene un límite y un desplazamiento.

¿Cómo puedo hacer esto con MySQL? Creo que quiero poner un DISTINCT en alguna parte ...

La consulta al minuto es así-

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

Además, ¿tengo razón al pensar que puedo usar CONCAT con LIKE de esta manera?

(Aprecio que INNER JOIN podría ser el tipo incorrecto de JOIN para usar. De hecho, no tengo ni idea de cuál es la diferencia entre los diferentes JOIN. ¡Voy a investigar eso ahora!)

Es posible que desee probar lo siguiente:

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;

Tenga en cuenta que a JOINes solo un sinónimo de INNER JOIN.

Caso de prueba:

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');

Resultado (consulta sin LIMITy 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 está trabajando con consultas pesadas, es mejor que mueva la solicitud a la última fila en la cláusula where. Es mucho más rápido y se ve más limpio.

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
   )

Suponiendo que la columna de incremento automático en customer_datase llama Id, que puede hacer:

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

Para cualquier persona que deba trabajar con una versión anterior de MySQL (anterior a 5.0 ish), no puede realizar subconsultas para este tipo de consulta. Aquí está la solución que pude hacer y pareció funcionar muy bien.

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;

Básicamente, se trata de encontrar la identificación máxima de su tabla de datos uniéndola al cliente y luego uniendo la tabla de datos a la identificación máxima encontrada. La razón de esto es porque seleccionar el máximo de un grupo no garantiza que el resto de los datos coincida con la identificación a menos que lo vuelva a unir a sí mismo.

No lo he probado en versiones más recientes de MySQL pero funciona en 4.0.30.

Sé que esta pregunta es antigua, pero ha recibido mucha atención a lo largo de los años y creo que le falta un concepto que pueda ayudar a alguien en un caso similar. Lo agrego aquí en aras de la integridad.

Si no puede modificar el esquema de su base de datos original, entonces se han proporcionado muchas buenas respuestas y resuelve el problema sin problemas.

Sin embargo, si puede modificar su esquema, le aconsejo que agregue un campo en su customertabla que contenga idel último customer_dataregistro de este cliente:

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
);

Consultar clientes

La consulta es tan fácil y rápida como puede ser:

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

El inconveniente es la complejidad adicional al crear o actualizar un cliente.

Actualización de un cliente

Siempre que desee actualizar un cliente, inserte un nuevo registro en la customer_datatabla y actualice el customerregistro.

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;

Creando un cliente

Crear un cliente es solo una cuestión de insertar la customerentrada y luego ejecutar las mismas declaraciones:

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;

Terminando

La complejidad adicional para crear / actualizar un cliente puede ser temible, pero se puede automatizar fácilmente con activadores.

Finalmente, si está usando un ORM, esto puede ser muy fácil de administrar. El ORM puede encargarse de insertar los valores, actualizar los identificadores y unir las dos tablas automáticamente por usted.

Así es como Customerse vería su modelo 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();
    }
}

Y su CustomerDatamodelo inmutable , que solo contiene captadores:

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%' 

Creo que necesitas cambiar c.customer_id a c.id

else actualizar la estructura de la tabla

También puedes hacer esto

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;

Es una buena idea registrar los datos reales en la tabla " customer_data ". Con estos datos puede seleccionar todos los datos de la tabla "customer_data" como desee.