Contribute to the jOOQ community

jOOQ lives from your feedback and support

jOOQ is a very interactive project. It lives from your feedback and support. There are many ways how you can contribute to the jOOQ community.

The technical community

Hall of Fame

Passionate contributors have made jOOQ what it is. Here's a list of contributors worth mentioning (in alphabetical order)

Aaron Digulla: jOOQ-codegen cleanup
Christopher Deckers: jOOQ-Console contribution
Christopher Klewes: Maven integration
Ed Schaller: Improvements to unsigned data types (jOOU)
Espen Stromsnes: DB2, H2, Sybase, and HSQLDB integrations
Florian Adler: jOOQ-minuteproject contribution
Ivan Dugic: Various GitHub ticket contributions
Lukas Eder: Project lead
Rakesh Waghela: Spreading the news
Robin Stocker: Git, GitHub, and Scala support
Sander Plas: jOOQ-codegen-maven, jOOQ-wicket contribution
Sergey Epik: jOOQ-spring contribution
Sugiharto Lim: Firebird integration
Vladislav "FractalizeR" Rastrusny: MySQL integration feedback

You can contribute too!

The easiest way to contribute is by providing feedback. Tell me, tell us, tell the world! How to do it? Telling us:
The jOOQ User Group

Telling the world:
http://stackoverflow.com/questions/tagged/jooq

... or blog about jOOQ. Write articles! Advertise jOOQ!

Contributing code

... or contribute code! If you want to share code, please follow these instructions

If you haven't already, download Eclipse (Indigo or Juno) from http://www.eclipse.org/. While you could develop with other IDEs as well, you wouldn't profit from all the installed launch configurations, etc.
Be sure that you have http://www.eclipse.org/egit/ installed in your Eclipse distribution
Check out the codebase from GitHub: git@github.com:jOOQ/jOOQ.git
Import the jOOQ projects into Eclipse
If you haven't already, get M2E, the Eclipse Maven plugin to build jOOQ with Maven in Eclipse (The one from Sonatype, NOT the one from Eclipse)
Use the Eclipse formatting settings that have been checked in with the projects. Keeps the code nice and clean. Your code should not change (not much), if formatted with Ctrl-Shift-F. But don't format jOOQ DSL query code!
Send me your changes directly to the user group or in a GitHub ticket.
Send your changes as an Eclipse-compatible .patch file (or the sum of the modified Java classes). Ideally, the .patch file can be applied to the latest version of jOOQ on the SVN trunk.
I'll review, audit your changes and it goes into the repository with the next release, if I'm happy :-) AND: you'll make it to the hall of fame. Provide me with links to your webpage / blog / etc, if you would like to see that mentioned.
If you are a committer on GitHub, please commit with the following comment scheme:
[#Issue-ID] GitHub-Ticket-Title - Your specific comment

Hints for new features

A lot of ideas are around already. Check out this GitHub Milestone to see some of them

Hints for new database integrations

Should you wish to provide an extension/support for a new RDBMS (such as Informix, Firebird, etc) your work would consist of these steps:

Extend Eclipse .classpath files and .launch targets such that all developers are able to use your newly added database / JDBC drivers
Implement code generation for the new RDBMS. For that, you'll need to provide an implementation for AbstractDatabase in jOOQ-meta
Make the integration tests for the new RDBMS run.

Or in more detail:

In detail, you have to do these steps:

Migrate create.sql and reset.sql scripts to your dialect
Create the above schema (create.sql) and data (reset.sql) in your test database
Extend org.jooq.util.AbstractDatabase. Ideally, you'll use your own generated meta-schema classes and the jOOQ API to navigate through your RDBMS's meta-schema in order to discover your test schema. Apart from the integration tests, this adds an additional layer of "proof of concept". See for instance org.jooq.util.oracle.OracleDatabase, where rather complex nested queries are used to navigate through Oracle foreign key relationships.
For a minimal implementation, check out org.jooq.util.sqlite.SQLiteDatabase, which only implements loadPrimaryKeys0() and getTables0(). All other implementations are optional extensions.

Once you've done these steps, in order to be sure that everything works fine you'll also have to do this:

Let jOOQ generate the integration test schema
Extend the org.jooq.test.jOOQAbstractTest for your RDBMS
Run the integration tests for your RDBMS
Fix all issues. You should get syntax errors, SQLDialectNotSupportedExceptions, etc

If you provide me with instructions how to set up your RDBMS instance and any partial implementation of the above, I'm going to take that into the jOOQ code base (giving you credit, of course) and guaranteeing implementation integrity in the future.

So let's get to work, then! :-)

Cheers, Lukas

The business community

Invest in jOOQ

jOOQ is currently looking for partnerships. If you are a database vendor or a software vendor and you wish to get basic or advanced support for your specific database product integrated in jOOQ, or if you have any other specific feature request, please contact me directly at lukas.eder@gmail.com.

Advertise on www.jooq.org

jOOQ has a growing community in dire need for good database products. Make yourself heard to many database users!

Donations

If you simply wish to donate, that is fine too.

The latest news, links

Follow jOOQ on any of these channels to get the latest news:

On Twitter: https://twitter.com/#!/JavaOOQ
On Wordpress: http://blog.jooq.org
On SourceForge: https://sourceforge.net/projects/jooq/
On GitHub: https://github.com/jOOQ/jOOQ
On ohloh: https://www.ohloh.net/p/jooq
On freecode: http://freecode.com/projects/jooq

The jOOQ Brand

Want to publish something about jOOQ? Use the official brand! Right-click on any image and choose "Save As..." to store the image on your computer. contact me for more specific formats: