Come posso ottenere l'SQL di un PreparedStatement?

Ho un metodo Java generale con la seguente firma del metodo:

private static ResultSet runSQLResultSet(String sql, Object... queryParams)

Apre una connessione, crea un PreparedStatementusando l'istruzione sql e i parametri nella queryParamsmatrice di lunghezza variabile, la esegue, memorizza nella cache ResultSet(in a CachedRowSetImpl), chiude la connessione e restituisce il set di risultati memorizzato nella cache.

Ho una gestione delle eccezioni nel metodo che registra gli errori. Registro l'istruzione sql come parte del registro poiché è molto utile per il debug. Il mio problema è che la registrazione della variabile String sqlregistra l'istruzione template con? 'Anziché i valori effettivi. Voglio registrare l' istruzione effettiva che è stata eseguita (o tentata di eseguire).

Quindi ... C'è un modo per ottenere l'istruzione SQL effettiva che verrà eseguita da un PreparedStatement? ( Senza costruirlo da solo. Se non riesco a trovare un modo per accedere a PreparedStatement'sSQL, probabilmente finirò per costruirlo da solo catch.

Utilizzando le istruzioni preparate, non esiste una "query SQL":

• Hai una dichiarazione, contenente segnaposto
  • viene inviato al server DB
  • e preparato lì
  • il che significa che l'istruzione SQL viene "analizzata", analizzata, alcune strutture di dati che la rappresentano vengono preparate in memoria
• E, quindi, hai le variabili associate
  • che vengono inviati al server
  • e la dichiarazione preparata viene eseguita - lavorando su quei dati

Ma non è possibile ricostruire una vera query SQL reale, né sul lato Java, né sul lato database.

Pertanto, non è possibile ottenere l'istruzione SQL dell'istruzione preparata, poiché non esiste tale SQL.

A scopo di debug, le soluzioni sono:

• Esegui il codice dell'istruzione, con i segnaposto e l'elenco dei dati
• O "costruire" manualmente alcune query SQL ".

Non è definito da nessuna parte nel contratto API JDBC, ma se sei fortunato, il driver JDBC in questione potrebbe restituire l'intero SQL semplicemente chiamando PreparedStatement#toString(). ie

System.out.println(preparedStatement);

Almeno i driver MySQL 5.xe PostgreSQL 8.x JDBC lo supportano. Tuttavia, la maggior parte degli altri driver JDBC non lo supporta. Se ne hai uno, la tua scommessa migliore è usare Log4jdbc o P6Spy .

In alternativa, è anche possibile scrivere una funzione generica che accetta a Connection, una stringa SQL e i valori dell'istruzione e restituisce a PreparedStatementdopo aver registrato la stringa SQL e i valori. Esempio di avvio:

public static PreparedStatement prepareStatement(Connection connection, String sql, Object... values) throws SQLException {
    PreparedStatement preparedStatement = connection.prepareStatement(sql);
    for (int i = 0; i < values.length; i++) {
        preparedStatement.setObject(i + 1, values[i]);
    }
    logger.debug(sql + " " + Arrays.asList(values));
    return preparedStatement;
}

e usalo come

try {
    connection = database.getConnection();
    preparedStatement = prepareStatement(connection, SQL, values);
    resultSet = preparedStatement.executeQuery();
    // ...

Un'altra alternativa è quella di implementare un'abitudine PreparedStatementche avvolge (decora) il reale PreparedStatement nella costruzione e sovrascrive tutti i metodi in modo che chiami i metodi del reale PreparedStatement e raccolga i valori in tutti i setXXX()metodi e costruisca pigramente la stringa SQL "effettiva" ogni volta che uno di i executeXXX()metodi sono chiamati (piuttosto un lavoro, ma la maggior parte degli IDE fornisce autogeneratori per i metodi di decorazione, Eclipse fa). Finalmente basta usarlo invece. Questo è fondamentalmente ciò che P6Spy e le consorti già fanno sotto i cofani.

Sto usando Java 8, driver JDBC con connettore MySQL v. 5.1.31.

Posso ottenere una vera stringa SQL usando questo metodo:

// 1. make connection somehow, it's conn variable
// 2. make prepered statement template
PreparedStatement stmt = conn.prepareStatement(
    "INSERT INTO oc_manufacturer" +
    " SET" +
    " manufacturer_id = ?," +
    " name = ?," +
    " sort_order=0;"
);
// 3. fill template
stmt.setInt(1, 23);
stmt.setString(2, 'Google');
// 4. print sql string
System.out.println(((JDBC4PreparedStatement)stmt).asSql());

Quindi restituisce smth in questo modo:

INSERT INTO oc_manufacturer SET manufacturer_id = 23, name = 'Google', sort_order=0;

Se si sta eseguendo la query e in attesa di un ResultSet(si è in questo scenario, almeno) allora si può semplicemente chiamare ResultSet's getStatement()in questo modo:

ResultSet rs = pstmt.executeQuery();
String executedQuery = rs.getStatement().toString();

La variabile executedQueryconterrà l'istruzione utilizzata per creare il file ResultSet.

Ora, mi rendo conto che questa domanda è piuttosto vecchia, ma spero che questo aiuti qualcuno ..

Ho estratto il mio sql da PreparedStatement usando preparStatement.toString () Nel mio caso toString () restituisce String in questo modo:

org.hsqldb.jdbc.JDBCPreparedStatement@7098b907[sql=[INSERT INTO 
TABLE_NAME(COLUMN_NAME, COLUMN_NAME, COLUMN_NAME) VALUES(?, ?, ?)],
parameters=[[value], [value], [value]]]

Ora ho creato un metodo (Java 8), che utilizza regex per estrarre sia query che valori e inserirli nella mappa:

private Map<String, String> extractSql(PreparedStatement preparedStatement) {
    Map<String, String> extractedParameters = new HashMap<>();
    Pattern pattern = Pattern.compile(".*\\[sql=\\[(.*)],\\sparameters=\\[(.*)]].*");
    Matcher matcher = pattern.matcher(preparedStatement.toString());
    while (matcher.find()) {
      extractedParameters.put("query", matcher.group(1));
      extractedParameters.put("values", Stream.of(matcher.group(2).split(","))
          .map(line -> line.replaceAll("(\\[|])", ""))
          .collect(Collectors.joining(", ")));
    }
    return extractedParameters;
  }

Questo metodo restituisce la mappa in cui sono presenti coppie chiave-valore:

"query" -> "INSERT INTO TABLE_NAME(COLUMN_NAME, COLUMN_NAME, COLUMN_NAME) VALUES(?, ?, ?)"
"values" -> "value,  value,  value"

Ora - se vuoi valori come elenco puoi semplicemente usare:

List<String> values = Stream.of(yourExtractedParametersMap.get("values").split(","))
    .collect(Collectors.toList());

Se readyStatement.toString () è diverso rispetto al mio caso, è solo una questione di "regolazione" di regex.

Utilizzando PostgreSQL 9.6.x con driver Java ufficiale 42.2.4:

...myPreparedStatement.execute...
myPreparedStatement.toString()

Mostrerà l'SQL con il ?già sostituito, che è quello che stavo cercando. Ho appena aggiunto questa risposta per coprire il caso Postgres.

Non avrei mai pensato che potesse essere così semplice.

Ho implementato il seguente codice per la stampa di SQL da PrepareStatement

public void printSqlStatement(PreparedStatement preparedStatement, String sql) throws SQLException{
        String[] sqlArrya= new String[preparedStatement.getParameterMetaData().getParameterCount()];
        try {
               Pattern pattern = Pattern.compile("\\?");
               Matcher matcher = pattern.matcher(sql);
               StringBuffer sb = new StringBuffer();
               int indx = 1;  // Parameter begin with index 1
               while (matcher.find()) {
             matcher.appendReplacement(sb,String.valueOf(sqlArrya[indx]));
               }
               matcher.appendTail(sb);
              System.out.println("Executing Query [" + sb.toString() + "] with Database[" + "] ...");
               } catch (Exception ex) {
                   System.out.println("Executing Query [" + sql + "] with Database[" +  "] ...");
            }

    }

Snippet di codice per convertire SQL PreparedStaments con l'elenco di argomenti. Per me funziona

  /**
         * 
         * formatQuery Utility function which will convert SQL
         * 
         * @param sql
         * @param arguments
         * @return
         */
        public static String formatQuery(final String sql, Object... arguments) {
            if (arguments != null && arguments.length <= 0) {
                return sql;
            }
            String query = sql;
            int count = 0;
            while (query.matches("(.*)\\?(.*)")) {
                query = query.replaceFirst("\\?", "{" + count + "}");
                count++;
            }
            String formatedString = java.text.MessageFormat.format(query, arguments);
            return formatedString;
        }

Molto tardi :) ma puoi ottenere l'SQL originale da un OraclePreparedStatementWrapper da

((OraclePreparedStatementWrapper) preparedStatement).getOriginalSql();

Se stai usando MySQL puoi registrare le query usando il registro delle query di MySQL . Non so se altri fornitori offrono questa funzionalità, ma è probabile che lo facciano.

Semplicemente funzione:

public static String getSQL (Statement stmt){
    String tempSQL = stmt.toString();

    //please cut everything before sql from statement
    //javadb...: 
    int i1 = tempSQL.indexOf(":")+2;
    tempSQL = tempSQL.substring(i1);

    return tempSQL;
}

Va bene anche per Preparated State.

Sto usando Oralce 11g e non sono riuscito a ottenere l'SQL finale da PreparedStatement. Dopo aver letto la risposta @Pascal MARTIN capisco perché.

Ho appena abbandonato l'idea di utilizzare PreparedStatement e ho usato un semplice formattatore di testo che si adattava alle mie esigenze. Ecco il mio esempio:

//I jump to the point after connexion has been made ...
java.sql.Statement stmt = cnx.createStatement();
String sqlTemplate = "SELECT * FROM Users WHERE Id IN ({0})";
String sqlInParam = "21,34,3434,32"; //some random ids
String sqlFinalSql = java.text.MesssageFormat(sqlTemplate,sqlInParam);
System.out.println("SQL : " + sqlFinalSql);
rsRes = stmt.executeQuery(sqlFinalSql);

Capisci che sqlInParam può essere creato dinamicamente in un ciclo (per, mentre) Ho appena reso semplice arrivare al punto di usare la classe MessageFormat per fungere da formatore di modelli di stringa per la query SQL.

Per fare ciò è necessaria una connessione JDBC e / o un driver che supporti la registrazione di sql a un livello basso.

Dai un'occhiata a log4jdbc