Comment enregistrer des instructions SQL dans Grails

Réglage

datasource { ... logSql = true } 

dans DataSource.groovy (selon ces instructions) était suffisant pour le faire fonctionner dans mon environnement. Il semble que certaines parties de la FAQ soient obsolètes (par exemple, la question des “nombreuses-à-plusieurs colonnes en arrière”), donc cela pourrait aussi être quelque chose qui a changé entre-temps.

Je trouve plus utile de faire ce qui suit, qui consiste à permettre à Hibernate de consigner le code SQL avec les variables de liaison (afin de voir les valeurs transmises à vos appels et de répliquer facilement le SQL dans votre éditeur ou autre).

Dans Config.groovy , ajoutez ce qui suit à votre bloc log4j:

 log4j = { // Enable Hibernate SQL logging with param values trace 'org.hibernate.type' debug 'org.hibernate.SQL' //the rest of your logging config // ... } 

Pour grails 3. *

Option # 1 ajoute ce qui suit à logback.groovy

 logger("org.hibernate.SQL", DEBUG, ["STDOUT"], false) logger("org.hibernate.type.descriptor.sql.BasicBinder", TRACE, ["STDOUT"], false) 

ou

Option n ° 2 ajoute ce qui suit à dataSource dans le fichier application.yml. Cependant, cette approche ne consigne pas les valeurs des parameters

 environments: local: dataSource: logSql: true formatSql: true 

Essaye ça:

 log4j = { ... debug 'org.hibernate.SQL' trace 'org.hibernate.type.descriptor.sql.BasicBinder' } 

Il évite les problèmes de performances liés à la consignation de trace dans le package de type Hibernate. Cela fonctionne avec Hibernate 3.6 et supérieur. Je l’ai eu de: https://burtbeckwith.com/blog/?p=1604

La solution ne concerne que le développement et non la production.

Toutes les réponses ci-dessus fonctionnent et sont correctes. Mais ils ne montrent pas la requête complète d’une manière lisible par l’homme. Si vous voulez voir la requête finale (sans aucune?,?), Vous avez deux options.

A) proxy votre connexion jdbc avec log4jdbc ou p6Spy.

B) regarder au niveau de la firebase database. Par exemple vraiment facile à faire avec mysql.

Découvrez où se trouve general_log_file. Journal général actif si aucun n’est déjà activé.

 mysql command line> show variables like "%general_log%"; mysql command line> set global general_log = true; 

Maintenant, tout est enregistré dans votre fichier journal. Mac / linux exemple pour montrer le stream de vos requêtes.

 tail -f path_to_log_file 

Pure for reference only, mais j’utilise p6spy pour enregistrer les requêtes SQL. C’est un petit pilote jdbc intermédiaire. La requête exacte est enregistrée car elle serait envoyée au serveur (avec les parameters inclus).

inclure dans votre projet:

 runtime 'p6spy:p6spy:3.0.0' 

Changez votre pilote de source de données:

 driverClassName: com.p6spy.engine.spy.P6SpyDriver 

Et votre URL jdbc:

 url: jdbc:p6spy:mysql:// 

Configurez-le à l’aide de spy.properties (dans grails-app / conf).

 driverlist=org.h2.Driver,com.mysql.jdbc.Driver autoflush=true appender=com.p6spy.engine.spy.appender.StdoutLogger databaseDialectDateFormat=yyyy-MM-dd logMessageFormat=com.p6spy.engine.spy.appender.MultiLineFormat 

N’oubliez pas de désactiver cette fonction pour la production!

Je sais que cela a été demandé et répondu depuis longtemps. Mais il m’est arrivé de voir cette question et je ne pouvais pas m’empêcher de répondre ou de partager notre approche d’implémentation de SQL logging dans notre projet. J’espère que ça aidera.

Actuellement, il est en développement. Nous utilisons “Log4jdbc Driver Spy” pour enregistrer SQL.

Configuration:

Dans votre BuildConfig.groovy: ajoutez les dépendances suivantes:

 dependencies { ..... runtime 'org.lazyluke:log4jdbc-remix:0.2.7' } 

Et dans votre source de données ou autre élément lié à la configuration: [où que vous ayez défini la configuration associée à la source de données], ajoutez:

 datasources{ ..... driverClassName: "net.sf.log4jdbc.DriverSpy", url: "jdbc:log4jdbc:oracle:thin:@(DESCRIPTION =(ADDRESS_LIST = (ADDRESS = (PROTOCOL = TCP)(HOST = XXXXX.XX>XXX)(PORT = 1521))) (CONNECT_DATA = (SID = XXXX)(SERVER =DEDICATED)))", .... } log4j = { info 'jdbc.sqlonly' //, 'jdbc.resultsettable' } 

D’après mon expérience personnelle, je l’ai trouvé très utile et utile lors du débogage. Aussi plus d’informations que vous pouvez trouver sur ce site. https://code.google.com/p/log4jdbc-remix/

Cordialement

Pour un bloc de code particulier, nous pouvons également créer une méthode qui accepte une fermeture. par exemple.

  static def executeBlockAndGenerateSqlLogs(Closure closure) { Logger sqlLogger = Logger.getLogger("org.hibernate.SQL"); Level currentLevel = sqlLogger.level sqlLogger.setLevel(Level.TRACE) def result = closure.call() sqlLogger.setLevel(currentLevel) result } executeBlockAndGenerateSqlLogs{DomainClazz.findByPropertyName("property value")} 

Si le plug-in de la console est installé, vous pouvez obtenir une connexion SQL avec ce petit extrait de code.

 ctx.sessionFactory.settings.sqlStatementLogger.logToStdout = true try {  } finally { ctx.sessionFactory.settings.sqlStatementLogger.logToStdout = false } 

Ceci est une variante de la plupart des solutions ci-dessus, mais vous permet de modifier la valeur à l'exécution. Et tout comme les autres solutions qui traitent de logToStdout elles logToStdout uniquement les requêtes et non les valeurs de liaison.

L'idée a été volée à un poste de burtbeckwith que j'ai lu il y a quelques années et que je ne trouve pas en ce moment.

Une technique similaire peut être utilisée pour activer la journalisation pour des tests d'intégration spécifiques:

 class SomeIntegrationSpec extends IntegrationSpec { def sessionFactory def setup() { sessionFactory.settings.sqlStatementLogger.logToStdout = true } def cleanup() { sessionFactory.settings.sqlStatementLogger.logToStdout = false } void "some test"() { ... } 

Cela activera la journalisation SQL uniquement pour les tests de ce fichier.