Comment puis-je obtenir le SQL d'un PreparedStatement?

J'ai une méthode Java générale avec la signature de méthode suivante:

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

Il ouvre une connexion, construit une PreparedStatementà l'aide de l'instruction sql et des paramètres du queryParamstableau de longueur variable, l'exécute, met en cache le ResultSet(dans a CachedRowSetImpl), ferme la connexion et renvoie le jeu de résultats mis en cache.

J'ai la gestion des exceptions dans la méthode qui enregistre les erreurs. Je consigne l'instruction sql dans le cadre du journal car elle est très utile pour le débogage. Mon problème est que la journalisation de la variable String sqlenregistre l'instruction de modèle avec des? Au lieu des valeurs réelles. Je veux enregistrer l' instruction réelle qui a été exécutée (ou qui a tenté d'exécuter).

Alors ... Existe-t-il un moyen d'obtenir l'instruction SQL réelle qui sera exécutée par un PreparedStatement? ( Sans le construire moi-même. Si je ne trouve pas un moyen d'accéder au PreparedStatement'sSQL, je finirai probablement par le construire moi-même dans mon catches.)

En utilisant des instructions préparées, il n'y a pas de "requête SQL":

• Vous avez une instruction contenant des espaces réservés
  • il est envoyé au serveur DB
  • et préparé là-bas
  • ce qui signifie que l'instruction SQL est "analysée", analysée, une certaine structure de données la représentant est préparée en mémoire
• Et puis, vous avez des variables liées
  • qui sont envoyés au serveur
  • et l'instruction préparée est exécutée - travailler sur ces données

Mais il n'y a pas de reconstruction d'une vraie requête SQL réelle - ni du côté Java, ni du côté de la base de données.

Donc, il n'y a aucun moyen d'obtenir le SQL de l'instruction préparée - car il n'y a pas de tel SQL.

À des fins de débogage, les solutions sont les suivantes:

• Ouput le code de l'instruction, avec les espaces réservés et la liste des données
• Ou pour "construire" une requête SQL "à la main".

Il n'est défini nulle part dans le contrat de l'API JDBC, mais si vous avez de la chance, le pilote JDBC en question peut renvoyer le SQL complet en appelant simplement PreparedStatement#toString(). C'est à dire

System.out.println(preparedStatement);

Au moins les pilotes JDBC MySQL 5.x et PostgreSQL 8.x le prennent en charge. Cependant, la plupart des autres pilotes JDBC ne le prennent pas en charge. Si vous en avez un, votre meilleur pari est d'utiliser Log4jdbc ou P6Spy .

Vous pouvez également écrire une fonction générique qui prend a Connection, une chaîne SQL et les valeurs de l'instruction et retourne a PreparedStatementaprès avoir consigné la chaîne SQL et les valeurs. Exemple de lancement:

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;
}

et utilisez-le comme

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

Une autre alternative consiste à implémenter une personnalisation PreparedStatementqui enveloppe (décore) le réel PreparedStatement lors de la construction et remplace toutes les méthodes afin d'appeler les méthodes du réel PreparedStatement et de collecter les valeurs dans toutes les setXXX()méthodes et de construire paresseusement la chaîne SQL "réelle" chaque fois que l'un des les executeXXX()méthodes sont appelées (tout un travail, mais la plupart des IDE fournissent des générateurs automatiques pour les méthodes décoratrices, Eclipse le fait). Enfin, utilisez-le à la place. C'est aussi fondamentalement ce que P6Spy et ses consorts font déjà sous le capot.

J'utilise Java 8, pilote JDBC avec connecteur MySQL v. 5.1.31.

Je peux obtenir une vraie chaîne SQL en utilisant cette méthode:

// 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());

Donc, il retourne comme ceci:

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

Si vous exécutez la requête et attendez un ResultSet(vous êtes au moins dans ce scénario), vous pouvez simplement appeler ResultSetles getStatement()comme ceci:

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

La variable executedQuerycontiendra l'instruction qui a été utilisée pour créer leResultSet .

Maintenant, je réalise que cette question est assez ancienne, mais j'espère que cela aidera quelqu'un.

J'ai extrait mon sql de PreparedStatement en utilisant prepareStatement.toString () Dans mon cas, toString () retourne String comme ceci:

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

Maintenant, j'ai créé une méthode (Java 8), qui utilise regex pour extraire à la fois la requête et les valeurs et les mettre dans la carte:

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;
  }

Cette méthode renvoie la carte où nous avons des paires clé-valeur:

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

Maintenant, si vous voulez des valeurs sous forme de liste, vous pouvez simplement utiliser:

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

Si votre prepareStatement.toString () est différent de mon cas, c'est juste une question de "réglage" de regex.

Utilisation de PostgreSQL 9.6.x avec le pilote Java officiel 42.2.4:

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

Montrera le SQL avec le ?déjà remplacé, ce que je cherchais. Je viens d'ajouter cette réponse pour couvrir l'affaire postgres.

Je n'aurais jamais pensé que cela pouvait être aussi simple.

J'ai implémenté le code suivant pour imprimer SQL à partir de 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[" +  "] ...");
            }

    }

Extrait de code pour convertir SQL PreparedStaments avec la liste des arguments. Ça marche pour moi

  /**
         * 
         * 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;
        }

Très tard :) mais vous pouvez obtenir le SQL d'origine à partir d'un OraclePreparedStatementWrapper par

((OraclePreparedStatementWrapper) preparedStatement).getOriginalSql();

Si vous utilisez MySQL, vous pouvez enregistrer les requêtes en utilisant le journal des requêtes de MySQL . Je ne sais pas si d'autres fournisseurs proposent cette fonctionnalité, mais il y a de fortes chances qu'ils le fassent.

Fonctionne simplement:

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;
}

C'est bien aussi pour PreparStatement.

J'utilise Oralce 11g et je n'ai pas réussi à obtenir le SQL final à partir du PreparedStatement. Après avoir lu la réponse de @Pascal MARTIN, je comprends pourquoi.

J'ai juste abandonné l'idée d'utiliser PreparedStatement et utilisé un formateur de texte simple qui répondait à mes besoins. Voici mon exemple:

//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);

Vous comprenez que sqlInParam peut être construit de manière dynamique dans une boucle (for, while).

Pour ce faire, vous avez besoin d'une connexion JDBC et / ou d'un pilote qui prend en charge la journalisation du SQL à un niveau bas.

Jetez un œil à log4jdbc