Discussion :

[Sadneth]

bonjour,

j'ai un traitement dans une appli web qui me bouffe pas mal de ressource. Je souhaiterai donc faire une procédure stockée pour accélérer les traitements.

Partons de la requête suivante :

select * from T_ES

Description de la table :

CD_ES, varchar de 5 (clé primaire)
LB_ES, varchar de 50
CD_ESRGPT, varchar de 5 (clé étrangère pointant sur CD_ES)

Dans CD_ESRGPT (qui veut dire Code de l'ES de regroupement), si j'ai quelque chose de rempli, c'est une ES de regroupement.

La demande de mon client est :

Je renseigne une ES et je dois donc descendre sa hiérarchie (je dois donc partir de CD_ESRGPT.

Par exemple pour l'ES donné 00001 (Appelons ça le niveau N),

je vais faire :

select CD_ES, CD_LB_ES, CD_ESRGPT from T_ES
WHERE CD_ESRGPT = '00001'

L'analyseur de requête me renvoeit par exemple :

00002, toto, 00001
00003, titi, 00001
00004, tati, 00001

Appelons ça le niveau N-1 et amusons nous à descendre le niveau N-2 !

Manuellement, je vais faire :

select CD_ES, CD_LB_ES, CD_ESRGPT from T_ES
WHERE CD_ESRGPT in ('00002', '00003', '00004')

L'anyseur de requête me renverrait tjs dans notre exemple :

00005, dzadaz, 00002
00006, rtgerger, 00002
00007, ezfezf, 00003
00008, jlefklzef, 00003
00009, mlkfezf, 00003

En gros, faudrait que la procédure stockée me renvoit directement quand je lui envoit en paramètre (sans tri imposer, ni groupement) 00001 :

00002, toto, 00001
00003, titi, 00001
00004, tati, 00001
00005, dzadaz, 00002
00006, rtgerger, 00002
00007, ezfezf, 00003
00008, jlefklzef, 00003
00009, mlkfezf, 00003

Le problème n'étant pas spécialement débutant dans les procédures stockées, mais dès que c'est complexe, je fuis et du coup, là ca devient carrément urgent ne sachant pas comment faire....

[inoussa]

Salut.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
--CREATE TABLE Test( cle Int PRIMARY KEY, Libelle varchar(50), ext int)
 
CREATE FUNCTION fnSearch( @Aext Int)
  RETURNS @_ret TABLE( cle Int PRIMARY KEY, Libelle varchar(50), ext int) AS 
BEGIN
 
  DECLARE @_tmp TABLE( cle Int PRIMARY KEY) 
  DECLARE @_tmp2 TABLE( cle Int PRIMARY KEY, Libelle varchar(50), ext int) 
  DECLARE @i Int
 
  INSERT @_tmp SELECT cle FROM Test WHERE ( ext = @Aext )
  WHILE ( Exists( SELECT * FROM @_tmp ) ) BEGIN
    DELETE @_tmp2
    SELECT TOP 1 @i = cle FROM @_tmp  
 
    INSERT @_tmp2 
      SELECT cle, Libelle, ext 
        FROM Test 
        WHERE ( cle = @i ) Or ( ext = @i )
 
    INSERT @_ret
      SELECT t.cle, t.Libelle, t.ext
        FROM @_tmp2 t
        LEFT JOIN @_ret r
          ON ( r.cle = t.cle )
        WHERE ( r.cle IS NULL )
 
    INSERT @_tmp 
      SELECT t.cle
        FROM @_tmp2 t
        LEFT JOIN @_tmp r
          ON ( r.cle = t.cle )
        WHERE ( r.cle IS NULL )
 
    DELETE @_tmp WHERE ( cle = @i )
  END
 
  RETURN
END

[Sadneth]

bonjour

merci de la réponse inoussa mais j'ai du mal à te décrypter. Pourrais tu stp me commenter ce que tu as fait ?

[Sadneth]

bah en fait, je ne comprends pas pkoi ca s'est transformé en fonction ?

@ la base, je désirais créer une proc stockée

[inoussa]

Salut.
Pour avoir la procedure:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
CREATE PROCEDURE psSearch( @Aext Int) AS
BEGIN
  SELECT * FROM dbo.fnSearch( @Aext )
END

[inoussa]

En ce qui concerne l'algorithme, c'est le parcours d'un arbre à l'aide d'une pile. Les reccursivités simples sont tranformables en boucle(en utilisant les piles). Les avantages sont notamment:
-profndeur plus accrue(avec les fonctions reccursives sous SQL SERVER 2000 tu es limité à 32 )
-Plus de performance( pas d'appel de fonction )

L'inconvenient que je trouve c'est que c'est un peu plus compliqué.