¿Cómo ver las consultas SQL emitidas por JPA?

Cuando mi código emite una llamada como esta:

entityManager.find(Customer.class, customerID);

¿Cómo puedo ver la consulta SQL para esta llamada? Suponiendo que no tengo acceso al servidor de base de datos para perfilar / monitorear las llamadas, ¿hay alguna forma de registrar o ver dentro de mi IDE las consultas SQL correspondientes emitidas por llamadas JPA? Voy en contra de SQL Server 2008 R2 usando el controlador jTDS.

Las opciones de registro son específicas del proveedor. Necesita saber qué implementación de JPA utiliza.

• Hibernate ( ver aquí ):

  <property name = "hibernate.show_sql" value = "true" />

• EclipseLink ( ver aquí ):

  <property name="eclipselink.logging.level" value="FINE"/>

• OpenJPA ( ver aquí ):

  <property name="openjpa.Log" value="DefaultLevel=WARN,Runtime=INFO,Tool=INFO,SQL=TRACE"/>

• DataNucleus ( ver aquí ):

  Establezca la categoría de registro DataNucleus.Datastore.Nativea un nivel, como DEBUG.

Además, si está utilizando EclipseLink y desea generar los valores de los parámetros SQL, puede agregar esta propiedad a su archivo persistence.xml:

<property name="eclipselink.logging.parameters" value="true"/>

Si usa hibernate y logback como su registrador, podría usar lo siguiente (muestra solo los enlaces y no los resultados):

<appender
    name="STDOUT"
    class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
        <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} -
            %msg%n</pattern>
    </encoder>
    <filter class="ch.qos.logback.core.filter.EvaluatorFilter">
        <evaluator>
            <expression>return message.toLowerCase().contains("org.hibernate.type") &amp;&amp;
                logger.startsWith("returning");</expression>
        </evaluator>
        <OnMismatch>NEUTRAL</OnMismatch>
        <OnMatch>DENY</OnMatch>
    </filter>
</appender>

org.hibernate.SQL = DEBUG imprime la consulta

<logger name="org.hibernate.SQL">
    <level value="DEBUG" />
</logger>

org.hibernate.type = TRACE imprime los enlaces y normalmente los resultados, que se suprimirán a través del filtro personalizado

<logger name="org.hibernate.type">
    <level value="TRACE" />
</logger>

Necesita la dependencia de janino (http://logback.qos.ch/manual/filters.html#JaninoEventEvaluator):

<dependency>
    <groupId>org.codehaus.janino</groupId>
    <artifactId>janino</artifactId>
    <version>2.6.1</version>
</dependency>

En EclipseLink para obtener el SQL para una consulta específica en tiempo de ejecución, puede usar la API DatabaseQuery:

Query query = em.createNamedQuery("findMe"); 
Session session = em.unwrap(JpaEntityManager.class).getActiveSession(); 
DatabaseQuery databaseQuery = ((EJBQueryImpl)query).getDatabaseQuery(); 
databaseQuery.prepareCall(session, new DatabaseRecord());

String sqlString = databaseQuery.getSQLString();

Este SQL contendrá? para los parámetros Para traducir el SQL con los argumentos, necesita un DatabaseRecord con los valores de los parámetros.

DatabaseRecord recordWithValues= new DatabaseRecord();
recordWithValues.add(new DatabaseField("param1"), "someValue");

String sqlStringWithArgs = 
         databaseQuery.getTranslatedSQLString(session, recordWithValues);

Fuente: Cómo obtener el SQL para una consulta

Para ver todos los SQL y parámetros en OpenJPA, coloque estos dos parámetros en persistence.xml:

<property name="openjpa.Log" value="DefaultLevel=WARN, Runtime=INFO, Tool=INFO, SQL=TRACE"/>
<property name="openjpa.ConnectionFactoryProperties" value="PrintParameters=true" />

Si desea ver las consultas exactas con valores de parámetros y valores de retorno, puede usar un controlador proxy jdbc. Interceptará todas las llamadas jdbc y registrará sus valores. Algunos proxies:

• log4jdbc
• jdbcspy

También pueden proporcionar algunas características adicionales, como medir el tiempo de ejecución de consultas y recopilar estadísticas.

Ejemplo usando log4j ( src \ log4j.xml ):

<?xml version="1.0" encoding="UTF-8" ?>

<appender name="CA" class="org.apache.log4j.AsyncAppender">
    <param name="BufferSize" value="512"/>
    <appender-ref ref="CA_OUTPUT"/>
</appender>
<appender name="CA_OUTPUT" class="org.apache.log4j.ConsoleAppender">
    <layout class="org.apache.log4j.PatternLayout">
        <param name="ConversionPattern" value="[%p] %d %c %M - %m%n"/>
    </layout>
</appender>

<logger name="org.hibernate.SQL" additivity="false">
    <level value="DEBUG"/>
    <appender-ref ref="CA"/>
</logger>

<root>
    <level value="WARN"/>
    <appender-ref ref="CA"/>
</root>

He hecho una hoja de trucos que creo que puede ser útil para otros. En todos los ejemplos, puede eliminar la format_sqlpropiedad si desea mantener las consultas registradas en una sola línea (sin impresión bonita).

Imprima bastante las consultas SQL para estandarizar sin parámetros de declaraciones preparadas y sin optimizaciones de un marco de registro :

application.properties expediente:

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

application.yml expediente:

spring:
  jpa:
    show-sql: true
    properties:
      hibernate:
        format_sql: true

Imprima consultas SQL con parámetros de declaraciones preparadas utilizando un marco de registro :

application.properties expediente:

spring.jpa.properties.hibernate.format_sql=true
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

application.yml expediente:

spring:
  jpa:
    properties:
      hibernate:
        format_sql: true
logging:
  level:
    org:
      hibernate:
        SQL: DEBUG
        type:
          descriptor:
            sql:
              BasicBinder: TRACE

Imprima consultas SQL sin parámetros de declaraciones preparadas utilizando un marco de registro :

application.properties expediente:

spring.jpa.properties.hibernate.format_sql=true
logging.level.org.hibernate.SQL=DEBUG

application.yml expediente:

spring:
  jpa:
    properties:
      hibernate:
        format_sql: true
logging:
  level:
    org:
      hibernate:
        SQL: DEBUG

Fuente (y más detalles): https://www.baeldung.com/sql-logging-spring-boot

Además, si usa WildFly / JBoss, establezca el nivel de registro de org.hibernate en DEBUG

Otra buena opción si tiene demasiado registro y desea colocar solo como temporal System.out.println(), puede, según su proveedor:

CriteriaBuilder criteriaBuilder = getEntityManager().getCriteriaBuilder();
CriteriaQuery<ExaminationType> criteriaQuery = criteriaBuilder.createQuery(getEntityClass()); 

/* For Hibernate */
System.out.println(getEntityManager().createQuery(criteriaQuery).unwrap(org.hibernate.Query.class).getQueryString());

/* For OpenJPA */ 
System.out.println(getEntityManager().createQuery(criteriaQuery).unwrap(org.apache.openjpa.persistence.QueryImpl.class).getQueryString());

/* For EclipseLink */
System.out.println(getEntityManager().createQuery(criteriaQuery).unwrap(JpaQuery.class).getSQLString());

Si está utilizando Spring Framework. Modifique su archivo application.properties como se muestra a continuación

#Logging JPA Queries, 1st line Log Query. 2nd line Log parameters of prepared statements 
logging.level.org.hibernate.SQL=DEBUG  
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE  

#Logging JdbcTemplate Queries, 1st line Log Query. 2nd line Log parameters of prepared statements 
logging.level.org.springframework.jdbc.core.JdbcTemplate=DEBUG  
logging.level.org.springframework.jdbc.core.StatementCreatorUtils=TRACE  

Consulte No se puede hacer que la hibernación deje de mostrar SQL utilizando Spring JPA Vendor Adapter

Con Spring Boot simplemente agregue: spring.jpa.show-sql = true a application.properties. Esto mostrará la consulta pero sin los parámetros reales (¿verá? En lugar de cada parámetro).

Durante el desarrollo exploratorio, y para enfocar el registro de depuración de SQL en el método específico que quiero verificar, decoro ese método con las siguientes declaraciones de registrador:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;

((ch.qos.logback.classic.Logger) LoggerFactory.getLogger("org.hibernate.SQL")).setLevel(Level.DEBUG);
entityManager.find(Customer.class, customerID);
((ch.qos.logback.classic.Logger) LoggerFactory.getLogger("org.hibernate.SQL")).setLevel(Level.INFO);

EclipseLink para generar el SQL (persistence.xml config):

<property name="eclipselink.logging.level.sql" value="FINE" />

Hay un archivo llamado persistence.xml Presione Ctrl + Shift + R y encuéntrelo, luego, hay un lugar escrito como showSQL.

Solo ponlo como cierto

No estoy seguro de si el servidor debe iniciarse como modo de depuración. Verifique los SQL creados en la consola.