Re: Spécifier un premier élément dans une clause select... order by

Bonjour,

est-il possible de spécifier un premier élément dans une clause
select... order by ?

Par exemple, avec une table d'utilisateurs :

Colonne | Type |
------------+-------------------+
id_etu | integer |
nom_etu | text |
prenom_etu | text |

est-il possible de demander quelque chose du genre :

SELECT * from etu order by nom_etu, prenom_etu « with first id_etu =
300 »;

L'étape suivante serait que, à la fin de la liste des utilisateurs
triés et commençant à l'id_etu 300, figure le début de la liste qui est
omise dans la clause ci-dessus.

Merci d'avance.
--
Denis

Bonjour sauf erreur de compréhension de ma part, il faut le spécifier
dans la clause where :
select * from etu where id_etu >= 300 order by nom_etu,prenom_etu;

Pour l'étape suivante, peut être utiliser une union?

Cordialement,

Le mardi 15 décembre 2009 à 16:11 +0100, Denis Bitouzé a écrit :
> Bonjour,
>
> est-il possible de spécifier un premier élément dans une clause
> select... order by ?
>
> Par exemple, avec une table d'utilisateurs :
>
> Colonne | Type |
> ------------+-------------------+
> id_etu | integer |
> nom_etu | text |
> prenom_etu | text |
>
> est-il possible de demander quelque chose du genre :
>
> SELECT * from etu order by nom_etu, prenom_etu « with first id_etu =
> 300 »;
>
> L'étape suivante serait que, à la fin de la liste des utilisateurs
> triés et commençant à l'id_etu 300, figure le début de la liste qui est
> omise dans la clause ci-dessus.
>
> Merci d'avance.
> --
> Denis
>
>
>

--
Jean-Christophe Arnu <jean-christophe(dot)arnu(at)c-s(dot)fr>
C-S communication et système

Bonjour,

Le mardi 15 décembre 2009 à 16:11:51, Denis Bitouzé a écrit :
> [...]
> est-il possible de spécifier un premier élément dans une clause
> select... order by ?
>
> Par exemple, avec une table d'utilisateurs :
>
> Colonne | Type |
> ------------+-------------------+
> id_etu | integer |
> nom_etu | text |
> prenom_etu | text |
>
> est-il possible de demander quelque chose du genre :
>
> SELECT * from etu order by nom_etu, prenom_etu « with first id_etu =
> 300 »;
>
> L'étape suivante serait que, à la fin de la liste des utilisateurs
> triés et commençant à l'id_etu 300, figure le début de la liste qui est
> omise dans la clause ci-dessus.
>

Ceci devrait le faire :

SELECT * from etu order by id_etu >= 300, id_etu;

--
Guillaume.
http://www.postgresqlfr.org
http://dalibo.com

Le mardi 15 décembre 2009 à 16:31:47, Denis Bitouzé a écrit :
> Le mardi 15/12/09 à 16h23,
>
> Guillaume Lelarge <guillaume(at)lelarge(dot)info> a écrit :
> > Ceci devrait le faire :
> >
> > SELECT * from etu order by id_etu >= 300, id_etu;
>
> Ne serait-ce pas plutôt :
>
> SELECT * from etu order by nom_etu,id_etu >= 300;
>

Si tu fais ça, tu auras un tri par les noms en premier.

> que tu voulais dire ? Mais ça ne fonctionne dans aucun des cas : les
> id_etu < 300 ne sont pas omis.
>

Ton histoire n'est pas claire. Tu veux trier par la colonne id_etu ou filtrer
?

Si tu veux omettre les id_etu < 300, faut le mettre dans la clause WHERE :

SELECT * from etu where id_etu >= 300 order by nom_etu;

--
Guillaume.
http://www.postgresqlfr.org
http://dalibo.com

Le mardi 15/12/09 à 16h19,
Jean-Christophe Arnu <jean-christophe(dot)arnu(at)c-s(dot)fr> a écrit :

> sauf erreur de compréhension de ma part, il faut le spécifier
> dans la clause where :
> select * from etu where id_etu >= 300 order by nom_etu,prenom_etu;

Cela ne convient pas dans mon cas car je souhaite effectuer :

1. d'abord le tri ;
2. ensuite seulement la troncature.

> Pour l'étape suivante, peut être utiliser une union?

OK, je m'en vais regarder cela.

Merci !
--
Denis

Le mardi 15/12/09 à 16h23,
Guillaume Lelarge <guillaume(at)lelarge(dot)info> a écrit :

> Ceci devrait le faire :
>
> SELECT * from etu order by id_etu >= 300, id_etu;

Ne serait-ce pas plutôt :

SELECT * from etu order by nom_etu,id_etu >= 300;

que tu voulais dire ? Mais ça ne fonctionne dans aucun des cas : les
id_etu < 300 ne sont pas omis.

Merci !
--
Denis

Le mardi 15 décembre 2009 à 16:44:12, Denis Bitouzé a écrit :
> Le mardi 15/12/09 à 16h19,
>
> Jean-Christophe Arnu <jean-christophe(dot)arnu(at)c-s(dot)fr> a écrit :
> > sauf erreur de compréhension de ma part, il faut le spécifier
> > dans la clause where :
> > select * from etu where id_etu >= 300 order by nom_etu,prenom_etu;
>
> Cela ne convient pas dans mon cas car je souhaite effectuer :
>
> 1. d'abord le tri ;
> 2. ensuite seulement la troncature.
>

Je ne comprends pas, le résultat sera identique de toute façon ? sinon tu peux
toujours faire un :

SELECT *
FROM
(SELECT * FROM etu ORDER BY nom_etu, prenom_etu) AS tmp
WHERE id_etu >= 300;

> > Pour l'étape suivante, peut être utiliser une union?
>
> OK, je m'en vais regarder cela.
>
> Merci !
>

--
Guillaume.
http://www.postgresqlfr.org
http://dalibo.com

Le mardi 15/12/09 à 16h41,
Guillaume Lelarge <guillaume(at)lelarge(dot)info> a écrit

>
> Le mardi 15 décembre 2009 à 16:31:47, Denis Bitouzé a écrit :
> > Le mardi 15/12/09 à 16h23,
> >
> > Guillaume Lelarge <guillaume(at)lelarge(dot)info> a écrit :
> > > Ceci devrait le faire :
> > >
> > > SELECT * from etu order by id_etu >= 300, id_etu;
> >
> > Ne serait-ce pas plutôt :
> >
> > SELECT * from etu order by nom_etu,id_etu >= 300;
> >
>
> Si tu fais ça, tu auras un tri par les noms en premier.

Euh... Avec :

SELECT * from etu order by id_etu >= 300, id_etu;

j'ai tous les enregistrements, y compris d'id_etu < 300 et classés par
ordre sur les id_etu.

> > que tu voulais dire ? Mais ça ne fonctionne dans aucun des cas : les
> > id_etu < 300 ne sont pas omis.
> >
>
> Ton histoire n'est pas claire.

J'en ai conscience :)

> Tu veux trier par la colonne id_etu ou filtrer ?

Comme précisé à Jean-Christophe, je souhaite :

1. d'abord effectuer le tri sur les noms et prénoms
2. ensuite tronquer le résultat en n'y faisant pas figurer ceux dont
l'id_etu est < 300.

> Si tu veux omettre les id_etu < 300, faut le mettre dans la clause
> WHERE :
>
> SELECT * from etu where id_etu >= 300 order by nom_etu;

Oui, mais ça, ça effectue les opérations dans l'ordre inverse :

1. d'abord ça élimine les id_etu < 300 ;
2. ensuite ça trie.

Et j'ai besoin de l'inverse.

Pour être plus clair, voici un exemple :

CREATE TABLE test (
id_etu integer NOT NULL,
nom_etu text NOT NULL,
prenom_etu text NOT NULL
);

COPY test (id_etu, nom_etu, prenom_etu) FROM stdin;
1 Newton Isaac
2 Einstein Albert
3 Descartes René
4 Galois Évariste
\.

Je souhaite trier par ordre alphabétique :

SELECT * from test order by nom_etu ,prenom_etu;
id_etu | nom_etu | prenom_etu
--------+-----------+------------
3 | Descartes | René
2 | Einstein | Albert
4 | Galois | Évariste
1 | Newton | Isaac
(4 lignes)

mais en ne faisant commencer cette liste qu'à Einstein (id_etu >=2), de
façon à obtenir :

id_etu | nom_etu | prenom_etu
--------+-----------+------------
2 | Einstein | Albert
4 | Galois | Évariste
1 | Newton | Isaac

Les solutions qui m'ont été proposées ne fonctionnent pas :

select * from test where id_etu >= 2 order by nom_etu,prenom_etu;
id_etu | nom_etu | prenom_etu
--------+-----------+------------
3 | Descartes | René
2 | Einstein | Albert
4 | Galois | Évariste

J'ai (3 | Descartes | René) non souhaité et pas (1 | Newton | Isaac)
qui est souhaité. Il en est de même de :

SELECT *
FROM
(SELECT * FROM test ORDER BY nom_etu, prenom_etu) AS tmp
WHERE id_etu >= 2

Merci !
--
Denis

Le mardi 15 décembre 2009 à 17:09:53, Denis Bitouzé a écrit :
> Le mardi 15/12/09 à 16h41,
> Guillaume Lelarge <guillaume(at)lelarge(dot)info> a écrit
>
> > Le mardi 15 décembre 2009 à 16:31:47, Denis Bitouzé a écrit :
> > > Le mardi 15/12/09 à 16h23,
> > >
> > > Guillaume Lelarge <guillaume(at)lelarge(dot)info> a écrit :
> > > > Ceci devrait le faire :
> > > >
> > > > SELECT * from etu order by id_etu >= 300, id_etu;
> > >
> > > Ne serait-ce pas plutôt :
> > >
> > > SELECT * from etu order by nom_etu,id_etu >= 300;
> >
> > Si tu fais ça, tu auras un tri par les noms en premier.
>
> Euh... Avec :
>
> SELECT * from etu order by id_etu >= 300, id_etu;
>
> j'ai tous les enregistrements, y compris d'id_etu < 300 et classés par
> ordre sur les id_etu.
>
> > > que tu voulais dire ? Mais ça ne fonctionne dans aucun des cas : les
> > > id_etu < 300 ne sont pas omis.
> >
> > Ton histoire n'est pas claire.
>
> J'en ai conscience :)
>
> > Tu veux trier par la colonne id_etu ou filtrer ?
>
> Comme précisé à Jean-Christophe, je souhaite :
>
> 1. d'abord effectuer le tri sur les noms et prénoms
> 2. ensuite tronquer le résultat en n'y faisant pas figurer ceux dont
> l'id_etu est < 300.
>
> > Si tu veux omettre les id_etu < 300, faut le mettre dans la clause
> > WHERE :
> >
> > SELECT * from etu where id_etu >= 300 order by nom_etu;
>
> Oui, mais ça, ça effectue les opérations dans l'ordre inverse :
>
> 1. d'abord ça élimine les id_etu < 300 ;
> 2. ensuite ça trie.
>
> Et j'ai besoin de l'inverse.
>
> Pour être plus clair, voici un exemple :
>
> CREATE TABLE test (
> id_etu integer NOT NULL,
> nom_etu text NOT NULL,
> prenom_etu text NOT NULL
> );
>
> COPY test (id_etu, nom_etu, prenom_etu) FROM stdin;
> 1 Newton Isaac
> 2 Einstein Albert
> 3 Descartes René
> 4 Galois Évariste
> \.
>
> Je souhaite trier par ordre alphabétique :
>
> SELECT * from test order by nom_etu ,prenom_etu;
> id_etu | nom_etu | prenom_etu
> --------+-----------+------------
> 3 | Descartes | René
> 2 | Einstein | Albert
> 4 | Galois | Évariste
> 1 | Newton | Isaac
> (4 lignes)
>
> mais en ne faisant commencer cette liste qu'à Einstein (id_etu >=2), de
> façon à obtenir :
>
> id_etu | nom_etu | prenom_etu
> --------+-----------+------------
> 2 | Einstein | Albert
> 4 | Galois | Évariste
> 1 | Newton | Isaac
>

Oh, je crois avoir compris ce que tu veux. Tu ne veux pas filtrer avec
id_etu>=2, mais tu veux conserver toutes les lignes à partir de celle qui a 2
pour id_etu.

J'obtiens à peu près ça avec une fonction Window (Donc 8.4 obligatoirement):

SELECT id_etu, nom_etu, prenom_etu
FROM
(SELECT *, row_number() OVER (ORDER BY nom_etu, prenom_etu)
FROM test
ORDER BY nom_etu, prenom_etu) AS t
WHERE row_number>=2;

id_etu | nom_etu | prenom_etu
--------+----------+------------
2 | Einstein | Albert
4 | Galois | Évariste
1 | Newton | Isaac
(3 lignes)

Mais bon, c'est triché.

Pour les versions antérieures à la 8.4, le plus simple est d'utiliser une
procédure stockée.

--
Guillaume.
http://www.postgresqlfr.org
http://dalibo.com

Le mardi 15/12/09 à 18h06,
Guillaume Lelarge <guillaume(at)lelarge(dot)info> a écrit :

> Oh, je crois avoir compris ce que tu veux.

Aaaaahhhh, je désespérais de me faire comprendre un jour ! ;)

Y a-t-il moyen d'exprimer mon problème dans un langage facile à
comprendre pour un habitué des SGBDR en général, de PostgreSQL en
particulier ?

> Tu ne veux pas filtrer
> avec id_etu>=2, mais tu veux conserver toutes les lignes à partir de
> celle qui a 2 pour id_etu.

Yes ! Ah ben voilà, c'est infiniment plus clair ainsi ;)

> J'obtiens à peu près ça avec une fonction Window

Tiens, je ne connais pas...

> (Donc 8.4
> obligatoirement):

Rhaaaa...

> SELECT id_etu, nom_etu, prenom_etu
> FROM
> (SELECT *, row_number() OVER (ORDER BY nom_etu, prenom_etu)
> FROM test
> ORDER BY nom_etu, prenom_etu) AS t
> WHERE row_number>=2;
>
> id_etu | nom_etu | prenom_etu
> --------+----------+------------
> 2 | Einstein | Albert
> 4 | Galois | Évariste
> 1 | Newton | Isaac
> (3 lignes)
>
> Mais bon, c'est triché.

Ouais, d'autant que je n'ai pas la 8.4 sur le poste sur lequel est ma
base.

> Pour les versions antérieures à la 8.4, le plus simple est d'utiliser
> une procédure stockée.

Glurps ! Vraiment ?

Merci !
--
Denis

Denis Bitouzé <dbitouze(at)wanadoo(dot)fr> 2009-12-15 17:10
> 1. d'abord effectuer le tri sur les noms et prénoms
> 2. ensuite tronquer le résultat en n'y faisant pas figurer ceux dont
> l'id_etu est < 300.

Et avec ca ?

SELECT * FROM test WHERE (nom_etu) >= (SELECT nom_etu FROM test WHERE id_etu=300) ORDER BY nom_etu,prenom_etu;

--
Patrick Mevzek
The reasonable man adapts himself to the world; the unreasonable one
persists in trying to adapt the world to himself. Therefore all
progress depends on the unreasonable man. -- George Bernard Shaw

Le mardi 15 décembre 2009 à 21:12:23, Patrick Mevzek a écrit :
> Denis Bitouzé <dbitouze(at)wanadoo(dot)fr> 2009-12-15 17:10
>
> > 1. d'abord effectuer le tri sur les noms et prénoms
> > 2. ensuite tronquer le résultat en n'y faisant pas figurer ceux dont
> > l'id_etu est < 300.
>
> Et avec ca ?
>
> SELECT * FROM test WHERE (nom_etu) >= (SELECT nom_etu FROM test WHERE
> id_etu=300) ORDER BY nom_etu,prenom_etu;
>

Wow, impressionnant. Ça fonctionne sur l'exemple de Denis en tout cas.

--
Guillaume.
http://www.postgresqlfr.org
http://dalibo.com

Bonjour,
Voici ma contribution. J'utilise la clause VALUES uniquement pour éviter
de créer la table :

SELECT *
FROM (SELECT *
FROM (VALUES (100,'MOZART','WOLFGANG AmadeusAMADEUS'),
(200,'BEETHOVEN','LUDWIG VAN'),
(300,'VIVALDI','ANTONIO'),
(400,'BACH','JEAN SEBASTIEN')) AS compositeur
(id_etu,nom_etu,prenom_etu)
ORDER BY nom_etu,prenom_etu) tri_compositeur_nom_prenom
WHERE id_etu >=300;
Le résultat :
*id_etu* *nom_etu* *prenom_etu*
400 BACH JEAN SEBASTIEN
300 VIVALDI ANTONIO

Il me semble que la requête ci-dessous marche avec le jeu d'essai
proposé, mais n'est pas correcte en fait : En essayant de l'utiliser
avec mon jeu d'essai, elle ne sort qu'une ligne :
*id_etu* *nom_etu* *prenom_etu*
*300* *VIVALDI* *ANTONIO*

Cordialement
JM Souchard
-------- Message original --------
Sujet : Re: [pgsql-fr-generale] Spécifier un premier élément dans une
clause select... order by
De : Guillaume Lelarge <guillaume(at)lelarge(dot)info>
Pour : pgsql-fr-generale(at)postgresql(dot)org
Copie à : Patrick Mevzek <pat(at)patoche(dot)org>
Date : 15/12/2009 21:34
> Le mardi 15 décembre 2009 à 21:12:23, Patrick Mevzek a écrit :
>
>> Denis Bitouzé <dbitouze(at)wanadoo(dot)fr> 2009-12-15 17:10
>>
>>
>>> 1. d'abord effectuer le tri sur les noms et prénoms
>>> 2. ensuite tronquer le résultat en n'y faisant pas figurer ceux dont
>>> l'id_etu est < 300.
>>>
>> Et avec ca ?
>>
>> SELECT * FROM test WHERE (nom_etu) >= (SELECT nom_etu FROM test WHERE
>> id_etu=300) ORDER BY nom_etu,prenom_etu;
>>
>>
>
> Wow, impressionnant. Ça fonctionne sur l'exemple de Denis en tout cas.
>
>
>

Le mardi 15/12/09 à 21h12,
Patrick Mevzek <pat(at)patoche(dot)org> a écrit :

> Et avec ca ?
>
> SELECT * FROM test WHERE (nom_etu) >= (SELECT nom_etu FROM test WHERE
> id_etu=300) ORDER BY nom_etu,prenom_etu;

Mais, mais, mais... c'est parfait ça ! Comme dirait Guillaume : « Wow
» !

Merci beaucoup !
--
Denis

Le mercredi 16/12/09 à 08h11,
SOUCHARD Jean-Michel DSIC BIP <jean-michel(dot)souchard(at)interieur(dot)gouv(dot)fr>
a écrit :

> Il me semble que la requête ci-dessous marche avec le jeu d'essai
> proposé, mais n'est pas correcte en fait : En essayant de l'utiliser
> avec mon jeu d'essai, elle ne sort qu'une ligne :
> *id_etu* *nom_etu* *prenom_etu*
> *300* *VIVALDI* *ANTONIO*

Euh... si, elle est correcte, du moins pour le problème que j'avais
(difficilement) exprimé, à savoir :

1. d'abord effectuer le tri sur les noms et prénoms
2. ensuite tronquer le résultat en y conservant seulement les lignes à
partir de celle qui a 300 pour id_etu (ma formulation « tronquer le
résultat en n'y faisant pas figurer ceux dont l'id_etu est < 300 »
était, il faut bien l'avouer, incorrecte).

Dans votre jeu d'essai,

1. le tri sur les noms et prénoms sur les noms et prénoms donne :

400 BACH JEAN SEBASTIEN
200 BEETHOVEN LUDWIG VAN
100 MOZART WOLFGANG AMADEUS
300 VIVALDI ANTONIO

2. la troncature de ce résultat en y conservant seulement les lignes à
partir de celle qui a 300 pour id_etu donne bien :

300 VIVALDI ANTONIO

En tous cas, merci !
--
Denis

Denis Bitouzé wrote:

> 1. le tri sur les noms et prénoms sur les noms et prénoms donne :
>
> 400 BACH JEAN SEBASTIEN
> 200 BEETHOVEN LUDWIG VAN
> 100 MOZART WOLFGANG AMADEUS
> 300 VIVALDI ANTONIO
>
> 2. la troncature de ce résultat en y conservant seulement les lignes à
> partir de celle qui a 300 pour id_etu donne bien :
>
> 300 VIVALDI ANTONIO

Mais s'il y a une autre entrée avec nom=VIVALDI et prénom=ALBAN, la requête
postée la conserve au lieu de l'éliminer, contrairement à ce qui est attendu.

Dans l'esprit, la requête postée est bien la solution, mais elle n'est pas
finie car elle ne gère pas le prénom en critère de tri de deuxième niveau.

Dans les versions récentes de postgres, il suffit de faire
(nom,prenom)>=(select nom,prenom where id_etu=...), et avec de plus
anciennes, pas sûr que ça marche, il faut peut-être découper le test en deux
clauses, du genre (nom>(select nom...)) OR (nom=(select nom...) AND
prenom>=(select prenom...))

Cordialement,
--
Daniel

Le jeudi 17/12/09 à 17h33,
"Daniel Verite" <daniel(at)manitou-mail(dot)org> a écrit :

> Dans l'esprit, la requête postée est bien la solution, mais elle
> n'est pas finie car elle ne gère pas le prénom en critère de tri de
> deuxième niveau.
>
> Dans les versions récentes de postgres, il suffit de faire
> (nom,prenom)>=(select nom,prenom where id_etu=...), et avec de plus
> anciennes, pas sûr que ça marche, il faut peut-être découper le test
> en deux clauses, du genre (nom>(select nom...)) OR (nom=(select
> nom...) AND
> prenom>=(select prenom...))

En effet. Merci pour cette remarque pas tombée dans l'oeil d'un
aveugle ! :)
--
Denis