The Curious Engineer

All blogs / Databases

Java, SQL and jOOQ.

blog.jooq.org

Best Practices and Lessons Learned from Writing Awesome Java and SQL Code. Get some hands-on insight on what's behind developing jOOQ.

DatabasesJava / JVMEngineering blogs

’15’20’25
Posts
786 from 20 Jul 2011 to 7 May 2026
Posting
now and then (3 in the last year)
Kind
company blog
Feed
https://blog.jooq.org/feed/

2026 3

  1. Simplifying ANTI JOIN with jOOQ Syntax
  2. Why JOIN USING Can Lead to Errors in SQL
  3. Managing Sensitive Data in jOOQ 3.21+ Logs

2025 5

  1. Consider using JSON arrays instead of JSON objects for serialisation
  2. When SQL Meets Lambda Expressions
  3. Think About SQL MERGE in Terms of a RIGHT JOIN
  4. Resisting the Urge to Document Everything Everywhere
  5. jOOQ 3.20 released with ClickHouse, Databricks, and much more DuckDB support, new modules, Oracle type hierarchies, more spatial support, decfloat and synonym support, hidden columns, Scala 3, Kotlin 2, and much more

2024 4

  1. Emulating SQL FILTER with Oracle JSON Aggregate Functions
  2. Getting Top 1 Values Per Group in Oracle
  3. An Efficient Way to Check for Existence of Multiple Values in SQL
  4. A Hidden Benefit of Implicit Joins: Join Elimination

2023 16

  1. jOOQ 3.19’s new Explicit and Implicit to-many path joins
  2. Workaround for MySQL’s “can’t specify target table for update in FROM clause” Error
  3. jOOQ 3.19.0 Released with DuckDB, Trino, Oracle 23c support, join path improvements, an official gradle plugin, commercial maven repositories, policies, UDT paths, trigger meta data, hierarchies, and much more
  4. Maven Coordinates of the most popular JDBC Drivers
  5. To DAO or not to DAO
  6. JDBC Connection URLs of the Most Popular RDBMS
  7. How to Generate Package Private Code with jOOQ’s Code Generator
  8. How to Pass a Table Valued Parameter to a T-SQL Function with jOOQ
  9. How to Turn a List of Flat Elements into a Hierarchy in Java, SQL, or jOOQ
  10. 3.18.0 Release with Support for more Diagnostics, SQL/JSON, Oracle Associative Arrays, Multi dimensional Arrays, R2DBC 1.0
  11. How to use jOOQ’s Converters with UNION Operations
  12. How to Write a Derived Table in jOOQ
  13. The Performance Impact of SQL’s FILTER Clause
  14. Emulating Window Functions in MySQL 5.7
  15. Why You Should Execute jOOQ Queries With jOOQ
  16. jOOQ’s R2DBC LoggingConnection to log all SQL statements

2022 37

  1. When to Use jOOQ and When to Use Native SQL
  2. LATERAL is Your Friend to Create Local Column Variables in SQL
  3. Calling Procedures with Default Parameters using JDBC or jOOQ
  4. Using jOOQ’s Implicit Join From Within the JOIN .. ON Clause
  5. A Brief Overview over the Most Common jOOQ Types
  6. How to Plot an ASCII Bar Chart with SQL
  7. The Second Best Way to Fetch a Spring Data JPA DTO Projection
  8. Cannot resolve symbol ‘VERSION_3_17’ in jOOQ generated code
  9. jOOQ 3.17 Supports Implicit Join also in DML
  10. A Condition is a Field
  11. The Many Ways to Return Data From SQL DML
  12. How to Integration Test Stored Procedures with jOOQ
  13. Using H2 as a Test Database Product with jOOQ
  14. The Best Way to Call Stored Procedures from Java: With jOOQ
  15. Create Dynamic Views with jOOQ 3.17’s new Virtual Client Side Computed Columns
  16. 3.17.0 Release with Computed Columns, Audit Columns, Pattern Matching, Reactive Transactions and Kotlin Coroutine Support
  17. How to Filter a SQL Nested Collection by a Value
  18. The Performance of Various To-Many Nesting Algorithms
  19. Changing SELECT .. FROM Into FROM .. SELECT Does Not “Fix” SQL
  20. The Many Different Ways to Fetch Data in jOOQ
  21. Setting the JDBC Statement.setFetchSize() to 1 for Single Row Queries
  22. How to Typesafely Map a Nested SQL Collection into a Nested Java Map with jOOQ
  23. A Quick and Dirty Way to Concatenate Two Vaguely Related Tables in SQL
  24. Nested Transactions in jOOQ
  25. How to Fetch Sequence Values with jOOQ
  26. Various Meanings of SQL’s PARTITION BY Syntax
  27. Use MULTISET Predicates to Compare Data Sets
  28. Projecting Type Safe Nested TableRecords with jOOQ 3.17
  29. jOOQ 3.16 and Java EE vs Jakarta EE
  30. No More MultipleBagFetchException Thanks to Multiset Nested Collections
  31. Approximating e With SQL
  32. Traversing jOOQ Expression Trees with the new Traverser API
  33. Detect Accidental Blocking Calls when Using R2DBC
  34. A Rarely Seen, but Useful SQL Feature: CORRESPONDING
  35. Using jOOQ’s DiagnosticsConnection to detect N+1 Queries
  36. The Useful BigQuery * EXCEPT Syntax
  37. 3.16.0 Release with a new Public Query Object Model API, Spatial Support, YugabyteDB Support and Much More

2021 32

  1. How to customise a jOOQ Configuration that is injected using Spring Boot
  2. Using JDK Collectors to De-duplicate parent/child nested collections
  3. Why You Should Use jOOQ With Code Generation
  4. Fun with PostGIS: Mandelbrot Set, Game of Life, and More
  5. PostgreSQL 14’s enable_memoize For Improved Performance of Nested Loop Joins
  6. Java’s Checked Exceptions Are Just Weird Union Types
  7. Functional Dependencies in SQL GROUP BY
  8. Write C-Style Local Static Variables in Java 16
  9. The jOOQ Parser Ignore Comment Syntax
  10. Use jOOλ’s Sneaky Throw to Avoid Checked Exceptions
  11. Using Testcontainers to Generate jOOQ Code
  12. Using jOOQ to write vendor agnostic SQL with JPA’s native query or @Formula
  13. Vendor Agnostic, Dynamic Procedural Logic with jOOQ
  14. MySQL’s allowMultiQueries flag with JDBC and jOOQ
  15. 10 Things You Didn’t Know About jOOQ
  16. Formatting ASCII Charts With jOOQ
  17. Standard SQL/JSON – The Sobering Parts
  18. Ad-hoc Data Type Conversion with jOOQ 3.15
  19. Reactive SQL with jOOQ 3.15 and R2DBC
  20. 3.15.0 Release with Support for R2DBC, Nested ROW, ARRAY, and MULTISET types, 5 new SQL dialects, CREATE PROCEDURE, FUNCTION, and TRIGGER support and Much More
  21. jOOQ 3.15’s New Multiset Operator Will Change How You Think About SQL
  22. Quickly Trying out jOOQ with Jbang!
  23. How to Prevent Execution Plan Troubles when Querying Skewed Data, with jOOQ
  24. Use ResultQuery.collect() to Implement Powerful Mappings
  25. How to Get an RDBMS Server Version with SQL
  26. Use IN List Padding to Your JDBC Application to Avoid Cursor Cache Contention Problems
  27. Never Again Forget to Call .execute() in jOOQ
  28. Calculating Pagination Metadata Without Extra Roundtrips in SQL
  29. Simulating Latency with SQL / JDBC
  30. Translating Stored Procedures Between Dialects
  31. Implementing a generic REDUCE aggregate function with SQL
  32. jOOQ Internals: Pushing up SQL fragments

2020 17

  1. Automatically Transform Oracle Style Implicit Joins to ANSI JOIN using jOOQ
  2. jOOQ 3.14 Released With SQL/XML and SQL/JSON Support
  3. Using jOOQ 3.14 Synthetic Foreign Keys to Write Implicit Joins on Views
  4. Nesting Collections With jOOQ 3.14’s SQL/XML or SQL/JSON support
  5. Having “constant” columns in foreign keys
  6. Use NATURAL FULL JOIN to compare two tables in SQL
  7. Could we Have a Language That Hides Collections From Us?
  8. Using SQL Server FOR XML and FOR JSON Syntax on Other RDBMS With jOOQ
  9. The Many Flavours of the Arcane SQL MERGE Statement
  10. What’s a “String” in the jOOQ API?
  11. Create Empty Optional SQL Clauses with jOOQ
  12. Using Java 13+ Text Blocks for Plain SQL with jOOQ
  13. Never Concatenate Strings With jOOQ
  14. 5 Ways to Better Understand SQL by Adding Optional Parentheses
  15. SQL DISTINCT is not a function
  16. Use the jOOQ-Refaster Module for Automatic Migration off of Deprecated jOOQ API
  17. jOOQ 3.13 Released with More API and Tooling for DDL Management

2019 24

  1. Stop Mapping Stuff in Your Middleware. Use SQL’s XML or JSON Operators Instead
  2. A Guide to SQL Naming Conventions
  3. Dogfooding in Product Development
  4. A Quick Trick to Make a Java Stream Construction Lazy
  5. How to Map MySQL’s TINYINT(1) to Boolean in jOOQ
  6. What’s Faster? COUNT(*) or COUNT(1)?
  7. Oracle’s BINARY_DOUBLE Can Be Much Faster Than NUMBER
  8. Using DISTINCT ON in Non-PostgreSQL Databases
  9. Quantified LIKE ANY predicates in jOOQ 3.12
  10. jOOQ 3.12 Released With a new Procedural Language API
  11. How to Fetch All Current Identity Values in Oracle
  12. How to Use jOOQ’s Commercial Distributions with Spring Boot
  13. How to Write a Simple, yet Extensible API
  14. Using IGNORE NULLS With SQL Window Functions to Fill Gaps
  15. Calling an Oracle Function with PL/SQL BOOLEAN Type from SQL
  16. The Difference Between SQL’s JOIN .. ON Clause and the Where Clause
  17. The Cost of Useless Surrogate Keys in Relationship Tables
  18. Calculating Weighted Averages When Joining Tables in SQL
  19. How to Statically Override the Default Settings in jOOQ
  20. How to Calculate a Cumulative Percentage in SQL
  21. Lesser Known jOOλ Features: Useful Collectors
  22. How to Emulate PERCENTILE_DISC in MySQL and Other RDBMS
  23. Calculate Percentiles to Learn About Data Set Skew in SQL
  24. How to Work Around ORA-38104: Columns referenced in the ON Clause cannot be updated

2018 37

  1. How to Unit Test Your Annotation Processor using jOOR
  2. How to Create a Good MCVE (Minimal Complete Verifiable Example)
  3. How to Aggregate an Archive Log’s Deltas into a Snapshot with SQL
  4. How to Use jOOQ’s UpdatableRecord for CRUD to Apply a Delta
  5. Imperative Loop or Functional Stream Pipeline? Beware of the Performance Impact!
  6. Writing Custom Aggregate Functions in SQL Just Like a Java 8 Stream Collector
  7. How to Use SQL UPDATE .. RETURNING to Run DML More Efficiently
  8. How to Write a Multiplication Aggregate Function in SQL
  9. How to Reduce Syntactic Overhead Using the SQL WINDOW Clause
  10. Beware of Hidden PL/SQL to SQL Context Switches
  11. Find the Next Non-NULL Row in a Series With SQL
  12. A Frequent Question: Does jOOQ Have a First Level Cache?
  13. How to Write Multiset Conditions With Oracle VARRAY Types
  14. How SQL DISTINCT and ORDER BY are Related
  15. PostgreSQL 11’s Support for SQL Standard GROUPS and EXCLUDE Window Function Clauses
  16. Using UNPIVOT to Traverse a Configuration Table’s Rows and Columns
  17. Oracle’s OFFSET .. FETCH Can be Slower than Classic ROWNUM Filtering
  18. How to Patch Your IDE to Fix an Urgent Bug
  19. jOOQ 3.11 Released With 4 New Databases, Implicit Joins, Diagnostics, and Much More
  20. Truth First, or Why You Should Mostly Implement Database First Designs
  21. How to Group By “Nothing” in SQL
  22. Selecting all Columns Except One in PostgreSQL
  23. How to Run a Bulk INSERT .. RETURNING Statement With Oracle and JDBC
  24. The Performance Difference Between SQL Row-by-row Updating, Batch Updating, and Bulk Updating
  25. When Using Bind Variables is not Enough: Dynamic IN Lists
  26. Why SQL Bind Variables are Important for Performance
  27. Mocking JDBC Using a Set of SQL String / Result Pairs
  28. How to Compile a Class at Runtime with Java 8 and 9
  29. A Completely Overhauled, Modularised jOOQ 3.11, Ready for Java 11
  30. Correct Reflective Access to Interface Default Methods in Java 8, 9, 10
  31. Top 10 SQL Dialect Emulations Implemented in jOOQ
  32. Map Reducing a Set of Values Into a Dynamic SQL UNION Query
  33. How to Order Versioned File Names Semantically in Java
  34. Type Safe Implicit JOIN Through Path Navigation in jOOQ 3.11
  35. How to Implement Your Own XJC Plugin to Generate toString(), equals(), and hashCode() Methods
  36. Calculating Tupper’s Self-Referential Formula With SQL
  37. Top 5 Hidden jOOQ Features

2017 59

  1. Do not GRANT ALL PRIVILEGES to your Production Users
  2. Creating a Microsoft Excel Style Pivot Table With Grand Totals in SQL
  3. The Cost of JDBC Server Roundtrips
  4. How to Fetch Oracle DBMS_OUTPUT from JDBC
  5. A Common Mistake Developers Make When Caching Nullable Values
  6. How to Ensure Your Code Works With Older JDKs
  7. Using JDK 10’s Local Variable Type Inference with jOOQ
  8. How to Avoid Excessive Sorts in Window Functions
  9. Squeezing Another 10% Speed Increase out of jOOQ using JMC and JMH
  10. jOOQ Tuesdays: Nicolai Parlog Talks About Java 9
  11. Benchmarking JDK String.replace() vs Apache Commons StringUtils.replace()
  12. 10 Cool SQL Optimisations That do not Depend on the Cost Model
  13. How to Write Efficient TOP N Queries in SQL
  14. JOIN Elimination: An Essential Optimiser Feature for Advanced SQL Usage
  15. jOOQ 3.10 Supports JPA AttributeConverter
  16. Finding all Palindromes Contained in Strings with SQL
  17. jOOQ Tuesdays: Oliver Gierke Talks About Spring Data
  18. 5 Things You May Not Have Known About jOOQ
  19. jOOQ 3.10 Supports Exciting MySQL 8.0 Features
  20. A Curious Java Language Feature and How it Produced a Subtle Bug
  21. Don’t Overdo the “Principle of Least Astonishment” Cargo Cult
  22. Don’t Extract Everything Into a Method
  23. How I Incorrectly Fetched JDBC ResultSets. Again.
  24. Are Java 8 Streams Truly Lazy? Not Completely!
  25. A Basic Programming Pattern: Filter First, Map Later
  26. ORMs Should Update “Changed” Values, Not Just “Modified” Ones
  27. jOOQ Tuesdays: Gerald Sangudi and Keshav Murthy Reveal the Secrets of N1QL (SQL on JSON)
  28. Using Kotlin’s Apply Function for Dynamic SQL with jOOQ
  29. How to Use SQL INTERSECT to Work Around SQL’s NULL Logic
  30. How to Find Redundant Indexes in SQL
  31. How to Execute a SQL Query Only if Another SQL Query has no Results
  32. When to Use Bind Values, and When to Use Inline Values in SQL
  33. How to Generate at Least One Row in SQL
  34. 10 Nice Examples of Writing SQL in Kotlin With jOOQ
  35. 10 Tips on How to be a Great Programmer
  36. The Difficulty of Tuning Queries Over a Database Link – Or How I Learned to Stop Worrying and Love the DUAL@LINK Table
  37. Don’t Use the String Concatenation “Trick” in SQL Predicates
  38. How to Calculate Multiple Aggregate Functions in a Single Query
  39. jOOQ Tuesdays: Richard North Makes Database Testing More Reproducible with Testcontainers
  40. How to Fetch Multiple Oracle Execution Plans in One Nice Query
  41. SQL IN Predicate: With IN List or With Array? Which is Faster?
  42. How to Benchmark Alternative SQL Queries to Find the Fastest Query
  43. The Open-Closed Principle is Often Not What You Think it Is
  44. Creating Tables Dum and Dee in PostgreSQL
  45. A Nice API Design Gem: Strategy Pattern With Lambdas
  46. Faster SQL Through Occasionally Choosing Natural Keys Over Surrogate Keys
  47. Many SQL Performance Problems Stem from “Unnecessary, Mandatory Work”
  48. Impress Your Coworkers With the Incredible NATURAL FULL OUTER JOIN!
  49. jOOQ Tuesdays: Brett Wooldridge Shows What it Takes to Write the Fastest Java Connection Pool
  50. Should I Implement the Arcane Iterator.remove() Method? Yes You (Probably) Should
  51. Beautiful SQL: Lateral Unnesting of Array Columns
  52. How to Fetch Oracle 12c Implicit Cursors with JDBC and jOOQ
  53. How to Execute SQL Batches With JDBC and jOOQ
  54. How to Emulate Partial Indexes in Oracle
  55. A Functional Programming Approach to Dynamic SQL with jOOQ
  56. A Probably Incomplete, Comprehensive Guide to the Many Different Ways to JOIN Tables in SQL
  57. jOOQ 3.10 Supports SQL Server’s Table Valued Parameters
  58. How to Write a Quick and Dirty Converter in jOOQ
  59. How to Prevent JDBC Resource Leaks with JDBC and with jOOQ

2016 68

  1. jOOQ Tuesdays: Mario Fusco Talks About Functional and Declarative Programming
  2. What we Need is Standardised Non-OSS Licenses
  3. Do You Really Have to Name Everything in Software?
  4. SQL, Streams, For Comprehension… It’s All the Same
  5. A Beginner’s Guide to the True Order of SQL Operations
  6. Prevent SQL Injection with SQL Builders Like jOOQ
  7. Use jOOQ to Read / Write Oracle PL/SQL RECORD Types
  8. Applying Queueing Theory to Dynamic Connection Pool Sizing with FlexyPool
  9. Why You Should (Sometimes) Avoid Expressions in SQL Predicates
  10. A Little Known SQL Feature: Use Logical Windowing to Aggregate Sliding Ranges
  11. Don’t Even use COUNT(*) For Primary Key Existence Checks
  12. How to Quickly Rename all Primary Keys in Oracle
  13. Be Careful When Emulating Parameterised Views with SYS_CONTEXT in Oracle
  14. jOOQ Tuesdays: Daniel Dietrich Explains the Benefits of Object-Functional Programming
  15. Does Your Database Really Use Your Index?
  16. Why You Should Design Your Database to Optimise for Statistics
  17. When to Choose SQL and When to Choose NoSQL
  18. A Hidden jOOQ Gem: Foreach Loop Over ResultQuery
  19. Avoid Using COUNT() in SQL When You Could Use EXISTS()
  20. Using jOOλ to Combine Several Java 8 Collectors into One
  21. jOOQ Tuesdays: Chris Saxon Explains the 3 Things Every Developer Should Know About SQL
  22. All Libraries Should Follow a Zero-Dependency Policy
  23. Why Most Programmers Get Pagination Wrong
  24. Why I Completely Forgot That Programming Languages Have While Loops
  25. Say NO to Excessive Use of Surrogate Keys if Performance Really Matters to You
  26. The Java JIT Compiler is Darn Good at Optimization
  27. How to Know if a Given Index Can be Dropped
  28. How Adding a UNIQUE Constraint on a OneToOne Relationship Helps Performance
  29. Quantified Comparison Predicates – Some of SQL’s Rarest Species
  30. “What Java ORM do You Prefer, and Why?” – SQL of Course!
  31. Say NO to Venn Diagrams When Explaining JOINs
  32. How Functional Programming will (Finally) do Away With the GoF Patterns
  33. With Commercial Licensing, Invest in Innovation, not Protection
  34. jOOQ Tuesdays: Thorben Janssen Shares his Hibernate Performance Secrets
  35. Correlated Subqueries are Evil and Slow. Or are They?
  36. Cyclops-react Organises the Cambrian Explosion of Java 8 Libraries
  37. JSR-308 and the Checker Framework Add Even More Typesafety to jOOQ 3.9
  38. 10 SQL Tricks That You Didn’t Think Were Possible
  39. The Parameterless Generic Method Antipattern
  40. jOOQ Tuesdays: Ming-Yee Iu Gives Insight into Language Integrated Querying
  41. Would We Still Criticise Checked Exceptions, If Java had a Better try-catch Syntax?
  42. Using jOOQ’s ExecuteListener to Prevent Write Operations on a Connection
  43. Using SQL to Calculate the Popularity (on Stack Overflow) of Derby, H2, and HSQLDB
  44. 10 Features I Wish Java Would Steal From the Kotlin Language
  45. Watch Out For Recursion in Java 8’s [Primitive]Stream.iterate()
  46. Time for some Funky SQL: Prefix Sum Calculation
  47. 10 Easy Steps to a Complete Understanding of SQL
  48. Ceylon Might Just be the Only (JVM) Language that Got Nulls Right
  49. Java 10’s new Local-Variable Type Inference
  50. SQL JOIN or EXISTS? Chances Are, You’re Doing it Wrong
  51. UI Developers! Choose Sensible Default Ordering!
  52. How to Support Java 6, 8, 9 in a Single API
  53. (Ab)using Java 8 FunctionalInterfaces as Local Methods
  54. A Very Peculiar, but Possibly Cunning Kotlin Language Feature
  55. The Mute Design Pattern
  56. An Ingenious Workaround to Emulate an Application of Union Types in Java
  57. jOOQ Tuesdays: Glenn Paulley Gives Insight into SQL’s History
  58. Dear API Designer. Are You Sure, You Want to Return a Primitive?
  59. The 5 Golden Rules of Giving Awesome Customer Support
  60. Using Oracle AQ via Java 8 Streams
  61. How to Detect Slow Queries with jOOQ
  62. How to Pattern-Match Files and Display Adjacent Lines in Java
  63. Use JUnit’s expected exceptions sparingly
  64. Impress Your Coworkers by Using SQL UNPIVOT!
  65. Reactive Database Access – Part 3 – Using jOOQ with Scala, Futures and Actors
  66. If Java Were Designed Today: The Synchronizable Interface
  67. 2016 Will be the Year Remembered as When Java Finally Had Window Functions!
  68. A Curious Incidence of a jOOQ API Design Flaw

2015 85

  1. Oracle LONG and LONG RAW Causing “Stream has already been closed” Exception
  2. Please, Java. Do Finally Support Multiline String Literals
  3. JEP 277 “Enhanced Deprecation” is Nice. But Here’s a Much Better Alternative
  4. How to Fill Sparse Data With the Previous Non-Empty Value in SQL
  5. Reactive Database Access – Part 2 – Actors
  6. jOOQ Tuesdays: Rafael Winterhalter is Wrestling Byte Code with Byte Buddy
  7. SQL GROUP BY and Functional Dependencies: A Very Useful Feature
  8. 3 Reasons why You Shouldn’t Replace Your for-loops by Stream.forEach()
  9. Reactive Database Access – Part 1 – Why “Async”
  10. A Subtle AutoCloseable Contract Change Between Java 7 and Java 8
  11. How to Find the Longest Consecutive Series of Events in SQL
  12. How to Find the Closest Subset Sum with SQL
  13. The Danger of Subtype Polymorphism Applied to Tuples
  14. jOOQ Tuesdays: Markus Winand is on a Modern SQL Mission
  15. The 10 Most Popular DB Engines (SQL and NoSQL) in 2015
  16. Semi Join and Anti Join Should Have Their Own Syntax in SQL
  17. A Beginner’s Guide to Using Java EE with jOOQ
  18. How to Quickly Enumerate Indexes in Oracle 11gR2
  19. You Probably don’t Use SQL INTERSECT or EXCEPT Often Enough
  20. Let’s Meet at JAX London and Other Events to Talk About SQL
  21. It is all about the JDBC Basics
  22. Comparing Imperative and Functional Algorithms in Java 8
  23. Don’t Format Dates in SQL. Use the DATE Literal!
  24. How to use Java 8 Functional Programming to Generate an Alphabetic Sequence
  25. There is no Such Thing as Object-Relational Impedance Mismatch
  26. Divided we Stand: Optional
  27. jOOQ Tuesdays: Thomas Müller Unveils How HSQLDB Evolved into the Popular H2 Database
  28. Common SQL Clauses and Their Equivalents in Java 8 Streams
  29. Top 10 Useful, Yet Paranoid Java Programming Techniques
  30. RAM is the new SSD
  31. INTERSECT – the Underestimated Two-Way IN Predicate
  32. Java 8’s Method References Put Further Restrictions on Overloading
  33. NULL is Not The Billion Dollar Mistake. A Counter-Rant
  34. What the sun.misc.Unsafe Misery Teaches Us
  35. What’s Even Harder Than Dates and Timezones? Dates and Timezones in SQL / JDBC!
  36. How to Debug Your Maven Build with Eclipse
  37. Implementing Client-Side Row-Level Security with jOOQ
  38. Querying Your Database from Millions of Fibers (Rather than Thousands of Threads)
  39. jOOQ Tuesdays: Axel Fontaine Predicts Exciting Times as our Industry is Maturing
  40. What Exactly are SQL Views?
  41. Do Not Make This Mistake When Developing an SPI
  42. How to Access a Method’s Result Value From the Finally Block
  43. Use This Preference to Speed up Your Eclipse m2e Configuration
  44. Functional Programming in Java 8 with vavr
  45. Use this Neat Window Function Trick to Calculate Time Differences in a Time Series
  46. PostgreSQL’s Best-Kept Secret, and how to Use it with jOOQ
  47. How SQL GROUP BY Should Have Been Designed – Like Neo4j’s Implicit GROUP BY
  48. This Common API Technique is Actually an Anti-Pattern
  49. Do Not Think That One Second is Fast for Query Execution
  50. Let’s Review How to Insert Clob or Blob via JDBC
  51. Is Your Eclipse Running a Bit Slow? Just Use This Simple Trick!
  52. jOOQ Tuesdays: Vlad Mihalcea Gives Deep Insight into SQL and Hibernate
  53. It’s the Little Things: The PL/SQL NULL Statement, and why Every Language Should have One
  54. How to FlatMap a JDBC ResultSet with Java 8?
  55. How to Avoid the Dreaded Dead Lock when Pessimistic Locking – And some Awesome Java 8 Usage!
  56. How to Use Java 8 Streams to Swiftly Replace Elements in a List
  57. Don’t be Fooled by Generics and Backwards-Compatibility. Use Generic Generic Types
  58. Hack up a Simple JDBC ResultSet Cache Using jOOQ’s MockDataProvider
  59. jOOQ vs. Hibernate: When to Choose Which
  60. One Year After Java 8’s Release, IDEs and Compilers are not Fully Ready Yet
  61. The 10 Things Everyone does Wrong when Committing Pull Requests
  62. 3 Reasons why It’s Okay to Stick with SQL
  63. Integrating jOOQ with Grails Featuring the UWS-jOOQ Plugin
  64. Yak Shaving is a Good Way to Improve an API
  65. The Java Legacy is Constantly Growing
  66. Avoid Recursion in ConcurrentHashMap.computeIfAbsent()
  67. jOOQ – Ein alternativer Weg mit Java und SQL zu arbeiten
  68. How to use SQL PIVOT to Compare Two Tables in Your Database
  69. How to Extract a Date Part in SQL
  70. jOOQ vs. Slick – Pros and Cons of Each Approach
  71. Thou Shalt Not Name Thy Method “Equals”
  72. jOOQ Tuesdays: Raoul-Gabriel Urma Explores What Java 8 and English have in Common
  73. 10 SQL Articles Everyone Must Read
  74. Top 10 Easy Performance Optimisations in Java
  75. Still Using Windows 3.1? So why stick to SQL-92?
  76. Top 5 Use-Cases For Nested Types
  77. You Will Regret Applying Overloading with Lambdas!
  78. How to Translate SQL GROUP BY and Aggregations to Java 8
  79. jOOQ Newsletter: January 21, 2015 – Groovy and Open Source – jOOQ and the strong Swiss Franc
  80. Open Source Doesn’t Need More Support. It Needs Better Business Models
  81. Suis-je Groovy? No! What Pivotal’s Decision Means for Open Source Software
  82. Using Java 8 to Prevent Excessively Wide Logs
  83. Infinite Loops. Or: Anything that Can Possibly Go Wrong, Does.
  84. Transform Your SQL Data into Charts Using jOOQ and JavaFX
  85. How to Emulate the MEDIAN() Aggregate Function Using Inverse Distribution Functions

2014 132

  1. The Awesome PostgreSQL 9.4 / SQL:2003 FILTER Clause for Aggregate Functions
  2. Leaky Abstractions, or How to Bind Oracle DATE Correctly with Hibernate
  3. Are You Binding Your Oracle DATEs Correctly? I Bet You Aren’t
  4. A True SQL Gem You Didn’t Know Yet: The EVERY() Aggregate Function
  5. jOOQ Tuesdays: Yalım Gerger brings Git to Oracle
  6. Really Too Bad that Java 8 Doesn’t Have Iterable.stream()
  7. The Inconvenient Truth About Dynamic vs. Static Typing
  8. Don’t be “Clever”: The Double Curly Braces Anti Pattern
  9. Do You Really Understand SQL’s GROUP BY and HAVING clauses?
  10. How to Integrate Commercial Third-Party Artefacts into Your Maven Build
  11. Use MySQL’s Strict Mode on all new Projects!
  12. jOOQ Tip of the Day: Discover all Primary Keys
  13. Don’t Migrate to MariaDB just yet. MySQL is Back!
  14. Have You Ever Wondered About the Difference Between NOT NULL and DEFAULT?
  15. Don’t Miss out on Awesome SQL Power with FIRST_VALUE(), LAST_VALUE(), LEAD(), and LAG()
  16. Access PL/SQL Procedures From Java with jOOQ, a JPublisher Alternative
  17. 10 Things You Didn’t Know About Java
  18. A RESTful JDBC HTTP Server built on top of jOOQ
  19. Let’s Stream a Map in Java 8 with jOOλ
  20. Stop Claiming that you’re Using a Schemaless Database
  21. The dreaded DefaultAbstractHelperImpl
  22. Don’t Miss out on Writing Java 8 SQL One-Liners with jOOλ or jOOQ
  23. The Caveats of Dual-Licensing
  24. Using Your RDBMS for Messaging is Totally OK
  25. Asynchronous SQL Execution with jOOQ and Java 8’s CompletableFuture
  26. Top 10 Most Popular Articles on the jOOQ Blog
  27. How Nashorn Impacts API Evolution on a New Level
  28. This Just In!! Updated Silly Keyword Metrics
  29. This is the Final Discussion!
  30. Why You Should NOT Implement Layered Architectures
  31. When the Java 8 Streams API is not Enough
  32. Look no Further! The Final Answer to “Where to Put Generated Code?”
  33. Stop Manually Importing Your ERD Export into jOOQ
  34. Awesome SQL Trick: Constraints on Views
  35. jOOQ Newsletter: September 02, 2014 – Do You Really Need Support?
  36. PL/SQL backtraces for debugging
  37. Integrating jOOQ with PostgreSQL: Partitioning
  38. All You Ever Need to Know About Recursive SQL
  39. jOOQ Newsletter: August 15, 2014 – jOOQ 3.5 Outlook
  40. A Wonderful SQL Feature: Quantified Comparison Predicates (ANY, ALL)
  41. The Difference Between ROW_NUMBER(), RANK(), and DENSE_RANK()
  42. The “Free”, “Standard”, “Open” Software Heresy
  43. SQL Tip of the Day: Be Wary of SELECT COUNT(*)
  44. Join the No OFFSET Movement!
  45. Are You Using SQL PIVOT Yet? You Should!
  46. The 10 Most Annoying Things Coming Back to Java After Some Days of Scala
  47. Using Oracle AQ in Java Won’t Get Any Easier Than This
  48. jOOQ Tip of the Day: Reuse Bind Values
  49. Top 10 Very Very VERY Important Topics to Discuss
  50. jOOQ Newsletter: jOOLY 23, 2014 – Only 8 Days Left in jOOLY
  51. Frightening Facts about MySQL
  52. Keeping things DRY: Method overloading
  53. Logon Triggers: The Oracle Database Magic Bullet
  54. Java 8 Friday: More Functional Relational Transformation
  55. PostgreSQL’s Table-Valued Functions
  56. jOOQ Newsletter: July 2, 2014 – jOOLY 20% Discount Offering
  57. Stop Unit Testing Database Code
  58. Flyway and jOOQ for Unbeatable SQL Development Productivity
  59. Should I Put That Table Alias or Not?
  60. SQL Server ALTER TABLE SET DEFAULT
  61. What Big Data Really Is
  62. Java 8 Friday: The Best Java 8 Resources – Your Weekend is Booked
  63. jOOQ Newsletter: June 18, 2014 – jOOQ goes JavaOne™
  64. Conference Legal Disclaimers
  65. Java 8 Friday: 10 Subtle Mistakes When Using the Streams API
  66. Stop Trying to Emulate SQL OFFSET Pagination with Your In-House DB Framework!
  67. Java 8 Friday: JavaScript goes SQL with Nashorn and jOOQ
  68. Don’t Forget to Set the SEQUENCE CACHE Size
  69. Java 8 Friday: Most Internal DSLs are Outdated
  70. QueryDSL vs. jOOQ. Feature Completeness vs. Now More Than Ever
  71. What if Developing a Simple Data Management Application Just Took 1-2 Days?
  72. Yet Another 10 Common Mistakes Java Developers Make When Writing SQL (You Won’t BELIEVE the Last One)
  73. Java 8 Friday: Better Exceptions
  74. Oracle Tip: v$sql Table or View does not Exist
  75. jOOQ Newsletter: May 21, 2014 – jOOQ Community Video Tutorials
  76. Free as in Beer has caused Heartbleed (and Much More)
  77. Java 8 Friday: API Designers, be Careful
  78. SQL Server Trick: Circumvent Missing ORDER BY Clause
  79. The Index You’ve Added is Useless. Why?
  80. Java 8 Friday: Language Design is Subtle
  81. How to Implement Sort Indirection in SQL
  82. Three-State Booleans in Java
  83. Java 8 Friday: Let’s Deprecate Those Legacy Libs
  84. jOOQ Newsletter: April 30, 2014
  85. NoSQL? No, SQL! – How to Calculate Running Totals
  86. jOOQ Newsletter: April 16, 2014 – Monthly, Yearly, Perpetual licenses now available
  87. How can I do This? – With SQL of Course!
  88. Java Rocks More Than Ever
  89. The Top 10 Productivity Booster Techs for Programmers
  90. Java 8 Friday: The Dark Side of Java 8
  91. jOOQ Newsletter: April 2, 2014
  92. Spring API Bingo
  93. Open Source Completely Underestimates Contributor License Agreements
  94. Java 8 Friday: Optional Will Remain an Option in Java
  95. CUME_DIST(), a Lesser-Known SQL Gem
  96. Java 8 Friday: Java 8 Will Revolutionize Database Access
  97. A Better Query Language than SQL
  98. A SQL query DSL for Scala by ScalikeJDBC
  99. Java 8 Friday Goodies: Lean Concurrency
  100. The 10 Commandments of Programming
  101. jOOQ Newsletter: March 12, 2014
  102. Java 8 Friday Goodies: SQL ResultSet Streams
  103. An Open Source License to Increase Your Street Credibility
  104. Modern Shareholder Value Hopes
  105. Java 8 Friday Goodies: Easy-as-Pie Local Caching
  106. How to Eliminate Bugs Through High Cohesion
  107. jOOQ Newsletter: February 26, 2014
  108. The JDBC Boolean Compatibility List
  109. Feature Request for the JLS: Auto-Rethrow
  110. Java 8 Friday Goodies: Local Transaction Scope
  111. An MS Access SQL Transformation Odyssey
  112. When All Else Fails: Using “the Unsafe”
  113. Free Java Profiling with Oracle Java Mission Control
  114. Java 8 Friday Goodies: Map Enhancements
  115. No CROSS JOIN in MS Access
  116. jOOQ Newsletter: February 12, 2014
  117. Why Everyone Hates Operator Overloading
  118. Java 8 Friday Goodies: Lambdas and SQL
  119. You’re Very Likely to Have Gotten SQL Date Time Arithmetic Wrong!
  120. JDBC 4.0’s Lesser-known Clob.free() and Blob.free() Methods
  121. Java 8 Friday Goodies: Lambdas and Sorting
  122. Introducing CQLC – a Query DSL for Cassandra’s CQL in Go, Inspired by jOOQ
  123. Java 8 Friday Goodies: The New New I/O APIs
  124. jOOQ Newsletter: January 22, 2014
  125. Java 8 Friday Goodies: Lambdas and XML
  126. What you Didn’t Know About JDBC Batch
  127. Do You Want to be a Better Software Developer?
  128. Advanced Java Trickery for Typesafe Query DSLs
  129. Lesser-Known SQL Features: DEFAULT VALUES
  130. The SQL Language’s Most Missing Feature
  131. Why Did SQLJ Die?
  132. Why Your Boring Data Will Outlast Your Sexy New Technology

2013 138

  1. Typesafe’s Slick is Not About SQL
  2. jOOQ Newsletter: December 30, 2013. Happy New Year!
  3. MySQL Bad Idea #666
  4. Ecto a Slick Query DSL for the Elixir Language
  5. MyBatis’ Alternative Transaction Management
  6. A Bit of SQL History
  7. Simplernate. A Query DSL for Hibernate, Inspired by jOOQ
  8. MongoDB “Lightning Fast Aggregation” Challenged with Oracle
  9. The Crystal Ball. Or, Oops, Michael Stonebraker did it Again
  10. Add LATERAL Joins or CROSS APPLY to Your SQL Tool Chain
  11. jOOQ, a Love Story
  12. Counting Distinct Records in SQL
  13. Free Open Source with Commercial Support
  14. When Source Code Comments Indicate Trouble
  15. Top 10 Ceylon Language Features I Wish We Had In Java
  16. The Jodd SQL Generator
  17. The Open Source Bikeshed.
  18. Detect JDBC API Misusage with JDBCLint
  19. Using jOOQ with JAX-RS to Build a Simple License Server
  20. A Lesser-Known Java 8 Feature: Generalized Target-Type Inference
  21. Using jOOQ With Groovy
  22. Deep Stack Traces Can be a Sign for Good Code Quality
  23. On Friday Dec 13th 2013, Things *WILL* go Wrong
  24. How to Create a Range From 1 to 10 in SQL
  25. Faster SQL Pagination with Keysets, Continued
  26. Where’s the Self-Confidence when Advertising Java 8, Oracle?
  27. A History of Databases in “No-tation”
  28. Popular ORMs Don’t do SQL
  29. Oracle GlassFish, or Why You Should Think About Open Source Again
  30. ID Lists Aren’t the Best Solution for the N+1 Problem
  31. Using SQL Injection Vulnerabilities to Dump Your Database
  32. Probably the Coolest SQL Feature: Window Functions
  33. Top 10 Lists of Common Java Mistakes (That Makes Top 100!)
  34. CUBRID: A Lesser-Known Korean OSS Database Gem
  35. jOOQ Newsletter October 28, 2013
  36. Top 5 Useful Hidden Eclipse Features
  37. Faster SQL Pagination with jOOQ Using the Seek Method
  38. Recursive SQL for Data Normalisation
  39. Who Says “I Want to Contribute” ?
  40. On Degrading Merchandise Quality
  41. A Significant Difference Between Open Source and Commercial Software
  42. Add Some Entropy to Your JVM
  43. The End of US Internet Governance
  44. Eclipse’s Awesome Block Selection Mode
  45. jOOQ Newsletter October 10, 2013
  46. jOOQ™ 3.2 Offering Commercial Licensing and Support
  47. SQL Trick: row_number() is to SELECT what dense_rank() is to SELECT DISTINCT
  48. Java Auto-Unboxing Gotcha. Beware!
  49. On MongoDB’s Success. Or Do Not Let Cynicism Kill Your Spirit
  50. The Premature Return to SQL
  51. This Beats Everything: Koding in the Cloud
  52. Will Another Play-Style Framework Make its Way to Java?
  53. Why do We Need RDBMS?
  54. Do You View Database Applications as Military Campaigns?
  55. Brian Goetz’s Final State of the Lambda Documentation
  56. Amazing Web Applications with PL/SQL and Formspider
  57. Fast File System Operations with Xtend, Lambdas, and ThreadPools
  58. jOOQ Newsletter September 17, 2013
  59. Why PostgreSQL is so Awesome
  60. PostgreSQL Syntax is a Mystery Only Exceeded by its Power
  61. Crazy Translations of Simple SQL Expressions to Various SQL Dialects
  62. PostgreSQL 9.3 Released!
  63. jOOQ Newsletter September 2013
  64. Tech Pro: Next Generation Social Content Syndication
  65. Heavyweights Martin Odersky, Erik Meijer and Roland Kuhn Team up for a Coursera Course
  66. Awesome Tweets About Recent Blog Post
  67. Column Stores: Teaching an Old Elephant New Tricks
  68. Silly Metrics: The Most Used Java Keywords
  69. How to Speed Up Apache Xalan’s XPath Processor by Factor 10x
  70. MIT Prof. Michael Stonebraker: “The Traditional RDBMS Wisdom is All Wrong”
  71. Plagiarism is Copyright Infringement AND Poor Form
  72. What Will be Oracle’s Next Big Acquisition?
  73. The Myth About Slow SQL JOIN Operations
  74. 10 Subtle Best Practices when Coding Java
  75. Apache Derby About to Adopt the Awesome SQL:2003 MERGE Statement
  76. Java EE 7: JSRs That Make You Powerful
  77. jOOQ Newsletter August 2013
  78. What if every object was an array? No more NullPointerExceptions!
  79. 10 More Common Mistakes Java Developers Make when Writing SQL
  80. Conference Gem: The MEDIT Symposium
  81. Twitter and the JVM
  82. Use ModelMapper and jOOQ to Regain Control of your Domain Model
  83. Oracle 12c Goodies: { CROSS | OUTER } APPLY
  84. 10 Reasons not to Choose a Particular Open Source software
  85. On Terms and Conditions
  86. MySQL Bad Idea #573
  87. SAP’s Hilarious SQL Whitepaper(s)
  88. jOOQ at the MEDIT Symposium
  89. The Announcer Badge on Stack Overflow
  90. 10 Common Mistakes Java Developers Make when Writing SQL
  91. Jenkins (and Others) about Dropping Support for Java 5
  92. How to Generate Date Ranges in Oracle SQL
  93. Leap Seconds. Will our Understanding of Time Change in 2015?
  94. How to Make Your Advertisement Look Like Spam
  95. 10 Things in SQL Server Which Don’t Work as Expected
  96. Nice Tutorial for Creating an External DSL with Xtext
  97. The Great Benevolent Dictator Getting Some Beating
  98. Internal DSLs on the Fast Lane
  99. SQL Templating with jOOQ or MyBatis
  100. Usability vs. Reusability
  101. Static, Non-Static. Mockable, Non-Mockable… Instead, Let’s Focus on Real Added Value…
  102. High Complexity and Low Throughput. Reasons for Using an ORM.
  103. LINQ and Java
  104. RedHat and MariaDB
  105. The Dangers of Correlating Subtype Polymorphism with Generic Polymorphism
  106. Using jOOQ with Play Framework
  107. A Couple of Reasons Why You Should Use PostgreSQL
  108. Strategy: Stop Using Linked-Lists
  109. Pinterest and SQL vs. NoSQL
  110. Subtle Changes in Java 8: Repeatable Annotations
  111. SQL Query Transformation Fun: Predicates with Row Value Expressions
  112. Rare Uses of a “ControlFlowException”
  113. jOOQ as a “PL/Java” language
  114. On Java 8’s introduction of Optional
  115. A Great Counter-Rant
  116. The Lame Side of Java’s Backwards-Compatibility
  117. A jOOX First-Time Experience Article
  118. How to Design a Good, Regular API
  119. Inadvertent Recursion Protection with Java ThreadLocals
  120. Java Streams Preview vs .Net LINQ
  121. Will Java add LINQ to EL 3.0 in JSR-341?
  122. Java Collections API Quirks
  123. Hibernate, and Querying 50k Records. Too Much?
  124. JUnit’s Evolving Structure
  125. How to Behave on Mailing Lists
  126. How to Execute Something Multiple Times in Java
  127. The Golden Rules of Code Documentation
  128. A Typesafety Comparison of SQL Access APIs
  129. Duck Typing in Scala: Structural Typing
  130. Easy Mocking of Your Database
  131. jOOQ’s Reason for Being
  132. Get hidden feature requests from your users
  133. Java, if this were a better world
  134. Java trivia: the double-checked locking pattern
  135. Defensive API evolution with Java interfaces
  136. A dirt-ugly hack to modify private final fields in Java
  137. Bloated JavaBeans™, Part II – or Don’t Add “Getters” to Your API
  138. Emulating the SQL standard derived column list

2012 68

  1. A map of all those new NoSQL, NewSQL, post-SQL, structured, unstructured database options that came out over the past year
  2. Row value expressions and the BETWEEN predicate
  3. Row value expressions and the NULL predicate
  4. Big Fail. How to recognise bad software
  5. JDEclipse: A must-have Java Decompiler
  6. Architect-Senior Java Developer with jOOQ skills
  7. JDK 8: State of the Collections
  8. How to provide a good pull request
  9. Wikileaks To Leak 5000 Open Source Java Projects With All That Private/Final Bullshit Removed
  10. JavaBeans™ should be extended to reduce bloat
  11. ElSql, a new external SQL DSL for Java
  12. J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource… WAT??
  13. Learn Eclipse Keyboard Shortcuts Easily
  14. The IS DISTINCT FROM predicate
  15. How to get Oracle execution plans with Starts, E-Rows, A-Rows and A-Time columns
  16. A nice way of using jOOQ with Spring
  17. Throw checked exceptions like runtime exceptions in Java
  18. Alvor: Static SQL analysis in Strings passed to JDBC
  19. Syntax for calling “super” in Java 8 Defender methods
  20. Serious SQL: A “convex hull” of “correlated tables”
  21. You never stop learning about Oracle features
  22. SLICK, integrating SQL into Scala
  23. Survey about the Java 8 “default method” syntax
  24. MySQL Bad Idea #384
  25. The true spirit of Open Source
  26. Hilarious Rant about SQL Injection
  27. When will we have LINQ in Java?
  28. Database Abstraction and SQL Injection
  29. NOT IN vs. NOT EXISTS vs. LEFT JOIN / IS NULL: MySQL
  30. Open source user rants
  31. “NoSQL” should be called “SQL with alternative storage models”
  32. Funky String Function Simulation in SQLite
  33. Array, list, set, map, tuple, record literals in Java
  34. MyBatis’ Wicked Statement Builders
  35. FOR UPDATE simulation in SQL Server and CUBRID
  36. Simulation of TRUNC() in Derby
  37. How to simulate MySQL’s INSERT statement extensions
  38. ORM vs. SQL, compared to C vs. ASM
  39. jOOQ and Hibernate, a discussion
  40. jOOQ users’ most frequently used databases
  41. Exciting ideas in Java 8: Streams
  42. Must-have Eclipse plugin: AnyEdit Tools
  43. jDBI: A simple convenience layer on top of JDBC
  44. jOOQ website re-launch
  45. SQL tooling, the ranking
  46. A very refreshing point of view about language design
  47. Which database are you using jOOQ with?
  48. Blog has “moved”
  49. The Visitor Pattern Re-visited
  50. CROSS JOIN, a nice example for a rarely used operation
  51. Advanced SQL: Relational division in jOOQ
  52. jOOQ compared to iBatis
  53. Subtle SQL differences: IDENTITY columns
  54. Binary data in SQL, more trivia
  55. SQL and booleans, some trivia
  56. The depths of Java: API leak exposed through covariance
  57. The truth about IN and EXISTS in SQL
  58. jOOX and XSLT. An XML love story, continued
  59. SQL incompatibilities: NOT IN and NULL values
  60. CSS selectors in Java
  61. Use Xalan’s extension functions natively in jOOX
  62. jOOX answers many Stack Overflow questions
  63. Java 8 will have some support for unsigned integers
  64. jOOQ’s fluent API in BNF notation
  65. if – else coding style best practices
  66. The good API design
  67. Let’s revise the SQL FROM clause
  68. The Java Fluent API Designer Crash Course

2011 61

  1. Cut down 90% on RDBMS costs switching from Oracle to EnterpriseDB
  2. A neater way to use reflection in Java
  3. A Brief, Incomplete, and Mostly Wrong History of Programming Languages
  4. SQL in Scala, where jOOQ could go
  5. Java 8 virtual extension methods
  6. The ultimate SQL-DSL: jOOQ in Scala
  7. Subtle SQL differences: Constraint names
  8. A success story of SQL scaling horizontally
  9. A DBA’s point of view of Hibernate
  10. Arcane magic with the SQL:2003 MERGE statement
  11. GROUP BY ROLLUP / CUBE
  12. How schema meta data impacts Oracle query transformations
  13. Join the “dark side” with jOOQ
  14. Java’s missing unsigned integer types
  15. Overload API methods with care – the sequel
  16. jOOQ-meta. A “hard-core SQL” proof of concept
  17. Overload API methods with care
  18. Development schema, production schema
  19. Op4j and Lambda-J. For more fluency in Java
  20. Use jOOQ inside your H2 database
  21. SQL DSL’s in other languages
  22. jOOQ Tutorial by Ikai Lan
  23. What feature are you missing most in jOOQ?
  24. The comprehensive SQL bitwise operations compatibility list
  25. Derby casting madness – the sequel
  26. Java’s Arrays.asList(…) is underused
  27. jOOQ in the wild
  28. JDBC batch operations with jOOQ
  29. Liquibase for DB Migrations
  30. jOOQ and Google Cloud SQL Example
  31. Use jOOQ to transform java.sql.ResultSet
  32. Debug logging SQL with jOOQ
  33. Cloud Fever now also at Sybase
  34. What are procedures and functions after all?
  35. SQL Trouble with dummy tables
  36. Google Cloud SQL, the next step for jOOQ?
  37. Recursive queries with Oracle’s CONNECT BY clause
  38. How to use H2 with jOOQ
  39. Vaadin, a very nice web framework
  40. Stored procedures returning multiple cursors
  41. jOOQ has a new home page
  42. Suggestions for the Java, SQL and jOOQ Blog
  43. MentaBean, the ORM/SQL Builder of Mentawai
  44. Database schema navigation in Java
  45. Elmer Fudd’s opinion on jOOQ
  46. jOOX brand launch
  47. Oracle scalar subquery caching
  48. RDBMS bind variable casting madness
  49. Postgres INSERT .. RETURNING clause and how this can be simulated in other RDBMS
  50. Loading CSV data with jOOQ
  51. There’s still potential for new SQL dialects
  52. Oracle’s object-oriented PL/SQL extensions
  53. FluentDOM, another mimick of jQuery DOM manipulation, in PHP
  54. Another Fluent API: jOOX. Porting jQuery to Java
  55. The art of doing it right – who knows it?
  56. iciql, a fork of H2’s JaQu
  57. jOOQ and Java 7
  58. jOOQ makes a step forward towards JPA
  59. “Stop Hating Java” – A Funny Post by Igor Polevoy
  60. The power of REF CURSOR types
  61. Developer blog started for interesting insights in Java, SQL and jOOQ