How can I log SQL statements in Spring Boot?

Question

I want to log SQL statements in a file.

I have the following properties in application.properties:

spring.datasource.url=...
spring.datasource.username=user
spring.datasource.password=1234
spring.datasource.driver-class-name=net.sourceforge.jtds.jdbc.Driver

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

security.ignored=true
security.basic.enabled=false

logging.level.org.springframework.web=INFO
logging.level.org.hibernate=INFO
logging.file=c:/temp/my-log/app.log

When I run my application,

cmd> mvn spring-boot:run

I can see SQL statements in the console, but they don't appear in a file, app.log. The file contains only basic logs from Spring.

What should I do to see SQL statements in the log file?

Follow instructions on https://www.baeldung.com/sql-logging-spring-boot — Lu55, Feb 04 '21 at 19:31

score 601 · Accepted Answer · edited May 31 '22 at 14:21

601

Try using this in your properties file:

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

edited May 31 '22 at 14:21

Peter Mortensen

30,030
21
100
124

answered Jul 06 '15 at 15:39

Paul Woods

6,309
1
14
9

108

If you want to log values too: `logging.level.org.hibernate.type=TRACE` – elysch Jun 11 '16 at 00:48
3

But this logs only few bind values. How can I log values from the criteria-API? If I use Specifications, I get no output for bound parameters created with the CriteriaBuilder. – Josh Aug 10 '16 at 05:48
What about people that use `EclipseLink` instead of `Hibernate` ? – payne Oct 26 '21 at 21:12

score 281 · Answer 2 · edited May 31 '22 at 14:37

281

This works for standard output too:

spring.jpa.properties.hibernate.show_sql=true
spring.jpa.properties.hibernate.use_sql_comments=true
spring.jpa.properties.hibernate.format_sql=true

To log values:

logging.level.org.hibernate.type=trace

Just add this to application.properties.

edited May 31 '22 at 14:37

Peter Mortensen

30,030
21
100
124

answered May 26 '16 at 15:20

v.ladynev

18,125
7
41
62

15

If you want to log values too: `spring.jpa.properties.hibernate.type=trace` – elysch Jun 11 '16 at 00:48
1

This doesn't write to log file, this writes to STDOUT – Muhammad Hewedy Jun 29 '16 at 08:34
4

I still see only `?` instead of the parameters. Was that solution supposed to show them to me? – Adeynack Feb 02 '18 at 08:54
@Adeynack Sorry I can't help you. I just added it according _elysch's_ words. – v.ladynev Feb 02 '18 at 09:59
@v.ladynev: But does it shows the parameters' value to you or does it shows question marks? – Adeynack Feb 05 '18 at 21:41
1

spring.jpa.properties.hibernate.type=trace doesn't affect my log file ;( – gstackoverflow Sep 04 '18 at 16:54
1

The "type=trace" is not a spring property, so it does not work. The solution given out below https://stackoverflow.com/a/41594913/5107365 is the right one for that. – Raj Feb 06 '20 at 01:00
@Raj Thank you very much. I have updated the answer. – v.ladynev Feb 06 '20 at 16:00
What about people that use `EclipseLink` instead of `Hibernate` ? – payne Oct 26 '21 at 21:12

score 135 · Answer 3 · edited May 31 '22 at 14:25

135

This works for me (YAML):

spring:
  jpa:
    properties:
      hibernate:
        show_sql: true
        format_sql: true
logging:
  level:
    org:
      hibernate:
        type: trace

edited May 31 '22 at 14:25

Peter Mortensen

30,030
21
100
124

answered Jan 11 '17 at 15:37

Michel

8,850
13
42
58

1

I always thought that `show_sql: true` belongs to `jpa` – ka3ak Jan 13 '22 at 09:12

Vlad Mihalcea · Answer 4 · 2021-01-09T23:04:14.023

Settings to avoid

You should not use this setting:

spring.jpa.show-sql=true

The problem with show-sql is that the SQL statements are printed in the console, so there is no way to filter them, as you'd normally do with a Logging framework.

Using Hibernate logging

In your log configuration file, if you add the following logger:

<logger name="org.hibernate.SQL" level="debug"/>

Then, Hibernate will print the SQL statements when the JDBC PreparedStatement is created. That's why the statement will be logged using parameter placeholders:

INSERT INTO post (title, version, id) VALUES (?, ?, ?)

If you want to log the bind parameter values, just add the following logger as well:

<logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="trace"/>

Once you set the BasicBinder logger, you will see that the bind parameter values are logged as well:

DEBUG [main]: o.h.SQL - insert into post (title, version, id) values (?, ?, ?)
TRACE [main]: o.h.t.d.s.BasicBinder - binding parameter [1] as [VARCHAR] - [High-Performance Java Persistence, part 1]
TRACE [main]: o.h.t.d.s.BasicBinder - binding parameter [2] as [INTEGER] - [0]
TRACE [main]: o.h.t.d.s.BasicBinder - binding parameter [3] as [BIGINT] - [1]

Using datasource-proxy

The datasource-proxy OSS framework allows you to proxy the actual JDBC DataSource, as illustrated by the following diagram:

You can define the dataSource bean that will be used by Hibernate as follows:

@Bean
public DataSource dataSource(DataSource actualDataSource) {
    SLF4JQueryLoggingListener loggingListener = new SLF4JQueryLoggingListener();
    loggingListener.setQueryLogEntryCreator(new InlineQueryLogEntryCreator());
    return ProxyDataSourceBuilder
        .create(actualDataSource)
        .name(DATA_SOURCE_PROXY_NAME)
        .listener(loggingListener)
        .build();
}

Notice that the actualDataSource must be the DataSource defined by the [connection pool][2] you are using in your application.

Next, you need to set the net.ttddyy.dsproxy.listener log level to debug in your logging framework configuration file. For instance, if you're using Logback, you can add the following logger:

<logger name="net.ttddyy.dsproxy.listener" level="debug"/>

Once you enable datasource-proxy, the SQl statement are going to be logged as follows:

Name:DATA_SOURCE_PROXY, Time:6, Success:True,
Type:Prepared, Batch:True, QuerySize:1, BatchSize:3,
Query:["insert into post (title, version, id) values (?, ?, ?)"],
Params:[(Post no. 0, 0, 0), (Post no. 1, 0, 1), (Post no. 2, 0, 2)]

What exactly does to enable the `datasource-proxy` means here? Is it another configuration? Is there something extra that needs configuration apart from creating the bean with the proper datasource? Do we also need to configure something in the log4j.properties at this point? — Christos Karapapas, Oct 02 '20 at 18:23

score 28 · Answer 5 · edited May 31 '22 at 14:28

28

Please use:

logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type=TRACE
spring.jpa.show-sql=true

edited May 31 '22 at 14:28

Peter Mortensen

30,030
21
100
124

answered Dec 21 '17 at 08:50

rahulnikhare

1,218
15
24

5

`logging.level.org.hibernate.SQL=DEBUG` made it work for me and was missing for other answers. Thanks! – Vic Mar 27 '19 at 16:58

score 24 · Answer 6 · edited May 31 '22 at 14:27

24

If you have a logback-spring.xml file or something like that, add the following code to it:

<logger name="org.hibernate.SQL" level="trace" additivity="false">
    <appender-ref ref="file" />
</logger>

That works for me.

To get bind variables as well:

<logger name="org.hibernate.type.descriptor.sql" level="trace">
    <appender-ref ref="file" />
</logger>

edited May 31 '22 at 14:27

Peter Mortensen

30,030
21
100
124

answered Jul 17 '17 at 06:41

Edye Chan

384
3
7

1

With Spring Boot you have to use `` – Ortomala Lokni May 03 '18 at 15:28
appender ref is the name of the appender that you have defined in the logback xml. It is only a variable – Raja Anbazhagan Jul 19 '18 at 12:25

score 14 · Answer 7 · edited May 31 '22 at 14:24

For the SQL Server driver (Microsoft SQL Server JDBC Driver), try using:

logging.level.com.microsoft.sqlserver.jdbc=debug

in your application.properties file.

My personal preference is to set:

logging.level.com.microsoft.sqlserver.jdbc=info
logging.level.com.microsoft.sqlserver.jdbc.internals=debug

You can look at these links for reference:

score 13 · Answer 8 · answered Mar 12 '19 at 21:39

13

Translated accepted answer to YAML works for me

logging:
  level:
    org:
      hibernate:
        SQL:
          TRACE
        type:
          descriptor:
            sql:
              BasicBinder:
                TRACE

answered Mar 12 '19 at 21:39

Robert.Li

169
1
7

6

You can also use flat properties in YAML if you don't want to nest for single use props, like: `logging.level.org.hibernate.SQL: TRACE` `logging.level.org.hibernate.type.descriptor.sql.BasicBinder: TRACE` – MarcinJ Jan 23 '20 at 15:53

score 11 · Answer 9 · edited May 31 '22 at 14:27

11

According to documentation it is:

spring.jpa.show-sql=true # Enable logging of SQL statements.

edited May 31 '22 at 14:27

Peter Mortensen

30,030
21
100
124

answered Nov 21 '17 at 20:54

Max Farsikov

2,066
16
20

I have reverse problem, setting this to false, and org.hibernate to level ERROR and its still printing drop/create/insert/select – Kalpesh Soni Nov 01 '18 at 22:14

score 10 · Answer 10 · edited Jun 20 '20 at 09:12

Log in to standard output

Add to application.properties

### to enable
spring.jpa.show-sql=true
### to make the printing SQL beautify
spring.jpa.properties.hibernate.format_sql=true

This the simplest way to print the SQL queries though it doesn't log the parameters of prepared statements. And its is not recommended since its not such as optimized logging framework.

Using Logging Framework

Add to application.properties

### logs the SQL queries
logging.level.org.hibernate.SQL=DEBUG
### logs the prepared statement parameters
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
### to make the printing SQL beautify
spring.jpa.properties.hibernate.format_sql=true

By specifying above properties, logs entries will be sent to the configured log appender such as log-back or log4j.

score 6 · Answer 11 · edited May 31 '22 at 14:30

If you want to view the actual parameters used to query you can use

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

Then notice that actual parameter value is shown as binding parameter...:

    2018-08-07 14:14:36.079 DEBUG 44804 --- [           main] org.hibernate.SQL                        : select employee0_.id as id1_0_, employee0_.department as departme2_0_, employee0_.joining_date as joining_3_0_, employee0_.name as name4_0_ from employee employee0_ where employee0_.joining_date=?
     2018-08-07 14:14:36.079 TRACE 44804 --- [           main] o.h.type.descriptor.sql.BasicBinder      : binding parameter [1] as [TIMESTAMP] - [Tue Aug 07 00:00:00 SGT 2018]

score 6 · Answer 12 · edited May 31 '22 at 14:47

We can use any one of these in the application.properties file:

spring.jpa.show-sql=true

Example:

//Hibernate: select country0_.id as id1_0_, country0_.name as name2_0_ from country country0_

or

logging.level.org.hibernate.SQL=debug

Example:

2018-11-23 12:28:02.990 DEBUG 12972 --- [nio-8086-exec-2] org.hibernate.SQL   : select country0_.id as id1_0_, country0_.name as name2_0_ from country country0_

score 4 · Answer 13 · answered Aug 03 '20 at 12:57

4

use this code in the file application.properties:

#Enable logging for config troubeshooting
logging.level.org.hibernate.SQL=DEBUG
logging.level.com.zaxxer.hikari.HikariConfig=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

answered Aug 03 '20 at 12:57

BRAIEK AYEMN

89
1
5

score 4 · Answer 14 · edited Dec 09 '21 at 06:16

4

You can simply add the below lines in application.properties for stdout SQL queries:

spring.jpa.properties.hibernate.show_sql=true

edited Dec 09 '21 at 06:16

cigien

55,661
11
60
99

answered Dec 09 '21 at 05:29

Mohit Kaushal

51
2

score 2 · Answer 15 · answered Sep 09 '19 at 02:39

If you're having trouble with this setting and it seems to work sometimes and not other times - consider if the times where it doesn't work are during unit tests.

Many people declare custom test-time properties via the @TestPropertySources annotation declared somewhere in your test inheritance hierarchy. This will override whatever you put in your application.properties or other production properties settings so those values you're setting are effectively being ignored at test-time.

score 2 · Answer 16 · answered Sep 16 '19 at 14:00

Putting spring.jpa.properties.hibernate.show_sql=true in application.properties didn't help always.

You can try to add properties.put("hibernate.show_sql", "true"); to the properties of the database configuration.

public class DbConfig {

    @Primary
    @Bean(name = "entityManagerFactory")
    public LocalContainerEntityManagerFactoryBean
    entityManagerFactory(
            EntityManagerFactoryBuilder builder,
            @Qualifier("dataSource") DataSource dataSource
    ) {
        Map<String, Object> properties = new HashMap();
        properties.put("hibernate.hbm2ddl.auto", "validate");
        properties.put("hibernate.show_sql", "true");

        return builder
                .dataSource(dataSource)
                .packages("com.test.dbsource.domain")
                .persistenceUnit("dbsource").properties(properties)
                .build();
    }

Java Developer · Answer 17 · 2020-07-21T08:13:27.710

2

You just need to set spring.jpa.show-sql=true in application.properties for example you may reffer this https://github.com/007anwar/ConfigServerRepo/blob/master/application.yaml

edited Jul 21 '20 at 08:13

answered Jun 15 '20 at 12:17

Java Developer

179
1
6

score 1 · Answer 18 · edited Oct 08 '21 at 07:52

The basic way is to add the following lines in your application.properties. This will enable spring boot to log all your SQL queries that get executed:

spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

The 2nd line is used to beautify the SQL Statements.

If you want to use loggers, you can use the following lines:

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

The 2nd line is used to print all the parameters that get bound with your queries. Hope this works for you. Please let me know if you have any further queries!

score 0 · Answer 19 · answered Aug 31 '21 at 05:40

0

In my yaml:

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

Spring boot version: 2.3.5.RELEASE

answered Aug 31 '21 at 05:40

shenyu1997

504
6
3

score 0 · Answer 20 · edited Nov 19 '21 at 01:08

0

Add these in the properties. Quoting Hibernate Show SQL:

#show sql statement
logging.level.org.hibernate.SQL=debug

#show sql values
logging.level.org.hibernate.type.descriptor.sql=trace

edited Nov 19 '21 at 01:08

Laurel

5,771
12
29
54

answered Nov 18 '21 at 18:13

AnkitSingh2099

1
2

score 0 · Answer 21 · answered Jan 28 '22 at 18:15

0

If you are using JdbcTemplate, add the below in application.properties file to log sql and parameter values.

logging.level.org.springframework.jdbc.core.JdbcTemplate=DEBUG
logging.level.org.springframework.jdbc.core.StatementCreatorUtils=TRACE

answered Jan 28 '22 at 18:15

Shafiul

1,264
11
21

How can I log SQL statements in Spring Boot?

21 Answers21

Settings to avoid

Using Hibernate logging

Using datasource-proxy

Log in to standard output

Using Logging Framework

Linked

Related