Forum du club des développeurs et IT Pro - Blogs - escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/ Developpez.com, le Club des Développeurs et IT Pro fr Fri, 01 May 2026 20:28:46 GMT vBulletin 15 https://forum.developpez.be/images/misc/rss.jpg Forum du club des développeurs et IT Pro - Blogs - escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/ DB2 for Z/OS : créer un calendrier https://www.developpez.net/forums/blogs/795608-escartefigue/b10667/db2-for-z-os-creer-calendrier/ Fri, 31 Jan 2025 14:30:46 GMT Créer un calendrier par... Créer un calendrier par requête est un besoin fréquent et assez simple à mettre en œuvre.

Les fonctions date et chaîne de caractères étant assez différentes d'un dialecte SQL à l'autre en fonction du SGBD-R sous-jacent, voici la variante DB2 for Z/OS, qu'on pourra assez facilement décliner pour tout autre SGBD-R.

Ici, le calendrier contiendra une ligne par date avec :
  • le N° du jour dans la semaine au format ISO (de 1=lundi à 7=dimanche) ;
  • le libellé du jour, ici j'ai préféré ne pas utiliser la fonction DAYNAME, rarement implémentée sur les sites Z/OS ;
  • le quantième ;
  • le numéro de semaine ;
  • la notion de jour ouvrable O/N applicable en France, hors spécificités régionales.


Pour les jours ouvrables, seuls ceux calculables sont affectés par la requête, les jours variables (Pâques, ascension...) seront à corriger manuellement post requête.
Comme il s'agit ici d'un calendrier global, les particularités régionales (Alsace et Moselle, Guadeloupe, Guyane...) ne sont pas prises en compte.
De la même façon, la notion de jour ouvré étant propre à chaque site, elle n'est pas gérée ici : le cas échéant, il faut créer un calendrier par site.

La requête (on adaptera la date de début et le nombre de dates à stocker en fonction du besoin) :

Code SQL : 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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
-- creation d'un calendrier à partir d'une date de début DTDEB                 
-- et pour un nombre de jours paramétré                                        
   with T0(DTDEB) as                                                           
       (select '2025-01-01'                                                    
        from SYSIBM.SYSDUMMY1                                                  
       )                                                                       
-- la fonction DAYNAME est rarement implémentée, d'où T1 "en dur"              
      , T1(T1JNUM, T1JNOM) as                                                  
       (select 1, 'lundi'    from SYSIBM.SYSDUMMY1   union all                 
        select 2, 'mardi'    from SYSIBM.SYSDUMMY1   union all                 
        select 3, 'mercredi' from SYSIBM.SYSDUMMY1   union all                 
        select 4, 'jeudi'    from SYSIBM.SYSDUMMY1   union all                 
        select 5, 'vendredi' from SYSIBM.SYSDUMMY1   union all                 
        select 6, 'samedi'   from SYSIBM.SYSDUMMY1   union all                 
        select 7, 'dimanche' from SYSIBM.SYSDUMMY1                             
       )                                                                       
      , T2(T2DTE, T2JNUM, T2JNOM, T2QQQ, T2SEM, T2OUV, T2SEQ) as               
       (select  cast(DTDEB as date)                                            
             ,  dayofweek_iso(DTDEB)                                           
             ,  T1JNOM                                                         
             ,  days(DTDEB)-days(substr(DTDEB, 01, 05) !! '01-01') + 1         
             ,  week_iso(DTDEB)                                                
             ,  case when dayofweek_iso(DTDEB)  = 7       then 0               
                     when substr(DTDEB, 06, 05) = '01-01' then 0               
                     when substr(DTDEB, 06, 05) = '05-01' then 0               
                     when substr(DTDEB, 06, 05) = '05-08' then 0               
                     when substr(DTDEB, 06, 05) = '07-14' then 0               
                     when substr(DTDEB, 06, 05) = '08-15' then 0               
                     when substr(DTDEB, 06, 05) = '11-01' then 0               
                     when substr(DTDEB, 06, 05) = '11-11' then 0               
                     when substr(DTDEB, 06, 05) = '12-25' then 0               
                     else 1                                                    
                end                                                            
             ,  cast(1 as smallint)                                            
        from T0                                                                
        inner join T1                                                          
           on T1JNUM=DAYOFWEEK_ISO(DTDEB)                                      
        union all                                                              
        select  T2DTE + 1 days                                                 
             ,  DAYOFWEEK_ISO(T2DTE + 1 days)                                  
             ,  T1JNOM                                                         
             ,  days(T2DTE + 1 days)                                           
                - days(substr(char(T2DTE), 01, 05) !! '01-01') + 1             
             ,  week_iso(T2DTE + 1 days)                                       
             ,  case when dayofweek_iso(T2DTE + 1 days)  = 7  then 0           
                     when substr(char(T2DTE+1 days), 06, 05) ='01-01'          
                     then 0                                                    
                     when substr(char(T2DTE+1 days), 06, 05) ='05-01'          
                     then 0                                                    
                     when substr(char(T2DTE+1 days), 06, 05) ='05-08'          
                     then 0                                                    
                     when substr(char(T2DTE+1 days), 06, 05) ='07-14'          
                     then 0                                                    
                     when substr(char(T2DTE+1 days), 06, 05) ='08-15'          
                     then 0                                                    
                     when substr(char(T2DTE+1 days), 06, 05) ='11-01'          
                     then 0                                                    
                     when substr(char(T2DTE+1 days), 06, 05) ='11-11'          
                     then 0                                                    
                     when substr(char(T2DTE+1 days), 06, 05) ='12-25'          
                     then 0                                                    
                     else 1                                                    
                end                                                            
             ,  T2SEQ + 1                                                      
        from T2                                                                
        inner join T1                                                          
           on T1JNUM=DAYOFWEEK_ISO(T2DTE + 1 days)                             
        where   T2SEQ < 366                                                    
       )                                                                       
   select T2DTE, T2JNUM, T2JNOM, T2QQQ, T2SEM, T2OUV                           
   from T2                                                                     
   order by T2DTE                                                              
   ;

Résultat (extrait) :

Nom : Sans titre.png Affichages : 3248 Taille : 41,6 Ko ]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10667/db2-for-z-os-creer-calendrier/ SQL et logique trivaluée : null vs vide https://www.developpez.net/forums/blogs/795608-escartefigue/b10585/sql-logique-trivaluee-null-vs-vide/ Thu, 29 Feb 2024 15:26:54 GMT Il est important de... Il est important de comprendre la différence entre une colonne marquée "Null" et une colonne dont la valeur est vide.
Confondre l'un et l'autre est une source fréquente d'erreurs.


NULL :
  • null n'est pas une valeur, mais un marqueur d'absence de valeur ;
  • null est applicable sur tout type de colonnes (caractère, numérique, date...) à l'exception bien entendu de celles ayant une contrainte "not null" 
    mais null est obtenu en cas de jointure externe (OUTER JOIN) non satisfaite, y compris si la colonne concernée est marquée "not null" ;
  • null est à prendre en compte dans les tables de décision avec les opérateurs AND, OR et NOT (voir plus bas) ;
  • comme Null est une absence de valeur, on ne peut pas écrire IF MA_COLONNE = null, car null n'est égal à rien, pas même à null ! On écrira donc IF MA_COLONNE is null ;
  • pour remplacer une réponse "Null" par une valeur, on peut utiliser au choix la fonction ISNULL() ou COALESCE().



VIDE :
  • vide n'a de sens que pour les types chaînes de caractères (char, varchar, nchar, nvarchar, text) ;
  • IF MA_COLONNE = '' est une expression valide puisque vide est une valeur.



L'exemple suivant, applicable sur tous les SGBD à l'exception d'Oracle qui confond allègrement "null" et vide, au mépris des normes SQL et de toute logique :aie: , montre bien ces différences entre chaîne vide et marqueur "null" :

Code SQL : 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
-- création d'une table dont toutes les colonnes sont "nullables" 
-- pour démonstration : null <> vide
create table T1
      (  T1INTG  integer
       , T1CHA1  char(4)
       , T1CHA2  char(4)  
       , T1DATE  date
      )
;
insert into T1(T1INTG, T1CHA1, T1CHA2, T1DATE)
values (0001, 'TOTO', 'TOTO', '2024-02-27')
     , (0002,  null,   '',     null       )
     , (null, 'TITI', 'TOTO', '2024-02-28')
;
-- insertion d'une valeur vide dans des colonnes de type char : pas de problème
insert into T1(T1INTG, T1CHA1, T1CHA2, T1DATE)
values (0004, ''    , '',     '2024-02-29')
     , (0005,  null , null,   '2024-02-29')
;
select T1INTG
     , T1CHA1
     , T1CHA2  
     , T1DATE 
     , case when T1CHA1 = T1CHA2 then 'égal'  
            else 'différent'
       end as "CHA1/CHA2"
from T1
;
-- tentative d'insertion d'une valeur vide dans une colonne d'un autre type : KO
insert into T1(T1INTG, T1CHA1, T1CHA2, T1DATE)
values (0005, 'XXXX', 'YYYY', '')

Résultat (le message d'erreur de la tentative d'insertion d'un "vide" dans une colonne de type non char dépend du SGBD, ici c'est sous MySQL 8.0 :
Nom : Sans titre.png Affichages : 17906 Taille : 10,1 Ko


Table de décision avec les marqueurs "null"

Nom : Sans titre.png Affichages : 2800 Taille : 5,2 Ko ]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10585/sql-logique-trivaluee-null-vs-vide/ <![CDATA[DB2 for Z/OS : analyser l'impact d'un DROP TABLE]]> https://www.developpez.net/forums/blogs/795608-escartefigue/b10564/db2-for-z-os-analyser-l-impact-d-drop-table/ Thu, 28 Dec 2023 10:34:09 GMT La requête ci-dessous permet... La requête ci-dessous permet d'identifier les impact de la destruction d'une table sur les objets dépendants (table spaces, vues, triggers...)


Code SQL : 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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
-- analyse d'impact d'un drop de table(s)                                      
   set current_schema = 'SYSIBM'                                               
   ;                                                                           
-- schemas/tables à analyser                                                   
   with CT1(SCH1, TAB1) as                                                     
       (select 'REC1', 'TR01' from SYSIBM.SYSDUMMY1   union all                
        select 'REC2', 'TA60' from SYSIBM.SYSDUMMY1                   
       )                                                                       
-- 1°) impact table space                                                      
select C1 as "Creator"                                                         
     , C2 as "Table"                                                           
     , C3 as "Type obj"                                                        
     , C4 as "Nom obj"                                                         
     , C5 as "Infos"                                                           
from (                                                                         
      select substr(CREATOR, 01, 08)   as C1                                   
           , substr(NAME, 01, 08)      as C2                                   
           , 'Table Space'             as C3                                   
           , cast(TSNAME as char(25))  as C4                                   
           , cast(DBNAME as char(10))  as C5                                                                                                         
           , 01                        as C6                                   
      from SYSTABLES                                                           
      inner join CT1                                                           
         on CREATOR = SCH1                                                     
        and NAME    = TAB1                                                     
      where TYPE = 'T'                                                         
-- 2°) impact vues                                                             
      union all                                                                
      select substr(BSCHEMA, 01, 08)   as C1                                   
           , substr(BNAME, 01, 08)     as C2                                   
           , 'View       '             as C3                                   
           , cast(DNAME as char(25))   as C4                                   
           , cast(DSCHEMA as char(10)) as C5                                   
           , 02                        as C6                                   
      from SYSDEPENDENCIES                                                     
      inner join CT1                                                           
         on BNAME        = TAB1                                                
        and BSCHEMA      = SCH1                                                
      where BTYPE = 'T'                                                        
-- 3°) impact index                                                            
      union all                                                                
      select substr(TBCREATOR, 01, 08)  as C1                                  
           , substr(TBNAME, 01, 08)     as C2                                  
           , 'Index      '              as C3                                  
           , cast(NAME as char(25))     as C4                                  
           , cast(case when uniquerule = 'P' and clustering='Y'                
                            then 'PK-Cluster'                                  
                       when uniquerule = 'P' and clustering='N'                
                            then 'PK-Non Cls'                                  
                       when uniquerule<> 'D' and clustering='Y'                
                            then 'U -Cluster'                                  
                       when uniquerule<> 'D' and clustering='N'                
                            then 'U -Non Cls'                                  
                       when uniquerule = 'D' and clustering='Y'                
                            then 'Dup-Clust.'                                  
                       when uniquerule = 'D' and clustering='N'                
                            then 'Dup-NonCls'                                  
                   end as char(10))     as C5                                  
           , 03                         as C6                                  
      from SYSINDEXES                                                          
      inner join CT1                                                           
         on TBNAME       = TAB1                                                
        and TBCREATOR    = SCH1                                                
-- 4°) impact alias                                                            
      union all                                                                
      select substr(SCH1, 01, 08)       as C1                                  
           , substr(TBNAME, 01, 08)     as C2                                  
           , 'Alias      '              as C3                                  
           , cast(NAME as char(25))     as C4                                  
           , cast(CREATOR as char(10))  as C5                                  
           , 04                         as C6                                  
      from SYSTABLES                                                           
      inner join CT1                                                           
         on TBNAME       = TAB1                                                
        and TBCREATOR    = SCH1                                                
      where TYPE = 'A'                                                         
-- 5°) impact rules "on delete"                                                
      union all                                                                
      select substr(REFTBCREATOR, 01, 08) as C1                                
           , substr(REFTBNAME, 01, 08)    as C2                                
           , 'Rule       '                as C3                                
           , cast(RELNAME as char(25))    as C4                                
           , cast(TBNAME as char(10))     as C5                                
           , 05                           as C6                                
      from SYSRELS                                                             
      inner join CT1                                                           
         on REFTBNAME    = TAB1                                                
        and REFTBCREATOR = SCH1                                                
-- 6°) impact triggers                                                         
      union all                                                                
      select substr(TBOWNER, 01, 08)       as C1                               
           , substr(TBNAME, 01, 08)        as C2                               
           , 'Trigger    '                 as C3                               
           , cast(substr(NAME, 01, 25) as char(25)) as C4                      
           , cast(case when TRIGTIME = 'B' then 'Before  '                     
                       when TRIGTIME = 'A' then 'After   '                     
                       else                     'Instead '                     
                  end                                                          
                  !! TRIGEVENT as char(10))         as C5                      
           , 06                            as C6                               
      from SYSTRIGGERS                                                         
      inner join CT1                                                           
         on TBNAME       = TAB1                                                
        and TBOWNER      = SCH1                                                
-- 7°) impact packages                                                         
      union all                                                                
      select substr(BQUALIFIER, 01, 08)    as C1                               
           , substr(BNAME, 01, 08)         as C2                               
           , 'Package    '                 as C3                               
           , cast(DNAME as char(25))       as C4                               
           , cast(DCOLLID as char(10))     as C5                               
           , 07                            as C6                               
      from SYSPACKDEP                                                          
      inner join CT1                                                           
         on BNAME        = TAB1                                                
        and BQUALIFIER   = SCH1                                                
     )                                                                         
order by C1, C2, C6                                                            
;


Exemple de résultat :

Nom : Tab.png Affichages : 133 Taille : 18,9 Ko ]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10564/db2-for-z-os-analyser-l-impact-d-drop-table/ DB2 for Z/OS : analyser les index https://www.developpez.net/forums/blogs/795608-escartefigue/b10553/db2-for-z-os-analyser-index/ Wed, 29 Nov 2023 12:44:55 GMT Voici une requête permettant... Voici une requête permettant d'extraire du catalogue DB2 les éléments relatifs aux index des tables, l'index primaire est restitué en premier, les index uniques ensuite, puis les index multiples.


Code SQL : 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
40
41
42
43
44
45
-- Cette requete extrait les informations liées aux index d'une table           
-- PUD = P (primary) soit unique et not null, U (unique), D (duplicate)         
-- Cls = Y (index cluster), N (non cluster)                                     
-- Ratio = cluster ratio si c'est un index cluster (>=95%, c'est optimal)       
-- Kseq = ordre de la colonne dans l'index                                      
-- Col  = nom de la colonne                                                     
-- Typ  = type de la colonne                                                    
-- Lng  = longueur de la colonne                                                
-- Paramêtres à modifier en fonction du besoin :                                
--   IX.TBCREATOR                                                               
--   IX.TBNAME                                                                  
   set CURRENT SCHEMA = 'SYSIBM'                                                
   ;                                                                            
   select substr(IX.TBCREATOR, 01, 04)  as "Schm"                               
        , substr(IX.TBNAME, 01, 08)     as "Table"                              
        , substr(IX.NAME  , 01, 08)     as "Index"                              
        , IX.UNIQUERULE                 as "PUD"                                
        , IX.CLUSTERING                 as "Cls"                                
        , case when IX.CLUSTERING = 'Y'                                         
                    then substr(digits(IX.CLUSTERRATIO), 3, 3)                  
               else ' - '                                                       
          end                           as "Ratio"                              
        , KY.COLSEQ                     as "KSeq"                               
        , substr(KY.COLNAME, 01, 30)    as "Col"                                
        , KY.ORDERING                   as "Ord"                                
        , CO.COLTYPE                    as "Typ"                                
        , CO.LENGTH                     as "Lng"                                
   from SYSINDEXES       as IX                                                  
   left join SYSKEYS     as KY                                                  
     on KY.IXCREATOR = IX.TBCREATOR                                             
    and KY.IXNAME    = IX.NAME                                                  
   left join SYSCOLUMNS  as CO                                                  
     on CO.TBCREATOR = IX.TBCREATOR                                             
    and CO.TBNAME    = IX.TBNAME                                                
    and CO.NAME      = KY.COLNAME                                               
   where IX.TBCREATOR = 'SCH1'                                                  
     and IX.TBNAME    = 'TABX'                                                  
   order by "Schm"                                                              
          , "Table"                                                             
          , case when "PUD" = 'P' then 0                                        
                 when "PUD" = 'U' then 1                                        
                 else 2                                                         
            end                                                                 
          , "Index"                                                             
   ;
]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10553/db2-for-z-os-analyser-index/ DB2 for Z/OS : analyser les contraintes CHECK et REFERENCE https://www.developpez.net/forums/blogs/795608-escartefigue/b10552/db2-for-z-os-analyser-contraintes-check-reference/ Wed, 29 Nov 2023 10:49:54 GMT Voici des requêtes qui... Voici des requêtes qui permettent d'extraire du catalogue les informations relatives aux contraintes de contenu (CHECK) et de référence à des clefs étrangères (REFERENCE FOREIGN KEY) sur DB2 for Z/OS
Les noms d'objets sont restitués sur 8 caractères, car c'est la longueur maximale la plus souvent utilisée dans le monde Z/OS pour des raisons historiques, à adapter si besoin.

Contraintes de contenu :

Code SQL : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
-- liste des contraintes CHECK                             
   select substr(TBOWNER,   01, 08)  as "Schema"           
        , substr(TBNAME,    01, 08)  as "Table"            
        , substr(CHECKNAME, 01, 30)  as "Nom"              
        , CHECKCONDITION             as "Cond"             
   from  SYSIBM.SYSCHECKS                                  
   where TBOWNER = 'SCH1'                                  
   order by 1, 2, 3                                        
   ;


Contraintes de référence à des clefs étrangères :

Code SQL : 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
-- Cette requete analyse les contraintes d'intégrité entre tables               
   set current schema = 'SYSIBM'                                  
   ;                                                              
   with CT1(SCH1, TAB1) as                                        
       (select 'SCH0', 'T020' from SYSIBM.SYSDUMMY1   union all   
        select 'SCH0', 'T021' from SYSIBM.SYSDUMMY1               
       )                                                          
   select distinct                                                
          substr(RL.CREATOR, 01, 4)     as "Schm"                 
        , substr(RL.REFTBNAME, 01, 08)  as "ParentTb"             
        , substr(RL.TBNAME, 01, 08)     as "Child Tb"             
        , substr(RL.RELNAME, 01, 20)    as "Constr"               
        , RL.DELETERULE                 as "OnDel"                
        , RL.ENFORCED                   as "Enf"                  
        , RL.CHECKEXISTINGDATA          as "Chk"                  
        , substr(KY.COLNAME, 01, 08)    as "ParenCol"             
        , KY.COLNO                      as "PColNo"               
        , substr(FK.COLNAME, 01, 08)    as "ChildCol"             
        , FK.COLNO                      as "CColNo"               
   from  SYSRELS  RL                                              
   inner join CT1 CT                                              
      on (RL.CREATOR      = CT.SCH1  and  RL.TBNAME    = CT.TAB1) 
      or (RL.REFTBCREATOR = CT.SCH1  and  RL.REFTBNAME = CT.TAB1) 
   inner join SYSFOREIGNKEYS FK                                   
      on FK.CREATOR = RL.CREATOR                                  
     and FK.RELNAME = RL.RELNAME                                  
   left  join SYSKEYS KY                                          
      on KY.IXCREATOR=CT.SCH1                                     
     and KY.IXNAME   =RL.IXNAME                                   
     and KY.COLSEQ   =FK.COLSEQ                                   
   order by "ParentTb"                                            
          , "Child Tb"                                            
          , "Constr"                                              
          , "CColNo"                                              
   ;

On rappellera que dans une base de données relationnelle, seules les les contraintes de type REFERENCE permettent de garantir l'intégrité parent/enfant.
Malheureusement, on rencontre un grand nombre de sites dans lesquels aucune contrainte de ce type n'est installée, sous toutes sortes de prétextes, parfois avancés par les DBA eux-mêmes... et tant pis pour l'intégrité !
Jusqu'à aujourd'hui, je n'ai jamais vu de site dépourvu de contrainte REFERENCE et sur lequel aucun orphelin n'existait... ]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10552/db2-for-z-os-analyser-contraintes-check-reference/ DB2 for Z/OS : analyser le besoin de réorganisation https://www.developpez.net/forums/blogs/795608-escartefigue/b10551/db2-for-z-os-analyser-besoin-reorganisation/ Wed, 29 Nov 2023 10:03:57 GMT Voici une requête qui permet... Voici une requête qui permet de vérifier le cluster ratio des index cluster sur DB2 for Z/OS, et donc, le besoin éventuel d'exécuter des réorgs.

Les noms d'objets sont restitués sur 8 caractères, car c'est la longueur maximale la plus souvent utilisée dans le monde Z/OS pour des raisons historiques, à adapter si besoin.

Si le cluster ratio est fortement dégradé, il faut peut-être augmenter la fréquence des réorgs ou augmenter la valeur du paramètre PCTFREE pour les tables à insertion fréquente et volumineuse.
Peut-être également qu'un événement inhabituel a fortement chargé les TS concernés, auquel cas une surveillance particulière aurait due être mise en place.

Sur Z/OS, l'essentiel des requêtes est livré dans des packages, il faut donc penser à exécuter les statistiques si elles n'ont pas été activées lors des réorgs, puis à faire un REBIND des packages pour qu'ils reconsidèrent leur chemin d'accès.

Code SQL : 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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
-- Cette requete analyse la désorganisation des tablespaces en vérifiant le     
-- cluster ratio des index cluster et restitue le nombre de MàJ depuis la       
-- dernière réorg                                                               
-- Le ratio est bon si >= 95%                                                   
-- Paramêtres à modifier en fonction du besoin :                                
--    TB.CREATOR et TB.NAME dans le WHERE                                       
   set current schema = 'SYSIBM'                                                
   ;                                                                            
-- analyse du cluster ratio des index cluster (besoin de réorg ?)               
   select substr(TB.CREATOR, 01, 08)   as SCHEMA                                
        , substr(TB.NAME, 01, 08)      as TABLE                                 
        , substr(IX.NAME, 01, 10)      as INDEX                                 
        , IX.UNIQUERULE                as UNIQ                                  
        , IX.CLUSTERING                as CLSG                                  
        , IX.CLUSTERED                 as CLSD                                  
        , IX.CLUSTERRATIO              as RATIO                                 
        , TB.CARDF                     as CARDF                                 
        , TB.NPAGESF                   as NPAGESF                               
        , subq.RGDAT                   as REOGDATE                              
        , subq.RGISR                   as REORGISR                              
        , subq.RGDEL                   as REORGDEL                              
        , subq.RGUPD                   as REORGUPD                              
   from       SYSTABLES      as TB  -- table des tables                         
   inner join SYSTABLESPACE  as TS  -- table des tablespaces                    
     on  TS.DBID = TB.DBID                                                      
     and TS.NAME = TB.TSNAME                                                    
   inner join SYSINDEXES     as IX  -- table des index                          
     on  IX.TBCREATOR = TB.CREATOR                                              
     and IX.TBNAME    = TB.NAME                                                 
   left  join -- nombre d'insert/delete/update depuis la dernière réorg         
        (select DBID                                                            
              , PSID                                                            
              , date(REORGLASTTIME) as RGDAT                                    
             -- les 3 cols sont "nullables" d'où COALESCE + CAST                
              , sum(cast(coalesce(REORGINSERTS, 0) as bigint)) as RGISR         
              , sum(cast(coalesce(REORGDELETES, 0) as bigint)) as RGDEL         
              , sum(cast(coalesce(REORGUPDATES, 0) as bigint)) as RGUPD         
         from SYSTABLESPACESTATS    -- table des RTS (Real Time Statistics)     
         group by DBID                                                          
                , PSID                                                          
                , DATE(REORGLASTTIME)                                           
        ) subq                                                                  
     on  subq.DBID = TB.DBID                                                    
     and subq.PSID = TS.PSID                                                    
   where IX.CLUSTERING = 'Y'            -- index cluster                        
     and IX.CLUSTERED  = 'N'            -- mal organisé                         
     and TB.TYPE       = 'T'            -- type table                           
     and (TB.CARDF = -1 or TB.CARDF >0) -- sauf tables vides                    
   -- modifier les schemas et préfixes de tables ci-dessous                     
     and TB.CREATOR in ('SCH1', 'SCH2')                                         
     and TB.NAME like 'TR%'                                                    
   order by TB.NAME                                                             
          , TB.CREATOR

Et une autre approche donnant le détail par partition (merci à Bernard59139)

Code SQL : 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
  set CURRENT PRECISION = 'D31.2'                                               
  ;                                                                             
  select substr(RTS.DBNAME, 01, 08)                   as "DataBase"             
       , substr(RTS.NAME, 01, 08)                     as "Table Space"          
       , TP.PARTITION                                 as "Part"                 
       , TS.TYPE                                      as "Type"                 
       , cast (RTS.REORGINSERTS/dec(RTS.TOTALROWS)*100 as dec(5,2))             
                                                      as "RTSIsr%"              
       , cast (RTS.REORGDELETES/dec(RTS.TOTALROWS)*100 as dec(5,2))             
                                                      as "RTSDel%"              
       , cast (RTS.REORGUNCLUSTINS/dec(RTS.TOTALROWS)*100                       
                                        as dec(5,2))  as "UnClus%"              
       , cast ( (RTS.REORGNEARINDREF+RTS.REORGFARINDREF)                        
               / dec(RTS.TOTALROWS)*100 as dec(5,2))  as "Malplace"             
       , cast (replace(varchar_format                                           
                (RTS.REORGMASSDELETE,'999,999,999,999'), ',', ' ')              
                as char(16))                          as "MassDel"              
       , cast (replace(varchar_format                                           
                (RTS.TOTALROWS,'999,999,999,999'), ',', ' ')                    
                as char(16))                          as "TotalRows"            
       , cast (replace(varchar_format                                           
                (RTS.NPAGES,'999,999,999,999'), ',', ' ')                      
                as char(16))                          as "Pages"               
       , RTS.REORGLASTTIME                            as "Last Réorg"          
  from        SYSIBM.SYSTABLESPACESTATS as RTS                                 
  inner join  SYSIBM.SYSTABLESPACE      as TS                                  
     on TS.DBNAME = RTS.DBNAME                                                 
    and TS.NAME   = RTS.NAME                                                   
  inner join  SYSIBM.SYSTABLEPART       as TP                                  
     on TP.DBNAME    = TS.DBNAME                                               
    and TP.TSNAME    = TS.NAME                                                 
    and TP.PARTITION = RTS.PARTITION                                           
  where RTS.TOTALROWS > 50                                                     
    and TS.DBNAME='Ma_database'                                                   
  order by 1, 2, 3                                                             
  ;
]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10551/db2-for-z-os-analyser-besoin-reorganisation/ Quand utiliser SELECT * https://www.developpez.net/forums/blogs/795608-escartefigue/b10457/utiliser-select/ Wed, 19 Apr 2023 14:06:53 GMT On trouve très souvent des... On trouve très souvent des traitements dans lesquels les requêtes utilisent des ordres SELECT *.

Or il faut savoir que, avec SELECT *
  • on transporte des colonnes dont on n'a pas besoin, ce qui charge le réseau inutilement et pénalise les performances :
    - il est très rare qu'on ait besoin de toutes les colonnes d'une table dans un traitement,
    - si la requête utilise des jointures, toutes les colonnes de jointure sont présentes plusieurs fois ;
  • les études d'impact sont difficiles puisqu'on ne sait pas quelles sont les colonnes réellement utiles au traitement ;
  • en cas de modification de la table ou de la vue, le traitement plante ou les résultats sont erronés ;
  • les index couvrants, si présents, sont inutilisables.


Et si le SELECT est utilisé pour réaliser une insertion, en cas d'ajout de colonnes dans la table ou, c'est plus rare, de modification de l'ordre des colonnes, la requête devient invalide !

Pour ces raisons, certaines entreprises interdisent purement et simplement de coder SELECT * dans un livrable !

Les seuls cas où l'on peut s'autoriser SELECT * sont les suivants :
  • requête jetable, exécutée à la volée, mais qui n'a pas vocation à être intégrée dans un livrable ;
  • cas particulier du test d'existence avec (NOT) EXISTS
    En effet, dans ce cas, le SELECT ne transporte qu'un booléen (vrai/faux), il n'y a donc pas d'inconvénient à coder SELECT *.
    Toutefois, le risque subsiste qu'un développeur ne connaissant pas cette particularité copie/colle ce code pour un autre usage, retombant ainsi dans les travers évoqués plus haut.
    C'est pourquoi, pour un test d'existence, je préfère coder SELECT 1 dans la requête corrélée.
]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10457/utiliser-select/ <![CDATA[Renumérotation des identifiants d'une base de données... l'éternelle question]]> https://www.developpez.net/forums/blogs/795608-escartefigue/b10384/renumerotation-identifiants-d-base-donnees-l-eternelle-question/ Fri, 30 Sep 2022 12:21:26 GMT Voici le genre de questions... Voici le genre de questions très fréquemment posées sur ce forum et ailleurs :

Citation Envoyé par un participant
Comment puis-je renuméroter les identifiants de ma table qui présentent des "trous"
ou encore

Citation Envoyé par un autre participant
J'aimerais réorganiser les identifiants de ma table .
Tout d'abord, un peu de sémantique
Dans une base de données, la réorganisation est une opération consistant à défragmenter les espaces physiques de stockage des données et des index.
Pour les pages de données, il s'agit de les ranger selon la séquence de rangement définie par l'index cluster
Pour les pages d'index, il s'agit de de les ranger selon l'ordre des colonnes de l'index
Dans les deux cas, l'opération de réorganisation ne modifie aucune valeur de quelque colonne que ce soit dans les tables !

À l'inverse, une renumérotation modifie la valeur d'une colonne

Il ne faut donc pas confondre réorganisation et renumérotation, ce sont deux opérations bien distinctes


Ensuite, quel est le rôle d'un identifiant ?

Un identifiant au niveau conceptuel (au stade du MCD donc), qui devient clef primaire au niveau SQL, n'a pour fonction que de permettre d'identifier de façon certaine une occurrence d'entité (au niveau conceptuel) et donc une ligne particulière dans une table (au niveau SQL).
Les caractéristiques d'une clef primaire sont d'être unique, stable, non "nullable" et irréductible.
  • Unique : comme son nom l'indique, chaque valeur ne peut exister qu'une seule fois ;
  • Stable : la valeur d'une PK (clef primaire) se propage dans les tables associées au travers des contraintes d'intégrité ;
  • Non "nullable" : la valeur est obligatoire, aucune PK ne peut être marquée "null" ;
  • Irréductible : une sous-partie de la PK ne peut suffire à garantir l'unicité.



Si l'on changeait la valeur d'un identifiant et donc d'une clef primaire (dite "PK" pour Primary Key), c'est le 2e point, la stabilité, qui pose problème : à cause du phénomène de cascade, l'envie autant compulsive qu'inutile de "boucher les trous", peut engendrer des millions, voire des milliards de mises à jour inutiles et mettre à plat la base de données.

Et tout ça pour quoi ?

Une valeur d'identifiant manquante peut être causée par
  • une ligne supprimée par un ordre DELETE ;
  • une insertion non commitée ;
  • un pas d'incrément différent de 1.


De plus, il faut savoir que la valeur des identifiants n'a pas de sens chronologique
  • on peut à tout moment forcer la valeur d'un identifiant dans l'ordre INSERT en en communiquant la valeur  ;
  • sur certains SGBD, les valeurs d'identifiants sont distribuées par paquet pour éviter de solliciter le moteur à chaque insertion, mais bien entendu, l'utilisation des identifiants dans chaque thread concurrent n'est pas obligatoirement choronologique, ainsi, l'identifiant de valeur 100 a très bien pu être commité (validé) après celui de valeur 120.


Enfin, boucher les trous serait un chantier permanent
Comme expliqué plus haut, il est normal que certaines valeurs d'identifiant soient absentes, si on voulait que ce ne soit pas le cas, il faudrait renuméroter en permanence les ID, plusieurs fois par jour même :aie:


Vous avez besoin d'un chrono unique et dont les valeurs sont contiguës ?
utilisez la fonction ROW_NUMBER(), elle est faite pour ça, mais par pitié, ne touchez pas aux identifiants.


Vous avez besoin de connaître la chronologie d'insertion des lignes dans une table
ajoutez une colonne d'horodatage fin, type timestamp, mais n'utilisez jamais les identifiants ]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b10384/renumerotation-identifiants-d-base-donnees-l-eternelle-question/ Combinaisons de jointures INNER et OUTER https://www.developpez.net/forums/blogs/795608-escartefigue/b9908/combinaisons-jointures-inner-outer/ Mon, 23 Nov 2020 16:22:42 GMT Voici un autre sujet qui... Voici un autre sujet qui revient de temps à autres, celui des requêtes incluant à la fois des jointures internes et externes.
Pour combiner ces deux types de jointures, il faut appliquer la syntaxe suivante :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
SELECT [...]
FROM T1
(FULL/LEFT/RIGTH) OUTER JOIN T2
    INNER JOIN T3   
       ON critères de jointure T3/T2
    ON critères de joiture T2/T1
Or, on rencontre souvent des requêtes écrites ainsi
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
SELECT [...]
FROM T1
(FULL/LEFT/RIGTH) OUTER JOIN T2
    ON critères de joiture T2/T1
INNER JOIN T3   
    ON critères de jointure T3/T2
Dans le premier cas, on construit T1 left (T2 inner T3)
Dans le deuxième, on construit (T1 left T2) inner T3

Pour bien voir la différence, vous pouvez copier-coller le jeu d'essai qui suit dans votre interpréteur SQL :

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
with CTE1 (id1, ch1, mt1) as                                  
    (select 001, 'ABC', 100.03           
     union all                                                
     select 002, 'DEF', 025.15           
     union all                                                
     select 003, 'IER', 305.22           
     union all                                                
     select 004, 'BGT', 602.00           
     union all                                                
     select 005, 'XAA', 780.15           
     union all                                                
     select 006, 'REE', 018.77           
     union all                                                
     select 007, 'AZE', 051.66       )   
  , CTE2 (id2, dt2, id1) as                               
   (select 001, '2018-01-05', 004    
    union all                                             
    select 004, '2018-01-10', 001    
    union all                                             
    select 002, '2018-01-12', 006    
    union all                                             
    select 005, '2018-01-13', 006    
    union all                                             
    select 006, '2018-01-20', 003   )     
  , CTE3 (id3, mt3, id2) as                                
   (select 001, 800, 001              
    union all                                              
    select 002, 250, 001              
    union all                                              
    select 003, 500, 005              
    union all                                              
    select 004, 200, 006              
    union all                                              
    select 005, 100, 006            )
Qu'obtient-on avec la première requête ?

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
    SELECT T1.ID1           
         , T1.MT1           
         , T1.CH1           
         , T2.ID2           
         , T2.DT2           
         , T3.MT3           
    FROM  CTE1 T1           
    LEFT  JOIN CTE2 T2      
          INNER JOIN CTE3 T3      
             ON T3.ID2 = T2.ID2   
      ON  T2.ID1 = T1.ID1
Le résultat est celui attendu, les colonnes marquées "null" confirment la mise en oeuvre d'une jointure externe (OUTER JOIN) :

Nom : Sans titre.png Affichages : 107 Taille : 12,7 Ko

Qu'en est-il avec l'autre syntaxe ?
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
    SELECT T1.ID1           
         , T1.MT1           
         , T1.CH1           
         , T2.ID2           
         , T2.DT2           
         , T3.MT3           
    FROM  CTE1 T1           
    LEFT  JOIN CTE2 T2      
      ON  T2.ID1 = T1.ID1  
    INNER JOIN CTE3 T3      
      ON  T3.ID2 = T2.ID2
    ;
Plus de marqueur "null", ma requête est traitée comme une jointure interne (INNER JOIN) :

Nom : Sans titre.png Affichages : 105 Taille : 6,4 Ko

Notez que l'ajout de parenthèses ne change rien, seul l'ordre des prédicats de jointure compte. ]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b9908/combinaisons-jointures-inner-outer/ Selectionner la ligne la plus récente pour un critère https://www.developpez.net/forums/blogs/795608-escartefigue/b3239/selectionner-ligne-plus-recente-critere/ Wed, 14 Jun 2017 13:22:53 GMT Le sujet étant archi... Le sujet étant archi récurrent, voici plusieurs méthodes permettant d'identifier la ligne la plus récente ou la plus ancienne pour un critère.

Tout d'abord, il convient de rappeler que les identifiants techniques attribués par le SGBD (identity column, auto_incrément...) ne doivent en aucun cas être utilisés pour ce besoin. En effet, si ces identifiants sont souvent chronologiques en tout début de vie d'une table, quand il y a eu peu d'insertions, ce n'est rapidement plus le cas, dès que cette table vit un peu. Ne tombez donc pas dans ce piège !

Donc, dans les exemples ci-dessous, on utilisera une colonne de type timestamp.

Soit les tables suivantes :
TBB7 :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
B7IDEN   B7CPTE     B7JOUR   B7DBCR 
------ ---------- ---------- ------ 
     1 1234567890 2017-01-02      0 
     2 4455667788 2017-01-15      0 
     3 0012005564 2017-06-14      1 
     4 7564534231 2017-01-14      1 
     5 1111122222 2017-01-16      1
La PK est B7IDEN

TBB8 :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
B8IDEN B8SEQN      B8MONT                 B8DTHR          
------ ------ ----------------- --------------------------
     1      1           145.280 2017-06-14-14.41.06.079306
     1      2           311.470 2017-06-14-14.41.06.097249
     2      2           -16.800 2017-06-14-14.41.06.098156
     2      1            33.210 2017-06-14-14.41.06.098746
     2      3            -5.100 2017-06-14-14.41.06.099171
     4      2           155.250 2017-06-14-14.41.06.103170
     4      3           800.400 2017-06-14-14.41.06.103651
La PK est B8IDEN+B8SEQN
avec une contrainte sur B8IDEN qui fait référence à B7IDEN

L'éternelle question est : comment rechercher la ligne détail la plus récente pour chaque ligne entête

Méthode 1 : utilisation de MAX()
Code sql : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
  SELECT B7IDEN                       
       , B7CPTE                       
       , B8SEQN                       
       , B8MONT                       
       , B8DTHR                       
  FROM TBB7                           
  INNER JOIN TBB8  B8                 
    ON  B8IDEN = B7IDEN               
  WHERE B8DTHR =                      
       (SELECT MAX(B8DTHR)            
        FROM TBB8 S8                  
        WHERE S8.B8IDEN = B8.B8IDEN)  
  ;

Méthode 2 : utilisation de EXISTS
Code sql : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
   SELECT B7IDEN                        
        , B7CPTE                        
        , B8SEQN                        
        , B8MONT                        
        , B8DTHR                        
   FROM TBB7                            
   INNER JOIN TBB8  B8                  
     ON  B8IDEN = B7IDEN                
   WHERE NOT EXISTS                     
        (SELECT 1                       
         FROM TBB8 S8                   
         WHERE S8.B8IDEN = B8.B8IDEN    
           AND S8.B8DTHR > B8.B8DTHR)   
   ;

Méthode 3 : utilisation de RANK ou DENSE_RANK
Code sql : 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
   WITH CTE1 (RG, C2, C3, C4, C5, C6) AS      
       ( SELECT DENSE_RANK()                  
                   OVER (PARTITION BY B7IDEN  
                         ORDER BY B8DTHR DESC)
              , B7IDEN                        
              , B7CPTE                        
              , B8SEQN                        
              , B8MONT                        
              , B8DTHR                        
         FROM TBB7                            
         INNER JOIN TBB8                      
           ON  B8IDEN = B7IDEN )              
   SELECT C2, C3, C4, C5, C6                  
   FROM CTE1                                  
   WHERE RG=1                                 
   ;
Cette dernière méthode ne peut pas être utilisée avec MySQL* ou Access qui n'intègrent pas les fonctions OLAP
*MySQL a intégré les fonctions OLAP dans la V8 ]]> escartefigue https://www.developpez.net/forums/blogs/795608-escartefigue/b3239/selectionner-ligne-plus-recente-critere/