Wie werden die von JPA ausgegebenen SQL-Abfragen angezeigt?

Wenn mein Code einen Aufruf wie diesen ausgibt:

entityManager.find(Customer.class, customerID);

Wie kann ich die SQL-Abfrage für diesen Aufruf sehen? Angenommen, ich habe keinen Zugriff auf den Datenbankserver, um die Anrufe zu profilieren / überwachen. Gibt es eine Möglichkeit, die entsprechenden SQL-Abfragen, die von JPA-Aufrufen ausgegeben werden, in meiner IDE zu protokollieren oder anzuzeigen? Ich gehe gegen SQL Server 2008 R2 mit dem jTDS-Treiber.

Die Protokollierungsoptionen sind anbieterspezifisch. Sie müssen wissen, welche JPA-Implementierung Sie verwenden.

• Ruhezustand ( siehe hier ):

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

• EclipseLink ( siehe hier ):

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

• OpenJPA ( siehe hier ):

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

• DataNucleus ( siehe hier ):

  Stellen Sie die Protokollkategorie DataNucleus.Datastore.Nativeauf eine Ebene wie ein DEBUG.

Wenn Sie EclipseLink verwenden und die SQL-Parameterwerte ausgeben möchten, können Sie diese Eigenschaft Ihrer Datei persistence.xml hinzufügen:

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

Wenn Sie den Ruhezustand und den Logback als Logger verwenden, können Sie Folgendes verwenden (zeigt nur die Bindungen und nicht die Ergebnisse an):

<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 druckt die Abfrage

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

org.hibernate.type = TRACE druckt die Bindungen und normalerweise die Ergebnisse, die durch den benutzerdefinierten Filter unterdrückt werden

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

Sie benötigen die Janino-Abhängigkeit (http://logback.qos.ch/manual/filters.html#JaninoEventEvaluator):

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

In EclipseLink können Sie die DatabaseQuery-API verwenden, um die SQL für eine bestimmte Abfrage zur Laufzeit abzurufen:

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

Diese SQL wird enthalten? für Parameter. Um die SQL mit den Argumenten zu übersetzen, benötigen Sie einen DatabaseRecord mit den Parameterwerten.

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

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

Quelle: So erhalten Sie SQL für eine Abfrage

Fügen Sie diese beiden Parameter in die Datei persistence.xml ein, um alle SQL- und Parameter in OpenJPA anzuzeigen:

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

Wenn Sie die genauen Abfragen mit Parameterwerten und Rückgabewerten anzeigen möchten, können Sie einen JDBC-Proxy-Treiber verwenden. Es werden alle JDBC-Aufrufe abgefangen und ihre Werte protokolliert. Einige Proxies:

• log4jdbc
• jdbcspy

Sie bieten möglicherweise auch einige zusätzliche Funktionen, z. B. das Messen der Ausführungszeit für Abfragen und das Sammeln von Statistiken.

Beispiel mit 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>

Wenn Sie WildFly / JBoss verwenden, setzen Sie außerdem die Protokollierungsstufe von org.hibernate auf DEBUG

Eine weitere gute Option, wenn Sie zu viel Protokoll haben und nur als temporäres Protokoll verwenden möchten System.out.println(), können Sie je nach Anbieter Folgendes tun:

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

Wenn Sie das Spring Framework verwenden. Ändern Sie die Datei application.properties wie folgt

#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  

Ich habe einen Spickzettel erstellt, von dem ich denke, dass er für andere nützlich sein kann. In allen Beispielen können Sie das entfernenformat_sql Eigenschaft wenn Sie die protokollierten Abfragen in einer einzelnen Zeile halten möchten (kein hübsches Drucken).

Hübsche SQL-Abfragen zum Standardisieren ohne Parameter vorbereiteter Anweisungen und ohne Optimierungen eines Protokollierungsframeworks :

application.properties Datei:

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

application.yml Datei:

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

Hübsche SQL-Abfragen mit Parametern vorbereiteter Anweisungen unter Verwendung eines Protokollierungsframeworks drucken :

application.properties Datei:

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

application.yml Datei:

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

Hübsche Druck-SQL-Abfragen ohne Parameter vorbereiteter Anweisungen unter Verwendung eines Protokollierungsframeworks :

application.properties Datei:

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

application.yml Datei:

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

Quelle (und weitere Details): https://www.baeldung.com/sql-logging-spring-boot

Siehe Der Ruhezustand kann die Anzeige von SQL mit dem Spring JPA Vendor Adapter nicht beenden

Fügen Sie mit Spring Boot einfach Folgendes hinzu: spring.jpa.show-sql = true to application.properties. Dies zeigt die Abfrage, jedoch ohne die tatsächlichen Parameter (Sie sehen? Anstelle jedes Parameters).

Während der explorativen Entwicklung und um die SQL-Debugging-Protokollierung auf die spezifische Methode zu konzentrieren, die ich überprüfen möchte, dekoriere ich diese Methode mit den folgenden Logger-Anweisungen:

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 zur Ausgabe von SQL (persistence.xml config):

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

Es gibt eine Datei namens persistence.xml. Drücken Sie Strg + Umschalt + R und finden Sie sie. Dann gibt es einen Ort, der so etwas wie showSQL geschrieben hat.

Sagen Sie es einfach als wahr

Ich bin nicht sicher, ob der Server als Debug-Modus gestartet werden muss. Überprüfen Sie die auf der Konsole erstellten SQLs.