Cómo registrar sentencias SQL en Grails

Me parece más útil hacer lo siguiente, que es habilitar el registro de Hibernate para registrar el SQL junto con las variables bind (para que pueda ver los valores pasados a sus llamadas y replicar fácilmente el SQL en su editor o de otra manera).

En su Config.groovy, agregue lo siguiente a su bloque log4j:

log4j = {

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

Para los griales 3.*

Opción #1 agregue lo siguiente a logback.groovy

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

O

Opción #2 agregue lo siguiente a DataSource en la aplicación.yml. Sin embargo, este enfoque no registra los valores de los parámetros

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

Prueba esto:

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

Evita los problemas de rendimiento del registro de trazas del paquete Hibernate type. Esto funciona con Hibernate 3.6 y superior. Tengo esto de: https://burtbeckwith.com/blog/?p=1604

La solución es solo para el desarrollo, no para la producción.

Todas las respuestas anteriores funcionan y son correctas. Pero no muestran la consulta completa de una manera agradable legible por humanos. Si quieres ver la final (sin ninguna?, ?) consulta tienes dos opciones.

A) proxy de su conexión jdbc con log4jdbc o p6Spy.

B) míralo a nivel de base de datos. Por ejemplo, muy fácil de hacer con mysql.

Averigüe dónde está general_log_file. Registro general activo si no está activado ya.

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

Ahora todo está registrado en su archivo de registro. Ejemplo de Mac / linux para mostrar un buen flujo de sus consultas.

tail -f path_to_log_file 

Pure solo para referencia, pero uso p6spy para registrar las consultas SQL. Es un pequeño controlador intermedio jdbc. La consulta exacta se registra como se enviaría al servidor (con los parámetros incluidos).

Inclúyelo en tu proyecto:

runtime 'p6spy:p6spy:3.0.0'

Cambie el controlador de la fuente de datos:

driverClassName: com.p6spy.engine.spy.P6SpyDriver

Y su url jdbc:

url: jdbc:p6spy:mysql://

Configúrelo usando spy.propiedades (en 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

No se olvide de desactivar esto para la producción!

Sé que esto fue preguntado y contestado hace mucho tiempo .Pero simplemente vi esta pregunta y no pude detenerme en responder o compartir nuestro enfoque de implementación de sql Logging en nuestro proyecto. Espero que sea de alguna ayuda.

Actualmente se encuentra en entorno de desarrollo. Estamos usando "log4jdbc Driver Spy" para registrar sql.

Configuración:

En tu BuildConfig.groovy: añadir dependencias debajo:

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

Y en su fuente de datos u otra configuración relacionada: [donde quiera que ha definido la configuración relacionada con la fuente de datos] , Añadir:

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'

}

Desde mi experiencia personal me pareció muy útil y útil durante la depuración. También puede encontrar más información en este sitio. https://code.google.com/p/log4jdbc-remix /

Saludos del Rey

Para un Bloque de código en particular también podemos crear un método que acepte un cierre. eg.

 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 tiene instalado el complemento console, puede obtener el registro sql con este pequeño fragmento de código.

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

Esta es una variación de muchas de las soluciones anteriores, pero le permite ajustar el valor en tiempo de ejecución. Y al igual que las otras soluciones que tratan con logToStdout solo muestra las consultas y no los valores de enlace.

La idea fue robada de un post de burtbeckwith que leí hace algunos años que no puedo encontrar en este momento.

Una técnica similar se puede utilizar para girar en el registro para pruebas de integración específicas:

class SomeIntegrationSpec extends IntegrationSpec {

    def sessionFactory

    def setup() {
        sessionFactory.settings.sqlStatementLogger.logToStdout = true
    }

    def cleanup() {
        sessionFactory.settings.sqlStatementLogger.logToStdout = false
    }

    void "some test"() {
           ...
    }

Esto activará el registro sql solo para las pruebas en este archivo.