Dans le cas d'un projet pour un client, je suis en train de mettre en
place un annuaire téléphonique sur un serveur SQL 2000.
La plupart des requetes porteront sur un scoring prénom et lieu (ville
et/ou codepostal)
La structure actuelle de la base est donc la suivant:
|---------------------|
| table prenoms |
|---------------------|
| Id int | <- clé primaire
| Prenom varchar(64)|
|---------------------|
|---------------------|
| table lieux |
|---------------------|
| Id int | <- clé primaire
| Ville varchar(64)|
| CP char(5) |
|---------------------|
|---------------------|
| table annuaire |
|---------------------|
| Id int | <- clé primaire
| Nom varchar(64)|
| Prenom int | <- index
| Lieu int | <- index
| Tel varchar(10)|
|---------------------|
Les requetes types sont du genre:
SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L
WHERE
P.Id = A.Prenom AND
P.Prenom = 'gregoire' AND
L.Id = A.Lieu AND
L.CP = '69003'
Ma question est toute bête. Sachant que la base va contenir plusieurs
milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je
amélioré la rapidité de mes requetes car elle prennent actuellement
entre 10 et 60 secondes.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
bruno reiter [MVP]
en mettant des index au moins pour les colonnes utilisées dans les clauses where et les jointures
br
Anonyme wrote in message news:
Salut à tous.
Dans le cas d'un projet pour un client, je suis en train de mettre en place un annuaire téléphonique sur un serveur SQL 2000.
La plupart des requetes porteront sur un scoring prénom et lieu (ville et/ou codepostal)
La structure actuelle de la base est donc la suivant:
|---------------------| | table prenoms | |---------------------| | Id int | <- clé primaire | Prenom varchar(64)| |---------------------|
|---------------------| | table lieux | |---------------------| | Id int | <- clé primaire | Ville varchar(64)| | CP char(5) | |---------------------|
|---------------------| | table annuaire | |---------------------| | Id int | <- clé primaire | Nom varchar(64)| | Prenom int | <- index | Lieu int | <- index | Tel varchar(10)| |---------------------|
Les requetes types sont du genre: SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L WHERE P.Id = A.Prenom AND P.Prenom = 'gregoire' AND L.Id = A.Lieu AND L.CP = '69003'
Ma question est toute bête. Sachant que la base va contenir plusieurs milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je amélioré la rapidité de mes requetes car elle prennent actuellement entre 10 et 60 secondes.
Merci à tous de vos réponses
en mettant des index au moins pour les colonnes utilisées dans les
clauses where
et les jointures
br
Anonyme wrote in message
news:eLzXQjixDHA.3216@TK2MSFTNGP11.phx.gbl...
Salut à tous.
Dans le cas d'un projet pour un client, je suis en train de mettre en
place un annuaire téléphonique sur un serveur SQL 2000.
La plupart des requetes porteront sur un scoring prénom et lieu (ville
et/ou codepostal)
La structure actuelle de la base est donc la suivant:
|---------------------|
| table prenoms |
|---------------------|
| Id int | <- clé primaire
| Prenom varchar(64)|
|---------------------|
|---------------------|
| table lieux |
|---------------------|
| Id int | <- clé primaire
| Ville varchar(64)|
| CP char(5) |
|---------------------|
|---------------------|
| table annuaire |
|---------------------|
| Id int | <- clé primaire
| Nom varchar(64)|
| Prenom int | <- index
| Lieu int | <- index
| Tel varchar(10)|
|---------------------|
Les requetes types sont du genre:
SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L
WHERE
P.Id = A.Prenom AND
P.Prenom = 'gregoire' AND
L.Id = A.Lieu AND
L.CP = '69003'
Ma question est toute bête. Sachant que la base va contenir plusieurs
milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je
amélioré la rapidité de mes requetes car elle prennent
actuellement
entre 10 et 60 secondes.
en mettant des index au moins pour les colonnes utilisées dans les clauses where et les jointures
br
Anonyme wrote in message news:
Salut à tous.
Dans le cas d'un projet pour un client, je suis en train de mettre en place un annuaire téléphonique sur un serveur SQL 2000.
La plupart des requetes porteront sur un scoring prénom et lieu (ville et/ou codepostal)
La structure actuelle de la base est donc la suivant:
|---------------------| | table prenoms | |---------------------| | Id int | <- clé primaire | Prenom varchar(64)| |---------------------|
|---------------------| | table lieux | |---------------------| | Id int | <- clé primaire | Ville varchar(64)| | CP char(5) | |---------------------|
|---------------------| | table annuaire | |---------------------| | Id int | <- clé primaire | Nom varchar(64)| | Prenom int | <- index | Lieu int | <- index | Tel varchar(10)| |---------------------|
Les requetes types sont du genre: SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L WHERE P.Id = A.Prenom AND P.Prenom = 'gregoire' AND L.Id = A.Lieu AND L.CP = '69003'
Ma question est toute bête. Sachant que la base va contenir plusieurs milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je amélioré la rapidité de mes requetes car elle prennent actuellement entre 10 et 60 secondes.
Merci à tous de vos réponses
chris
un jour mon prof m'a dit : Une bonne base est une base ou tous les champs sont indéxés ... c'est vrai que c'est plus rapide en recherche après, mais bon, ca prend plus de place non ?
cordialement chris
"bruno reiter [MVP]" a écrit dans le message de news:
en mettant des index au moins pour les colonnes utilisées dans les clauses
where
et les jointures
br
Anonyme wrote in message news: > Salut à tous. > > > Dans le cas d'un projet pour un client, je suis en train de mettre en > place un annuaire téléphonique sur un serveur SQL 2000. > > La plupart des requetes porteront sur un scoring prénom et lieu (ville > et/ou codepostal) > > La structure actuelle de la base est donc la suivant: > > |---------------------| > | table prenoms | > |---------------------| > | Id int | <- clé primaire > | Prenom varchar(64)| > |---------------------| > > > |---------------------| > | table lieux | > |---------------------| > | Id int | <- clé primaire > | Ville varchar(64)| > | CP char(5) | > |---------------------| > > > |---------------------| > | table annuaire | > |---------------------| > | Id int | <- clé primaire > | Nom varchar(64)| > | Prenom int | <- index > | Lieu int | <- index > | Tel varchar(10)| > |---------------------| > > Les requetes types sont du genre: > SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L > WHERE > P.Id = A.Prenom AND > P.Prenom = 'gregoire' AND > L.Id = A.Lieu AND > L.CP = '69003' > > > Ma question est toute bête. Sachant que la base va contenir plusieurs > milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je > amélioré la rapidité de mes requetes car elle prennent actuellement > entre 10 et 60 secondes. > > > Merci à tous de vos réponses >
un jour mon prof m'a dit :
Une bonne base est une base ou tous les champs sont indéxés ...
c'est vrai que c'est plus rapide en recherche après, mais bon, ca prend
plus
de place non ?
cordialement
chris
"bruno reiter [MVP]" <remove.this.br33@bol.com.br> a
écrit dans le message
de news:uPM6lAjxDHA.3208@tk2msftngp13.phx.gbl...
en mettant des index au moins pour les colonnes utilisées dans les
clauses
where
et les jointures
br
Anonyme wrote in
message
news:eLzXQjixDHA.3216@TK2MSFTNGP11.phx.gbl...
> Salut à tous.
>
>
> Dans le cas d'un projet pour un client, je suis en train de mettre en
> place un annuaire téléphonique sur un serveur SQL 2000.
>
> La plupart des requetes porteront sur un scoring prénom et lieu
(ville
> et/ou codepostal)
>
> La structure actuelle de la base est donc la suivant:
>
> |---------------------|
> | table prenoms |
> |---------------------|
> | Id int | <- clé primaire
> | Prenom varchar(64)|
> |---------------------|
>
>
> |---------------------|
> | table lieux |
> |---------------------|
> | Id int | <- clé primaire
> | Ville varchar(64)|
> | CP char(5) |
> |---------------------|
>
>
> |---------------------|
> | table annuaire |
> |---------------------|
> | Id int | <- clé primaire
> | Nom varchar(64)|
> | Prenom int | <- index
> | Lieu int | <- index
> | Tel varchar(10)|
> |---------------------|
>
> Les requetes types sont du genre:
> SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L
> WHERE
> P.Id = A.Prenom AND
> P.Prenom = 'gregoire' AND
> L.Id = A.Lieu AND
> L.CP = '69003'
>
>
> Ma question est toute bête. Sachant que la base va contenir
plusieurs
> milions d'enregistrements (j'ai testé avec 15 millions), comment
puis-je
> amélioré la rapidité de mes requetes car elle
prennent actuellement
> entre 10 et 60 secondes.
>
>
> Merci à tous de vos réponses
>
un jour mon prof m'a dit : Une bonne base est une base ou tous les champs sont indéxés ... c'est vrai que c'est plus rapide en recherche après, mais bon, ca prend plus de place non ?
cordialement chris
"bruno reiter [MVP]" a écrit dans le message de news:
en mettant des index au moins pour les colonnes utilisées dans les clauses
where
et les jointures
br
Anonyme wrote in message news: > Salut à tous. > > > Dans le cas d'un projet pour un client, je suis en train de mettre en > place un annuaire téléphonique sur un serveur SQL 2000. > > La plupart des requetes porteront sur un scoring prénom et lieu (ville > et/ou codepostal) > > La structure actuelle de la base est donc la suivant: > > |---------------------| > | table prenoms | > |---------------------| > | Id int | <- clé primaire > | Prenom varchar(64)| > |---------------------| > > > |---------------------| > | table lieux | > |---------------------| > | Id int | <- clé primaire > | Ville varchar(64)| > | CP char(5) | > |---------------------| > > > |---------------------| > | table annuaire | > |---------------------| > | Id int | <- clé primaire > | Nom varchar(64)| > | Prenom int | <- index > | Lieu int | <- index > | Tel varchar(10)| > |---------------------| > > Les requetes types sont du genre: > SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L > WHERE > P.Id = A.Prenom AND > P.Prenom = 'gregoire' AND > L.Id = A.Lieu AND > L.CP = '69003' > > > Ma question est toute bête. Sachant que la base va contenir plusieurs > milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je > amélioré la rapidité de mes requetes car elle prennent actuellement > entre 10 et 60 secondes. > > > Merci à tous de vos réponses >
bruno reiter [MVP]
Je pense qu'il y avait un contexte ;-)
les index sont bons en lecture, ils sont couteux en écriture.
donc une bonne base OLAP est très indexée, une bonne base OLTP est peu indexée.
et comme souvent une base est d'usage mixte, il faut des compromis, heureusement pour nous, on vit de ça ;-)
br
"chris" wrote in message news:3fe3be44$0$1177$
un jour mon prof m'a dit : Une bonne base est une base ou tous les champs sont indéxés ... c'est vrai que c'est plus rapide en recherche après, mais bon, ca prend plus de place non ?
cordialement chris
"bruno reiter [MVP]" a écrit dans le message de news: > en mettant des index au moins pour les colonnes utilisées dans les clauses where > et les jointures > > br > > "Grégoire PAILLER" wrote in message > news: > > Salut à tous. > > > > > > Dans le cas d'un projet pour un client, je suis en train de mettre en > > place un annuaire téléphonique sur un serveur SQL 2000. > > > > La plupart des requetes porteront sur un scoring prénom et lieu (ville > > et/ou codepostal) > > > > La structure actuelle de la base est donc la suivant: > > > > |---------------------| > > | table prenoms | > > |---------------------| > > | Id int | <- clé primaire > > | Prenom varchar(64)| > > |---------------------| > > > > > > |---------------------| > > | table lieux | > > |---------------------| > > | Id int | <- clé primaire > > | Ville varchar(64)| > > | CP char(5) | > > |---------------------| > > > > > > |---------------------| > > | table annuaire | > > |---------------------| > > | Id int | <- clé primaire > > | Nom varchar(64)| > > | Prenom int | <- index > > | Lieu int | <- index > > | Tel varchar(10)| > > |---------------------| > > > > Les requetes types sont du genre: > > SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L > > WHERE > > P.Id = A.Prenom AND > > P.Prenom = 'gregoire' AND > > L.Id = A.Lieu AND > > L.CP = '69003' > > > > > > Ma question est toute bête. Sachant que la base va contenir plusieurs > > milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je > > amélioré la rapidité de mes requetes car elle prennent actuellement > > entre 10 et 60 secondes. > > > > > > Merci à tous de vos réponses > > > > > > > > -- > > Grégoire PAILLER > > AllCore - Dirigeant > > > > (enlever 2 des 3 tirets pour m'écrire) > >
Je pense qu'il y avait un contexte ;-)
les index sont bons en lecture, ils sont couteux en écriture.
donc une bonne base OLAP est très indexée, une bonne base OLTP est peu indexée.
et comme souvent une base est d'usage mixte, il faut des compromis, heureusement
pour nous, on vit de ça ;-)
br
"chris" <chris.afpa_nospam@laposte.net> wrote in message
news:3fe3be44$0$1177$636a55ce@news.free.fr...
un jour mon prof m'a dit :
Une bonne base est une base ou tous les champs sont indéxés ...
c'est vrai que c'est plus rapide en recherche après, mais bon, ca prend plus
de place non ?
cordialement
chris
"bruno reiter [MVP]" <remove.this.br33@bol.com.br> a écrit dans le message
de news:uPM6lAjxDHA.3208@tk2msftngp13.phx.gbl...
> en mettant des index au moins pour les colonnes utilisées dans les clauses
where
> et les jointures
>
> br
>
> "Grégoire PAILLER" <gregg@p---gregg.com> wrote in message
> news:eLzXQjixDHA.3216@TK2MSFTNGP11.phx.gbl...
> > Salut à tous.
> >
> >
> > Dans le cas d'un projet pour un client, je suis en train de mettre en
> > place un annuaire téléphonique sur un serveur SQL 2000.
> >
> > La plupart des requetes porteront sur un scoring prénom et lieu (ville
> > et/ou codepostal)
> >
> > La structure actuelle de la base est donc la suivant:
> >
> > |---------------------|
> > | table prenoms |
> > |---------------------|
> > | Id int | <- clé primaire
> > | Prenom varchar(64)|
> > |---------------------|
> >
> >
> > |---------------------|
> > | table lieux |
> > |---------------------|
> > | Id int | <- clé primaire
> > | Ville varchar(64)|
> > | CP char(5) |
> > |---------------------|
> >
> >
> > |---------------------|
> > | table annuaire |
> > |---------------------|
> > | Id int | <- clé primaire
> > | Nom varchar(64)|
> > | Prenom int | <- index
> > | Lieu int | <- index
> > | Tel varchar(10)|
> > |---------------------|
> >
> > Les requetes types sont du genre:
> > SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L
> > WHERE
> > P.Id = A.Prenom AND
> > P.Prenom = 'gregoire' AND
> > L.Id = A.Lieu AND
> > L.CP = '69003'
> >
> >
> > Ma question est toute bête. Sachant que la base va contenir plusieurs
> > milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je
> > amélioré la rapidité de mes requetes car elle prennent actuellement
> > entre 10 et 60 secondes.
> >
> >
> > Merci à tous de vos réponses
> >
> >
> >
> > --
> > Grégoire PAILLER
> > AllCore - Dirigeant
> > gregg@p---gregg.com
> > (enlever 2 des 3 tirets pour m'écrire)
>
>
les index sont bons en lecture, ils sont couteux en écriture.
donc une bonne base OLAP est très indexée, une bonne base OLTP est peu indexée.
et comme souvent une base est d'usage mixte, il faut des compromis, heureusement pour nous, on vit de ça ;-)
br
"chris" wrote in message news:3fe3be44$0$1177$
un jour mon prof m'a dit : Une bonne base est une base ou tous les champs sont indéxés ... c'est vrai que c'est plus rapide en recherche après, mais bon, ca prend plus de place non ?
cordialement chris
"bruno reiter [MVP]" a écrit dans le message de news: > en mettant des index au moins pour les colonnes utilisées dans les clauses where > et les jointures > > br > > "Grégoire PAILLER" wrote in message > news: > > Salut à tous. > > > > > > Dans le cas d'un projet pour un client, je suis en train de mettre en > > place un annuaire téléphonique sur un serveur SQL 2000. > > > > La plupart des requetes porteront sur un scoring prénom et lieu (ville > > et/ou codepostal) > > > > La structure actuelle de la base est donc la suivant: > > > > |---------------------| > > | table prenoms | > > |---------------------| > > | Id int | <- clé primaire > > | Prenom varchar(64)| > > |---------------------| > > > > > > |---------------------| > > | table lieux | > > |---------------------| > > | Id int | <- clé primaire > > | Ville varchar(64)| > > | CP char(5) | > > |---------------------| > > > > > > |---------------------| > > | table annuaire | > > |---------------------| > > | Id int | <- clé primaire > > | Nom varchar(64)| > > | Prenom int | <- index > > | Lieu int | <- index > > | Tel varchar(10)| > > |---------------------| > > > > Les requetes types sont du genre: > > SELECT A.Nom, P.Prenom, L.Ville FROM annuaire A, prenoms P, lieux L > > WHERE > > P.Id = A.Prenom AND > > P.Prenom = 'gregoire' AND > > L.Id = A.Lieu AND > > L.CP = '69003' > > > > > > Ma question est toute bête. Sachant que la base va contenir plusieurs > > milions d'enregistrements (j'ai testé avec 15 millions), comment puis-je > > amélioré la rapidité de mes requetes car elle prennent actuellement > > entre 10 et 60 secondes. > > > > > > Merci à tous de vos réponses > > > > > > > > -- > > Grégoire PAILLER > > AllCore - Dirigeant > > > > (enlever 2 des 3 tirets pour m'écrire) > >
