sql tirant une ligne pour la rangée suivante ou précédente d'une ligne courante

id | titre de la photo | created_date 

XEi43 | ma famille | 2009 08 04 
dDls | groupe d'amis | 2009 08 05 
32kJ | bel endroit | 2009 08 06 
EOIk de travail | fin | 2009 08 07

Dire que j'ai l'id 32kJ. Comment aurais-je obtenir la ligne suivante ou la précédente?

source d'informationauteur Basit | 2009-08-11

mysql sql

C'est ce que j'utilise pour trouver les boutons précédent/suivant les dossiers. Une colonne de votre table peut être utilisée comme la colonne de tri, et pas de joint ni de méchant hacks sont nécessaires:

Enregistrement suivant (date de plus de enregistrement en cours):

SELECT id, title, MIN(created) AS created_date
FROM photo
WHERE created >
  (SELECT created FROM photo WHERE id = '32kJ')
GROUP BY created
ORDER BY created ASC
LIMIT 1;

Précédent record (date de moins que le record actuel):

SELECT id, title, MAX(created) AS created_date
FROM photo
WHERE created <
  (SELECT created FROM photo WHERE id = '32kJ')
GROUP BY created
ORDER BY created DESC
LIMIT 1;

Exemple:

CREATE TABLE `photo` (
`id` VARCHAR(5) NOT NULL,
`title` VARCHAR(255) NOT NULL,
`created` DATETIME NOT NULL,
INDEX `created` (`created` ASC),
PRIMARY KEY (`id`)
)
ENGINE = MyISAM;
INSERT INTO `photo` (`id`, `title`, `created`) VALUES ('XEi43', 'my family',       '2009-08-04');
INSERT INTO `photo` (`id`, `title`, `created`) VALUES ('dDls',  'friends group',   '2009-08-05');
INSERT INTO `photo` (`id`, `title`, `created`) VALUES ('32kJ',  'beautiful place', '2009-08-06');
INSERT INTO `photo` (`id`, `title`, `created`) VALUES ('EOIk',  'working late',    '2009-08-07');
SELECT * FROM photo ORDER BY created;
+-------+-----------------+---------------------+
| id    | title           | created             |
+-------+-----------------+---------------------+
| XEi43 | my family       | 2009-08-04 00:00:00 |
| dDls  | friends group   | 2009-08-05 00:00:00 |
| 32kJ  | beautiful place | 2009-08-06 00:00:00 |
| EOIk  | working late    | 2009-08-07 00:00:00 |
+-------+-----------------+---------------------+
SELECT id, title, MIN(created) AS next_date
FROM photo
WHERE created >
(SELECT created FROM photo WHERE id = '32kJ')
GROUP BY created
ORDER BY created ASC
LIMIT 1;
+------+--------------+---------------------+
| id   | title        | next_date           |
+------+--------------+---------------------+
| EOIk | working late | 2009-08-07 00:00:00 |
+------+--------------+---------------------+
SELECT id, title, MAX(created) AS prev_date
FROM photo
WHERE created <
(SELECT created FROM photo WHERE id = '32kJ')
GROUP BY created
ORDER BY created DESC
LIMIT 1;
+------+---------------+---------------------+
| id   | title         | prev_date           |
+------+---------------+---------------------+
| dDls | friends group | 2009-08-05 00:00:00 |
+------+---------------+---------------------+

2

Je me rends compte que vous utilisez MySQL, mais juste pour la référence, ici, est de savoir comment vous le faire à l'aide d'Oracle fonctions analytiques de PLOMB et LAG:
```
select empno, ename, job,
lag(ename, 1) over (order by ename) as the_guy_above_me,
lead(ename, 2) over (order by ename) as the_guy_two_rows_below_me
from emp
order by ename
```
Je pense qu'il ya une raison pourquoi Oracle coûte de l'argent et MySQL est gratuit... 🙂

Cette page vous montre comment émuler les fonctions analytiques dans MySQL.

Ne voulez-vous la prochaine/précédente ligne par date? Si oui, vous pourriez faire ceci:

select MyTable.*
from MyTable
join
(select id
from MyTable
where created_date < (select created_date from MyTable where id = '32kJ')
order by created_date desc, id desc
limit 1
) LimitedTable on LimitedTable.id = MyTable.fund_id;

À l'aide de Mike MAX/MIN astuce on peut faire précédent\prochaine sauts pour toutes sortes de choses. Cette msAccess exemple sera de retour à la précédente à la fermeture, pour chaque enregistrement, dans un marché de la bourse de table de données. Remarque: le '<=' est pour les week-ends et les jours fériés.

SELECT 
tableName.Date,
tableName.Close,
(SELECT Close 
FROM tableName 
WHERE Date = (SELECT MAX(Date) FROM tableName 
WHERE Date <= iJoined.yesterday)
) AS previousClose
FROM 
(SELECT Date, DateAdd("d",-1, Date) AS yesterday FROM tableName)
AS iJoined 
INNER JOIN 
tableName ON tableName.Date=iJoined.Date;

..."hier" illustre l'utilisation d'une fonction(Date-1) de saut; on pourrait avoir tout simplement utilisé...

(SELECT Date FROM tableName) AS iJoined
/* previous record */
(SELECT MAX(Date) FROM tableName WHERE Date < iJoined.Date)
/* next record */
(SELECT MIN(Date) FROM tableName WHERE Date > iJoined.Date)

Le truc, c'est que nous pouvons précédente\prochaines # quel(s) avec MAX\MIN et une fonction de saut()

Horrible hack - je n'aime pas cela, mais pourrait fonctionner..

with yourresult as
(
select id, photo_title, created_date, ROW_NUMBER() over(order by created_date) as 'RowNum' from your_table
)
-- Previous
select * from yourresult where RowNum = ((select RowNum from yourresult where id = '32kJ') -1)
-- Next
select * from yourresult where RowNum = ((select RowNum from yourresult where id = '32kJ') +1)

Que de toute utilisation?

J'ai considéré id comme clé primaire dans la table (et en tant que "numéro de ligne"), et l'a utilisé pour comparer chaque enregistrement avec la fonction d'enregistrement avant.
Le code suivant doit travailler.

CREATE SCHEMA temp
create table temp.emp (id integer,name varchar(50), salary  varchar(50));
insert into temp.emp values(1,'a','25000');
insert into temp.emp values(2,'b','30000');
insert into temp.emp values(3,'c','35000');
insert into temp.emp values(4,'d','40000');
insert into temp.emp values(5,'e','45000');
insert into temp.emp values(6,'f','20000');
select * from temp.emp
SELECT
current.id, current.name, current.salary,
case 
when current.id = 1 then current.salary 
else 
case
when current.salary > previous.salary then previous.salary
else current.salary  
end
end
FROM
temp.emp AS current
LEFT OUTER JOIN temp.emp AS previous
ON current.id = previous.id + 1

Vous devez vous connecter pour publier un commentaire.