Comment enregistrer les instructions SQL dans Grails

Je trouve plus utile de faire ce qui suit, qui est d'activer la journalisation D'Hibernate pour enregistrer le SQL avec les variables de liaison (de sorte que vous pouvez voir les valeurs passées dans vos appels, et répliquer facilement le SQL dans votre éditeur ou autrement).

Dans votre 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 graal 3.*

Option # 1 Ajoutez ce qui suit à logback.groovy

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

Ou

Option # 2 Ajoutez ce qui suit à dataSource dans l'application.yml. Cependant, cette approche ne consigne pas les valeurs des paramètres

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

Essayez ceci:

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

Il évite les problèmes de performance de la journalisation de trace du package Hibernate type. Cela fonctionne avec Hibernate 3.6 et supérieur. Je l'ai obtenu de: https://burtbeckwith.com/blog/?p=1604

Solution est seulement pour le développement, pas la production.

Toutes les réponses ci-dessus 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 finale (sans aucun?, ? requête de), vous avez deux options.

A) proxy votre connexion jdbc avec log4jdbc ou p6Spy.

B) regardez-le au niveau de la base de données. Par exemple vraiment facile à faire avec mysql.

Découvrez où vous general_log_file est. Journal général actif si non activé déjà.

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

Maintenant, tout est enregistré dans votre fichier journal. Exemple Mac / linux pour afficher un bon flux de vos requêtes.

tail -f path_to_log_file 

Pur pour référence seulement, mais j'utilise p6spy pour enregistrer les requêtes SQL. C'est un petit pilote JDBC intermédiaire. La requête exacte est consignée comme elle serait envoyée au serveur (avec les paramètres inclus).

Incluez - le dans votre projet:

runtime 'p6spy:p6spy:3.0.0'

Modifiez votre pilote de source de données:

driverClassName: com.p6spy.engine.spy.P6SpyDriver

Et votre url jdbc:

url: jdbc:p6spy:mysql://

Configurez-le en utilisant spy.propriétés (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 ceci pour la production!

Je sais que cela a été demandé et répondu longtemps .Mais je viens de voir cette question et je ne pouvais pas m'empêcher de répondre ou de partager notre approche d'implémentation de journalisation sql dans notre projet. Espérons qu'il sera de peu d'aide.

Actuellement, il est dans l'environnement de développement. Nous utilisons "Log4jdbc Driver Spy" pour enregistrer sql.

Configuration:

Dans votre BuildConfig.groovy: ajouter des dépendances ci-dessous:

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

Et dans votre source de données ou autre config liée: [où que vous ont défini la configuration liée à la source de données] , Ajouter:

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. Également plus d'informations que vous pouvez trouver dans ce site. https://code.google.com/p/log4jdbc-remix/

Roi Salutations

Pour un Bloc de code particulier, nous pouvons également créer une méthode qui acceptent de 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 vous avez installé le plugin console, vous pouvez obtenir la journalisation sql avec ce petit extrait de code.

ctx.sessionFactory.settings.sqlStatementLogger.logToStdout = true
try {
   <code that will log sql queries>
}
finally {
    ctx.sessionFactory.settings.sqlStatementLogger.logToStdout = false
}

Ceci est une variation sur la plupart des solutions ci-dessus, mais vous permet de modifier la valeur au moment de l'exécution. Et tout comme les autres solutions qui traitent de logToStdout, il ne montre que les requêtes et non les valeurs de liaison.

L'idée a été volée dans un post de burtbeckwith que j'ai lu il y a quelques années et que je ne trouve pas pour l'instant.

Une technique similaire peut être utilisée pour tourner lors de 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 pour seulement les tests dans ce fichier.