Comment imprimer une chaîne de requête avec des valeurs de paramètre lors de l'utilisation d'Hibernate

Question

Est-il possible dans Hibernate d'imprimer des requêtes SQL générées avec des valeurs réelles au lieu de points d'interrogation?

Comment suggéreriez-vous d’imprimer des requêtes avec des valeurs réelles si cela n’est pas possible avec l’API Hibernate?

Pascal Thivent · Accepted Answer

Vous devez activer logging pour les catégories suivantes:

org.hibernate.SQL - défini sur debug pour consigner toutes les instructions SQL DML au fur et à mesure de leur exécution
org.hibernate.type - défini sur trace pour consigner tous les paramètres JDBC

Ainsi, une configuration log4j pourrait ressembler à:

# logs the SQL statements log4j.logger.org.hibernate.SQL=debug # Logs the JDBC parameters passed to a query log4j.logger.org.hibernate.type=trace

Le premier est équivalent à hibernate.show_sql=true legacy property , le second affiche les paramètres liés, entre autres.

Une autre solution (non basée sur l'hibernation) serait d'utiliser un pilote de proxy JDBC tel que P6Spy .

Christoph · Answer

Juste pour plus de commodité, voici le même exemple de configuration pour Logback (SLF4J)

<appender name="SQLROLLINGFILE"> <File>/tmp/sql.log</File> <rollingPolicy> <FileNamePattern>logFile.%d{yyyy-MM-dd}.log</FileNamePattern> </rollingPolicy> <layout> <Pattern>%-4date | %msg %n</Pattern> </layout> </appender> <logger name="org.hibernate.SQL" additivity="false" > <level value="DEBUG" /> <appender-ref ref="SQLROLLINGFILE" /> </logger> <logger name="org.hibernate.type" additivity="false" > <level value="TRACE" /> <appender-ref ref="SQLROLLINGFILE" /> </logger>

La sortie dans votre sql.log (exemple) ressemble alors à ceci:

2013-08-30 18:01:15,083 | update stepprovider set created_at=?, lastupdated_at=?, version=?, bundlelocation=?, category_id=?, customer_id=?, description=?, icon_file_id=?, name=?, shareStatus=?, spversion=?, status=?, title=?, type=?, num_used=? where id=? 2013-08-30 18:01:15,084 | binding parameter [1] as [TIMESTAMP] - 2012-07-11 09:57:32.0 2013-08-30 18:01:15,085 | binding parameter [2] as [TIMESTAMP] - Fri Aug 30 18:01:15 CEST 2013 2013-08-30 18:01:15,086 | binding parameter [3] as [INTEGER] - 2013-08-30 18:01:15,086 | binding parameter [4] as [VARCHAR] - com.mypackage.foo 2013-08-30 18:01:15,087 | binding parameter [5] as [VARCHAR] - 2013-08-30 18:01:15,087 | binding parameter [6] as [VARCHAR] - 2013-08-30 18:01:15,087 | binding parameter [7] as [VARCHAR] - TODO 2013-08-30 18:01:15,087 | binding parameter [8] as [VARCHAR] - 2013-08-30 18:01:15,088 | binding parameter [9] as [VARCHAR] - MatchingStep@com.mypackage.foo 2013-08-30 18:01:15,088 | binding parameter [10] as [VARCHAR] - PRIVATE 2013-08-30 18:01:15,088 | binding parameter [11] as [VARCHAR] - 1.0 2013-08-30 18:01:15,088 | binding parameter [12] as [VARCHAR] - 32 2013-08-30 18:01:15,088 | binding parameter [13] as [VARCHAR] - MatchingStep 2013-08-30 18:01:15,089 | binding parameter [14] as [VARCHAR] - 2013-08-30 18:01:15,089 | binding parameter [15] as [INTEGER] - 0 2013-08-30 18:01:15,089 | binding parameter [16] as [VARCHAR] - 053c2e65-5d51-4c09-85f3-2281a1024f64

Hari · Answer

Remplacez hibernate.cfg.xml par:

<property name="show_sql">true</property> <property name="format_sql">true</property> <property name="use_sql_comments">true</property>

Incluez les entrées log4j et ci-dessous dans "log4j.properties":

log4j.logger.org.hibernate=INFO, hb log4j.logger.org.hibernate.SQL=DEBUG log4j.logger.org.hibernate.type=TRACE log4j.appender.hb=org.Apache.log4j.ConsoleAppender log4j.appender.hb.layout=org.Apache.log4j.PatternLayout

Alan Hay · Answer

Log4JDBC est une solution agréable qui imprime le exact SQL allant dans la base de données avec les paramètres en place plutôt que la réponse la plus populaire ici, qui ne le fait pas. L’un des principaux avantages de cette méthode est que vous pouvez copier le code SQL directement dans votre base de données et l’exécuter tel quel.

http://log4jdbc.sourceforge.net/

https://code.google.com/p/log4jdbc-remix/

Ce dernier génère également une représentation sous forme de tableau des résultats de la requête.

Exemple de sortie montrant le SQL généré avec les paramètres en place ainsi que la table de jeu de résultats de la requête:

5. insert into ENQUIRY_APPLICANT_DETAILS (ID, INCLUDED_IN_QUOTE, APPLICANT_ID, TERRITORY_ID, ENQUIRY_ID, ELIGIBLE_FOR_COVER) values (7, 1, 11, 1, 2, 0) 10 Oct 2013 16:21:22 4953 [main] INFO jdbc.resultsettable - |---|--------|--------|-----------|----------|---------|-------| 10 Oct 2013 16:21:22 4953 [main] INFO jdbc.resultsettable - |ID |CREATED |DELETED |CODESET_ID |NAME |POSITION |PREFIX | 10 Oct 2013 16:21:22 4953 [main] INFO jdbc.resultsettable - |---|--------|--------|-----------|----------|---------|-------| 10 Oct 2013 16:21:22 4953 [main] INFO jdbc.resultsettable - |2 |null |null |1 |Country 2 |1 |60 | 10 Oct 2013 16:21:22 4953 [main] INFO jdbc.resultsettable - |---|--------|--------|-----------|----------|---------|-------|

Mise à jour 2016

Dernièrement, j'utilisais log4jdbc-log4j2 ( https://code.google.com/archive/p/log4jdbc-log4j2/ ) avec SLF4j et la consignation. Les dépendances Maven requises pour mon installation sont les suivantes:

<dependency> <groupId>org.bgee.log4jdbc-log4j2</groupId> <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId> <version>1.16</version> </dependency> <dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-api</artifactId> <version>${slf4j.version}</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-core</artifactId> <version>${logback.version}</version> </dependency> <dependency> <groupId>ch.qos.logback</groupId> <artifactId>logback-classic</artifactId> <version>$logback.version}</version> </dependency>

Le pilote et les URL de base de données ressemblent alors à:

database.driver.class=net.sf.log4jdbc.sql.jdbcapi.DriverSpy database.url=jdbc:log4jdbc:hsqldb:mem:db_name #Hsql #database.url=jdbc:log4jdbc:mysql://localhost:3306/db_name

Mon fichier de configuration logback.xml ressemble à ce qui suit: il génère toutes les instructions SQL avec les paramètres, ainsi que les tables de jeu de résultats pour toutes les requêtes.

<?xml version="1.0" encoding="UTF-8"?> <configuration> <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender"> <encoder> <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n </pattern> </encoder> </appender> <logger name="jdbc.audit" level="ERROR" /> <logger name="jdbc.connection" level="ERROR" /> <logger name="jdbc.sqltiming" level="ERROR" /> <logger name="jdbc.resultset" level="ERROR" /> <!-- UNCOMMENT THE BELOW TO HIDE THE RESULT SET TABLE OUTPUT --> <!--<logger name="jdbc.resultsettable" level="ERROR" /> --> <root level="debug"> <appender-ref ref="STDOUT" /> </root> </configuration>

Enfin, je devais créer un fichier nommé log4jdbc.log4j2.properties à la racine du chemin de classe, par exemple. src/test/resources ou src/main/resources dans un projet Mevn. Ce fichier a une ligne qui est la suivante:

log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator

Ce qui précède dépend de votre bibliothèque de journalisation. Consultez la documentation sur https://code.google.com/archive/p/log4jdbc-log4j2 pour plus d'informations.

Exemple de sortie:

10:44:29.400 [main] DEBUG jdbc.sqlonly - org.hibernate.engine.jdbc.internal.ResultSetReturnImpl.extract(ResultSetReturnImpl.Java:70) 5. select memberrole0_.member_id as member_i2_12_0_, memberrole0_.id as id1_12_0_, memberrole0_.id as id1_12_1_, memberrole0_.member_id as member_i2_12_1_, memberrole0_.role_id as role_id3_12_1_, role1_.id as id1_17_2_, role1_.name as name2_17_2_ from member_roles memberrole0_ left outer join roles role1_ on memberrole0_.role_id=role1_.id where memberrole0_.member_id=104 10:44:29.402 [main] INFO jdbc.resultsettable - |----------|---|---|----------|--------|---|-----| |member_id |id |id |member_id |role_id |id |name | |----------|---|---|----------|--------|---|-----| |----------|---|---|----------|--------|---|-----|

JRichardsz · Answer

Si vous utilisez une chaussure à ressort, configurez simplement ceci:

aplication.yml

logging: level: org.hibernate.SQL: DEBUG org.hibernate.type: TRACE

aplication.properties

logging.level.org.hibernate.SQL=DEBUG logging.level.org.hibernate.type=TRACE

et rien de plus.

HTH

Michal Z m u d a · Answer

Vous pouvez ajouter des lignes de catégorie à log4j.xml:

<category name="org.hibernate.type"> <priority value="TRACE"/> </category>

et ajoutez des propriétés d'hibernation:

<property name="show_sql">true</property> <property name="format_sql">true</property> <property name="use_sql_comments">true</property>

Vlad Mihalcea · Answer

Vous pouvez le faire en utilisant le datasource-proxy , comme je l'ai décrit dans ce post .

En supposant que votre application attend un bean dataSource (par exemple via @Resource), voici comment vous pouvez configurer datasource-proxy:

<bean id="actualDataSource" class="bitronix.tm.resource.jdbc.PoolingDataSource" init-method="init" destroy-method="close"> <property name="className" value="bitronix.tm.resource.jdbc.lrc.LrcXADataSource"/> <property name="uniqueName" value="actualDataSource"/> <property name="minPoolSize" value="0"/> <property name="maxPoolSize" value="5"/> <property name="allowLocalTransactions" value="false" /> <property name="driverProperties"> <props> <prop key="user">${jdbc.username}</prop> <prop key="password">${jdbc.password}</prop> <prop key="url">${jdbc.url}</prop> <prop key="driverClassName">${jdbc.driverClassName}</prop> </props> </property> </bean> <bean id="proxyDataSource" class="net.ttddyy.dsproxy.support.ProxyDataSource"> <property name="dataSource" ref="testDataSource"/> <property name="listener"> <bean class="net.ttddyy.dsproxy.listener.ChainListener"> <property name="listeners"> <list> <bean class="net.ttddyy.dsproxy.listener.CommonsQueryLoggingListener"> <property name="logLevel" value="INFO"/> </bean> <bean class="net.ttddyy.dsproxy.listener.DataSourceQueryCountListener"/> </list> </property> </bean> </property> </bean> <alias name="proxyDataSource" alias="dataSource"/>

Maintenant la sortie Hibernate vs datasource-proxy:

INFO [main]: n.t.d.l.CommonsQueryLoggingListener - Name:, Time:1, Num:1, Query:{[select company0_.id as id1_6_, company0_.name as name2_6_ from Company company0_][]} INFO [main]: n.t.d.l.CommonsQueryLoggingListener - Name:, Time:0, Num:1, Query:{[insert into WarehouseProductInfo (id, quantity) values (default, ?)][19]} INFO [main]: n.t.d.l.CommonsQueryLoggingListener - Name:, Time:0, Num:1, Query:{[insert into Product (id, code, company_id, importer_id, name, version) values (default, ?, ?, ?, ?, ?)][phoneCode,1,-5,Phone,0]}

Les requêtes datasource-proxy contiennent des valeurs de paramètre et vous pouvez même ajouter des intercepteurs d'instructions JDBC personnalisés afin que vous puissiez capturer les problèmes de requête N + 1 dès vos tests d'intégration .

Ravshan Samandarov · Answer

ajoutez les propriétés et les valeurs suivantes à votre configuration log4j ou logback:

org.hibernate.sql=DEBUG org.hibernate.type.descriptor.sql.BasicBinder=TRACE

flybywire · Answer

activez le org.hibernate.type Logger pour voir comment les paramètres réels sont liés aux points d'interrogation.

V N V SATYANARAYANA · Answer

<!-- A time/date based rolling appender --> <appender name="FILE" class="org.Apache.log4j.RollingFileAppender"> <param name="File" value="logs/system.log" /> <param name="Append" value="true" /> <param name="ImmediateFlush" value="true" /> <param name="MaxFileSize" value="200MB" /> <param name="MaxBackupIndex" value="100" /> <layout class="org.Apache.log4j.PatternLayout"> <param name="ConversionPattern" value="%d %d{Z} [%t] %-5p (%F:%L) - %m%n" /> </layout> </appender> <appender name="journaldev-hibernate" class="org.Apache.log4j.RollingFileAppender"> <param name="File" value="logs/project.log" /> <param name="Append" value="true" /> <param name="ImmediateFlush" value="true" /> <param name="MaxFileSize" value="200MB" /> <param name="MaxBackupIndex" value="50" /> <layout class="org.Apache.log4j.PatternLayout"> <param name="ConversionPattern" value="%d %d{Z} [%t] %-5p (%F:%L) - %m%n" /> </layout> </appender> <logger name="com.journaldev.hibernate" additivity="false"> <level value="DEBUG" /> <appender-ref ref="journaldev-hibernate" /> </logger> <logger name="org.hibernate" additivity="false"> <level value="INFO" /> <appender-ref ref="FILE" /> </logger> <logger name="org.hibernate.type" additivity="false"> <level value="TRACE" /> <appender-ref ref="FILE" /> </logger> <root> <priority value="INFO"></priority> <appender-ref ref="FILE" /> </root>

Vijay Bhatt · Answer

**If you want hibernate to print generated sql queries with real values instead of question marks.** **add following entry in hibernate.cfg.xml/hibernate.properties:** show_sql=true format_sql=true use_sql_comments=true **And add following entry in log4j.properties :** log4j.logger.org.hibernate=INFO, hb log4j.logger.org.hibernate.SQL=DEBUG log4j.logger.org.hibernate.type=TRACE log4j.appender.hb=org.Apache.log4j.ConsoleAppender log4j.appender.hb.layout=org.Apache.log4j.PatternLayout

Manuel Romeiro · Answer

Cette réponse est un petit écart pour la question . Parfois, nous n'avons besoin de SQL que pour le débogage au moment de l'exécution . Dans ce cas, il existe un moyen plus simple d'utiliser debug sur les éditeurs.

Placez un point d'arrêt sur org.hibernate.loader.Loader.loadEntityBatch (ou naviguez jusqu'à la pile jusqu'à la fin).
Lorsque l'exécution est suspendue, recherchez la valeur de variable this.sql;

Ceci est pour Hibernate 3. Je ne suis pas sûr que cela fonctionne sur d'autres versions.

Ghurdyl · Answer

En utilisant Hibernate 4 et slf4j/log4j2, j'ai essayé d'ajouter les éléments suivants dans ma configuration log4j2.xml:

<Logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="trace" additivity="false"> <AppenderRef ref="Console"/> </Logger> <Logger name="org.hibernate.type.EnumType" level="trace" additivity="false"> <AppenderRef ref="Console"/> </Logger>

Mais sans succès.

J'ai découvert par ce fil que le framework jboss-logging utilisé par hibernate devait être configuré pour pouvoir se connecter via slf4j. J'ai ajouté l'argument suivant aux arguments VM de l'application:

-Dorg.jboss.logging.provider=slf4j

Et ça a fonctionné comme un charme.

zime · Answer

La solution est correcte, mais enregistre également toutes les liaisons pour les objets de résultat . Pour éviter cela, il est possible de créer un éditeur distinct et d'activer le filtrage, par exemple:

<!-- A time/date based rolling appender --> <appender name="FILE_HIBERNATE" class="org.jboss.logging.appender.DailyRollingFileAppender"> <errorHandler class="org.jboss.logging.util.OnlyOnceErrorHandler"/> <param name="File" value="${jboss.server.log.dir}/hiber.log"/> <param name="Append" value="false"/> <param name="Threshold" value="TRACE"/> <!-- Rollover at midnight each day --> <param name="DatePattern" value="'.'yyyy-MM-dd"/> <layout class="org.Apache.log4j.PatternLayout"> <!-- The default pattern: Date Priority [Category] Message
 --> <param name="ConversionPattern" value="%d %-5p [%c] %m%n"/> </layout> <filter class="org.Apache.log4j.varia.StringMatchFilter"> <param name="StringToMatch" value="bind" /> <param name="AcceptOnMatch" value="true" /> </filter> <filter class="org.Apache.log4j.varia.StringMatchFilter"> <param name="StringToMatch" value="select" /> <param name="AcceptOnMatch" value="true" /> </filter> <filter class="org.Apache.log4j.varia.DenyAllFilter"/> </appender> <category name="org.hibernate.type"> <priority value="TRACE"/> </category> <logger name="org.hibernate.type"> <level value="TRACE"/> <appender-ref ref="FILE_HIBERNATE"/> </logger> <logger name="org.hibernate.SQL"> <level value="TRACE"/> <appender-ref ref="FILE_HIBERNATE"/> </logger>

clevertension · Answer

le pilote mysql jdbc a déjà fourni un moyen pratique de répondre à cette exigence, vous devez au moins avoir la version jar> = mysql-connect-jar-5.1.6.jar

étape 1: [configurez votre jdbc.url pour ajouter un enregistreur et une journalisation personnalisée]

 jdbc.url=jdbc:mysql://Host:port/your_db?logger=com.mysql.jdbc.log.Slf4JLogger&profileSQL=true&profilerEventHandler=com.xxx.CustomLoggingProfilerEventHandler

maintenant, il utilise la journalisation slf4j, si votre journalisation par défaut est log4j, vous devez ajouter les dépendances slf4j-api, slf4j-log4j12 pour utiliser la journalisation slf4j

étape 2: [écrivez votre journalisation personnalisée]

package com.xxx; import Java.sql.SQLException; import Java.util.Properties; import com.mysql.jdbc.Connection; import com.mysql.jdbc.log.Log; public class CustomLoggingProfilerEventHandler implements ProfilerEventHandler { private Log log; public LoggingProfilerEventHandler() { } public void consumeEvent(ProfilerEvent evt) { /** * you can only print the sql as this.log.logInfo(evt.getMessage()) * you can adjust your sql print log level with: DEBUG,INFO * you can also handle the message to meet your requirement */ this.log.logInfo(evt); } public void destroy() { this.log = null; } public void init(Connection conn, Properties props) throws SQLException { this.log = conn.getLog(); } }

V N V SATYANARAYANA · Answer

<appender name="console" class="org.Apache.log4j.ConsoleAppender"> <layout class="org.Apache.log4j.PatternLayout"> <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n" /> </layout> </appender> <logger name="org.hibernate" additivity="false"> <level value="INFO" /> <appender-ref ref="console" /> </logger> <logger name="org.hibernate.type" additivity="false"> <level value="TRACE" /> <appender-ref ref="console" /> </logger>

S&#39;chn T&#39;gai Spock · Answer

Voici ce qui a fonctionné pour moi, défini sous la propriété dans le fichier log4j.file:

log4j.logger.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

Paramètres de propriétés Hibernate:

hibernate.show_sql=true

Frizz1977 · Answer

J'aime ceci pour log4j:

log4j.logger.org.hibernate.SQL=trace log4j.logger.org.hibernate.engine.query=trace log4j.logger.org.hibernate.type=trace log4j.logger.org.hibernate.jdbc=trace log4j.logger.org.hibernate.type.descriptor.sql.BasicExtractor=error log4j.logger.org.hibernate.type.CollectionType=error

diy · Answer

si vous utilisez Hibernate 3.2.xx , utilisez

log4j.logger.org.hibernate.SQL=trace

au lieu de

log4j.logger.org.hibernate.SQL=debug

Jason D · Answer

Toutes les réponses ici sont utiles, mais si vous utilisez un contexte XML d'application Spring pour configurer votre fabrique de sessions, la définition de la variable de niveau SQL log4j ne vous permet qu'une partie du chemin, vous devez également définir la variable hibernate.show_sql dans le contexte même de l'application pour que Hibernate commence à afficher les valeurs.

ApplicationContext.xml a:

<property name="hibernateProperties"> <value> hibernate.jdbc.batch_size=25 ... <!-- Other parameter values here --> hibernate.show_sql=true </value> </property>

Et vos besoins en fichiers log4j

log4j.logger.org.hibernate.SQL=DEBUG

Sindhoo Oad · Answer

La journalisation fonctionne, mais pas exactement ce que vous voulez ou ce que je voulais il y a quelque temps, mais P6Spy fonctionne vraiment parfaitement,

voici le didacticiel simple à mettre en œuvre aussi MKYONG tutoriel pour P6Spy .

pour moi cela a fonctionné comme un charme.

Télécharger la bibliothèque P6Spy

Obtenez le “p6spy-install.jar“

Extrait le

Extrayez le fichier p6spy-install.jar, cherchez p6spy.jar et spy.properties

Ajouter une dépendance à la bibliothèque

Ajoutez p6spy.jar dans la dépendance de votre bibliothèque de projet

Modifier le fichier de propriétés P6Spy

Modifiez le fichier de configuration de votre base de données. Vous devez remplacer votre pilote JDBC existant par un pilote JDBC P6Spy - com.p6spy.engine.spy.P6SpyDriver

Le pilote JDBC MySQL est d'origine - com.mysql.jdbc.Driver

<session-factory> <property name="hibernate.bytecode.use_reflection_optimizer">false</property> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.password">password</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mkyong</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="show_sql">true</property> </session-factory>

Changé en pilote JDBC P6Spy - com.p6spy.engine.spy.P6SpyDriver

<session-factory> <property name="hibernate.bytecode.use_reflection_optimizer">false</property> <property name="hibernate.connection.driver_class">com.p6spy.engine.spy.P6SpyDriver </property> <property name="hibernate.connection.password">password</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mkyong</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="show_sql">true</property> </session-factory>

Modifier le fichier de propriétés P6Spy Modifier le fichier de propriétés P6Spy - spy.properties

Remplacez le real driver par votre pilote JDBC MySQL existant

realdriver=com.mysql.jdbc.Driver #specifies another driver to use realdriver2= #specifies a third driver to use realdriver3=

Modifier l'emplacement du fichier journal Modifier l'emplacement du fichier journal dans la propriété logfile, toutes les instructions SQL se connecteront à ce fichier.

Les fenêtres

logfile = c:/spy.log

*rien

logfile = /srv/log/spy.log

Copier “spy.properties” dans le chemin de classe du projet

Copiez “spy.properties” dans le dossier racine de votre projet, assurez-vous que votre projet peut localiser «spy.properties», sinon l'invite “spy.properties” fera exception au fichier introuvable.

ejaenv · Answer

Vous pouvez vous connecter ceci:

net.sf.hibernate.hql.QueryTranslator

Exemple de sortie:

2013-10-31 14:56:19,029 DEBUG [net.sf.hibernate.hql.QueryTranslator] HQL: select noti.id, noti.idmicrosite, noti.fcaducidad, noti.fpublicacion, noti.tipo, noti.imagen, noti.visible, trad.titulo, trad.subtitulo, trad.laurl, trad.urlnom, trad.fuente, trad.texto from org.ibit.rol.sac.micromodel.Noticia noti join noti.traducciones trad where index(trad)='ca' and noti.visible='S' and noti.idmicrosite=985 and noti.tipo=3446 2013-10-31 14:56:19,029 DEBUG [net.sf.hibernate.hql.QueryTranslator] SQL: select noticia0_.NOT_CODI as x0_0_, noticia0_.NOT_MICCOD as x1_0_, noticia0_.NOT_CADUCA as x2_0_, noticia0_.NOT_PUBLIC as x3_0_, noticia0_.NOT_TIPO as x4_0_, noticia0_.NOT_IMAGEN as x5_0_, noticia0_.NOT_VISIB as x6_0_, traduccion1_.NID_TITULO as x7_0_, traduccion1_.NID_SUBTIT as x8_0_, traduccion1_.NID_URL as x9_0_, traduccion1_.NID_URLNOM as x10_0_, traduccion1_.NID_FUENTE as x11_0_, traduccion1_.NID_TEXTO as x12_0_ from GUS_NOTICS noticia0_ inner join GUS_NOTIDI traduccion1_ on noticia0_.NOT_CODI=traduccion1_.NID_NOTCOD where (traduccion1_.NID_CODIDI='ca' )and(noticia0_.NOT_VISIB='S' )and(noticia0_.NOT_MICCOD=985 )and(noticia0_.NOT_TIPO=3446 )

Mithun Khatri · Answer

Le plugin Log4Jdbc serait le mieux adapté à vos besoins. Cela montre ce qui suit-

1. Complete SQL query being hit to the db 2. Parameter values being passed to the query 3. Execution time taken by each query

Voir le lien ci-dessous pour configurer Log4Jdbc-

https://code.google.com/p/log4jdbc/

Aneesh Vijendran · Answer

Utilisez Wireshark ou quelque chose de similaire:

Aucune des réponses mentionnées ci-dessus n’imprimera correctement SQL avec des paramètres ou est une douleur. Pour ce faire, j'ai utilisé WireShark , qui capture toutes les commandes sql/envoyées depuis l'application vers Oracle/Mysql, etc.

Suneet Khurana · Answer

Hibernate affiche la requête et ses valeurs de paramètre sur différentes lignes.

Si vous utilisez application.properties au printemps, vous pouvez utiliser le paramètre mis en surbrillance ci-dessous dans application.properties.

org.hibernate.SQL affichera les requêtes

logging.level.org.hibernate.SQL = DEBUG
org.hibernate.type affichera toutes les valeurs de paramètre, qui mapperont avec les requêtes select, insert et update . logging.level.org.hibernate.type = TRACE
- org.hibernate.type.EnumType affichera la valeur du paramètre de type enum
  
  logging.level.org.hibernate.type.EnumType = TRACE
  
  exemple ::
```
2018-06-14 11:06:28,217 TRACE [main] [EnumType.Java : 321] Binding [active] to parameter: [1] 
```
- sql.BasicBinder affichera integer, varchar, la valeur du paramètre de type booléen
  
  logging.level.org.hibernate.type.descriptor.sql.BasicBinder = TRACE
  
  exemple ::
  - 2018-06-14 11: 28: 29,750 TRACE [http-nio-9891-exec-2] [BasicBinder.Java: 65] paramètre de liaison [1] en tant que [BOOLEAN] - [true]
  - 2018-06-14 11: 28: 29,751 TRACE [http-nio-9891-exec-2] [BasicBinder.Java: 65] paramètre de liaison [2] en tant que [INTEGER] - [1]
  - 2018-06-14 11: 28: 29,752 TRACE [http-nio-9891-exec-2] [BasicBinder.Java: 65] paramètre de liaison [3] en tant que [VARCHAR] - [public]

Fr&#233;d&#233;ric Nell · Answer

En Java:

Transformez votre requête en TypedQuery s'il s'agit d'un CriteriaQuery (javax.persistence).

Ensuite:

query.unwrap (org.hibernate.Query.class) .getQueryString ();

Cl&#233;ssio Mendes · Answer

La solution la plus simple pour moi consiste à implémenter un stringReplace régulier pour remplacer les entrées de paramètre par des valeurs de paramètre (traiter tous les paramètres comme une chaîne, par souci de simplicité):

 String debugedSql = sql; //then, for each named parameter debugedSql = debugedSql.replaceAll(":"+key, "'"+value.toString()+"'"); //and finnaly println(debugedSql);

ou quelque chose de similaire pour les paramètres de position (?).
Prenez soin des valeurs NULL et des types de valeur spécifiques tels que la date, si vous souhaitez qu'une exécution prête SQL soit enregistrée.

womd · Answer

pour le développement avec Wildfly (standalone.xml), ajoutez les enregistreurs suivants:

<logger category="org.hibernate.SQL"> <level name="DEBUG"/> </logger> <logger category="org.hibernate.type.descriptor.sql"> <level name="TRACE"/> </logger>

Comment imprimer une chaîne de requête avec des valeurs de paramètre lors de l'utilisation d'Hibernate

Mise à jour 2016

logging.level.org.hibernate.SQL = DEBUG

logging.level.org.hibernate.type.EnumType = TRACE

logging.level.org.hibernate.type.descriptor.sql.BasicBinder = TRACE