Oracle BLOB en base64 CLOB

À condition que stockées procs serait en dépit d'être une alternative viable pour vous, voici une solution possible à votre problème ...

Tout d'abord, faisons en sorte que cette belle base64encode() fonction de Tim Hall dans une procédure ...

create or replace procedure base64encode
    ( i_blob                        in blob
    , io_clob                       in out nocopy clob )
is
    l_step                          pls_integer := 22500; -- make sure you set a multiple of 3 not higher than 24573
    l_converted                     varchar2(32767);

    l_buffer_size_approx            pls_integer := 1048576;
    l_buffer                        clob;
begin
    dbms_lob.createtemporary(l_buffer, true, dbms_lob.call);

    for i in 0 .. trunc((dbms_lob.getlength(i_blob) - 1 )/l_step) loop
        l_converted := utl_raw.cast_to_varchar2(utl_encode.base64_encode(dbms_lob.substr(i_blob, l_step, i * l_step + 1)));
        dbms_lob.writeappend(l_buffer, length(l_converted), l_converted);

        if dbms_lob.getlength(l_buffer) >= l_buffer_size_approx then
            dbms_lob.append(io_clob, l_buffer);
            dbms_lob.trim(l_buffer, 0);
        end if;
    end loop;

    dbms_lob.append(io_clob, l_buffer);

    dbms_lob.freetemporary(l_buffer);
end;

Le "truc" ici est d'utiliser directement la persistance de la LOB locators dans les appels à des procédures/fonctions. Pourquoi "persistante"? Parce que si vous créez une fonction qui retourne un LOB, puis il y a un temporaire LOB créé dans le fond et cela signifie quelque TEMP disque/mémoire d'utilisation et LOB contenu de reproduction. Pour les grandes LOBs cela peut entraîner un gain de performance. Afin de satisfaire votre exigence de ce qui en fait le plus performant possible, vous devriez éviter ce TEMP d'utilisation de l'espace. Donc, pour cette approche, une procédure stockée à la place d'une fonction doit être utilisée.

Puis, bien sûr, la procédure doit être nourri avec la persistance d'un LOB locators. Que vous avez à faire qui, à nouveau, avec une procédure stockée, où, par exemple, vous insérez un vide LOB (dans les faits, la création d'un nouveau MÉTIER locator) à une table d'abord, et puis à fournir nouvellement créé LOB locator pour l'encodage base64 routine ...

create or replace procedure load_and_encode_image
    ( i_file_name       in varchar2 )
is
    l_input_bfile       bfile := bfilename('DIR_ANYTHING', i_file_name);
    l_image_base64_lob  test.imageBase64%type;
    l_image_raw         test.image%type;
begin
    insert into test(image, imageBase64)
    values (empty_blob(), empty_clob())
    returning image, imageBase64
    into l_image_raw, l_image_base64_lob;

    begin
        dbms_lob.fileopen(l_input_bfile);
        dbms_lob.loadfromfile(
            dest_lob => l_image_raw,
            src_lob => l_input_bfile,
            amount => dbms_lob.getlength(l_input_bfile)
        );
        dbms_lob.fileclose(l_input_bfile);
    exception
        when others then
            if dbms_lob.fileisopen(l_input_bfile) = 1 then
                dbms_lob.fileclose(l_input_bfile);
            end if;
            raise;
    end;

    base64encode(
        i_blob => l_image_raw,
        io_clob => l_image_base64_lob
    );
end;

Remarque: bien sûr, si vous en base64 encode seulement des petits fichiers, la taille réelle dépend de votre PGA paramètres, je deviner; une question pour un DBA, ce l'est), alors la fonction peut être tout aussi performantes que cette procédure basée sur un. Base64-encodage d'un fichier de 200 mo sur mon ordinateur portable a eu 55 secondes avec la fonction+approche de mise à jour, de 14 secondes à la procédure d'approche. Pas exactement un démon de la vitesse, afin de choisir ce qui convient à vos besoins.

Remarque: je crois que cette procédure basée sur l'approche peut être accéléré par la lecture du fichier d'inmemory morceaux en boucle, en base64 codant pour les morceaux à l'autre inmemory morceaux et en les ajoutant à la fois à la cible persistante LOBs. De cette façon, vous devriez faire de la charge de travail encore plus facile en évitant les re-lecture de la pleine test.image LOB contenu par le base64encode() procédure.

J'ai résolu ce même problème au travail, à l'aide d'un Java procédure stockée. Il n'y a pas de segmentation/contatenation de VARCHAR2s impliqués dans une telle approche, car la capacité de codage/décodage en base64 est nativement intégré à Java, il suffit d'écrire un Oracle de la fonction de cette mince enveloppe la méthode Java qui fonctionne bien et est de haute performance, car dès que vous avez exécuté une fois, de la JVM HotSpot compile le Java proc en au code de bas niveau (de haute performance comme un C fonction stockée). Je vais modifier cette réponse plus tard et ajouter les détails au sujet de ce code Java.

Mais pour reculer d'un pas question, pourquoi êtes-vous le stockage de ces données à la fois comme un BLOB et encodées en base64 (CLOB)? Est-ce parce que vous avez des clients qui veulent utiliser les données dans le dernier format? J'aimerais vraiment préfèrent ne stocker le BLOB format. Une raison en est que la version encodée en base 64 peut être le double de la taille de l'original BLOB binaire, afin de les stocker à la fois les moyens éventuellement 3x le stockage.

Une solution, celle que j'ai mis en œuvre au travail, pour créer votre propre Java fonction stockée base64_encode() qui code binaire --> base64, puis utiliser cette fonction pour encoder en base64 à la volée au moment de la requête (c'est pas cher). À partir de l'application/côté client, vous de requête serait quelque chose comme SELECT base64_encode(image) FROM test WHERE ...

Si le code de l'application ne peut pas être touché (c'est à dire des LITS d'application) ou, si les développeurs ne sont pas très heureux à ce sujet à l'aide d'une fonction, vous pourriez abstrait pour eux (puisque vous utilisez 11g+) en utilisant un VIRTUEL (calculée) de la colonne sur la table qui contient le résultat de base64_encode(image). Il fonctionnerait comme une vue, en ce qu'il ne serait pas physiquement magasin de la codées CLOBs, mais permettrait de générer eux au moment de la requête. Pour tout client, ils ne seraient pas en mesure de dire qu'ils ne sont pas de la lecture d'une colonne physique. L'autre avantage est que si vous mettez à jour le jpg (BLOB), le virtuel CLOB est immédiatement et automatiquement mis à jour. Si vous devez insérer/mettre à jour/supprimer un énorme lot de Gouttes, vous serais d'économiser 66% de la refaire/archivelog volume pour ne pas avoir à traiter toutes les CLOBs.

Enfin, pour les performances, assurez-vous que vous utilisez SecureFile Lob (à la fois pour les BLOBs et CLOBs). Ils sont vraiment beaucoup plus vite et mieux, dans tous les sens.

Mise à JOUR - j'ai trouvé mon code, au moins la version qui utilise Java Procédure Stockée pour faire l'inverse (la conversion d'un encodées en base64 CLOB à son BLOB binaire de la version). Il ne serait pas facile d'écrire l'inverse.

--DROP FUNCTION base64_decode ;
--DROP java source base64;
-- This is a PLSQL java wrapper function
create or replace
FUNCTION base64_decode (
myclob clob)
RETURN blob
AS LANGUAGE JAVA
NAME 'Base64.decode (
oracle.sql.CLOB) 
return oracle.sql.BLOB';
/
-- The Java code that base64 decodes a clob and returns a blob.
create or replace and compile java source named base64 as
import java.sql.*;
import java.io.*;
import oracle.sql.*;
import sun.misc.BASE64Decoder;
import oracle.jdbc.driver.*;
public class Base64 {
public static oracle.sql.BLOB decode(oracle.sql.CLOB  myBase64EncodedClob)
{
BASE64Decoder base64   = new BASE64Decoder();
OutputStream  outstrm  = null;
oracle.sql.BLOB myBlob = null;
ByteArrayInputStream instrm = null;
try
{
if (!myBase64EncodedClob.equals("Null"))
{
Connection conn = new OracleDriver().defaultConnection();
myBlob = oracle.sql.BLOB.createTemporary(conn, false,oracle.sql.BLOB.DURATION_CALL);
outstrm = myBlob.getBinaryOutputStream();
ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream();
InputStream in = myBase64EncodedClob.getAsciiStream();
int c;
while ((c = in.read()) != -1)
{
byteOutStream.write((char) c);
}
instrm = new ByteArrayInputStream(byteOutStream.toByteArray());
try  // Input stream to output Stream
{
base64.decodeBuffer(instrm, outstrm);
}
catch (Exception e)
{
e.printStackTrace();
}
outstrm.close();
instrm.close();
byteOutStream.close();
in.close();
conn.close();
}
}
catch (Exception e)
{
e.printStackTrace();
}
return myBlob;
}  // Public decode
} // Class Base64
;
/