Comment enregistrer des instructions SQL dans Grails

Je veux me connecter dans la console ou dans un fichier, toutes les requêtes que Grails fait, pour vérifier les performances.

J'avais configuré cela sans succès.

N'importe quelle idée aiderait.

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 «les colonnes plusieurs à plusieurs 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 à activer la journalisation d'Hibernate pour enregistrer le SQL avec les variables de liaison (afin que vous puissiez voir les valeurs passées dans vos appels et répliquer facilement le SQL dans votre éditeur ou autre).

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 les Grains 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

L'option n ° 2 ajoute ce qui suit à dataSource dans le fichier application.yml. Cependant, cette approche n'enregistre pas les valeurs des paramètres

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

Essaye ça:

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

Cela évite les problèmes de performances liés à la journalisation de trace du typepaquet Hibernate . Cela fonctionne avec Hibernate 3.6 et versions ultérieures. J'ai obtenu ceci de: https://burtbeckwith.com/blog/?p=1604

La solution ne concerne que le développement, pas 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 de votre connexion jdbc avec log4jdbc ou p6Spy.

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

Découvrez où se trouve votre fichier general_log_file. Journal général actif si non 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. Exemple Mac / Linux pour afficher un joli flux de vos requêtes.

tail -f path_to_log_file 

Pure 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 enregistrée comme elle serait envoyée au serveur (avec les paramètres inclus).

incluez-le 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 en utilisant 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 cela pour la production!

Next fonctionne pour moi:

grails-app / conf / application.yml

# ...
hibernate:
    format_sql: true # <<<<<<< ADD THIS <<<<<<<
    cache:
        queries: false
        use_second_level_cache: true
# ...
environments:
    development:
        dataSource:
            logSql: true // <<<<<<< ADD THIS <<<<<<<
            dbCreate: create-drop
            url: jdbc:h2:mem:...
# ...

grails-app / conf / logback.groovy

// ...
appender('STDOUT', ConsoleAppender) {
    encoder(PatternLayoutEncoder) {
        pattern = "%level %logger - %msg%n"
    }
}

// >>>>>>> ADD IT >>>>>>>
logger 'org.hibernate.type.descriptor.sql.BasicBinder', TRACE, ['STDOUT']
logger 'org.hibernate.SQL', TRACE, ['STDOUT']
// <<<<<<< ADD IT <<<<<<<

root(ERROR, ['STDOUT'])

def targetDir = BuildSettings.TARGET_DIR
// ...

Source: http://sergiodelamo.es/log-sql-grails-3-app/

Je sais que cela a été demandé et répondu il y a longtemps. J'espère que cela vous aidera.

Actuellement, il est dans un environnement de développement. Nous utilisons "log4jdbc Driver Spy" pour enregistrer sql.

Configuration:

Dans votre BuildConfig.groovy: ajoutez ci-dessous les dépendances:

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

Et dans votre DataSource ou autre configuration liée: [partout où vous avez défini la configuration lié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. Vous trouverez également plus d'informations sur ce site. https://code.google.com/p/log4jdbc-remix/

Salutations du roi

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 vous avez installé le plugin de console , vous pouvez obtenir une journalisation SQL avec ce petit extrait de code.

// grails 2.3
def logger=ctx.sessionFactory.settings.sqlStatementLogger

// grails 3.3  
def logger = ctx.sessionFactory.currentSession.jdbcCoordinator.statementPreparer.jdbcService.sqlStatementLogger

logger.logToStdout=true    
try {
   <code that will log sql queries>
}
finally {
    logger.logToStdout = false
}

Il s'agit d'une variante de 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 le traitent, logToStdoutaffiche uniquement les requêtes et non les valeurs de liaison.

L'idée a été volée à un burtbeck avec un post que j'ai lu il y a quelques années que je ne trouve pas pour le moment. Il a été édité pour fonctionner avec Grails 3.3.

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.