THIS IS A TEST INSTANCE. ALL YOUR CHANGES WILL BE LOST!!!!
JinQ (Java/Scala)
Jinq provides developers an easy and natural way to write database queries in Java and Scala. You can treat database data like normal Java objects stored in collections. You can iterate over them and filter them using normal Java commands, and all your code will be automatically translated into optimized database queries. Finally, LINQ-style queries are available for Java!
JaQu
JaQu stands for Java Query and allows to access databases using pure Java. JaQu provides a fluent interface (or internal DSL) for building SQL statements. JaQu replaces SQL, JDBC, and persistence frameworks such as Hibernate. JaQu is something like LINQ for Java (LINQ stands for "language integrated query" and is a Microsoft .NET technology).
http://www.h2database.com/html/jaqu.html
They also have a nice list of similar projects on their website.
iciql (JaQu fork)
iciql is...
a model-based, database access wrapper for JDBC
for modest database schemas and basic statement generation
for those who want to write code, instead of SQL, using IDE completion and compile-time type-safety
small (125KB) with no runtime dependencies
pronounced icicle (although it could be French: ici ql - here query language)
a friendly fork of the H2 JaQu project
iciql is not...
a complete alternative to JDBC
designed to compete with more powerful database query tools like jOOQ or Querydsl
designed to compete with enterprise ORM tools like Hibernate or mybatis
Querydsl
Querydsl (spell: query diesel) is a framework which enables the construction of statically typed SQL-like queries. Instead of writing queries as inline strings or externalizing them into XML files they can be constructed via a fluentDSL/API like Querydsl.
http://source.mysema.com/display/querydsl/Querydsl
jlibs DAOPattern
J2EE DAO Pattern made easier
http://code.google.com/p/jlibs/wiki/DAOPattern
jOOQ
A simple and intuitive approach to interface your database with Java. The jOOQ acronym stands for “JOOQ Object Oriented Querying”. jOOQ brings the relational world to Java without covering up its origins. jOOQ is relational. And object oriented. Just in a different way.
Torpedoquery
Finally you can now use your real classes to construct queries and use the power of your IDE to maintain and validate your queries.
Squeryl (Scala)
A Scala ORM and DSL for talking with Databases with minimum verbosity and maximum type safety http://squeryl.org/
JDBI
JDBI is a SQL convenience library for Java. It attempts to expose relational database access in idiommatic Java, using collections, beans, and so on, while maintaining the same level of detail as JDBC. It exposes two different style APIs, a fluent style and a sql object style.
Slick (Scala)
Slick is a modern database query and access library for Scala. It allows you to work with stored data almost as if you were using Scala collections while at the same time giving you full control over when a database access happens and which data is transferred. You can write your database queries in Scala instead of SQL, thus profiting from the static checking, compile-time safety and compositionality of Scala. Slick features an extensible query compiler which can generate code for different backends.
It includes the following features:
- Lifted query embedding (fully featured, composable, uses lifted types, evolved from ScalaQuery)
- Direct query embedding (experimental, limited features, uses ordinary Scala types, based on macros)
- Simple execution of raw SQL queries
- Session management based on JDBC Connections
ScalikeJDBC (Scala)
ScalikeJDBC is A tidy SQL-based DB access library for Scala developers. This library naturally wraps JDBC APIs and provides you easy-to-use APIs.
https://github.com/seratch/scalikejdbc
Discontinued
jPersist
jPersist is an extremely powerful object-relational persistence API that is based on the active-record and data-mapper patterns.
eodsql
EoD SQL Allows for fast, simple binding between a Relation Database Query and Java objects.
EoD SQL stands for Ease of Development, the API's key concerns are being:
Lightweight Designed to be small with a low memory footprint
Very Fast By re-using all of it's data as much as possible.
Easy to work with Annotation based, no setup, config or XML files.
Powerful Write your own SQL rather than hope it generates what you want.
Stable