Como posso obter o SQL de uma PreparedStatement?

Eu tenho um método Java geral com a seguinte assinatura de método:

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

Ele abre uma conexão, cria um PreparedStatementusando a instrução sql e os parâmetros na queryParamsmatriz de comprimento variável, a executa, armazena ResultSetem cache o (em a CachedRowSetImpl), fecha a conexão e retorna o conjunto de resultados em cache.

Eu tenho manipulação de exceção no método que registra erros. Registro a instrução sql como parte do log, pois é muito útil para depuração. Meu problema é que o registro da variável String sqlregistra a instrução do modelo com? Em vez de valores reais. Quero registrar a instrução real que foi executada (ou tentou executar).

Então ... Existe alguma maneira de obter a instrução SQL real que será executada por um PreparedStatement? ( Sem construí-lo eu mesmo. Se não conseguir encontrar uma maneira de acessar o PreparedStatement'sSQL, provavelmente acabarei construindo ele mesmo em meus catches.)

Usando instruções preparadas, não há "consulta SQL":

• Você tem uma declaração contendo espaços reservados
  • é enviado para o servidor DB
  • e preparado lá
  • o que significa que a instrução SQL é "analisada", analisada, alguma estrutura de dados que a representa é preparada na memória
• E então, você vinculou variáveis
  • que são enviados para o servidor
  • e a declaração preparada é executada - trabalhando nesses dados

Mas não há reconstrução de uma consulta SQL real real - nem no lado Java nem no lado do banco de dados.

Portanto, não há como obter o SQL da instrução preparada - pois não existe esse SQL.

Para fins de depuração, as soluções são:

• Sobre o código da instrução, com os espaços reservados e a lista de dados
• Ou para "construir" alguma consulta SQL "manualmente".

Não está definido em nenhum lugar no contrato da API JDBC, mas se você tiver sorte, o driver JDBC em questão pode retornar o SQL completo apenas ligando PreparedStatement#toString(). Ou seja,

System.out.println(preparedStatement);

Pelo menos os drivers MySQL 5.xe PostgreSQL 8.x JDBC suportam. No entanto, a maioria dos outros drivers JDBC não é compatível. Se você tiver esse, sua melhor aposta é usar o Log4jdbc ou o P6Spy .

Como alternativa, você também pode escrever uma função genérica que use a Connection, uma string SQL e os valores da instrução e retorne a PreparedStatementdepois de registrar a string SQL e os valores. Exemplo inicial:

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 use-o como

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

Outra alternativa é implementar um costume PreparedStatementque envolve (decora) o real PreparedStatement na construção e substitui todos os métodos para que ele chame os métodos do real PreparedStatement e colete os valores em todos os setXXX()métodos e construa preguiçosamente a string SQL "real" sempre que um dos os executeXXX()métodos são chamados (bastante trabalho, mas a maioria dos IDEs fornece geradores automáticos para métodos de decorador, o Eclipse fornece). Finalmente, basta usá-lo. Isso também é basicamente o que o P6Spy e os consortes já fazem sob o capô.

Estou usando o Java 8, driver JDBC com conector MySQL v. 5.1.31.

Eu posso obter uma string SQL real usando este método:

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

Então, ele retorna smth assim:

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

Se você estiver executando a consulta e esperando uma ResultSet(você está nesse cenário, pelo menos), basta chamar ResultSetda seguinte getStatement()maneira:

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

A variável executedQueryirá conter a afirmação de que foi usado para criar o ResultSet.

Agora, percebo que essa pergunta é bastante antiga, mas espero que isso ajude alguém.

Eu extraí meu sql do PreparedStatement usando o preparadoStatement.toString () No meu caso, toString () retorna String assim:

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

Agora eu criei um método (Java 8), que está usando o regex para extrair a consulta e os valores e colocá-los no mapa:

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

Este método retorna o mapa onde temos pares de valores-chave:

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

Agora - se você deseja valores como lista, pode simplesmente usar:

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

Se o seu preparadoStatement.toString () for diferente do meu caso, é apenas uma questão de "ajustar" a expressão regular.

Usando o PostgreSQL 9.6.x com o driver Java oficial 42.2.4:

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

Mostrará o SQL com o ?já substituído, que é o que eu estava procurando. Acabei de adicionar esta resposta para cobrir o caso do postgres.

Eu nunca teria pensado que poderia ser tão simples.

Eu implementei o seguinte código para imprimir SQL a 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[" +  "] ...");
            }

    }

Snippet de código para converter SQL PreparedStaments com a lista de argumentos. Funciona para mim

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

Muito tarde :), mas você pode obter o SQL original de um OraclePreparedStatementWrapper por

((OraclePreparedStatementWrapper) preparedStatement).getOriginalSql();

Se você estiver usando o MySQL, poderá registrar as consultas usando o log de consultas do MySQL . Não sei se outros fornecedores fornecem esse recurso, mas é provável que sim.

Simplesmente função:

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

Também está bom para a declaração preparada.

Estou usando o Oralce 11g e não consegui obter o SQL final do PreparedStatement. Depois de ler a resposta do @Pascal MARTIN, entendo o porquê.

Acabei de abandonar a ideia de usar PreparedStatement e usei um formatador de texto simples que atendesse às minhas necessidades. Aqui está o meu exemplo:

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

Você descobre que o sqlInParam pode ser criado dinamicamente em um loop (for, while). Simplesmente simplifiquei o ponto de usar a classe MessageFormat para servir como formador de modelo de string para a consulta SQL.

Para fazer isso, você precisa de uma conexão JDBC e / ou driver que suporte o log do sql em um nível baixo.

Dê uma olhada no log4jdbc