Affichage des articles dont le libellé est PL/SQL. Afficher tous les articles
Affichage des articles dont le libellé est PL/SQL. Afficher tous les articles

Fonctions Analytiques ROW_NUMBER et DENSE_RANK

Les fonctions analytiques sont très puissantes et très utiles, elles permettent d’alléger les requêtes SQL d’une façon élégante et performante.
Une fonction que j’ai utilisée récemment est la fonction ROW_NUMBER, elle permette de donner un ordre numérique pour les lignes, la pseudo-colonne ROWNUM existe mais son utilisation nécessite l’écriture de plus d’instruction.
Voila un exemple qui illustre l’utilité de cette fonction ; supposons que vous voulez faire un ordre sur la colonne salaire de la table EMP du schéma SCOTT :   

SQL> select EMPNO,ENAME,SAL
  2  from scotty.emp order by SAL;
     EMPNO ENAME             SAL
---------- ---------- ----------
      7369 SMITH             800
      7900 JAMES             950
      7876 ADAMS            1100
      7521 WARD             1250
      7654 MARTIN           1250
      7934 MILLER           1300
      7844 TURNER           1500
      7499 ALLEN            1600
      7782 CLARK            2450
      7698 BLAKE            2850
      7566 JONES            2975
     EMPNO ENAME             SAL
---------- ---------- ----------
      7788 SCOTT            3000
      7902 FORD             3000
      7839 KING             5000
14 ligne(s) selectionnee(s).

Ajoutons une colonne pour le classement de ces lignes selon le salaire, si on utilise directement ROWNUM ça marcherai pas :
SQL> select EMPNO,ENAME,SAL, rownum classement from scotty.emp order by SAL;
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7369 SMITH             800          1       7900 JAMES             950         12       7876 ADAMS            1100         11       7521 WARD             1250          3       7654 MARTIN           1250          5       7934 MILLER           1300         14       7844 TURNER           1500         10       7499 ALLEN            1600          2       7782 CLARK            2450          7       7698 BLAKE            2850          6       7566 JONES            2975          4
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7788 SCOTT            3000          8       7902 FORD             3000         13       7839 KING             5000          9
14 ligne(s) selectionnee(s).

Certes il a classé les donner mais c’est donne l’ordre de l’extraction des lignes mais pas dans l’ordre des valeurs des salaires, pour corriger ça  il faut écrire :
SQL> select EMPNO,ENAME,SAL,rownum classement from 
 2 (select EMPNO,ENAME,SAL from scotty.emp order by SAL) ;
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7369 SMITH             800          1       7900 JAMES             950          2       7876 ADAMS            1100          3       7521 WARD             1250          4       7654 MARTIN           1250          5       7934 MILLER           1300          6       7844 TURNER           1500          7       7499 ALLEN            1600          8       7782 CLARK            2450          9       7698 BLAKE            2850         10       7566 JONES            2975         11
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7788 SCOTT            3000         12       7902 FORD             3000         13       7839 KING             5000         14
14 ligne(s) selectionnee(s).

C’est la que devienne l’utilisation des fonctions analytiques intéressante,  voila le même résultat en utilisant ROW_NUMBER :
SQL> select EMPNO,ENAME,SAL, row_number() over(order by SAL) classement
  2  from scotty.emp
  3  order by SAL;
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7369 SMITH             800          1       7900 JAMES             950          2       7876 ADAMS            1100          3       7521 WARD             1250          4       7654 MARTIN           1250          5       7934 MILLER           1300          6       7844 TURNER           1500          7       7499 ALLEN            1600          8       7782 CLARK            2450          9       7698 BLAKE            2850         10       7566 JONES            2975         11
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7788 SCOTT            3000         12       7902 FORD             3000         13       7839 KING             5000         14
14 ligne(s) selectionnee(s).

Le résultat est bien trier selon les valeurs des salaires et il est classé mais il y a un problème sur les salaires égaux  (par exemple SCOTT et FORD) ont le même salaire mais un classement différent, la aussi c’est les fonctions analytiques qui viennent  au secours :
SQL>  select EMPNO,ENAME,SAL, DENSE_RANK() over(order by SAL) classement
  2  from scotty.emp
  3  order by SAL;
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7369 SMITH             800          1       7900 JAMES             950          2       7876 ADAMS            1100          3       7521 WARD             1250          4       7654 MARTIN           1250          4       7934 MILLER           1300          5       7844 TURNER           1500          6       7499 ALLEN            1600          7       7782 CLARK            2450          8       7698 BLAKE            2850          9       7566 JONES            2975         10
     EMPNO ENAME             SAL CLASSEMENT ---------- ---------- ---------- ----------       7788 SCOTT            3000         11       7902 FORD             3000         11       7839 KING             5000         12
14 ligne(s) selectionnee(s).

La fonction DENSE_RANK permet de donner le même classement pour les mêmes valeurs dans un résultat trié.
Chaque fois que vous écrivez des instructions SQL ou des blocs PL/SQL afin d’analyser les données, jeter un coup d’œil sur les fonctions analytiques vous pouvez y trouver un contournement.

SQL : Group BY ROLLUP

Une fonction bien pratique dans ORACLE depuis la version 9i est la fonction ROLLUP, cette fonction permet d'avoir des agrégations a certain niveaux que group by ne permet pas; analysons l'instruction suivante :
SQL> select deptno,job,sum(sal)
2 from emp group by deptno,job
3 order by deptno;

DEPTNO JOB SUM(SAL)
---------- --------- ----------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600

9 ligne(s) sélectionnée(s).
L'agrégation avec GROUP BY dans l'instruction précédente n'est utile que si on veut la somme en fonction des deux colonnes DEPTNO et JOB, si on veut aussi la somme en fonction de chaque DEPTNO nous auront deux choses soit faire une interrogation a part et la joindre avec un l'operateur UNION, soit utilisé la fonction ROLLUP :

SQL> select deptno,job,sum(sal)
2 from emp group by rollup(deptno,job)
3 order by deptno;

DEPTNO JOB SUM(SAL)
---------- --------- ----------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
10
8750
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
20
10875
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600
30
9400


29025

13 ligne(s) sélectionnée(s).

Remarquer aussi que la fonction ROLLUP permet de donner un total global de tous les départements, l'utilisation de ROLLUP est équivalent a group by() union group by deptno union group by deptno,job :

SQL> select deptno,job,sum(sal)
2 from emp group by deptno,job
3 union
4 select deptno,to_char(null),sum(sal)
5 from emp group by deptno
6 union
7 select to_number(null),to_char(null),sum(sal)
8 from emp;

DEPTNO JOB SUM(SAL)
---------- --------- ----------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
10
8750
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
20
10875
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600
30
9400


29025

13 ligne(s) sélectionnée(s).

Une autre fonction utile est la fonction CUBE.

SQL : Foncion Cube

La fonction CUBE est comme sa petite sœur ROLLUP est une fonction d'agrégation qui permet d'avoir tout les combinaisons entre les composants d'une agrégation, un exemple :
SQL> select deptno,job,sum(sal)
2 from emp group by cube(deptno,job)
3 order by deptno;

DEPTNO JOB SUM(SAL)
---------- --------- ----------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
10
8750
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
20
10875
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600
30
9400

ANALYST 6000

CLERK 4150

MANAGER 8275

PRESIDENT 5000

SALESMAN 5600


29025

18 ligne(s) sélectionnée(s).

Le résultat montre quatre agrégations par les deux colonnes (deptno,job), par deptno seulement, par job seulement et le total dans toute la table ce que revient à faire mais avec quatre passages de la table emp alors que la précédente le fait dans un seule passage :
SQL> select deptno,job,sum(sal) from emp group by deptno,job
2 union
3 select to_number(null),job,sum(sal) from emp group by job
4 union
5 select deptno,to_char(null),sum (sal) from emp group by deptno
6 union
7 select to_number(null),to_char(null),sum(sal) from emp;

DEPTNO JOB SUM(SAL)
---------- --------- ----------
10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
10
8750
20 ANALYST 6000
20 CLERK 1900
20 MANAGER 2975
20
10875
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 5600
30
9400

ANALYST 6000

CLERK 4150

MANAGER 8275

PRESIDENT 5000

SALESMAN 5600


29025
18 ligne(s) sélectionnée(s).

Le nombre d'agrégation de CUBE est 2^nombre de colonnes dans le select, par contre avec ROLLUP on seulement n+1 ou n est le nombre de colonnes dans le select.

SQL : Foncion Rank()

la fonction Rank() est une fonction ananlytique pemettant d'assigner un numero d'ordre à un resultat un exemple simple :
SQL> conn scott/tiger
Connecté.
SQL> select empno,ename,sal from emp order by sal;

EMPNO ENAME SAL
7369 SMITH 800
7900 JAMES 950
7876 ADAMS 1100
7521 WARD 1250
7654 MARTIN 1250
7934 MILLER 1300
7844 TURNER 1500
7499 ALLEN 1600
7782 CLARK 2450
7698 BLAKE 2850
7566 JONES 2975
7788 SCOTT 3000
7902 FORD 3000
7839 KING 5000

14 ligne(s) sélectionnée(s).
maintenant je veux assigné un numero d'ordre pour chaque employé en se basant sur son salaire :
SQL> select empno,ename,sal,rank() over(order by sal) as ord from emp;

EMPNO ENAME SAL ORD
---------- ---------- ---------- ----------
7369 SMITH 800 1
7900 JAMES 950 2
7876 ADAMS 1100 3
7521 WARD 1250 4
7654 MARTIN 1250 4
7934 MILLER 1300 6
7844 TURNER 1500 7
7499 ALLEN 1600 8
7782 CLARK 2450 9
7698 BLAKE 2850 10
7566 JONES 2975 11
7788 SCOTT 3000 12
7902 FORD 3000 12
7839 KING 5000 14

14 ligne(s) sélectionnée(s).

on le meme numero d'ordre pour les employés ayant le meme salaire.

voire le post fonctions analytiques

PL/SQL : La clause AUTHID CURRENT_USER

Quand on appelle une procédure, une fonction ou un package il y a deux modes de privilèges d'exécution :
Soit avec les droits de définition; le code utilisé permet d'accéder aux objets qu'il appelle avec les droits utilisateur qui a écrit ce code.
Soit avec les droits d'invocation; le code est alors appelé avec les droits de l'utilisateur qui appelé le code stocké.
Explication :
L’utilisateur Scott se connecte et fait une select sur la table employees qui est dans le schéma hr :
SQL> select first_name from HR.employees where employee_id=190;
select first_name from HR.employees where employee_id=190
*
ERREUR Ó la ligne 1 :
ORA-00942: Table ou vue inexistante
Il obtient une erreur; alors l'utilisateur HR crée une procédure qui fait la même chose et donne le droit d'exécution a Scott :
SQL> create or replace procedure normale_proc is
2 nom varchar2(20);
3 begin
4 select first_name into nom from employees where employee_id=190;
5 dbms_output.put_line('le nom est :'||nom);
6 end;
7 /
Procédure créée.
SQL> grant execute on normale_proc to scott;
Autorisation de privilèges (GRANT) accepte.
SQL>
Maintenant pour Scott ça donne le résultat suivant :
SQL> set serveroutput on
SQL> exec hr.normale_proc
le nom est :Timothy

Procédure PL/SQL terminée avec succès.
SQL>
Ce genre de fonctionnement peut s'avérer très pratiques si on ne veut pas donner des privilèges sur les objets auxquels il accède notre code, mais il peut s'avérer tres dangereux si notre code contient une quelconque vulnérabilité, par exemple une injection SQL alors les droits d'exécution seront ceux du propriétaire du code.
Pour activer les droits d'invocation pour un code il suffit d'ajouter la clause AUTHID CURRENT_USER avant IS, le même exemple :
SQL> create or replace procedure aut_proc AUTHID CURRENT_USER is
2 nom varchar2(20);
3 begin
4 select first_name into nom from employees where employee_id=190;
5 dbms_output.put_line('le nom est :'||nom);
6 end;
7 /
Procédure créée.

SQL> grant execute on aut_proc to scott;
Autorisation de privilèges (GRANT) acceptée.
SQL>
Maintenant pour Scott ca donne un 942:
SQL> exec hr.aut_proc
BEGIN hr.aut_proc; END;
*
ERREUR Ó la ligne 1 :
ORA-00942: Table ou vue inexistante
ORA-06512: Ó "HR.AUT_PROC", ligne 4
ORA-06512: Ó ligne 1

pour savoir quelle mode d'exécution pour une procédure on consulte la vue user_procedures :
SQL> select OBJECT_NAME,AUTHID from user_procedures
2 where OBJECT_NAME in ('AUT_PROC','NORMALE_PROC');

OBJECT_NAME AUTHID
------------------------------ ------------
AUT_PROC CURRENT_USER
NORMALE_PROC DEFINER

PL/SQL : Le package DBMS_RANDOM

Le package dbms_rnadom dans oracle permet de générer des valeurs aléatoires entres -2^31 et 2^31, pour ce faire vous devez initialiser le générateur pseudo-aléatoire (il n'y a pas de génération aléatoire à 100% dans l'informatique) avec une valeur numérique :
SQL> exec dbms_random.initialize(34);

Procédure PL/SQL terminée avec succès.

La procédure initialize ne prend que des valeurs numériques comme paramètre, une autre procédure qui fait la même chose mais qu'est obsolète est la procédure SEED, le seul avantage de SEED est l'utilisation de chaine de caractère pour initialiser le générateur :
SQL> exec dbms_random.seed('bla bla bla..');

Procédure PL/SQL terminée avec succès.

Une fois le générateur initialisé vous pouvez générer des nombres en appelant la fonction value :
SQL> select dbms_random.value(100,150) from dual;

DBMS_RANDOM.VALUE(100,150)
--------------------------
106,250729

SQL>
La fonction value prend deux paramètres qui constituent la plage dans laquelle les nombres seront générés

Oracle : injection du code PL/SQL

L’attaque du code PL/SQL par une injection SQL est toujours d'actualité malgré son apparition depuis plusieurs années, cela est du généralement aux mauvaises habitudes des développeurs, en gros l'attaque consiste à forgé une autre requête a partir d'une requête qui accepte des paramètres, exemple :
SQL> create or replace procedure vul_proc(param varchar2) is
2 type fir_name is table of hr.employees.first_name%type;
3 fname fir_name := fir_name();
4 stmt varchar2(300);
5 begin
6 stmt:='select first_name from hr.employees where last_name='''||param||'''';
7 execute immediate stmt bulk collect into fname;
8 for i in fname.first..fname.last loop
9 dbms_output.put_line(fname(i));
10 end loop;
11 end;
12 /

Procédure crée.

L’utilisation légitime de cette procédure est :
SQL> set serveroutput on
SQL> exec vul_proc('King')
Janette
Steven
Procédure PL/SQL terminée avec succès.
SQL>
Mais le paramètre param est concaténé à l'instruction stmt sans aucun contrôle ce qui peut donner des idées :
SQL> exec vul_proc('King'' or ''1''=''1 ')
Ellen
Sundar
Mozhe
David
Hermann
Shelli
....

ou pire encore :
SQL> exec vul_proc('King'' union select password from dba_users where ''1''=''1 ')
2BE6F80744E08FEB
2CA614501F09FCCC
2D594E86F93B17A1
3DF26A8B17D0F29F
3FB8EF9DB538647C
4A3BA55E08595C81
4C6D73C3E8B0F0DA
66F4EF5650C20355
71E687F036AD56E5
72979A94BAD2AF80
72E382A52E89575A
7C9BA362F8314299
7EFA02EC7EA6B86F
84B8CBCA4D477FA3
88A2B2C183431F00
88D8364765FCE6AF
8A8F025737A9097A
9793B3777CD3BD1A
9C30855E7E0CB02D
BFBA5A553FD9E28A
CE4A36B8E06CA59C
DF02A496267DEE66
F25A184809D6458D
F894844C34402B67
FA1D2B85B70213F3
FFF45BB2C0C327EC
Janette
Steven
anonymous

Procédure PL/SQL terminée avec succès.
Pour éviter ce genre de situation le mieux sera d'utiliser des variables attachées dans la chaine passer à execute immediate et une clause USING pour utiliser le paramètre :
SQL> create or replace procedure vul_proc(param varchar2) is
2 type fir_name is table of hr.employees.first_name%type;
3 fname fir_name := fir_name();
4 stmt varchar2(300);
5 begin
6 stmt:='select first_name from hr.employees where last_name= :param ';
7 execute immediate stmt bulk collect into fname using param;
8 for i in fname.first..fname.last loop
9 dbms_output.put_line(fname(i));
10 end loop;
11 end;
12 /

Procédure crue.

L’attaque par une injection SQL ne marchera pas, puisque ORACLE précompile l'instruction STMT et il ne permettra qu'un seul paramètre valide qui ne contiendra aucun mot clé SQL :
SQL> exec vul_proc('King'' union select password from dba_users where ''1''=''1 ')
BEGIN vul_proc('King'' union select password from dba_users where ''1''=''1 '); END;

*
ERREUR à la ligne 1 :
ORA-06502: PL/SQL : erreur numérique ou erreur sur une valeur
ORA-06512: à "SYS.VUL_PROC", ligne 8
ORA-06512: à ligne 1

SQL : Fonctions LAG et LEAD

Les fonctions LAG et LEAD sont deux fonctions analytiques qui permettent d'accéder à une ligne avant ou après la ligne courante, la syntaxe de ces fonctions est simple :
LAG|lead(colonne, nombre de ligne avant|après la ligne courante, valeur par default pour la première|dérniere ligne).

La valeur par défaut n'est pas obligatoire si vous l'omettez Oracle renvoie NULL à la place, un petit exemple :
SQL> select empno,sal,deptno,sal-lag(sal,1)
2 over (order by empno) as trou
3 from emp order by empno;

EMPNO SAL DEPTNO TROU
7369 800 20
7499 1600 30 800
7521 1250 30 -350
7566 2975 20 1725
7654 1250 30 -1725
7698 2850 30 1600
7782 2450 10 -400
7788 3000 20 550
7839 5000 10 2000
7844 1500 30 -3500
7876 1100 20 -400
7900 950 30 -150
7902 3000 20 2050
7934 1300 10 -1700

14 ligne(s) sélectionnée(s).

L’exemple précédent calcul la différence de salaire entre un employé et celui qui le précède directement dans empno, le suivant calcule l'inverse :

SQL> select empno,sal,deptno,sal-lead(sal,1)
2 over (order by empno) as trou
3 from emp order by empno;

EMPNO SAL DEPTNO TROU
7369 800 20 -800
7499 1600 30 350
7521 1250 30 -1725
7566 2975 20 1725
7654 1250 30 -1600
7698 2850 30 400
7782 2450 10 -550
7788 3000 20 -2000
7839 5000 10 3500
7844 1500 30 400
7876 1100 20 150
7900 950 30 -2050
7902 3000 20 1700
7934 1300 10

14 ligne(s) sélectionnée(s).

voire le post fonctions analytiques

Oracle : les fonctions analytiques

Les fonctions analytiques disponible dans ORACLE depuis 8.1 pour répondre à certains problèmes qu'il est difficile d'aborder avec SQL, comme les requêtes pour trouver les n premiers enregistrements dans un group; ou faire un calcul par rapport à la nième ligne, leurs utilisation est plus facile et plus performante que de faire des petites fonctions en PL/SQL, la syntaxe générale :
>fonction_analytique(argument) OVER ()

La clause partition :
Comme son nom l'indique permet de partitionner (pas au sens des tables partitionnées) un résultat en un ensemble de groups selon une valeur.

Exemple:
SQL> select ename,sal,deptno,avg(sal)
over(partition by deptno) from emp ;
ENAME SAL DEPTNO AVG(SAL)OVER(PARTITIONBYDEPTNO)
CLARK 2450 10 2916,66667
KING 5000 10 2916,66667
MILLER 1300 10 2916,66667
SMITH 800 20 2175
ADAMS 1100 20 2175
FORD 3000 20 2175
SCOTT 3000 20 2175
JONES 2975 20 2175
ALLEN 1600 30 1566,66667
BLAKE 2850 30 1566,66667
MARTIN 1250 30 1566,66667
JAMES 950 30 1566,66667
TURNER 1500 30 1566,66667
WARD 1250 30 1566,66667


14 ligne(s) sélectionné(s).
SQL>

La clause d'ordre :
Cette clause sert pour spécifier l'ordre dans lequel le groupe sera traité, attention ici l'ordre by à un comportement spécial il ajoute une fenêtre par défaut qui définit par la ligne en cours est tous les lignes précédentes dans le groupe.
Exemple:
SQL> select ename,sal,deptno,avg(sal)
over(partition by deptno order by ename) as avg_an from emp ;

ENAME SAL DEPTNO AVG_AN
CLARK 2450 10 2450
KING 5000 10 3725
MILLER 1300 10 2916,66667
ADAMS 1100 20 1100
FORD 3000 20 2050
JONES 2975 20 2358,33333
SCOTT 3000 20 2518,75
SMITH 800 20 2175
ALLEN 1600 30 1600
BLAKE 2850 30 2225
JAMES 950 30 1800
MARTIN 1250 30 1662,5
TURNER 1500 30 1630
WARD 1250 30 1566,66667

14 ligne(s) sélectionné(s).

Ici comme vous le constater le résultat est partitionné par deptno est le tri par ENAME dans chaque département, mais la moyenne du salaire est calculé par rapport aux lignes précédentes en même département, mais si vous ne spécifiez pas PARTITION BY alors le groupe pris est toute la table.

SQL> select ename,sal,deptno,avg(sal) over(order by ename) as avg_an from emp ;

ENAME SAL DEPTNO AVG_AN
ADAMS 1100 20 1100
ALLEN 1600 30 1350
BLAKE 2850 30 1850
CLARK 2450 10 2000
FORD 3000 20 2200
JAMES 950 30 1991,66667
JONES 2975 20 2132,14286
KING 5000 10 2490,625
MARTIN 1250 30 2352,77778
MILLER 1300 10 2247,5
SCOTT 3000 20 2315,90909
SMITH 800 20 2189,58333
TURNER 1500 30 2136,53846
WARD 1250 30 2073,21429

14 ligne(s) sélectionnée(s).

La clause de fenêtrage :
La clause de fenêtrage sert à définir une fenêtre dans le même groupe à lequel sera appliquée la fonction, exemple:

SQL> select ename,sal,deptno,avg(sal)
2 over(partition by deptno order by ename rows 2 preceding) as avg_an
3 from emp ;

ENAME SAL DEPTNO AVG_AN
CLARK 2450 10 2450
KING 5000 10 3725
MILLER 1300 10 2916,66667
ADAMS 1100 20 1100
FORD 3000 20 2050
JONES 2975 20 2358,33333
SCOTT 3000 20 2991,66667
SMITH 800 20 2258,33333
ALLEN 1600 30 1600
BLAKE 2850 30 2225
JAMES 950 30 1800
MARTIN 1250 30 1683,33333
TURNER 1500 30 1233,33333
WARD 1250 30 1333,33333

14 ligne(s) sélectionnée(s).

Ici la fenêtre est de 3 lignes et la moyenne est calculée à partir de la ligne courante et les deux lignes précédente (ex: scott (3000+2975+3000)/3 = 2991,6667), il y a autres spécificateurs de fenetrage pour la list complète consulter la reference SQL.

Si vous omettez toutes les clauses alors la pas de notion d'ordre mais la fenêtre est la partition ne font qu'un toute la table :

SQL> select ename,sal,deptno,avg(sal) over() as avg_an from emp;

ENAME SAL DEPTNO AVG_AN
SMITH 800 20 2073,21429
ALLEN 1600 30 2073,21429
WARD 1250 30 2073,21429
JONES 2975 20 2073,21429
MARTIN 1250 30 2073,21429
BLAKE 2850 30 2073,21429
CLARK 2450 10 2073,21429
SCOTT 3000 20 2073,21429
KING 5000 10 2073,21429
TURNER 1500 30 2073,21429
ADAMS 1100 20 2073,21429
JAMES 950 30 2073,21429
FORD 3000 20 2073,21429
MILLER 1300 10 2073,21429

14 ligne(s) sélectionnée(s).