¿Cómo puedo SELECCIONAR filas con MAX (valor de columna), DISTINCT por otra columna en SQL?

Mi mesa es:

id  home  datetime     player   resource
---|-----|------------|--------|---------
1  | 10  | 04/03/2009 | john   | 399 
2  | 11  | 04/03/2009 | juliet | 244
5  | 12  | 04/03/2009 | borat  | 555
3  | 10  | 03/03/2009 | john   | 300
4  | 11  | 03/03/2009 | juliet | 200
6  | 12  | 03/03/2009 | borat  | 500
7  | 13  | 24/12/2008 | borat  | 600
8  | 13  | 01/01/2009 | borat  | 700

Necesito seleccionar cada uno distinto home sosteniendo el valor máximo de datetime.

El resultado sería:

id  home  datetime     player   resource 
---|-----|------------|--------|---------
1  | 10  | 04/03/2009 | john   | 399
2  | 11  | 04/03/2009 | juliet | 244
5  | 12  | 04/03/2009 | borat  | 555
8  | 13  | 01/01/2009 | borat  | 700

Yo he tratado:

-- 1 ..by the MySQL manual: 

SELECT DISTINCT
  home,
  id,
  datetime AS dt,
  player,
  resource
FROM topten t1
WHERE datetime = (SELECT
  MAX(t2.datetime)
FROM topten t2
GROUP BY home)
GROUP BY datetime
ORDER BY datetime DESC

No funciona. El conjunto de resultados tiene 130 filas, aunque la base de datos contiene 187. El resultado incluye algunos duplicados de home.

-- 2 ..join

SELECT
  s1.id,
  s1.home,
  s1.datetime,
  s1.player,
  s1.resource
FROM topten s1
JOIN (SELECT
  id,
  MAX(datetime) AS dt
FROM topten
GROUP BY id) AS s2
  ON s1.id = s2.id
ORDER BY datetime 

No. Da todos los récords.

-- 3 ..something exotic: 

Con varios resultados.

preguntado el 04 de marzo de 09 a las 18:03

19 Respuestas

¡Estás muy cerca! Todo lo que necesita hacer es seleccionar AMBOS la casa y su fecha de hora máxima, luego unirse de nuevo a la topten tabla en AMBOS campos:

SELECT tt.*
FROM topten tt
INNER JOIN
    (SELECT home, MAX(datetime) AS MaxDateTime
    FROM topten
    GROUP BY home) groupedtt 
ON tt.home = groupedtt.home 
AND tt.datetime = groupedtt.MaxDateTime

Respondido 14 Feb 18, 12:02

Pruébelo para que sea distinto, si dos fechas máximas iguales están en la misma casa (con diferentes jugadores): Maksim Gontar

Creo que la forma clásica de hacer esto es con una combinación natural: "SELECT tt. * FROM topten tt NATURAL JOIN (SELECT home, MAX (datetime) AS datetime FROM topten GROUP BY home) mostrecent;" La misma consulta exactamente, pero posiblemente más legible: Parker

¿Qué pasa si hay dos filas que tienen los mismos valores de campo 'inicio' y 'fecha y hora'? - Kemal Durán

@Joven, el problema con tu consulta es que puede volver id, player y resource de fila no máxima para un hogar determinado, es decir, para el hogar = 10, puede obtener: 3 | 10 | 04/03/2009 | john | 300 En otras palabras, no garantiza que todas las columnas de una fila en el conjunto de resultados pertenezcan a max (fecha y hora) para una casa determinada. - sacrificar

Con respecto al comentario de @KemalDuran anterior, si hay dos filas con los mismos campos de inicio y fecha y hora, lo que debe hacer es tomar la solución de Michael La Voie y agregar MAX(id) AS MaxID al interior SELECT declaración y luego ir y agregar otra línea AND tt.id = groupedtt.MaxID al final. - cardamomo

El más rápido MySQL solución, sin consultas internas y sin GROUP BY:

SELECT m.*                    -- get the row that contains the max value
FROM topten m                 -- "m" from "max"
    LEFT JOIN topten b        -- "b" from "bigger"
        ON m.home = b.home    -- match "max" row with "bigger" row by `home`
        AND m.datetime < b.datetime           -- want "bigger" than "max"
WHERE b.datetime IS NULL      -- keep only if there is no bigger than max

Explicación:

Únase a la mesa consigo mismo usando el home columna. El uso de LEFT JOIN asegura todas las filas de la tabla m aparecen en el conjunto de resultados. Aquellos que no tienen una coincidencia en la mesa. b tendrá NULLs para las columnas de b.

La otra condición en el JOIN pide hacer coincidir solo las filas de b que tienen mayor valor en el datetime columna que la fila de m.

Usando los datos publicados en la pregunta, el LEFT JOIN producirá estos pares:

+------------------------------------------+--------------------------------+
|              the row from `m`            |    the matching row from `b`   |
|------------------------------------------|--------------------------------|
| id  home  datetime     player   resource | id    home   datetime      ... |
|----|-----|------------|--------|---------|------|------|------------|-----|
| 1  | 10  | 04/03/2009 | john   | 399     | NULL | NULL | NULL       | ... | *
| 2  | 11  | 04/03/2009 | juliet | 244     | NULL | NULL | NULL       | ... | *
| 5  | 12  | 04/03/2009 | borat  | 555     | NULL | NULL | NULL       | ... | *
| 3  | 10  | 03/03/2009 | john   | 300     | 1    | 10   | 04/03/2009 | ... |
| 4  | 11  | 03/03/2009 | juliet | 200     | 2    | 11   | 04/03/2009 | ... |
| 6  | 12  | 03/03/2009 | borat  | 500     | 5    | 12   | 04/03/2009 | ... |
| 7  | 13  | 24/12/2008 | borat  | 600     | 8    | 13   | 01/01/2009 | ... |
| 8  | 13  | 01/01/2009 | borat  | 700     | NULL | NULL | NULL       | ... | *
+------------------------------------------+--------------------------------+

Finalmente, la WHERE la cláusula mantiene solo los pares que tienen NULLs en las columnas de b (están marcados con * en la tabla de arriba); esto significa, debido a la segunda condición de la JOIN cláusula, la fila seleccionada de m tiene el mayor valor en la columna datetime.

Lea la Antipatrones SQL: evitar los errores de la programación de bases de datos libro para otros consejos de SQL.

respondido 09 mar '18, 16:03

Con SQLite, el primero es mucho más lento que la versión de La Voie cuando no hay un índice en la columna coincidente (es decir, "inicio"). (Probado con 24k filas resultando en 13k filas) - Tomas Tempelmann

Esta es la mejor respuesta, si muestra el plan de ejecución verá un paso menos con esta consulta - TlmaK0

¿Qué pasará si 2 filas tienen el mismo home y datetime y datetime es el máximo para ese home ? - istiaque ahmed

Ambas filas aparecen en el conjunto de resultados. Esta respuesta es una prueba de concepto. En tu código real probablemente tengas otro criterio para seleccionar solo uno de ellos en esta situación (quizás el primero o el último o usas otra columna para decidir). Simplemente agregue este criterio como una nueva condición en el ON cláusula. Fe ... ON ... AND m.id < b.id para mantener la entrada más reciente (la que tiene la mayor id) cuando dos filas tienen los mismos valores en home y datetime columnas y es el máximo datetime. - axiaco

Esta idea funciona para mí y me ayuda a simplificar mi subconsulta. Mickey

Aquí va T-SQL Versión:

-- Test data
DECLARE @TestTable TABLE (id INT, home INT, date DATETIME, 
  player VARCHAR(20), resource INT)
INSERT INTO @TestTable
SELECT 1, 10, '2009-03-04', 'john', 399 UNION
SELECT 2, 11, '2009-03-04', 'juliet', 244 UNION
SELECT 5, 12, '2009-03-04', 'borat', 555 UNION
SELECT 3, 10, '2009-03-03', 'john', 300 UNION
SELECT 4, 11, '2009-03-03', 'juliet', 200 UNION
SELECT 6, 12, '2009-03-03', 'borat', 500 UNION
SELECT 7, 13, '2008-12-24', 'borat', 600 UNION
SELECT 8, 13, '2009-01-01', 'borat', 700

-- Answer
SELECT id, home, date, player, resource 
FROM (SELECT id, home, date, player, resource, 
    RANK() OVER (PARTITION BY home ORDER BY date DESC) N
    FROM @TestTable
)M WHERE N = 1

-- and if you really want only home with max date
SELECT T.id, T.home, T.date, T.player, T.resource 
    FROM @TestTable T
INNER JOIN 
(   SELECT TI.id, TI.home, TI.date, 
        RANK() OVER (PARTITION BY TI.home ORDER BY TI.date) N
    FROM @TestTable TI
    WHERE TI.date IN (SELECT MAX(TM.date) FROM @TestTable TM)
)TJ ON TJ.N = 1 AND T.id = TJ.id

EDITAR
Desafortunadamente, no hay ninguna función RANK () OVER en MySQL.
Pero se puede emular, mira Emulando funciones analíticas (AKA Ranking) con MySQL.
Entonces esto es MySQL Versión:

SELECT id, home, date, player, resource 
FROM TestTable AS t1 
WHERE 
    (SELECT COUNT(*) 
            FROM TestTable AS t2 
            WHERE t2.home = t1.home AND t2.date > t1.date
    ) = 0

respondido 06 mar '09, 17:03

lo siento amigo, # 1064 - Tiene un error en su sintaxis SQL; Consulte el manual que corresponde a la versión de su servidor MySQL para conocer la sintaxis correcta para usar cerca de '() OVER (PARTICIÓN POR krd ORDEN POR DESC diurno) N DE @rapsa) M DONDE N =' en la línea 1 - Kaptah

ah, entonces estás usando MySQL. ¡Eso es por lo que deberías empezar! Actualizaré la respuesta pronto. - Maksim Gontar

@MaxGontar, su solución mysql es genial, gracias. ¿Qué pasa si en su @_TestTable elimina la fila # 1>: SELECT 1, 10, '2009-03-04', 'john', 399, esto es, qué sucede si tiene una sola fila para un valor de vivienda determinado? gracias. - egidiocos

ERROR: Reemplaza "RANK ()" con "ROW_NUMBER ()". Si tiene un empate (causado por un valor de fecha duplicado), tendrá dos registros con "1" para N. - miketevee

Esto funcionará incluso si tiene dos o más filas para cada home con igual DATETIME's:

SELECT id, home, datetime, player, resource
FROM   (
       SELECT (
              SELECT  id
              FROM    topten ti
              WHERE   ti.home = t1.home
              ORDER BY
                      ti.datetime DESC
              LIMIT 1
              ) lid
       FROM   (
              SELECT  DISTINCT home
              FROM    topten
              ) t1
       ) ro, topten t2
WHERE  t2.id = ro.lid

respondido 06 mar '09, 20:03

campo de tapa agregado en la tabla, No es bueno - Kaptah

Este no se ejecutó en PHPMyAdmin. La página se actualiza pero no hay resultado ni error ..? - Kaptah

WHERE ti.home = t1.home - ¿Puedes explicar la sintaxis? - istiaque ahmed

@IstiaqueAhmed: ¿qué es exactamente lo que no entiendes aquí? Es una consulta correlacionada y la expresión que menciona es una condición de correlación. - quassnoi

@Quassnoi, El select consulta que tiene la línea WHERE ti.home = t1.home no necesita el FROM cláusula que define t1. Entonces, ¿cómo se usa? - istiaque ahmed

Creo que esto te dará el resultado deseado:

SELECT   home, MAX(datetime)
FROM     my_table
GROUP BY home

PERO si también necesita otras columnas, simplemente haga una combinación con la tabla original (marque Michael La Voie respuesta)

Saludos cordiales.

respondido 26 nov., 15:12

También necesita otras columnas. - quassnoi

id, inicio, fecha y hora, jugador, recurso - quassnoi

Dado que la gente parece seguir encontrándose con este hilo (la fecha de los comentarios varía de 1.5 años), no es mucho más simple:

SELECT * FROM (SELECT * FROM topten ORDER BY datetime DESC) tmp GROUP BY home

No se necesitan funciones de agregación ...

Saludos.

Respondido el 05 de diciembre de 10 a las 17:12

Esto no parece funcionar. Mensaje de error: la columna 'x' no es válida en la lista de selección porque no está incluida en una función agregada ni en la cláusula GROUP BY. - Ave

Esto definitivamente no funcionará en SQL Server u Oracle, aunque parece que podría funcionar en MySQL. - ErikE

¡Esto es realmente hermoso! ¿Como funciona esto? ¿Usando DESC y la columna de retorno de grupo predeterminada? Entonces, si lo cambié a ASC de fecha y hora, ¿devolvería la fila más temprana para cada hogar? - camino del futuro

¡Esto es brillante! - Amante de los perros

Esto directamente no funciona si tiene columnas no agregadas (en MySQL). - Steve

También puede probar este y, para tablas grandes, el rendimiento de las consultas será mejor. Funciona cuando no hay más de dos registros para cada hogar y sus fechas son diferentes. Una mejor consulta general de MySQL es una de Michael La Voie arriba.

SELECT t1.id, t1.home, t1.date, t1.player, t1.resource
FROM   t_scores_1 t1 
INNER JOIN t_scores_1 t2
   ON t1.home = t2.home
WHERE t1.date > t2.date

O en el caso de Postgres o esas bases de datos que proporcionan funciones analíticas intente

SELECT t.* FROM 
(SELECT t1.id, t1.home, t1.date, t1.player, t1.resource
  , row_number() over (partition by t1.home order by t1.date desc) rw
 FROM   topten t1 
 INNER JOIN topten t2
   ON t1.home = t2.home
 WHERE t1.date > t2.date 
) t
WHERE t.rw = 1

Respondido 16 Jul 14, 21:07

¿Esta respuesta es correcta? Intenté usarlo, pero parece que no selecciona el registro con la fecha más reciente para 'casa', sino que solo elimina el registro con la fecha más antigua. He aquí un ejemplo: violín SQL - marcin93w

@kidOfDeath - Actualicé mi respuesta con contexto y consulta de Postgres - Shiva

Con SQLite, el primero es mucho más lento que la versión de La Voie cuando no hay un índice en la columna coincidente (es decir, "inicio"). - Tomas Tempelmann

SELECT  tt.*
FROM    TestTable tt 
INNER JOIN 
        (
        SELECT  coord, MAX(datetime) AS MaxDateTime 
        FROM    rapsa 
        GROUP BY
                krd 
        ) groupedtt
ON      tt.coord = groupedtt.coord
        AND tt.datetime = groupedtt.MaxDateTime

respondido 06 mar '09, 20:03

Esto funciona en Oracle:

with table_max as(
  select id
       , home
       , datetime
       , player
       , resource
       , max(home) over (partition by home) maxhome
    from table  
)
select id
     , home
     , datetime
     , player
     , resource
  from table_max
 where home = maxhome

respondido 05 mar '09, 23:03

¿Cómo elige esto la fecha y hora máxima? pidió agrupar por casa y seleccionar fecha y hora máxima. No veo cómo esto hace eso. - n00b

Pruebe esto para SQL Server:

WITH cte AS (
   SELECT home, MAX(year) AS year FROM Table1 GROUP BY home
)
SELECT * FROM Table1 a INNER JOIN cte ON a.home = cte.home AND a.year = cte.year

Respondido el 17 de enero de 14 a las 12:01

SELECT c1, c2, c3, c4, c5 FROM table1 WHERE c3 = (select max(c3) from table)

SELECT * FROM table1 WHERE c3 = (select max(c3) from table1)

respondido 01 mar '13, 18:03

Aquí está la versión de MySQL que imprime solo una entrada donde hay duplicados MAX (fecha y hora) en un grupo.

Podrías probar aquí http://www.sqlfiddle.com/#!2/0a4ae/1

Data de muestra

mysql> SELECT * from topten;
+------+------+---------------------+--------+----------+
| id   | home | datetime            | player | resource |
+------+------+---------------------+--------+----------+
|    1 |   10 | 2009-04-03 00:00:00 | john   |      399 |
|    2 |   11 | 2009-04-03 00:00:00 | juliet |      244 |
|    3 |   10 | 2009-03-03 00:00:00 | john   |      300 |
|    4 |   11 | 2009-03-03 00:00:00 | juliet |      200 |
|    5 |   12 | 2009-04-03 00:00:00 | borat  |      555 |
|    6 |   12 | 2009-03-03 00:00:00 | borat  |      500 |
|    7 |   13 | 2008-12-24 00:00:00 | borat  |      600 |
|    8 |   13 | 2009-01-01 00:00:00 | borat  |      700 |
|    9 |   10 | 2009-04-03 00:00:00 | borat  |      700 |
|   10 |   11 | 2009-04-03 00:00:00 | borat  |      700 |
|   12 |   12 | 2009-04-03 00:00:00 | borat  |      700 |
+------+------+---------------------+--------+----------+

Versión de MySQL con variable de usuario

SELECT *
FROM (
    SELECT ord.*,
        IF (@prev_home = ord.home, 0, 1) AS is_first_appear,
        @prev_home := ord.home
    FROM (
        SELECT t1.id, t1.home, t1.player, t1.resource
        FROM topten t1
        INNER JOIN (
            SELECT home, MAX(datetime) AS mx_dt
            FROM topten
            GROUP BY home
          ) x ON t1.home = x.home AND t1.datetime = x.mx_dt
        ORDER BY home
    ) ord, (SELECT @prev_home := 0, @seq := 0) init
) y
WHERE is_first_appear = 1;
+------+------+--------+----------+-----------------+------------------------+
| id   | home | player | resource | is_first_appear | @prev_home := ord.home |
+------+------+--------+----------+-----------------+------------------------+
|    9 |   10 | borat  |      700 |               1 |                     10 |
|   10 |   11 | borat  |      700 |               1 |                     11 |
|   12 |   12 | borat  |      700 |               1 |                     12 |
|    8 |   13 | borat  |      700 |               1 |                     13 |
+------+------+--------+----------+-----------------+------------------------+
4 rows in set (0.00 sec)

Salida de respuestas aceptadas

SELECT tt.*
FROM topten tt
INNER JOIN
    (
    SELECT home, MAX(datetime) AS MaxDateTime
    FROM topten
    GROUP BY home
) groupedtt ON tt.home = groupedtt.home AND tt.datetime = groupedtt.MaxDateTime
+------+------+---------------------+--------+----------+
| id   | home | datetime            | player | resource |
+------+------+---------------------+--------+----------+
|    1 |   10 | 2009-04-03 00:00:00 | john   |      399 |
|    2 |   11 | 2009-04-03 00:00:00 | juliet |      244 |
|    5 |   12 | 2009-04-03 00:00:00 | borat  |      555 |
|    8 |   13 | 2009-01-01 00:00:00 | borat  |      700 |
|    9 |   10 | 2009-04-03 00:00:00 | borat  |      700 |
|   10 |   11 | 2009-04-03 00:00:00 | borat  |      700 |
|   12 |   12 | 2009-04-03 00:00:00 | borat  |      700 |
+------+------+---------------------+--------+----------+
7 rows in set (0.00 sec)

Respondido 01 Feb 14, 09:02

Aunque me encanta esta respuesta, ya que me está ayudando mucho, tengo que señalar una falla importante, que depende del sistema mysql usado. Básicamente, esta solución se basa en la cláusula ORDER BY en la subselección. Esto PODRÍA, o NO PODRÍA funcionar en varios entornos mysql. No lo he probado en MySQL puro, pero seguro que esto no funciona FIABLE en MariaDB 10.1, como se explica aquí stackoverflow.com/questions/26372511/… pero el mismo código funciona bien en Percona Server. Para ser precisos, PODRÍA o NO PODRÍA obtener los mismos resultados, dependiendo de la cantidad de columnas t1. - Radek

El ejemplo de esta declaración es que en MariaDB 10.1 funcionó, cuando usé 5 columnas de la tabla t1. Tan pronto como agregué la sexta columna, obviamente jugando con la clasificación de datos "natural" en la tabla original, dejó de funcionar. La razón es que los datos en la subselección se desordenaron y, por lo tanto, tuve la condición "is_first_appear = 1" cumplida varias veces. El mismo código, con los mismos datos, funcionó bien en Percona. - Radek

Otra forma de obtener la fila más reciente por grupo usando una subconsulta que básicamente calcula un rango para cada fila por grupo y luego filtra las filas más recientes como con rank = 1

select a.*
from topten a
where (
  select count(*)
  from topten b
  where a.home = b.home
  and a.`datetime` < b.`datetime`
) +1 = 1

DEMO

Aquí está la demostración visual para clasificar no para cada fila para una mejor comprensión

Leyendo algunos comentarios ¿Qué pasa si hay dos filas que tienen los mismos valores de campo 'inicio' y 'fecha y hora'?

La consulta anterior fallará y devolverá más de 1 filas para la situación anterior. Para encubrir esta situación, será necesario otro criterio / parámetro / columna para decidir qué fila debe tomarse y cuál se encuentra en la situación anterior. Al ver el conjunto de datos de muestra, supongo que hay una columna de clave principal id que debe establecerse en incremento automático. Entonces podemos usar esta columna para elegir la fila más reciente ajustando la misma consulta con la ayuda de CASE declaración como

select a.*
from topten a
where (
  select count(*)
  from topten b
  where a.home = b.home
  and  case 
       when a.`datetime` = b.`datetime`
       then a.id < b.id
       else a.`datetime` < b.`datetime`
       end
) + 1 = 1

DEMO

La consulta anterior seleccionará la fila con la identificación más alta entre las mismas datetime valores

demostración visual para rango no para cada fila

respondido 05 nov., 17:13

¿Por qué no usar: SELECT home, MAX (datetime) AS MaxDateTime, player, resource FROM topten GROUP BY home ¿Me perdí algo?

Respondido 03 Oct 15, 11:10

Eso solo sería válido con MySQL, y solo las versiones anteriores a 5.7 (?) O posteriores a 5.7 con ONLY_FULL_GROUP_BY deshabilitado, ya que selecciona columnas que no se han agregado / GROUPed (reproductor, recurso), lo que significa que MySQL proporcionará valores elegidos aleatoriamente para aquellos dos campos de resultado. No sería un problema para la columna del jugador, ya que se correlaciona con la columna de inicio, pero la columna de recursos no se correlacionaría con la columna de inicio o de fecha y hora y no podría garantizar qué valor de recurso recibiría. - usuario simple

+1 para la explicación, PERO con la pregunta formulada, esta consulta no devolverá el expected salida en MySQL versión 5.6 y before y dudo mucho que se comporte de otra manera en MySQL versión 5.7 y after. - sacrificar

@simpleuser, `No sería un problema para la columna del jugador, ya que se correlaciona con la columna de inicio`. ¿Puede explicar más? - istiaque ahmed

@IstiaqueAhmed cuando lo miro de nuevo, esa declaración es incorrecta. Pensé que cada jugador siempre tenía el mismo valor de la vivienda, pero ahora veo que no es así, por lo que también ocurrirá el mismo problema de selección aleatoria para esa columna: usuario simple

@Michae La respuesta aceptada funcionará bien en la mayoría de los casos, pero falla en una como se muestra a continuación.

En caso de que hubiera 2 filas con HomeID y Datetime igual, la consulta devolverá ambas filas, no distintas HomeID como se requiere, para eso agregue Distinct en la consulta como se muestra a continuación.

SELECT DISTINCT tt.home  , tt.MaxDateTime
FROM topten tt
INNER JOIN
    (SELECT home, MAX(datetime) AS MaxDateTime
    FROM topten
    GROUP BY home) groupedtt 
ON tt.home = groupedtt.home 
AND tt.datetime = groupedtt.MaxDateTime

contestado el 08 de mayo de 17 a las 08:05

el resultado muestra - "# 1054 - Columna desconocida 'tt.MaxDateTime' en 'lista de campos'" - istiaque ahmed

@IstiaqueAhmed, ¿tiene MaxDatetime archivado, es decir, algún nombre de columna como ese ...? - manoj kargeti

No, la tabla en OP no tiene tal columna. - istiaque ahmed

el error también dice lo mismo por favor ... ¿qué es exactamente lo que quieres hacer? u puede enviar la estructura de la tabla y su consulta. - manoj kargeti

Prueba esta

select * from mytable a join
(select home, max(datetime) datetime
from mytable
group by home) b
 on a.home = b.home and a.datetime = b.datetime

Saludos K

respondido 04 mar '09, 20:03

Pruébelo para que sea distinto, si dos fechas máximas iguales están en la misma casa (con diferentes jugadores): Maksim Gontar

el alias de max(datetime) is datetime. ¿No supondrá ningún problema? - istiaque ahmed

Como es el mas alto datetime seleccionado? - istiaque ahmed

esta es la consulta que necesita:

 SELECT b.id, a.home,b.[datetime],b.player,a.resource FROM
 (SELECT home,MAX(resource) AS resource FROM tbl_1 GROUP BY home) AS a

 LEFT JOIN

 (SELECT id,home,[datetime],player,resource FROM tbl_1) AS b
 ON  a.resource = b.resource WHERE a.home =b.home;

Respondido 14 Jul 16, 08:07

¿puedes explicar tu respuesta? - istiaque ahmed

Espero que la siguiente consulta dé el resultado deseado:

Select id, home,datetime,player,resource, row_number() over (Partition by home ORDER by datetime desc) as rownum from tablename where rownum=1

Respondido el 14 de enero de 20 a las 17:01

(NOTA: La respuesta de Michael es perfecta para una situación en la que la columna de destino datetime no puede tener valores duplicados para cada uno de los home.)

Si tu mesa tiene filas duplicadas para homexdatetime y solo necesita seleccionar una fila para cada home visión de conjunto, aquí está mi solución:

Tu tabla necesita una columna única (como id). Si no es así, cree una vista y agréguele una columna aleatoria.

Utilice esta consulta para seleccionar una sola fila para cada única home valor. Selecciona el más bajo id en caso de duplicado datetime.

SELECT tt.*
FROM topten tt
INNER JOIN
    (
    SELECT min(id) as min_id, home from topten tt2
    INNER JOIN 
        (
        SELECT home, MAX(datetime) AS MaxDateTime
        FROM topten
        GROUP BY home) groupedtt2
    ON tt2.home = groupedtt2.home
    ) as groupedtt
ON tt.id = groupedtt.id

Respondido 08 Oct 20, 00:10

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.