Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
sous MySQL ...
Help !
--
Cordialement
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
sous MySQL ...
Help !
--
Cordialement
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
sous MySQL ...
Help !
--
Cordialement
En gros la liste chaînée permet de parcourir dans un ordre précis. Donc
peut-être une table avec un simple numéro d'ordre (avec des trous pour
pouvoir renuméroter uniquement si on a des collisions) ?
---
Patrice
"Timur" a écrit dans le message de
news:
>
> Bonjour,
>
>
> j'ai un soucis de modélisation d'une base de données.
>
> Je dois stocker une liste chainée dans laquelle
>
> - je dois pouvoir facilement ajouter ou enlever un élément
> - la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
> (on est plutôt sur un collier de perles !)
> - je n'ai besoin de parcourir ma liste que dans un seul sens
>
>
> J'ai bien pensé à une table (simplifiée bien sur)
>
> ID int autoincrémenté
> libElement varchar(100)
> Next ID int
>
> Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
> dans la chaîne.
>
>
> Par contre, comment faire un ordre SQL qui réponde à la question "Je
> les 200 élements suivant l'élement dont l'ID est xxx ?"
>
> Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
>
>
> Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
> sous MySQL ...
>
>
> Help !
>
> --
> Cordialement
>
>
>
>
En gros la liste chaînée permet de parcourir dans un ordre précis. Donc
peut-être une table avec un simple numéro d'ordre (avec des trous pour
pouvoir renuméroter uniquement si on a des collisions) ?
---
Patrice
"Timur" <fgregoire@enlever_ceci.freesurf.frzzz> a écrit dans le message de
news:Oodp7lD9FHA.2264@tk2msftngp13.phx.gbl...
>
> Bonjour,
>
>
> j'ai un soucis de modélisation d'une base de données.
>
> Je dois stocker une liste chainée dans laquelle
>
> - je dois pouvoir facilement ajouter ou enlever un élément
> - la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
> (on est plutôt sur un collier de perles !)
> - je n'ai besoin de parcourir ma liste que dans un seul sens
>
>
> J'ai bien pensé à une table (simplifiée bien sur)
>
> ID int autoincrémenté
> libElement varchar(100)
> Next ID int
>
> Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
> dans la chaîne.
>
>
> Par contre, comment faire un ordre SQL qui réponde à la question "Je
> les 200 élements suivant l'élement dont l'ID est xxx ?"
>
> Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
>
>
> Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
> sous MySQL ...
>
>
> Help !
>
> --
> Cordialement
>
>
>
>
En gros la liste chaînée permet de parcourir dans un ordre précis. Donc
peut-être une table avec un simple numéro d'ordre (avec des trous pour
pouvoir renuméroter uniquement si on a des collisions) ?
---
Patrice
"Timur" a écrit dans le message de
news:
>
> Bonjour,
>
>
> j'ai un soucis de modélisation d'une base de données.
>
> Je dois stocker une liste chainée dans laquelle
>
> - je dois pouvoir facilement ajouter ou enlever un élément
> - la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
> (on est plutôt sur un collier de perles !)
> - je n'ai besoin de parcourir ma liste que dans un seul sens
>
>
> J'ai bien pensé à une table (simplifiée bien sur)
>
> ID int autoincrémenté
> libElement varchar(100)
> Next ID int
>
> Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
> dans la chaîne.
>
>
> Par contre, comment faire un ordre SQL qui réponde à la question "Je
> les 200 élements suivant l'élement dont l'ID est xxx ?"
>
> Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
>
>
> Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
> sous MySQL ...
>
>
> Help !
>
> --
> Cordialement
>
>
>
>
mouais ... :(((((((
j'avais bien pensé à cette solution, mais ça n'est pas terrible
non ?
C'est pour une appli web, et je me vois mal renuméroter mes quelques
dizaines de milliers de lignes en temps réel !
Même une proc de maintenance le soir qui recrée les trous, c'est moyen !
En plus, cela suppose un début (no ordre le plus petit) et une fin (no
le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
'pointe' sur le plus petit pour faire la boucle)
--
Cordialement
"Patrice" a écrit dans le message de
news:
> En gros la liste chaînée permet de parcourir dans un ordre précis. Donc
> peut-être une table avec un simple numéro d'ordre (avec des trous pour
> pouvoir renuméroter uniquement si on a des collisions) ?
>
> ---
> Patrice
>
>
> "Timur" a écrit dans le message
> news:
> >
> > Bonjour,
> >
> >
> > j'ai un soucis de modélisation d'une base de données.
> >
> > Je dois stocker une liste chainée dans laquelle
> >
> > - je dois pouvoir facilement ajouter ou enlever un élément
> > - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> suivant"
> > (on est plutôt sur un collier de perles !)
> > - je n'ai besoin de parcourir ma liste que dans un seul sens
> >
> >
> > J'ai bien pensé à une table (simplifiée bien sur)
> >
> > ID int autoincrémenté
> > libElement varchar(100)
> > Next ID int
> >
> > Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> élément
> > dans la chaîne.
> >
> >
> > Par contre, comment faire un ordre SQL qui réponde à la question "Je
veux
> > les 200 élements suivant l'élement dont l'ID est xxx ?"
> >
> > Je ne peux pas faire de récursivité vu le nombre d'éléments à
> >
> >
> > Un autre point. L'appli est développé sous SQL 2000, mais doit être
> portable
> > sous MySQL ...
> >
> >
> > Help !
> >
> > --
> > Cordialement
> >
> >
> >
> >
>
>
mouais ... :(((((((
j'avais bien pensé à cette solution, mais ça n'est pas terrible
non ?
C'est pour une appli web, et je me vois mal renuméroter mes quelques
dizaines de milliers de lignes en temps réel !
Même une proc de maintenance le soir qui recrée les trous, c'est moyen !
En plus, cela suppose un début (no ordre le plus petit) et une fin (no
le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
'pointe' sur le plus petit pour faire la boucle)
--
Cordialement
"Patrice" <nobody@nowhere.com> a écrit dans le message de
news:uF3Yn5D9FHA.1188@TK2MSFTNGP12.phx.gbl...
> En gros la liste chaînée permet de parcourir dans un ordre précis. Donc
> peut-être une table avec un simple numéro d'ordre (avec des trous pour
> pouvoir renuméroter uniquement si on a des collisions) ?
>
> ---
> Patrice
>
>
> "Timur" <fgregoire@enlever_ceci.freesurf.frzzz> a écrit dans le message
> news:Oodp7lD9FHA.2264@tk2msftngp13.phx.gbl...
> >
> > Bonjour,
> >
> >
> > j'ai un soucis de modélisation d'une base de données.
> >
> > Je dois stocker une liste chainée dans laquelle
> >
> > - je dois pouvoir facilement ajouter ou enlever un élément
> > - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> suivant"
> > (on est plutôt sur un collier de perles !)
> > - je n'ai besoin de parcourir ma liste que dans un seul sens
> >
> >
> > J'ai bien pensé à une table (simplifiée bien sur)
> >
> > ID int autoincrémenté
> > libElement varchar(100)
> > Next ID int
> >
> > Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> élément
> > dans la chaîne.
> >
> >
> > Par contre, comment faire un ordre SQL qui réponde à la question "Je
veux
> > les 200 élements suivant l'élement dont l'ID est xxx ?"
> >
> > Je ne peux pas faire de récursivité vu le nombre d'éléments à
> >
> >
> > Un autre point. L'appli est développé sous SQL 2000, mais doit être
> portable
> > sous MySQL ...
> >
> >
> > Help !
> >
> > --
> > Cordialement
> >
> >
> >
> >
>
>
mouais ... :(((((((
j'avais bien pensé à cette solution, mais ça n'est pas terrible
non ?
C'est pour une appli web, et je me vois mal renuméroter mes quelques
dizaines de milliers de lignes en temps réel !
Même une proc de maintenance le soir qui recrée les trous, c'est moyen !
En plus, cela suppose un début (no ordre le plus petit) et une fin (no
le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
'pointe' sur le plus petit pour faire la boucle)
--
Cordialement
"Patrice" a écrit dans le message de
news:
> En gros la liste chaînée permet de parcourir dans un ordre précis. Donc
> peut-être une table avec un simple numéro d'ordre (avec des trous pour
> pouvoir renuméroter uniquement si on a des collisions) ?
>
> ---
> Patrice
>
>
> "Timur" a écrit dans le message
> news:
> >
> > Bonjour,
> >
> >
> > j'ai un soucis de modélisation d'une base de données.
> >
> > Je dois stocker une liste chainée dans laquelle
> >
> > - je dois pouvoir facilement ajouter ou enlever un élément
> > - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> suivant"
> > (on est plutôt sur un collier de perles !)
> > - je n'ai besoin de parcourir ma liste que dans un seul sens
> >
> >
> > J'ai bien pensé à une table (simplifiée bien sur)
> >
> > ID int autoincrémenté
> > libElement varchar(100)
> > Next ID int
> >
> > Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> élément
> > dans la chaîne.
> >
> >
> > Par contre, comment faire un ordre SQL qui réponde à la question "Je
veux
> > les 200 élements suivant l'élement dont l'ID est xxx ?"
> >
> > Je ne peux pas faire de récursivité vu le nombre d'éléments à
> >
> >
> > Un autre point. L'appli est développé sous SQL 2000, mais doit être
> portable
> > sous MySQL ...
> >
> >
> > Help !
> >
> > --
> > Cordialement
> >
> >
> >
> >
>
>
Avec des trous suffisamment grand, une rénumération devrait être
exceptionnelle. Pour le rebouclage, tu peux éventuellement faire une autre
requête pour compléter si tu ne sélectionnes que les derniers
enregistrements.
Sinon explique peut-être la nature des données plus que la représentation
technique que tu as retenue et cela pourra peut-être faire germer de
nouvelles idées.
Pourquoi la liste chaînée est-elle circulaire ?
--
Patrice
"Timur" a écrit dans le message de
news:
> mouais ... :(((((((
>
> j'avais bien pensé à cette solution, mais ça n'est pas terrible
quand-même,
> non ?
>
> C'est pour une appli web, et je me vois mal renuméroter mes quelques
> dizaines de milliers de lignes en temps réel !
> Même une proc de maintenance le soir qui recrée les trous, c'est moyen !
>
>
> En plus, cela suppose un début (no ordre le plus petit) et une fin (no
ordre
> le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
> 'pointe' sur le plus petit pour faire la boucle)
>
>
>
> --
> Cordialement
>
>
> "Patrice" a écrit dans le message de
> news:
> > En gros la liste chaînée permet de parcourir dans un ordre précis.
> > peut-être une table avec un simple numéro d'ordre (avec des trous pour
> > pouvoir renuméroter uniquement si on a des collisions) ?
> >
> > ---
> > Patrice
> >
> >
> > "Timur" a écrit dans le
de
> > news:
> > >
> > > Bonjour,
> > >
> > >
> > > j'ai un soucis de modélisation d'une base de données.
> > >
> > > Je dois stocker une liste chainée dans laquelle
> > >
> > > - je dois pouvoir facilement ajouter ou enlever un élément
> > > - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> > suivant"
> > > (on est plutôt sur un collier de perles !)
> > > - je n'ai besoin de parcourir ma liste que dans un seul sens
> > >
> > >
> > > J'ai bien pensé à une table (simplifiée bien sur)
> > >
> > > ID int autoincrémenté
> > > libElement varchar(100)
> > > Next ID int
> > >
> > > Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> > élément
> > > dans la chaîne.
> > >
> > >
> > > Par contre, comment faire un ordre SQL qui réponde à la question "Je
> veux
> > > les 200 élements suivant l'élement dont l'ID est xxx ?"
> > >
> > > Je ne peux pas faire de récursivité vu le nombre d'éléments à
retourner.
> > >
> > >
> > > Un autre point. L'appli est développé sous SQL 2000, mais doit être
> > portable
> > > sous MySQL ...
> > >
> > >
> > > Help !
> > >
> > > --
> > > Cordialement
> > >
> > >
> > >
> > >
> >
> >
>
>
Avec des trous suffisamment grand, une rénumération devrait être
exceptionnelle. Pour le rebouclage, tu peux éventuellement faire une autre
requête pour compléter si tu ne sélectionnes que les derniers
enregistrements.
Sinon explique peut-être la nature des données plus que la représentation
technique que tu as retenue et cela pourra peut-être faire germer de
nouvelles idées.
Pourquoi la liste chaînée est-elle circulaire ?
--
Patrice
"Timur" <fgregoire@enlever_ceci.freesurf.frzzz> a écrit dans le message de
news:ur78s9M9FHA.3876@TK2MSFTNGP09.phx.gbl...
> mouais ... :(((((((
>
> j'avais bien pensé à cette solution, mais ça n'est pas terrible
quand-même,
> non ?
>
> C'est pour une appli web, et je me vois mal renuméroter mes quelques
> dizaines de milliers de lignes en temps réel !
> Même une proc de maintenance le soir qui recrée les trous, c'est moyen !
>
>
> En plus, cela suppose un début (no ordre le plus petit) et une fin (no
ordre
> le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
> 'pointe' sur le plus petit pour faire la boucle)
>
>
>
> --
> Cordialement
>
>
> "Patrice" <nobody@nowhere.com> a écrit dans le message de
> news:uF3Yn5D9FHA.1188@TK2MSFTNGP12.phx.gbl...
> > En gros la liste chaînée permet de parcourir dans un ordre précis.
> > peut-être une table avec un simple numéro d'ordre (avec des trous pour
> > pouvoir renuméroter uniquement si on a des collisions) ?
> >
> > ---
> > Patrice
> >
> >
> > "Timur" <fgregoire@enlever_ceci.freesurf.frzzz> a écrit dans le
de
> > news:Oodp7lD9FHA.2264@tk2msftngp13.phx.gbl...
> > >
> > > Bonjour,
> > >
> > >
> > > j'ai un soucis de modélisation d'une base de données.
> > >
> > > Je dois stocker une liste chainée dans laquelle
> > >
> > > - je dois pouvoir facilement ajouter ou enlever un élément
> > > - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> > suivant"
> > > (on est plutôt sur un collier de perles !)
> > > - je n'ai besoin de parcourir ma liste que dans un seul sens
> > >
> > >
> > > J'ai bien pensé à une table (simplifiée bien sur)
> > >
> > > ID int autoincrémenté
> > > libElement varchar(100)
> > > Next ID int
> > >
> > > Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> > élément
> > > dans la chaîne.
> > >
> > >
> > > Par contre, comment faire un ordre SQL qui réponde à la question "Je
> veux
> > > les 200 élements suivant l'élement dont l'ID est xxx ?"
> > >
> > > Je ne peux pas faire de récursivité vu le nombre d'éléments à
retourner.
> > >
> > >
> > > Un autre point. L'appli est développé sous SQL 2000, mais doit être
> > portable
> > > sous MySQL ...
> > >
> > >
> > > Help !
> > >
> > > --
> > > Cordialement
> > >
> > >
> > >
> > >
> >
> >
>
>
Avec des trous suffisamment grand, une rénumération devrait être
exceptionnelle. Pour le rebouclage, tu peux éventuellement faire une autre
requête pour compléter si tu ne sélectionnes que les derniers
enregistrements.
Sinon explique peut-être la nature des données plus que la représentation
technique que tu as retenue et cela pourra peut-être faire germer de
nouvelles idées.
Pourquoi la liste chaînée est-elle circulaire ?
--
Patrice
"Timur" a écrit dans le message de
news:
> mouais ... :(((((((
>
> j'avais bien pensé à cette solution, mais ça n'est pas terrible
quand-même,
> non ?
>
> C'est pour une appli web, et je me vois mal renuméroter mes quelques
> dizaines de milliers de lignes en temps réel !
> Même une proc de maintenance le soir qui recrée les trous, c'est moyen !
>
>
> En plus, cela suppose un début (no ordre le plus petit) et une fin (no
ordre
> le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
> 'pointe' sur le plus petit pour faire la boucle)
>
>
>
> --
> Cordialement
>
>
> "Patrice" a écrit dans le message de
> news:
> > En gros la liste chaînée permet de parcourir dans un ordre précis.
> > peut-être une table avec un simple numéro d'ordre (avec des trous pour
> > pouvoir renuméroter uniquement si on a des collisions) ?
> >
> > ---
> > Patrice
> >
> >
> > "Timur" a écrit dans le
de
> > news:
> > >
> > > Bonjour,
> > >
> > >
> > > j'ai un soucis de modélisation d'une base de données.
> > >
> > > Je dois stocker une liste chainée dans laquelle
> > >
> > > - je dois pouvoir facilement ajouter ou enlever un élément
> > > - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> > suivant"
> > > (on est plutôt sur un collier de perles !)
> > > - je n'ai besoin de parcourir ma liste que dans un seul sens
> > >
> > >
> > > J'ai bien pensé à une table (simplifiée bien sur)
> > >
> > > ID int autoincrémenté
> > > libElement varchar(100)
> > > Next ID int
> > >
> > > Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> > élément
> > > dans la chaîne.
> > >
> > >
> > > Par contre, comment faire un ordre SQL qui réponde à la question "Je
> veux
> > > les 200 élements suivant l'élement dont l'ID est xxx ?"
> > >
> > > Je ne peux pas faire de récursivité vu le nombre d'éléments à
retourner.
> > >
> > >
> > > Un autre point. L'appli est développé sous SQL 2000, mais doit être
> > portable
> > > sous MySQL ...
> > >
> > >
> > > Help !
> > >
> > > --
> > > Cordialement
> > >
> > >
> > >
> > >
> >
> >
>
>
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
sous MySQL ...
Help !
--
Cordialement
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
sous MySQL ...
Help !
--
Cordialement
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
sous MySQL ...
Help !
--
Cordialement
Peut-être en essayant de modéliser par une représentation intervallaire
Excellent article de Fred Brouard sur :
http://sqlpro.developpez.com/cours/arborescence/
"Timur" a écrit dans le message de
news:
>
> Bonjour,
>
>
> j'ai un soucis de modélisation d'une base de données.
>
> Je dois stocker une liste chainée dans laquelle
>
> - je dois pouvoir facilement ajouter ou enlever un élément
> - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> suivant"
> (on est plutôt sur un collier de perles !)
> - je n'ai besoin de parcourir ma liste que dans un seul sens
>
>
> J'ai bien pensé à une table (simplifiée bien sur)
>
> ID int autoincrémenté
> libElement varchar(100)
> Next ID int
>
> Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> élément
> dans la chaîne.
>
>
> Par contre, comment faire un ordre SQL qui réponde à la question "Je
> les 200 élements suivant l'élement dont l'ID est xxx ?"
>
> Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
>
>
> Un autre point. L'appli est développé sous SQL 2000, mais doit être
> portable
> sous MySQL ...
>
>
> Help !
>
> --
> Cordialement
>
>
>
>
Peut-être en essayant de modéliser par une représentation intervallaire
Excellent article de Fred Brouard sur :
http://sqlpro.developpez.com/cours/arborescence/
"Timur" <fgregoire@enlever_ceci.freesurf.frzzz> a écrit dans le message de
news: Oodp7lD9FHA.2264@tk2msftngp13.phx.gbl...
>
> Bonjour,
>
>
> j'ai un soucis de modélisation d'une base de données.
>
> Je dois stocker une liste chainée dans laquelle
>
> - je dois pouvoir facilement ajouter ou enlever un élément
> - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> suivant"
> (on est plutôt sur un collier de perles !)
> - je n'ai besoin de parcourir ma liste que dans un seul sens
>
>
> J'ai bien pensé à une table (simplifiée bien sur)
>
> ID int autoincrémenté
> libElement varchar(100)
> Next ID int
>
> Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> élément
> dans la chaîne.
>
>
> Par contre, comment faire un ordre SQL qui réponde à la question "Je
> les 200 élements suivant l'élement dont l'ID est xxx ?"
>
> Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
>
>
> Un autre point. L'appli est développé sous SQL 2000, mais doit être
> portable
> sous MySQL ...
>
>
> Help !
>
> --
> Cordialement
>
>
>
>
Peut-être en essayant de modéliser par une représentation intervallaire
Excellent article de Fred Brouard sur :
http://sqlpro.developpez.com/cours/arborescence/
"Timur" a écrit dans le message de
news:
>
> Bonjour,
>
>
> j'ai un soucis de modélisation d'une base de données.
>
> Je dois stocker une liste chainée dans laquelle
>
> - je dois pouvoir facilement ajouter ou enlever un élément
> - la chaîne n'a ni début ni fin : tous les élements ont un "élement
> suivant"
> (on est plutôt sur un collier de perles !)
> - je n'ai besoin de parcourir ma liste que dans un seul sens
>
>
> J'ai bien pensé à une table (simplifiée bien sur)
>
> ID int autoincrémenté
> libElement varchar(100)
> Next ID int
>
> Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
> élément
> dans la chaîne.
>
>
> Par contre, comment faire un ordre SQL qui réponde à la question "Je
> les 200 élements suivant l'élement dont l'ID est xxx ?"
>
> Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
>
>
> Un autre point. L'appli est développé sous SQL 2000, mais doit être
> portable
> sous MySQL ...
>
>
> Help !
>
> --
> Cordialement
>
>
>
>
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
sous MySQL ...
Help !
--
Cordialement
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
sous MySQL ...
Help !
--
Cordialement
Bonjour,
j'ai un soucis de modélisation d'une base de données.
Je dois stocker une liste chainée dans laquelle
- je dois pouvoir facilement ajouter ou enlever un élément
- la chaîne n'a ni début ni fin : tous les élements ont un "élement
suivant"
(on est plutôt sur un collier de perles !)
- je n'ai besoin de parcourir ma liste que dans un seul sens
J'ai bien pensé à une table (simplifiée bien sur)
ID int autoincrémenté
libElement varchar(100)
Next ID int
Cela me fait une insertion + 1 update à chaque insertion d'un nouvel
élément
dans la chaîne.
Par contre, comment faire un ordre SQL qui réponde à la question "Je veux
les 200 élements suivant l'élement dont l'ID est xxx ?"
Je ne peux pas faire de récursivité vu le nombre d'éléments à retourner.
Un autre point. L'appli est développé sous SQL 2000, mais doit être
portable
sous MySQL ...
Help !
--
Cordialement
il s'agit de stocker des itinéraires pédestres en boucle dans une ville.
du style
ID LIB
IDNEXT
1 'sur la place xxx, prendre à gauche la rue YYY'
2
2 'Continuer tout droit sur 200 m'
3
3 'tourner à gauche'
4
4 'tourner encore à gauche'
1
Je peux avoir besoin de remplacer le ID 2 par plusieurs dizaines de lignes
permettant de passer par un autre chemin.
--
Cordialement
"Patrice" a écrit dans le message de
news:%23$
> Avec des trous suffisamment grand, une rénumération devrait être
> exceptionnelle. Pour le rebouclage, tu peux éventuellement faire une
> requête pour compléter si tu ne sélectionnes que les derniers
> enregistrements.
>
> Sinon explique peut-être la nature des données plus que la
> technique que tu as retenue et cela pourra peut-être faire germer de
> nouvelles idées.
>
> Pourquoi la liste chaînée est-elle circulaire ?
>
> --
> Patrice
>
> "Timur" a écrit dans le message
> news:
> > mouais ... :(((((((
> >
> > j'avais bien pensé à cette solution, mais ça n'est pas terrible
> quand-même,
> > non ?
> >
> > C'est pour une appli web, et je me vois mal renuméroter mes quelques
> > dizaines de milliers de lignes en temps réel !
> > Même une proc de maintenance le soir qui recrée les trous, c'est moyen
> >
> >
> > En plus, cela suppose un début (no ordre le plus petit) et une fin (no
> ordre
> > le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
> > 'pointe' sur le plus petit pour faire la boucle)
> >
> >
> >
> > --
> > Cordialement
> >
> >
> > "Patrice" a écrit dans le message de
> > news:
> > > En gros la liste chaînée permet de parcourir dans un ordre précis.
Donc
> > > peut-être une table avec un simple numéro d'ordre (avec des trous
> > > pouvoir renuméroter uniquement si on a des collisions) ?
> > >
> > > ---
> > > Patrice
> > >
> > >
> > > "Timur" a écrit dans le
message
> de
> > > news:
> > > >
> > > > Bonjour,
> > > >
> > > >
> > > > j'ai un soucis de modélisation d'une base de données.
> > > >
> > > > Je dois stocker une liste chainée dans laquelle
> > > >
> > > > - je dois pouvoir facilement ajouter ou enlever un élément
> > > > - la chaîne n'a ni début ni fin : tous les élements ont un
> > > suivant"
> > > > (on est plutôt sur un collier de perles !)
> > > > - je n'ai besoin de parcourir ma liste que dans un seul sens
> > > >
> > > >
> > > > J'ai bien pensé à une table (simplifiée bien sur)
> > > >
> > > > ID int autoincrémenté
> > > > libElement varchar(100)
> > > > Next ID int
> > > >
> > > > Cela me fait une insertion + 1 update à chaque insertion d'un
> > > élément
> > > > dans la chaîne.
> > > >
> > > >
> > > > Par contre, comment faire un ordre SQL qui réponde à la question
> > veux
> > > > les 200 élements suivant l'élement dont l'ID est xxx ?"
> > > >
> > > > Je ne peux pas faire de récursivité vu le nombre d'éléments à
> retourner.
> > > >
> > > >
> > > > Un autre point. L'appli est développé sous SQL 2000, mais doit
> > > portable
> > > > sous MySQL ...
> > > >
> > > >
> > > > Help !
> > > >
> > > > --
> > > > Cordialement
> > > >
> > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>
il s'agit de stocker des itinéraires pédestres en boucle dans une ville.
du style
ID LIB
IDNEXT
1 'sur la place xxx, prendre à gauche la rue YYY'
2
2 'Continuer tout droit sur 200 m'
3
3 'tourner à gauche'
4
4 'tourner encore à gauche'
1
Je peux avoir besoin de remplacer le ID 2 par plusieurs dizaines de lignes
permettant de passer par un autre chemin.
--
Cordialement
"Patrice" <nobody@nowhere.com> a écrit dans le message de
news:%23$ygKDN9FHA.952@TK2MSFTNGP12.phx.gbl...
> Avec des trous suffisamment grand, une rénumération devrait être
> exceptionnelle. Pour le rebouclage, tu peux éventuellement faire une
> requête pour compléter si tu ne sélectionnes que les derniers
> enregistrements.
>
> Sinon explique peut-être la nature des données plus que la
> technique que tu as retenue et cela pourra peut-être faire germer de
> nouvelles idées.
>
> Pourquoi la liste chaînée est-elle circulaire ?
>
> --
> Patrice
>
> "Timur" <fgregoire@enlever_ceci.freesurf.frzzz> a écrit dans le message
> news:ur78s9M9FHA.3876@TK2MSFTNGP09.phx.gbl...
> > mouais ... :(((((((
> >
> > j'avais bien pensé à cette solution, mais ça n'est pas terrible
> quand-même,
> > non ?
> >
> > C'est pour une appli web, et je me vois mal renuméroter mes quelques
> > dizaines de milliers de lignes en temps réel !
> > Même une proc de maintenance le soir qui recrée les trous, c'est moyen
> >
> >
> > En plus, cela suppose un début (no ordre le plus petit) et une fin (no
> ordre
> > le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
> > 'pointe' sur le plus petit pour faire la boucle)
> >
> >
> >
> > --
> > Cordialement
> >
> >
> > "Patrice" <nobody@nowhere.com> a écrit dans le message de
> > news:uF3Yn5D9FHA.1188@TK2MSFTNGP12.phx.gbl...
> > > En gros la liste chaînée permet de parcourir dans un ordre précis.
Donc
> > > peut-être une table avec un simple numéro d'ordre (avec des trous
> > > pouvoir renuméroter uniquement si on a des collisions) ?
> > >
> > > ---
> > > Patrice
> > >
> > >
> > > "Timur" <fgregoire@enlever_ceci.freesurf.frzzz> a écrit dans le
message
> de
> > > news:Oodp7lD9FHA.2264@tk2msftngp13.phx.gbl...
> > > >
> > > > Bonjour,
> > > >
> > > >
> > > > j'ai un soucis de modélisation d'une base de données.
> > > >
> > > > Je dois stocker une liste chainée dans laquelle
> > > >
> > > > - je dois pouvoir facilement ajouter ou enlever un élément
> > > > - la chaîne n'a ni début ni fin : tous les élements ont un
> > > suivant"
> > > > (on est plutôt sur un collier de perles !)
> > > > - je n'ai besoin de parcourir ma liste que dans un seul sens
> > > >
> > > >
> > > > J'ai bien pensé à une table (simplifiée bien sur)
> > > >
> > > > ID int autoincrémenté
> > > > libElement varchar(100)
> > > > Next ID int
> > > >
> > > > Cela me fait une insertion + 1 update à chaque insertion d'un
> > > élément
> > > > dans la chaîne.
> > > >
> > > >
> > > > Par contre, comment faire un ordre SQL qui réponde à la question
> > veux
> > > > les 200 élements suivant l'élement dont l'ID est xxx ?"
> > > >
> > > > Je ne peux pas faire de récursivité vu le nombre d'éléments à
> retourner.
> > > >
> > > >
> > > > Un autre point. L'appli est développé sous SQL 2000, mais doit
> > > portable
> > > > sous MySQL ...
> > > >
> > > >
> > > > Help !
> > > >
> > > > --
> > > > Cordialement
> > > >
> > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>
il s'agit de stocker des itinéraires pédestres en boucle dans une ville.
du style
ID LIB
IDNEXT
1 'sur la place xxx, prendre à gauche la rue YYY'
2
2 'Continuer tout droit sur 200 m'
3
3 'tourner à gauche'
4
4 'tourner encore à gauche'
1
Je peux avoir besoin de remplacer le ID 2 par plusieurs dizaines de lignes
permettant de passer par un autre chemin.
--
Cordialement
"Patrice" a écrit dans le message de
news:%23$
> Avec des trous suffisamment grand, une rénumération devrait être
> exceptionnelle. Pour le rebouclage, tu peux éventuellement faire une
> requête pour compléter si tu ne sélectionnes que les derniers
> enregistrements.
>
> Sinon explique peut-être la nature des données plus que la
> technique que tu as retenue et cela pourra peut-être faire germer de
> nouvelles idées.
>
> Pourquoi la liste chaînée est-elle circulaire ?
>
> --
> Patrice
>
> "Timur" a écrit dans le message
> news:
> > mouais ... :(((((((
> >
> > j'avais bien pensé à cette solution, mais ça n'est pas terrible
> quand-même,
> > non ?
> >
> > C'est pour une appli web, et je me vois mal renuméroter mes quelques
> > dizaines de milliers de lignes en temps réel !
> > Même une proc de maintenance le soir qui recrée les trous, c'est moyen
> >
> >
> > En plus, cela suppose un début (no ordre le plus petit) et une fin (no
> ordre
> > le plus grand), ce qui n'a pas de sens dans mon appli (le plus grand
> > 'pointe' sur le plus petit pour faire la boucle)
> >
> >
> >
> > --
> > Cordialement
> >
> >
> > "Patrice" a écrit dans le message de
> > news:
> > > En gros la liste chaînée permet de parcourir dans un ordre précis.
Donc
> > > peut-être une table avec un simple numéro d'ordre (avec des trous
> > > pouvoir renuméroter uniquement si on a des collisions) ?
> > >
> > > ---
> > > Patrice
> > >
> > >
> > > "Timur" a écrit dans le
message
> de
> > > news:
> > > >
> > > > Bonjour,
> > > >
> > > >
> > > > j'ai un soucis de modélisation d'une base de données.
> > > >
> > > > Je dois stocker une liste chainée dans laquelle
> > > >
> > > > - je dois pouvoir facilement ajouter ou enlever un élément
> > > > - la chaîne n'a ni début ni fin : tous les élements ont un
> > > suivant"
> > > > (on est plutôt sur un collier de perles !)
> > > > - je n'ai besoin de parcourir ma liste que dans un seul sens
> > > >
> > > >
> > > > J'ai bien pensé à une table (simplifiée bien sur)
> > > >
> > > > ID int autoincrémenté
> > > > libElement varchar(100)
> > > > Next ID int
> > > >
> > > > Cela me fait une insertion + 1 update à chaque insertion d'un
> > > élément
> > > > dans la chaîne.
> > > >
> > > >
> > > > Par contre, comment faire un ordre SQL qui réponde à la question
> > veux
> > > > les 200 élements suivant l'élement dont l'ID est xxx ?"
> > > >
> > > > Je ne peux pas faire de récursivité vu le nombre d'éléments à
> retourner.
> > > >
> > > >
> > > > Un autre point. L'appli est développé sous SQL 2000, mais doit
> > > portable
> > > > sous MySQL ...
> > > >
> > > >
> > > > Help !
> > > >
> > > > --
> > > > Cordialement
> > > >
> > > >
> > > >
> > > >
> > >
> > >
> >
> >
>
>
J'ai vu cet article, mais cela ne répond pas à mon besoin.
Cordialement
J'ai vu cet article, mais cela ne répond pas à mon besoin.
Cordialement
J'ai vu cet article, mais cela ne répond pas à mon besoin.
Cordialement
il s'agit de stocker des itinéraires pédestres en boucle dans une ville.
du style
ID LIB
IDNEXT
1 'sur la place xxx, prendre à gauche la rue YYY'
2
2 'Continuer tout droit sur 200 m'
3
3 'tourner à gauche'
4
4 'tourner encore à gauche'
1
Je peux avoir besoin de remplacer le ID 2 par plusieurs dizaines de lignes
permettant de passer par un autre chemin.
il s'agit de stocker des itinéraires pédestres en boucle dans une ville.
du style
ID LIB
IDNEXT
1 'sur la place xxx, prendre à gauche la rue YYY'
2
2 'Continuer tout droit sur 200 m'
3
3 'tourner à gauche'
4
4 'tourner encore à gauche'
1
Je peux avoir besoin de remplacer le ID 2 par plusieurs dizaines de lignes
permettant de passer par un autre chemin.
il s'agit de stocker des itinéraires pédestres en boucle dans une ville.
du style
ID LIB
IDNEXT
1 'sur la place xxx, prendre à gauche la rue YYY'
2
2 'Continuer tout droit sur 200 m'
3
3 'tourner à gauche'
4
4 'tourner encore à gauche'
1
Je peux avoir besoin de remplacer le ID 2 par plusieurs dizaines de lignes
permettant de passer par un autre chemin.