La solution la plus efficiente pour la lecture CLOB à la Chaîne, et la Chaîne de CLOB en Java?

Je ne peux pas utiliser la fonction "int longueur" constructeur de StringBuilder puisque la longueur de mon CLOB est plus qu'un int et a besoin d'un long valeur.

Si le CLOB longueur est plus grande que celui qui entre dans un int, les données CLOB ne rentre pas dans une Chaîne de caractères soit. Vous aurez à utiliser un streaming approche pour traiter cette quantité de données XML.

Si la longueur réelle de la CLOB est plus petit que Integer.MAX_VALUE, juste à la force de la long à int en mettant (int) en face d'elle.

Ma réponse est juste un goût de le même. Mais je l'ai testé avec de la sérialisation d'un zippé contenu et cela a fonctionné. Donc, je peux faire confiance à cette solution, contrairement à celui de la première (qui utilisent readLine), parce qu'il ignore les sauts de ligne et la corruption de l'entrée.

/*********************************************************************************************
 * From CLOB to String
 * @return string representation of clob
 *********************************************************************************************/
private String clobToString(java.sql.Clob data)
{
    final StringBuilder sb = new StringBuilder();

    try
    {
        final Reader         reader = data.getCharacterStream();
        final BufferedReader br     = new BufferedReader(reader);

        int b;
        while(-1 != (b = br.read()))
        {
            sb.append((char)b);
        }

        br.close();
    }
    catch (SQLException e)
    {
        log.error("SQL. Could not convert CLOB to string",e);
        return e.toString();
    }
    catch (IOException e)
    {
        log.error("IO. Could not convert CLOB to string",e);
        return e.toString();
    }

    return sb.toString();
}

Si vous devez vraiment utiliser uniquement des bibliothèques standard, alors vous avez juste à développer Omar solution un peu. (Apache IOUtils est fondamentalement juste un ensemble de méthodes pratiques qui économise beaucoup de codage)

Vous êtes déjà en mesure d'obtenir le flux d'entrée par le biais de clobObject.getAsciiStream()

Vous avez juste à "transférer manuellement" les personnages de la StringWriter:

InputStream in = clobObject.getAsciiStream();
Reader read = new InputStreamReader(in);
StringWriter write = new StringWriter();

int c = -1;
while ((c = read.read()) != -1)
{
    write.write(c);
}
write.flush();
String s = write.toString();

Garder à l'esprit que

1. Si votre clob contient plus de caractère que pourrait convenir à une chaîne, cela ne fonctionne pas.
2. Envelopper le InputStreamReader et StringWriter avec BufferedReader et BufferedWriter, respectivement, pour de meilleures performances.

public static final String tryClob2String(final Object value)
{
    final Clob clobValue = (Clob) value;
    String result = null;

    try
    {
        final long clobLength = clobValue.length();

        if (clobLength < Integer.MIN_VALUE || clobLength > Integer.MAX_VALUE)
        {
            log.debug("CLOB size too big for String!");
        }
        else
        {
            result = clobValue.getSubString(1, (int) clobValue.length());
        }
    }
    catch (SQLException e)
    {
        log.error("tryClob2String ERROR: {}", e);
    }
    finally
    {
        if (clobValue != null)
        {
            try
            {
                clobValue.free();
            }
            catch (SQLException e)
            {
                log.error("CLOB FREE ERROR: {}", e);
            }
        }
    }

    return result;
}

public static String readClob(Clob clob) throws SQLException, IOException {
    StringBuilder sb = new StringBuilder((int) clob.length());
    Reader r = clob.getCharacterStream();
    char[] cbuf = new char[2048];
    int n;
    while ((n = r.read(cbuf, 0, cbuf.length)) != -1) {
        sb.append(cbuf, 0, n);
    }
    return sb.toString();
}

L'approche ci-dessus est également très efficace.

CLOB sont comme des Fichiers, vous pouvez lire des pièces de il facilement

//read the first 1024 characters
String str = myClob.getSubString(0, 1024);

et vous pouvez écraser comme cela

//overwrite first 1024 chars with first 1024 chars in str
myClob.setString(0, str,0,1024);

Je vous suggère de ne pas utiliser StringBuilder et le remplir jusqu'à ce que vous obtenez une Exception, presque comme l'ajout de numéros à l'aveuglette jusqu'à ce que vous obtenez un dépassement de capacité. Clob, c'est comme un fichier texte et de la meilleure façon de lire c'est à l'aide d'un tampon, dans le cas où vous avez besoin de traiter, sinon vous pouvez les lire dans un fichier local, comme ce

int s = 0;
File f = new File("out.txt");
FileWriter fw new FileWriter(f);

while (s < myClob.length())
{
    fw.write(myClob.getSubString(0, 1024));
    s += 1024;
}

fw.flush();
fw.close();