Noyau 8.1.7 et UTL_ENCODE

Version imprimable

Voir 40 message(s) de cette discussion en une page

Voici en varchar2 -> raw

Code:

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
FUNCTION DECODE_64(p_chaine IN VARCHAR2) RETURN RAW IS
  r VARCHAR2(32767);
  i PLS_INTEGER;
  x PLS_INTEGER;
  y PLS_INTEGER;
  v RAW(32767);
BEGIN
  -- On supprime les CR+LF
  r := REPLACE(REPLACE(p_chaine, chr(13)), chr(10));
-- For every 4 bytes, split them into 3 8-bit units and map them to Ascii characters
  i := 1;
  WHILE ( i <= LENGTH(r) )
  LOOP
    x := unmap(ASCII(SUBSTR(r, i, 1))) * 262144
        + unmap(ASCII(SUBSTR(r, i + 1, 1))) * 4096
        + unmap(ASCII(SUBSTR(r, i + 2, 1))) * 64
        + unmap(ASCII(SUBSTR(r, i + 3, 1)));
    y := FLOOR(x / 65536); v := v || UTL_RAW.cast_to_raw(CHR(y)); x := x - y * 65536;
    IF SUBSTR(r, i+2, 1) <> '='
    THEN
	    y := FLOOR(x / 256); v := v || UTL_RAW.cast_to_raw(CHR(y)); x := x - y * 256;
  	END IF;
    IF SUBSTR(r, i+3, 1) <> '='
    THEN
	    v := v || UTL_RAW.cast_to_raw(CHR(x));
  	END IF;
    i := i + 4;	
	END LOOP;
 
   RETURN v;
 
END;

19/01/2012, 13h51
SheikYerbouti

Merci,

et caisse donc que unmap() ?

Désolé, ja n'avais pas vu le msg précedent
19/01/2012, 14h24
SheikYerbouti

Code:

ASCII(SUBSTR(r, i, 1))

génère des nombres qui ne sont pas dans la table unmap, comme 13 par exemple, d'ou un NO_DATA_FOUND

Oui, forcément, l'encodage Base64 crée des lignes de 64 caractères.

exemple d'une image dans un mail
Code:

1 2 3 4 YnhX/oKf+S8v/wATRRQAf8LE8K/9BT/yXl/+Jo/4WJ4V/wCgp/5Ly/8AxNFFAB/wsTwr/wBBT/yX l/8AiaP+FieFf+gp/wCS8v8A8TRRQAf8LE8K/wDQU/8AJeX/AOJo/wCFieFf+gp/5Ly//E0UUAH/ AAsTwr/0FP8AyXl/+Jo/4WJ4V/6Cn/kvL/8AE0UUAbemapZ6xZLeWE3nW7EgPtK8jrwQDVyiigD/ 2Q==
Les retours à la lignes ne sont pas des codes à prendre, il faut donc virer les chr(13) et chr(10), on peut le faire dans la function decode sans souci. Je corrige le post

Les 64 caractères de la base64 sont gérés par le unmap, ainsi que le = qui est rajouté en fin de chaine.

Voici qui fonctionne

Code:

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
  WHILE ( i <= LENGTH(r) )
  LOOP
    l := 2;
    z := ASCII(SUBSTR(r, i, 1));
    IF z != 10 AND z != 13 then 
    x := unmap(ASCII(SUBSTR(r, i, 1))) * 262144
       + unmap(ASCII(SUBSTR(r, i + 1, 1))) * 4096
       + unmap(ASCII(SUBSTR(r, i + 2, 1))) * 64
       + unmap(ASCII(SUBSTR(r, i + 3, 1)));
    y := FLOOR(x / 65536); v := v || UTL_RAW.cast_to_raw(CHR(y)); x := x - y * 65536;
    l := 3;
    IF SUBSTR(r, i+2, 1) <> '='
    THEN
        y := FLOOR(x / 256); v := v || UTL_RAW.cast_to_raw(CHR(y)); x := x - y * 256;
      END IF;
    l := 4;
    IF SUBSTR(r, i+3, 1) <> '='
    THEN
        v := v || UTL_RAW.cast_to_raw(CHR(x));
      END IF;
    i := i + 4;
    ELSE 
      i := i + 1 ;
    END IF ;
    END LOOP;

Cependant, c'est encore trop lent :?

19/01/2012, 15h36
McM

Citation:

Envoyé par SheikYerbouti

Cependant, c'est encore trop lent :?

Rahhh.. pénible ! :mouarf:
Bon, je vais tester, je ne suis pas sur du UTL_RAW.cast_to_raw(CHR(
19/01/2012, 16h08
SheikYerbouti

En fait, je pense que la fonction decode() devrait accepter un RAW à la place d'un VARCHAR2, de telle manière qu'il n'y ait pas d'interprétation de retour chariot pour un varchar.

ce code fonctionne correctement:

Code:

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
FUNCTION decode(r IN RAW) RETURN RAW IS
  i PLS_INTEGER;
  x PLS_INTEGER;
  y PLS_INTEGER;
  v RAW(32767);
BEGIN
 
-- For every 4 bytes, split them into 3 8-bit units and map them to Ascii characters
  i := 1;
  WHILE ( i <= LENGTH(r) )
  LOOP
    x := unmap(ASCII(utl_raw.SUBSTR(r, i, 1))) * 262144
       + unmap(ASCII(utl_raw.SUBSTR(r, i + 1, 1))) * 4096
       + unmap(ASCII(utl_raw.SUBSTR(r, i + 2, 1))) * 64
       + unmap(ASCII(utl_raw.SUBSTR(r, i + 3, 1)));
    y := FLOOR(x / 65536); v := v || UTL_RAW.cast_to_raw(CHR(y)); x := x - y * 65536;
    IF SUBSTR(r, i+2, 1) <> '='
    THEN
        y := FLOOR(x / 256); v := v || UTL_RAW.cast_to_raw(CHR(y)); x := x - y * 256;
      END IF;
    IF utl_raw.SUBSTR(r, i+3, 1) <> '='
    THEN
        v := v || UTL_RAW.cast_to_raw(CHR(x));
      END IF;
    i := i + 4;
    END LOOP;
 
   RETURN v;
END;

mais, il prend également trop de temps (9s pour une image de 24K0)

C'est bizarre, sur ma base de dev, ça va beaucoup plus vite :
avec des durées en centièmes de seconde

Image de 47 Ko : 1s pour encoder, 2s pour décoder.
Pdf de 500 Ko : 12s pour encoder , 22s pour décoder

Citation:

durée :4 taille départ:2496 encodé:3328
durée :7 taille départ:3328 decodé:2496

durée :80 taille départ:47735 encodé:63648
durée :163 taille départ:63648 decodé:47735

durée :1164 taille départ:592959 encodé:790612
durée :2152 taille départ:790612 decodé:592959

Voici mon code
param_logo (ste 1) contient le BLOB à encoder
wmc_param_logo (ste 0) contient (en type CLOB) l'encodage B64 du blob
param_logo (ste 0) contient le CLOB décodé.
Code:

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 DECLARE v varchar2(4000); v_buffer RAW(4000); d1 number; d2 number; v_logo BLOB; v_len number; v_clob CLOB; v_blob BLOB; v_amount NUMBER := 2040; BEGIN UPDATE param_logo set logo = NULL WHERE ste = 0 AND depo = 0; COMMIT; SELECT logo, DBMS_LOB.getlength(logo) INTO v_logo, v_len FROM param_logo WHERE ste = 1; -- d1 := dbms_utility.get_time; FOR i IN 1 .. CEIL(v_len / 2040) LOOP DBMS_LOB.READ(v_logo, v_amount, (i-1)*2040+1, v_buffer); v := demo_base64.encode(v_buffer); v_clob := v_clob || v; END LOOP; d2 := dbms_utility.get_time; dbms_output.put_line('durée :'|| (d2-d1) || ' taille départ:'|| v_len ||' encodé:'|| DBMS_LOB.getlength(v_clob)); UPDATE wmc_param_logo set logo = v_clob WHERE ste = 0; d1 := dbms_utility.get_time; v_len := 1; dbms_lob.createtemporary(v_blob,TRUE); FOR i IN 1 .. CEIL(DBMS_LOB.getlength(v_clob)/ 2048) LOOP v_amount := 2048; DBMS_LOB.READ(v_clob, v_amount, (i-1)*2048+1, v); v := demo_base64.DECODE_64(v); dbms_lob.WRITE(v_blob, UTL_RAW.LENGTH(v), v_len, v); v_len := v_len + UTL_RAW.LENGTH(v); END LOOP; d2 := dbms_utility.get_time; dbms_output.put_line('durée :'|| (d2-d1) || ' taille départ:'|| DBMS_LOB.getlength(v_clob) ||' decodé:'|| DBMS_LOB.getlength(v_blob)); UPDATE param_logo set logo = v_blob WHERE ste = 0; COMMIT; END;

Division du temps du decode par 2 avec utl_raw.concat

Citation:

durée :959 taille départ:592959 encodé:790612
durée :869 taille départ:790612 decodé:592959

Code:

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
FUNCTION DECODE_64(r IN VARCHAR2) RETURN RAW IS
  i PLS_INTEGER;
  x PLS_INTEGER;
  y PLS_INTEGER;
  v RAW(32767);
  v1 RAW(1); v2 RAW(1); v3 RAW(1);
BEGIN
 
  i := 1;
  WHILE ( i <= LENGTH(r) )
  LOOP
  	v1 := NULL; v2 := NULL; v3 := NULL;
  	IF ASCII(SUBSTR(r, i, 1)) IN (10, 13)
    THEN
    	i := i + 1;
    ELSE
        x := unmap(ASCII(SUBSTR(r, i, 1))) * 262144
            + unmap(ASCII(SUBSTR(r, i + 1, 1))) * 4096
          + unmap(ASCII(SUBSTR(r, i + 2, 1))) * 64
          + unmap(ASCII(SUBSTR(r, i + 3, 1)));
     		y := FLOOR(x / 65536);  x := x - y * 65536;
     		v1 :=UTL_RAW.cast_to_raw(CHR(y));
      IF SUBSTR(r, i+2, 1) <> '='
      THEN
       	y := FLOOR(x / 256); x := x - y * 256;
     		v2 :=UTL_RAW.cast_to_raw(CHR(y));
      END IF;
      IF SUBSTR(r, i+3, 1) <> '='
      THEN
     		v3 := UTL_RAW.cast_to_raw(CHR(x));
      END IF;
     	v := UTL_RAW.CONCAT(v, v1, v2, v3);
      i := i + 4;	
		END IF;
	END LOOP;
 
  RETURN v;
 
END;

19/01/2012, 17h01
SheikYerbouti

merci ;)
19/01/2012, 17h04
SheikYerbouti

ah oui !
cette fois oui !!
ha :ccool:

Encore plus rapide.. c'est mieux quand on a des fonctions internes qui font des choses (UTL_RAW.cast_from_binary_integer)

Je tombe à 6s pour 600 Ko

Citation:

durée :575 taille départ:790612 decodé:592959

Code:

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
FUNCTION DECODE_64(p_chaine IN VARCHAR2) RETURN RAW IS
  i PLS_INTEGER;
  x PLS_INTEGER;
  y PLS_INTEGER;
  v RAW(32767);
  pos_egal NUMBER;
  r VARCHAR2(32767) := p_chaine;
  len NUMBER;
BEGIN
 
-- For every 4 bytes, split them into 3 8-bit units and map them to Ascii characters
  i := 1;
  r := REPLACE(REPLACE(p_chaine, CHR(13)), CHR(10));
  len := LENGTH(r);
  pos_egal := INSTR(r, '=');
  WHILE ( i <= len )
  LOOP
  	  x := unmap(ASCII(SUBSTR(r, i, 1))) * 262144
            + unmap(ASCII(SUBSTR(r, i + 1, 1))) * 4096
            + unmap(ASCII(SUBSTR(r, i + 2, 1))) * 64
            + unmap(ASCII(SUBSTR(r, i + 3, 1)));
      IF pos_egal NOT BETWEEN i AND i + 3
      THEN
	      v := UTL_RAW.CONCAT(v, UTL_RAW.SUBSTR(UTL_RAW.cast_from_binary_integer(x),2)); 
	ELSIF pos_egal = i + 2
      THEN
        v := UTL_RAW.CONCAT(v, UTL_RAW.SUBSTR(UTL_RAW.cast_from_binary_integer(x),2, 1)); 
	ELSIF pos_egal = i + 3
      THEN
        v := UTL_RAW.CONCAT(v, UTL_RAW.SUBSTR(UTL_RAW.cast_from_binary_integer(x),2, 2)); 
  		END IF;
      i := i + 4;	
	END LOOP;
 
  RETURN v;
 
END;

20/01/2012, 09h17
SheikYerbouti

Parfait :bravo:

Bien sur, du coup, tu peux optimiser l'encodage (temps divisé par 2)

Avant : durée :1195 taille départ:592959 encodé:790612
Après : durée :694 taille départ:592959 encodé:790612

Code:

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
FUNCTION encode(r IN RAW) RETURN VARCHAR2 IS
  i PLS_INTEGER;	  x PLS_INTEGER;	  y PLS_INTEGER;
  v VARCHAR2(32767);
BEGIN
 
-- For every 3 bytes, split them into 4 6-bit units and map them to the Base64 characters
  i := 1;
  WHILE ( i + 2 <= UTL_RAW.LENGTH(r) )
  LOOP
    x := UTL_RAW.cast_to_binary_integer(UTL_RAW.SUBSTR(r, i, 3));
    y := FLOOR(x / 262144); v := v || map(y); x := x - y * 262144;
    y := FLOOR(x / 4096); v := v || map(y); x := x - y * 4096;
    y := FLOOR(x / 64); v := v || map(y); x := x - y * 64;
    v := v || map(x);
    i := i + 3;	
	END LOOP;
 
  -- Process the remaining bytes that has fewer than 3 bytes.
  IF UTL_RAW.LENGTH(r) - i = 0
  THEN
    x := UTL_RAW.cast_to_binary_integer(UTL_RAW.SUBSTR(r, i, 1));
    y := FLOOR(x / 4); v := v || map(y); x := x - y * 4;
    x := x * 16; v := v || map(x);
    v := v || '==';
  ELSIF UTL_RAW.LENGTH(r) - i = 1
  THEN
    x := UTL_RAW.cast_to_binary_integer(UTL_RAW.SUBSTR(r, i, 2));
    y := FLOOR(x / 1024); v := v || map(y); x := x - y * 1024;
    y := FLOOR(x / 16); 	v := v || map(y); x := x - y * 16;
    x := x * 4; v := v || map(x);
    v := v || '=';
  END IF;
 
  RETURN v;
 
END;

20/01/2012, 13h00
SheikYerbouti

Surtout ne t'arrêtes pas !
Encore quelques modifs et l'on parlera alors en terme de pico-secondes :mrgreen:
20/01/2012, 13h38
McM

euh.. je pars au ski 1 semaine... pas sur que j'ai le temps 8-)

Voir 40 message(s) de cette discussion en une page