Получение последней записи в каждой группе - MySQL
Есть таблица messages
которая содержит данные, как показано ниже:
Id Name Other_Columns
-------------------------
1 A A_data_1
2 A A_data_2
3 A A_data_3
4 B B_data_1
5 B B_data_2
6 C C_data_1
Если я выполню запрос select * from messages group by name
, я получу результат в виде:
1 A A_data_1
4 B B_data_1
6 C C_data_1
Какой запрос вернет следующий результат?
3 A A_data_3
5 B B_data_2
6 C C_data_1
То есть последняя запись в каждой группе должна быть возвращена.
В настоящее время это запрос, который я использую:
SELECT
*
FROM (SELECT
*
FROM messages
ORDER BY id DESC) AS x
GROUP BY name
Но это выглядит крайне неэффективно. Есть ли другие способы достижения того же результата?
Ответы
Ответ 1
MySQL 8.0 теперь поддерживает оконные функции, как почти все популярные реализации SQL. С помощью этого стандартного синтаксиса мы можем писать запросы с наибольшим числом групп:
WITH ranked_messages AS (
SELECT m.*, ROW_NUMBER() OVER (PARTITION BY name ORDER BY id DESC) AS rn
FROM messages AS m
)
SELECT * FROM ranked_messages WHERE rn = 1;
Ниже приведен оригинальный ответ, который я написал на этот вопрос в 2009 году:
Я пишу решение так:
SELECT m1.*
FROM messages m1 LEFT JOIN messages m2
ON (m1.name = m2.name AND m1.id < m2.id)
WHERE m2.id IS NULL;
Что касается производительности, то одно или другое решение может быть лучше, в зависимости от характера ваших данных. Таким образом, вы должны протестировать оба запроса и использовать тот, который лучше с точки зрения производительности, учитывая вашу базу данных.
Например, у меня есть копия дампа данных StackOverflow в августе. Я буду использовать это для сравнительного анализа. В таблице Posts
есть 1114 357 строк. Это работает на MySQL 5.0.75 на моем Macbook Pro 2,40 ГГц.
Я напишу запрос, чтобы найти самый последний пост для данного идентификатора пользователя (мой).
Сначала используйте технику, показанную @Eric с GROUP BY
в подзапросе:
SELECT p1.postid
FROM Posts p1
INNER JOIN (SELECT pi.owneruserid, MAX(pi.postid) AS maxpostid
FROM Posts pi GROUP BY pi.owneruserid) p2
ON (p1.postid = p2.maxpostid)
WHERE p1.owneruserid = 20860;
1 row in set (1 min 17.89 sec)
Даже анализ EXPLAIN
занимает более 16 секунд:
+----+-------------+------------+--------+----------------------------+-------------+---------+--------------+---------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+------------+--------+----------------------------+-------------+---------+--------------+---------+-------------+
| 1 | PRIMARY | <derived2> | ALL | NULL | NULL | NULL | NULL | 76756 | |
| 1 | PRIMARY | p1 | eq_ref | PRIMARY,PostId,OwnerUserId | PRIMARY | 8 | p2.maxpostid | 1 | Using where |
| 2 | DERIVED | pi | index | NULL | OwnerUserId | 8 | NULL | 1151268 | Using index |
+----+-------------+------------+--------+----------------------------+-------------+---------+--------------+---------+-------------+
3 rows in set (16.09 sec)
Теперь создайте тот же результат запроса, используя мою технику с LEFT JOIN
:
SELECT p1.postid
FROM Posts p1 LEFT JOIN posts p2
ON (p1.owneruserid = p2.owneruserid AND p1.postid < p2.postid)
WHERE p2.postid IS NULL AND p1.owneruserid = 20860;
1 row in set (0.28 sec)
Анализ EXPLAIN
показывает, что обе таблицы могут использовать свои индексы:
+----+-------------+-------+------+----------------------------+-------------+---------+-------+------+--------------------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+----------------------------+-------------+---------+-------+------+--------------------------------------+
| 1 | SIMPLE | p1 | ref | OwnerUserId | OwnerUserId | 8 | const | 1384 | Using index |
| 1 | SIMPLE | p2 | ref | PRIMARY,PostId,OwnerUserId | OwnerUserId | 8 | const | 1384 | Using where; Using index; Not exists |
+----+-------------+-------+------+----------------------------+-------------+---------+-------+------+--------------------------------------+
2 rows in set (0.00 sec)
Вот DDL для моей таблицы Posts
:
CREATE TABLE 'posts' (
'PostId' bigint(20) unsigned NOT NULL auto_increment,
'PostTypeId' bigint(20) unsigned NOT NULL,
'AcceptedAnswerId' bigint(20) unsigned default NULL,
'ParentId' bigint(20) unsigned default NULL,
'CreationDate' datetime NOT NULL,
'Score' int(11) NOT NULL default '0',
'ViewCount' int(11) NOT NULL default '0',
'Body' text NOT NULL,
'OwnerUserId' bigint(20) unsigned NOT NULL,
'OwnerDisplayName' varchar(40) default NULL,
'LastEditorUserId' bigint(20) unsigned default NULL,
'LastEditDate' datetime default NULL,
'LastActivityDate' datetime default NULL,
'Title' varchar(250) NOT NULL default '',
'Tags' varchar(150) NOT NULL default '',
'AnswerCount' int(11) NOT NULL default '0',
'CommentCount' int(11) NOT NULL default '0',
'FavoriteCount' int(11) NOT NULL default '0',
'ClosedDate' datetime default NULL,
PRIMARY KEY ('PostId'),
UNIQUE KEY 'PostId' ('PostId'),
KEY 'PostTypeId' ('PostTypeId'),
KEY 'AcceptedAnswerId' ('AcceptedAnswerId'),
KEY 'OwnerUserId' ('OwnerUserId'),
KEY 'LastEditorUserId' ('LastEditorUserId'),
KEY 'ParentId' ('ParentId'),
CONSTRAINT 'posts_ibfk_1' FOREIGN KEY ('PostTypeId') REFERENCES 'posttypes' ('PostTypeId')
) ENGINE=InnoDB;
Ответ 2
UPD: 2017-03-31, версия 5.7.5 MySQL включила ONLY_FULL_GROUP_BY переключатель по умолчанию (следовательно, не детерминированный Запросы GROUP BY отключены). Более того, они обновили реализацию GROUP BY, и решение может работать не так, как ожидалось, даже с отключенным коммутатором. Нужно проверить.
Решение Bill Karwin выше работает отлично, когда количество элементов внутри групп довольно мало, но производительность запроса становится плохой, когда группы довольно велики, так как для решения требуется около n*n/2 + n/2
только сравнений IS NULL
.
Я провел тесты в таблице InnoDB строк 18684446
с группами 1182
. Таблица содержит тестовые результаты для функциональных тестов и имеет (test_id, request_id)
в качестве первичного ключа. Таким образом, test_id
является группой, и я искал последний request_id
для каждого test_id
.
Решение Bill уже работает несколько часов на моем dell e4310, и я не знаю, когда он закончит, даже если он работает с индексом покрытия (следовательно, using index
в EXPLAIN).
У меня есть несколько других решений, основанных на тех же идеях:
- Если базовым индексом является индекс BTREE (как правило, это так), самая большая пара
(group_id, item_value)
- это последнее значение в каждом group_id
, которое является первым для каждого group_id
, если мы пройдем по индексу в по убыванию;
- если мы читаем значения, которые покрываются индексом, значения считываются в порядке индекса;
- каждый индекс неявно содержит столбцы первичного ключа, добавленные к этому (это первичный ключ в индексе покрытия). В приведенных ниже решениях я работаю непосредственно с первичным ключом, в этом случае вам просто нужно добавить столбцы первичного ключа в результат.
- во многих случаях гораздо дешевле собирать требуемые идентификаторы строк в требуемом порядке в подзапросе и присоединяться к результату подзапроса на идентификаторе. Поскольку для каждой строки результата подзапроса MySQL потребуется одиночная выборка на основе первичного ключа, подзапрос будет помещен первым в объединение, и строки будут выводиться в порядке идентификаторов в подзапросе (если мы опустим явно ORDER BY для соединения)
3 способа использования индексов MySQL - отличная статья, чтобы понять некоторые детали.
Решение 1
Это невероятно быстро, он занимает около 0,8 секунды на моих 18M + строках:
SELECT test_id, MAX(request_id), request_id
FROM testresults
GROUP BY test_id DESC;
Если вы хотите изменить заказ на ASC, поместите его в подзапрос, верните только идентификаторы и используйте это как подзапрос, чтобы присоединиться к остальным столбцам:
SELECT test_id, request_id
FROM (
SELECT test_id, MAX(request_id), request_id
FROM testresults
GROUP BY test_id DESC) as ids
ORDER BY test_id;
Это занимает около 1,2 с по моим данным.
Решение 2
Вот еще одно решение, которое занимает около 19 секунд для моей таблицы:
SELECT test_id, request_id
FROM testresults, (SELECT @group:=NULL) as init
WHERE IF(IFNULL(@group, -1)[email protected]:=test_id, 0, 1)
ORDER BY test_id DESC, request_id DESC
Он также возвращает тесты в порядке убывания. Он намного медленнее, так как он выполняет полное сканирование индекса, но здесь вы можете дать представление о том, как выводить N максимальных строк для каждой группы.
Недостатком запроса является то, что его результат не может быть кэширован кэшем запросов.
Ответ 3
Используйте подзапрос, чтобы вернуть правильную группировку, потому что вы на полпути.
Попробуйте следующее:
select
a.*
from
messages a
inner join
(select name, max(id) as maxid from messages group by name) as b on
a.id = b.maxid
Если это не id
, вам нужен максимум:
select
a.*
from
messages a
inner join
(select name, max(other_col) as other_col
from messages group by name) as b on
a.name = b.name
and a.other_col = b.other_col
Таким образом, вы избегаете коррелированных подзапросов и/или упорядочивания в ваших подзапросах, которые, как правило, очень медленны/неэффективны.
Ответ 4
Я пришел к другому решению, которое должно получить идентификаторы для последнего сообщения в каждой группе, а затем выбрать из таблицы сообщений, используя результат из первого запроса в качестве аргумента для конструкции WHERE x IN
:
SELECT id, name, other_columns
FROM messages
WHERE id IN (
SELECT MAX(id)
FROM messages
GROUP BY name
);
Я не знаю, как это работает по сравнению с некоторыми другими решениями, но он работал эффектно для моего стола с 3 миллионами строк. (Исполнение 4 секунды с результатами 1200+)
Это должно работать как на MySQL, так и на SQL Server.
Ответ 5
Решение по подзапросу скрипка Ссылка
select * from messages where id in
(select max(id) from messages group by Name)
Решение По условию объединения ссылка на скрипт
select m1.* from messages m1
left outer join messages m2
on ( m1.id<m2.id and m1.name=m2.name )
where m2.id is null
Причина для этого сообщения - дать ссылку на скрипку.
Тот же SQL уже предоставлен в других ответах.
Ответ 6
Я еще не тестировал большую БД, но я думаю, что это может быть быстрее, чем объединение таблиц:
SELECT *, Max(Id) FROM messages GROUP BY Name
Ответ 7
Подход со значительной скоростью заключается в следующем.
SELECT *
FROM messages a
WHERE Id = (SELECT MAX(Id) FROM messages WHERE a.Name = Name)
Результат
Id Name Other_Columns
3 A A_data_3
5 B B_data_2
6 C C_data_1
Ответ 8
Вот мое решение:
SELECT
DISTINCT NAME,
MAX(MESSAGES) OVER(PARTITION BY NAME) MESSAGES
FROM MESSAGE;
Ответ 9
Вот два предложения. Во-первых, если mysql поддерживает ROW_NUMBER(), это очень просто:
WITH Ranked AS (
SELECT Id, Name, OtherColumns,
ROW_NUMBER() OVER (
PARTITION BY Name
ORDER BY Id DESC
) AS rk
FROM messages
)
SELECT Id, Name, OtherColumns
FROM messages
WHERE rk = 1;
Я предполагаю, что "последний" означает последний в Id order. Если нет, измените предложение ORDER BY окна ROW_NUMBER() соответственно. Если ROW_NUMBER() недоступен, это еще одно решение:
Во-вторых, если это не так, это часто бывает хорошим способом:
SELECT
Id, Name, OtherColumns
FROM messages
WHERE NOT EXISTS (
SELECT * FROM messages as M2
WHERE M2.Name = messages.Name
AND M2.Id > messages.Id
)
Другими словами, выберите сообщения, в которых нет более позднего сообщения Id с тем же именем.
Ответ 10
Вот еще один способ получить последнюю связанную запись, используя GROUP_CONCAT
с order by и SUBSTRING_INDEX
чтобы выбрать одну из записей из списка
SELECT
'Id',
'Name',
SUBSTRING_INDEX(
GROUP_CONCAT(
'Other_Columns'
ORDER BY 'Id' DESC
SEPARATOR '||'
),
'||',
1
) Other_Columns
FROM
messages
GROUP BY 'Name'
Вышеупомянутый запрос сгруппирует все Other_Columns
которые находятся в одной группе Name
и с помощью ORDER BY id DESC
объединит все Other_Columns
в определенной группе в порядке убывания с предоставленным разделителем, в моем случае я использовал ||
использование SUBSTRING_INDEX
над этим списком выберет первый
Ответ 11
SELECT
column1,
column2
FROM
table_name
WHERE id IN
(SELECT
MAX(id)
FROM
table_name
GROUP BY column1)
ORDER BY column1 ;
Ответ 12
Очевидно, что существует множество разных способов получения одинаковых результатов, и, похоже, ваш вопрос состоит в том, как эффективно получить последние результаты в каждой группе в MySQL. Если вы работаете с огромными объемами данных и предполагаете, что используете InnoDB даже с самыми последними версиями MySQL (такими как 5.7.21 и 8.0.4-rc), тогда не может быть эффективного способа сделать это.
Иногда нам нужно делать это с таблицами с более чем 60 миллионами строк.
В этих примерах я буду использовать данные только с примерно 1,5 миллионами строк, где запросам нужно будет найти результаты для всех групп данных. В наших реальных случаях нам часто приходилось возвращать данные примерно из 2000 групп (что гипотетически не требовало бы изучения большой части данных).
Я буду использовать следующие таблицы:
CREATE TABLE temperature(
id INT UNSIGNED NOT NULL AUTO_INCREMENT,
groupID INT UNSIGNED NOT NULL,
recordedTimestamp TIMESTAMP NOT NULL,
recordedValue INT NOT NULL,
INDEX groupIndex(groupID, recordedTimestamp),
PRIMARY KEY (id)
);
CREATE TEMPORARY TABLE selected_group(id INT UNSIGNED NOT NULL, PRIMARY KEY(id));
Таблица температур заполнена примерно 1,5 миллионами случайных записей и 100 различными группами. Selected_group заполняется этими 100 группами (в наших случаях это обычно составляет менее 20% для всех групп).
Поскольку эти данные случайны, это означает, что несколько строк могут иметь одинаковые метки времени. Нам нужно получить список всех выбранных групп в порядке groupID с последним записанным значением метки для каждой группы, и если в одной и той же группе имеется более одной совпадающей строки, то последний совпадающий идентификатор этих строк.
Если гипотетически MySQL имеет функцию last(), которая возвращает значения из последней строки в специальном предложении ORDER BY, то мы можем просто сделать:
SELECT
last(t1.id) AS id,
t1.groupID,
last(t1.recordedTimestamp) AS recordedTimestamp,
last(t1.recordedValue) AS recordedValue
FROM selected_group g
INNER JOIN temperature t1 ON t1.groupID = g.id
ORDER BY t1.recordedTimestamp, t1.id
GROUP BY t1.groupID;
который должен был бы изучить только несколько 100 строк в этом случае, так как он не использует ни одну из обычных функций GROUP BY. Это будет выполнено за 0 секунд и, следовательно, будет очень эффективным. Обратите внимание, что обычно в MySQL мы видим предложение ORDER BY, следующее за предложением GROUP BY, однако это предложение ORDER BY используется для определения ORDER для функции last(), если это было после GROUP BY, то это было бы упорядочением GROUPS. Если предложение GROUP BY отсутствует, то последние значения будут одинаковыми во всех возвращаемых строках.
Однако в MySQL этого нет, поэтому давайте рассмотрим различные идеи того, что у него есть, и докажем, что ни один из них не эффективен.
Пример 1
SELECT t1.id, t1.groupID, t1.recordedTimestamp, t1.recordedValue
FROM selected_group g
INNER JOIN temperature t1 ON t1.id = (
SELECT t2.id
FROM temperature t2
WHERE t2.groupID = g.id
ORDER BY t2.recordedTimestamp DESC, t2.id DESC
LIMIT 1
);
Это проверило 3 009 254 строк и заняло ~ 0,859 секунды на 5.7.21 и немного дольше на 8.0.4-rc
Пример 2
SELECT t1.id, t1.groupID, t1.recordedTimestamp, t1.recordedValue
FROM temperature t1
INNER JOIN (
SELECT max(t2.id) AS id
FROM temperature t2
INNER JOIN (
SELECT t3.groupID, max(t3.recordedTimestamp) AS recordedTimestamp
FROM selected_group g
INNER JOIN temperature t3 ON t3.groupID = g.id
GROUP BY t3.groupID
) t4 ON t4.groupID = t2.groupID AND t4.recordedTimestamp = t2.recordedTimestamp
GROUP BY t2.groupID
) t5 ON t5.id = t1.id;
Это проверило 1505,331 рядов и заняло ~ 1,25 секунды на 5.7.21 и немного дольше на 8.0.4-rc
Пример 3
SELECT t1.id, t1.groupID, t1.recordedTimestamp, t1.recordedValue
FROM temperature t1
WHERE t1.id IN (
SELECT max(t2.id) AS id
FROM temperature t2
INNER JOIN (
SELECT t3.groupID, max(t3.recordedTimestamp) AS recordedTimestamp
FROM selected_group g
INNER JOIN temperature t3 ON t3.groupID = g.id
GROUP BY t3.groupID
) t4 ON t4.groupID = t2.groupID AND t4.recordedTimestamp = t2.recordedTimestamp
GROUP BY t2.groupID
)
ORDER BY t1.groupID;
Это проверило 3 009 685 строк и заняло ~ 1,95 секунды на 5.7.21 и немного дольше на 8.0.4-rc
Пример 4
SELECT t1.id, t1.groupID, t1.recordedTimestamp, t1.recordedValue
FROM selected_group g
INNER JOIN temperature t1 ON t1.id = (
SELECT max(t2.id)
FROM temperature t2
WHERE t2.groupID = g.id AND t2.recordedTimestamp = (
SELECT max(t3.recordedTimestamp)
FROM temperature t3
WHERE t3.groupID = g.id
)
);
Это проверило 6,137,810 строк и заняло ~ 2,2 секунды на 5.7.21 и немного дольше на 8.0.4-rc
Пример 5
SELECT t1.id, t1.groupID, t1.recordedTimestamp, t1.recordedValue
FROM (
SELECT
t2.id,
t2.groupID,
t2.recordedTimestamp,
t2.recordedValue,
row_number() OVER (
PARTITION BY t2.groupID ORDER BY t2.recordedTimestamp DESC, t2.id DESC
) AS rowNumber
FROM selected_group g
INNER JOIN temperature t2 ON t2.groupID = g.id
) t1 WHERE t1.rowNumber = 1;
Это проверило 6 017 808 строк и заняло ~ 4.2 секунды на 8.0.4-rc
Пример 6
SELECT t1.id, t1.groupID, t1.recordedTimestamp, t1.recordedValue
FROM (
SELECT
last_value(t2.id) OVER w AS id,
t2.groupID,
last_value(t2.recordedTimestamp) OVER w AS recordedTimestamp,
last_value(t2.recordedValue) OVER w AS recordedValue
FROM selected_group g
INNER JOIN temperature t2 ON t2.groupID = g.id
WINDOW w AS (
PARTITION BY t2.groupID
ORDER BY t2.recordedTimestamp, t2.id
RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
)
) t1
GROUP BY t1.groupID;
Это проверило 6 017 908 строк и заняло ~ 17.5 секунд на 8.0.4-rc
Пример 7
SELECT t1.id, t1.groupID, t1.recordedTimestamp, t1.recordedValue
FROM selected_group g
INNER JOIN temperature t1 ON t1.groupID = g.id
LEFT JOIN temperature t2
ON t2.groupID = g.id
AND (
t2.recordedTimestamp > t1.recordedTimestamp
OR (t2.recordedTimestamp = t1.recordedTimestamp AND t2.id > t1.id)
)
WHERE t2.id IS NULL
ORDER BY t1.groupID;
Этот брал навсегда, поэтому мне пришлось его убить.
Ответ 13
Попробуйте следующее:
SELECT jos_categories.title AS name,
joined .catid,
joined .title,
joined .introtext
FROM jos_categories
INNER JOIN (SELECT *
FROM (SELECT `title`,
catid,
`created`,
introtext
FROM `jos_content`
WHERE `sectionid` = 6
ORDER BY `id` DESC) AS yes
GROUP BY `yes`.`catid` DESC
ORDER BY `yes`.`created` DESC) AS joined
ON( joined.catid = jos_categories.id )
Ответ 14
Привет @Vijay Dev, если в вашей таблице сообщения содержится Id, который автоматически увеличивает первичный ключ, а затем для получения последней записи основы первичного ключа, который ваш запрос должен читать, как показано ниже
SELECT m1.* FROM messages m1 INNER JOIN (SELECT max(Id) as lastmsgId FROM messages GROUP BY Name) m2 ON m1.Id=m2.lastmsgId
Ответ 15
Вы также можете посмотреть и здесь.
http://sqlfiddle.com/#!9/ef42b/9
ПЕРВЫЙ РЕШЕНИЕ
SELECT d1.ID,Name,City FROM Demo_User d1
INNER JOIN
(SELECT MAX(ID) AS ID FROM Demo_User GROUP By NAME) AS P ON (d1.ID=P.ID);
ВТОРОЕ РЕШЕНИЕ
SELECT * FROM (SELECT * FROM Demo_User ORDER BY ID DESC) AS T GROUP BY NAME ;
Ответ 16
мы рассмотрим, как вы можете использовать MySQL для получения последней записи в группе записей. Например, если у вас есть этот набор результатов сообщений.
id category_id post_title
1 1 Title 1
2 1 Title 2
3 1 Title 3
4 2 Title 4
5 2 Title 5
6 3 Title 6
Я хочу иметь возможность получать последние сообщения в каждой категории: "Заголовок 3", "Заголовок 5" и "Заголовок 6.". Чтобы получить посты по категориям, вы будете использовать клавиатуру MySQL Group By.
select * from posts group by category_id
Но результаты, которые мы получаем от этого запроса, таковы.
id category_id post_title
1 1 Title 1
4 2 Title 4
6 3 Title 6
Группировка по всегда возвращает первую запись в группе в наборе результатов.
SELECT id, category_id, post_title FROM posts WHERE id IN ( SELECT MAX(id) FROM posts GROUP BY category_id );
Это вернет сообщения с самыми высокими идентификаторами в каждой группе.
id category_id post_title
3 1 Title 3
5 2 Title 5
6 3 Title 6
Ссылка Нажмите здесь
Ответ 17
Можно ли использовать этот метод для удаления дубликатов в таблице? Набор результатов в основном представляет собой набор уникальных записей, поэтому, если мы можем удалить все записи не в результирующем наборе, у нас фактически не будет дубликатов? Я пробовал это, но mySQL дал ошибку 1093.
DELETE FROM messages WHERE id NOT IN
(SELECT m1.id
FROM messages m1 LEFT JOIN messages m2
ON (m1.name = m2.name AND m1.id < m2.id)
WHERE m2.id IS NULL)
Есть ли способ сохранить результат в переменной temp, а затем удалить из NOT IN (временная переменная)? @Bill благодарит за очень полезное решение.
EDIT: Думаю, я нашел решение:
DROP TABLE IF EXISTS UniqueIDs;
CREATE Temporary table UniqueIDs (id Int(11));
INSERT INTO UniqueIDs
(SELECT T1.ID FROM Table T1 LEFT JOIN Table T2 ON
(T1.Field1 = T2.Field1 AND T1.Field2 = T2.Field2 #Comparison Fields
AND T1.ID < T2.ID)
WHERE T2.ID IS NULL);
DELETE FROM Table WHERE id NOT IN (SELECT ID FROM UniqueIDs);
Ответ 18
Следующий запрос будет работать в соответствии с вашим вопросом.
SELECT M1.*
FROM MESSAGES M1,
(
SELECT SUBSTR(Others_data,1,2),MAX(Others_data) AS Max_Others_data
FROM MESSAGES
GROUP BY 1
) M2
WHERE M1.Others_data = M2.Max_Others_data
ORDER BY Others_data;
Ответ 19
Если вам нужна последняя строка для каждого Name
, вы можете присвоить номер строки каждой группе строк Name
и упорядочить по Id
в порядке убывания.
QUERY
SELECT t1.Id,
t1.Name,
t1.Other_Columns
FROM
(
SELECT Id,
Name,
Other_Columns,
(
CASE Name WHEN @curA
THEN @curRow := @curRow + 1
ELSE @curRow := 1 AND @curA := Name END
) + 1 AS rn
FROM messages t,
(SELECT @curRow := 0, @curA := '') r
ORDER BY Name,Id DESC
)t1
WHERE t1.rn = 1
ORDER BY t1.Id;
Ответ 20
SELECT * FROM table_name WHERE primary_key IN (SELECT MAX(primary_key) FROM table_name GROUP BY column_name )
Ответ 21
select * from messages group by name desc
Ответ 22
Как насчет этого:
SELECT DISTINCT ON (name) *
FROM messages
ORDER BY name, id DESC;
У меня была аналогичная проблема (на postgresql tough) и на таблице записей 1M. Это решение занимает 1,7 с против 44, созданного с помощью LEFT JOIN.
В моем случае мне пришлось отфильтровать корреспондент вашего поля имени со значениями NULL, что привело к еще лучшим результатам на 0,2 секунды
Ответ 23
Если производительность действительно IsLastInGroup
вы можете ввести в таблицу новый столбец с именем IsLastInGroup
типа BIT.
Установите значение true в столбцах, которые являются последними, и сохраняйте его для каждой строки вставки/обновления/удаления. Запись будет медленнее, но вы получите пользу от чтения. Это зависит от вашего варианта использования, и я рекомендую его, только если вы ориентированы на чтение.
Таким образом, ваш запрос будет выглядеть так:
SELECT * FROM Messages WHERE IsLastInGroup = 1
Ответ 24
Вы можете группировать путем подсчета, а также получить последний элемент группы, как:
SELECT
user,
COUNT(user) AS count,
MAX(id) as last
FROM request
GROUP BY user
Ответ 25
Вы видели https://github.com/fhulufhelo/Get-Last-Record-in-Each-MySQL-Group? меня устраивает
$sql = "SELECT c.id, c.name, c.email, r.id, r.companyid, r.name, r.email FROM companytable c LEFT JOIN ( SELECT * FROM revisiontable WHERE id IN ( SELECT MAX(id) FROM revisiontable GROUP BY companyid )) r ON a.cid=b.r.id";
Ответ 26
**
**Здравствуйте, этот запрос может помочь:
**
SELECT
*
FROM
message
WHERE
'Id' IN (
SELECT
MAX('Id')
FROM
message
GROUP BY
'Name'
)
ORDER BY
'Id' DESC