Como obtenho o valor atual e o próximo maior em uma seleção?

Fazer um JOIN é uma coisa que você pode precisar.

SELECT l.id, l.time, r.time FROM 
    idtimes AS l LEFT JOIN idtimes AS r ON l.id = r.id

Suponho que a junção externa seja deliberada e você queira obter nulos. Mais sobre isso mais tarde.

WHERE l.time < r.time ORDER BY l.id ASC, l.time ASC;

Você só quer o r. linha que tem o menor tempo (MIN) que é maior que o l.time. Esse é o lugar onde você precisa de subconsultas.

WHERE r.time = (SELECT MIN(time) FROM idtimes r2 where r2.id = l.id AND r2.time > l.time)

Agora aos nulos. Se "não houver tempo próximo mais alto", o SELECT MIN() será avaliado como nulo (ou pior), e isso nunca será igual a nada, então sua cláusula WHERE nunca será satisfeita e o "tempo mais alto" para cada ID, nunca poderia aparecer no conjunto de resultados.

Você resolve eliminando seu JOIN e movendo a subconsulta escalar para a lista SELECT:

SELECT id, time, 
    (SELECT MIN(time) FROM idtimes sub 
        WHERE sub.id = main.id AND sub.time > main.time) as nxttime
  FROM idtimes AS main 

Sempre evito usar subconsultas seja em SELECTbloco ou em FROMbloco, pois isso torna o código "mais sujo" e às vezes menos eficiente.

Eu acho que uma maneira mais elegante de fazer isso é:

1. Encontre os tempos maiores que o tempo da linha

Você pode fazer isso com uma tabela JOINentre idtimes consigo mesma, restringindo a junção ao mesmo id e a tempos maiores que o tempo da linha atual.

Você deve usar LEFT JOINpara evitar a exclusão de linhas onde não há vezes maior que o da linha atual.

SELECT
    i1.id,
    i1.time AS time,
    i2.time AS greater_time
FROM
    idtimes AS i1
    LEFT JOIN idtimes AS i2 ON i1.id = i2.id AND i2.time > i1.time

O problema, como você mencionou, é que você tem várias linhas em que next_time é maior que time .

+-----+------------+--------------+
| id  | time       | greater_time |
+-----+------------+--------------+
| 155 | 1300000000 | 1311111111   |
| 155 | 1300000000 | 1322222222   |
| 155 | 1311111111 | 1322222222   |
| 155 | 1322222222 |       NULL   |
| 156 | 1312345678 | 1318765432   |
| 156 | 1318765432 |       NULL   |
+-----+------------+--------------+

2. Encontre as linhas em que maior_tempo não é apenas maior, mas próximo_tempo

A melhor maneira de filtrar todas essas linhas inúteis é descobrir se há tempos entre time (maior que) e maior_time (menor que) para esse id .

SELECT
    i1.id,
    i1.time AS time,
    i2.time AS next_time,
    i3.time AS intrudor_time
FROM
    idtimes AS i1
    LEFT JOIN idtimes AS i2 ON i1.id = i2.id AND i2.time > i1.time
    LEFT JOIN idtimes AS i3 ON i2.id = i3.id AND i3.time > i1.time AND i3.time < i2.time

ops, ainda temos um false next_time !

+-----+------------+--------------+---------------+
| id  | time       | next_time    | intrudor_time |
+-----+------------+--------------+---------------+
| 155 | 1300000000 | 1311111111   |         NULL  |
| 155 | 1300000000 | 1322222222   |    1311111111 |
| 155 | 1311111111 | 1322222222   |         NULL  |
| 155 | 1322222222 |       NULL   |         NULL  |
| 156 | 1312345678 | 1318765432   |         NULL  |
| 156 | 1318765432 |       NULL   |         NULL  |
+-----+------------+--------------+---------------+

Basta filtrar as linhas onde este evento acontece, adicionando a WHERErestrição abaixo

WHERE
    i3.time IS NULL

Voilà, temos o que precisamos!

+-----+------------+--------------+---------------+
| id  | time       | next_time    | intrudor_time |
+-----+------------+--------------+---------------+
| 155 | 1300000000 | 1311111111   |         NULL  |
| 155 | 1311111111 | 1322222222   |         NULL  |
| 155 | 1322222222 |       NULL   |         NULL  |
| 156 | 1312345678 | 1318765432   |         NULL  |
| 156 | 1318765432 |       NULL   |         NULL  |
+-----+------------+--------------+---------------+

Espero que você ainda precise de uma resposta depois de 4 anos!

Antes de apresentar a solução, devo observar que não é bonita. Seria muito mais fácil se você tivesse alguma AUTO_INCREMENTcoluna na sua mesa (você tem?)

SELECT 
  l.id, l.time, 
  SUBSTRING_INDEX(GROUP_CONCAT(r.time ORDER BY r.time), ',', 1)
FROM 
  idtimes AS l 
  LEFT JOIN idtimes AS r ON (l.id = r.id)
WHERE 
  l.time < r.time
GROUP BY
  l.id, l.time

Explicação:

• Mesma junção que a sua: junte duas mesas, a certa só ganha os tempos mais altos
• GROUP BY ambas as colunas da tabela esquerda: isso garante que obtenhamos todas as (id, time)combinações (que também são conhecidas por serem únicas).
• Para cada (l.id, l.time), obtenha o primeiro r.time que for maior que l.time. Isso acontece com a primeira ordenação do r.times via GROUP_CONCAT(r.time ORDER BY r.time), o fatiamento do primeiro token via SUBSTRING_INDEX.

Boa sorte e não espere um bom desempenho se esta tabela for grande.

Você também pode obter o que deseja de um min()e GROUP BYsem seleção interna:

SELECT l.id, l.time, min(r.time) 
FROM idtimes l 
LEFT JOIN idtimes r on (r.id = l.id and r.time > l.time)
GROUP BY l.id, l.time;

Eu quase apostaria uma grande quantia de dinheiro que o otimizador transforma isso na mesma coisa que a resposta de Erwin Smout de qualquer maneira, e é discutível se é mais claro, mas aí está a completude ...