sql2java

This is a fork of an abandoned project on SourceForge by the same name http://sql2java.sourceforge.net/. It is heavily modified from the original version. I started using this around 2005 as a quick & dirty way to generate Java beans and data access managers from a SQL database. I still use it, as I have found many ORM tools like Hibernate to be unweildy and more trouble than they're worth.

This differs from the original project in the following ways:

Build uses Maven. Packaged as a Maven plugin. sql2java-maven-plugin and sql2java-lib are in Maven Central.
New Maven plugin (sqlfile) for sourcing a SQL DDL before generation.
sql2java-lib runtime library is now a mandatory dependency.
No more web widgets or factories. Just beans and managers.
*Managers return Lists instead of arrays.
Manager class is gone. BaseManager now takes a DataSource directly.
Generates a (SchemaName)Database.java factory with get*Manager() methods for all managers. Intended as an easy entry point to extend as your application's DAO.
Management of transactions from the (SchemaName)Database.java class.
Uses generics to make the code more concise (and requires Java 1.5)
Not sure if anything but MySQL and HSQL support works anymore. PostgreSQL did work a while ago, but haven't checked in a bit.

To do in the future:

Add an interface for a cache providing a few convenience methods on top of a *Manager: T get(Id), List get(List), List get(Key). Add optional runtime library with cache implementations.
The CodeWriter and Database classes are messy and fragile. Port to use SchemaCrawler http://schemacrawler.sourceforge.net/. Also look at jOOQ http://www.jooq.org/ and see what they're doing.
Do something with foreign key mappings that is sane against bad definitions.
Do something better with compound primary keys (despite thinking they're a bad design decision).
Move the properties defined in the file into the Maven plugin definition. Allow a list of tables to be specified for generation.

Using the generator:

Easiest way to try it out is to copy the structure in sql2java-test/.

Add the following to your POM file's build section:

<build>
  <plugins>
    <plugin>
      <groupId>com.github.xgp</groupId>
      <artifactId>sql2java-maven-plugin</artifactId>
      <version>${sql2java.version}</version>
      <executions>
        <execution>
          <id>sql2java</id>
          <goals>
            <goal>sql2java</goal>
          </goals>
        </execution>
      </executions>
      <configuration>
        <outputDirectory>${project.build.directory}/generated-sources/sql2java</outputDirectory>
        <propertiesFile>${project.basedir}/src/main/resources/sql2java.properties</propertiesFile>
        <driver>org.hsqldb.jdbc.JDBCDriver</driver>
        <url>jdbc:hsqldb:file:${project.build.directory}/databases/test</url>
        <user>SA</user>
        <password></password>
        <schema>PUBLIC</schema>
        <packageName>com.test</packageName>
      </configuration>
      <dependencies>
        <!-- Add your JDBC driver here -->
        <dependency>
          <groupId>org.hsqldb</groupId>
          <artifactId>hsqldb</artifactId>
          <version>${hsqldb.version}</version>
        </dependency>
      </dependencies>
    </plugin>
  </plugins>
</build>

And run:

mvn sql2java:sql2java compile

There is a log at target/velocity.log that will tell you if anything failed, and running Maven with the -e flag should be somewhat informative.

Using the generated code:

Given the schema example in sql2java-test/src/main/sql/00-test.sql:

// Create a Database from your DataSource
PublicDatabase db = new PublicDatabase(ds);

// Transactionally create some rows
try {
    db.beginTransaction(Txn.Isolation.REPEATABLE_READ);
    Person s0 = db.createBean(Person.class);
    s0.setUsername("hansolo");
    s0.setFirstName("Harrison");
    s0.setLastName("Ford");
    s0.setCreateDate(new Date());
    s0 = db.save(s0);
    Phone m0 = db.createBean(Phone.class);
    m0.setPersonId(s0.getId());
    m0.setPhoneType(1);
    m0.setPhoneNumber("+14105551212");
    m0.setCreateDate(new Date());
    m0 = db.save(m0);
    db.commitTransaction();
} finally {
    db.endTransaction();
}

// Find the rows
Person s1 = db.loadUniqueByWhere(Person.class, "WHERE USERNAME='hansolo'");
Phone m1 = db.loadUniqueByWhere(Phone.class, "WHERE PHONE_NUMBER='+14105551212'");

// Delete the rows (auto-commit)
db.deleteByWhere(Phone.class, "WHERE PHONE_NUMBER='+14105551212'");
db.deleteByWhere(Person.class, "WHERE USERNAME='hansolo'");

Customizing:

The Velocity templates used by the code generator are in src/main/resources. If you add a new template, you must specify it in your properties file under mgrwriter.templates.perschema or mgrwriter.templates.pertable.

Dependencies:

Runtime dependencies for the generated code are sql2java-lib, slf4j for logging, and whatever JDBC driver you need for your database.

Feedback:

Please submit a pull request if you'd like to see something changed.

xgp / sql2java