Jooq and JDBCTemplate implementation of scenario eleven - call static statement (not prepared statement).

Author: bwajtr

dbscenarios.txt

@@ -8,4 +8,4 @@
 8. Update entities one-to-many relation - add two items, update two items and delete one item
 9. Complex select - construct select where conditions based on some boolean conditions + throw in some joins
 10. Call stored procedure/function and process results
-11. Optimistic locking
+11. Execute query using JDBC simple Statement (not PreparedStatement)

src/main/java/com/clevergang/dbtests/DbTestsApplication.java

@@ -2,16 +2,20 @@
 
 import org.jooq.conf.RenderNameStyle;
 import org.jooq.conf.Settings;
+import org.jooq.conf.StatementType;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
 
 @SpringBootApplication
 @Configuration
 public class DbTestsApplication {
 
     @Bean
+    @Primary
     public Settings jooqSettings() {
         Settings ret = new Settings();
         ret.withRenderSchema(false);
@@ -20,7 +24,15 @@ public Settings jooqSettings() {
         return ret;
     }
 
-	public static void main(String[] args) {
-		SpringApplication.run(DbTestsApplication.class, args);
-	}
+    @Bean
+    @Qualifier("static-statement-jooq-settings")
+    public Settings jooqStaticStatementSettings() {
+        Settings ret = jooqSettings();
+        ret.withStatementType(StatementType.STATIC_STATEMENT);
+        return ret;
+    }
+
+    public static void main(String[] args) {
+        SpringApplication.run(DbTestsApplication.class, args);
+    }
 }

src/main/java/com/clevergang/dbtests/Scenarios.java

@@ -218,14 +218,31 @@ public void scenarioNine() {
 
     /**
      * Execute stored procedure/function and process results
-     *
      */
     public void scenarioTen() {
         RegisterEmployeeOutput output = repository.callRegisterEmployee("Bretislav", "Wajtr", "bretislav.wajtr@test.com", new BigDecimal(40000), "MyDepartment", "MyCompany");
 
         logger.info("scenarioTen output: {}", output);
     }
 
+
+    /**
+     * Execute query using JDBC simple Statement (not PreparedStatement)
+     *
+     * Motivation why we need the "static statement" feature: In 96% of the cases, you’re better off writing
+     * a PreparedStatement rather than a static statement - it's safer (sql injection),
+     * easier (complex data types like dates) and sometimes faster (prepared statements reuse). However, there are
+     * edge cases for complex queries and lot of data where it's actually faster to use simple statement query, because
+     * your database’s cost-based optimiser or planner obtains some heads-up about what kind of data is really going to
+     * be affected by the query and can therefore execute the query faster.
+     *
+     * Good SQL API framework should offer way how to execute simple static statements.
+     */
+    public void scenarioEleven() {
+        Company output = repository.findCompanyUsingSimpleStaticStatement(1);
+
+        logger.info("Output: {}", output);
+    }
 }
 
 

src/main/java/com/clevergang/dbtests/repository/api/DataRepository.java

@@ -18,6 +18,8 @@ public interface DataRepository {
 
     Company findCompany(Integer pid);
 
+    Company findCompanyUsingSimpleStaticStatement(Integer pid);
+
     // departments
 
     Department findDepartment(Integer pid);

src/main/java/com/clevergang/dbtests/repository/impl/jdbctemplate/JDBCDataRepositoryImpl.java

@@ -58,6 +58,33 @@ public Company findCompany(Integer pid) {
         return company;
     }
 
+    @Override
+    public Company findCompanyUsingSimpleStaticStatement(Integer pid) {
+        String query;
+        query = "SELECT pid, address, name " +
+                "FROM company " +
+                "WHERE pid = " + pid;
+
+        RowMapper<Company> mapper = (rs, rowNum) -> {
+            Company row = new Company();
+            row.setPid(rs.getInt("pid"));
+            row.setAddress(rs.getString("address"));
+            row.setName(rs.getString("name"));
+            return row;
+        };
+
+        // In Spring's JDBCTemplate it's pretty easy to execute the query using static Statement (not the PreparedStatement):
+        // In this DAO we autowired NamedParameterJdbcTemplate, which does not allow static statements, but this class
+        // is just a wrapper around original JdbcTemplate which allows static statements -> so we used getJdbcOperations()
+        // to get such original object and then just used one of it's methods which internally calls the static
+        // statement (see javadoc for each JdbcOperations#query*() method)
+        Company company = jdbcTemplate.getJdbcOperations().queryForObject(query, mapper);
+
+        logger.info("Found company: " + company);
+
+        return company;
+    }
+
     @Override
     public Department findDepartment(Integer pid) {
         String query;

src/main/java/com/clevergang/dbtests/repository/impl/jooq/JooqDataRepositoryImpl.java

@@ -7,9 +7,12 @@
 import com.clevergang.dbtests.repository.impl.jooq.generated.tables.records.DepartmentRecord;
 import com.clevergang.dbtests.repository.impl.jooq.generated.tables.records.EmployeeRecord;
 import org.jooq.*;
+import org.jooq.conf.Settings;
+import org.jooq.impl.DSL;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Repository;
 
 import java.io.IOException;
@@ -21,6 +24,7 @@
 import java.sql.Date;
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 import static com.clevergang.dbtests.repository.impl.jooq.generated.Tables.*;
@@ -39,6 +43,10 @@ public class JooqDataRepositoryImpl implements DataRepository {
     @Autowired
     private DSLContext create;
 
+    @Autowired
+    @Qualifier("static-statement-jooq-settings")
+    private Settings staticStatementSettings;
+
     @Override
     public Company findCompany(Integer pid) {
         logger.info("Finding Company by ID using JOOQ");
@@ -49,10 +57,34 @@ public Company findCompany(Integer pid) {
                 .fetchOneInto(Company.class);
 
         logger.info("Found company: " + company);
-
         return company;
     }
 
+    @Override
+    public Company findCompanyUsingSimpleStaticStatement(Integer pid) {
+        // This is the only way I found how to actually do a static Statement in JOOQ (so not the default
+        // prepared statement, but simple static statement where you do not bind values). We create new instance of DSLContext
+        // using Settings which are configured to use static statements. The important factor here is
+        // to create new context based on the Connection of autowired DSLContext (therefore the usage of create.connection()
+        // method) - this is the only way to ensure that the this static statement will be executed in same transaction
+        // as other statements called through autowired DSLContext.
+        //
+        // If you create new DSLContext using the some generally available (autowired) datasource, then you'll create
+        // completely new JOOQ configuration with completely new connection -> such statements will be executed in
+        // their own transactions!
+        //
+        // FIXME: I don't like the usage of AtomicReference here to get the value out of the lambda. If anyone has better class where to store the value, please advise.
+        AtomicReference<Company> reference = new AtomicReference<>();
+        create.connection(connection -> {
+            DSLContext staticStatement = DSL.using(connection, create.dialect(), staticStatementSettings);
+            reference.set(staticStatement.
+                    selectFrom(COMPANY)
+                    .where(COMPANY.PID.eq(pid))
+                    .fetchOneInto(Company.class));
+        });
+        return reference.get();
+    }
+
     @Override
     public Department findDepartment(Integer pid) {
         return create.

src/test/java/com/clevergang/dbtests/JdbcTemplateScenariosTest.java

@@ -78,5 +78,9 @@ public void scenarioTen() {
         scenarios.scenarioTen();
     }
 
+    @Test
+    public void scenarioEleven() {
+        scenarios.scenarioEleven();
+    }
 
 }

src/test/java/com/clevergang/dbtests/JooqScenariosTest.java

@@ -78,6 +78,11 @@ public void scenarioTen() {
         scenarios.scenarioTen();
     }
 
+    @Test
+    public void scenarioEleven() {
+        scenarios.scenarioEleven();
+    }
+
 }