Java: rendimiento del marco de persistencia JOOQ y retroalimentación

persistence sqlbuilder

Question

Me he stumbled con un bonito marco de trabajo de construcción de SQL, llamado JOOQ . Por cierto, en ruso, JOOQ suena como sustantivo que significa "insecto" (como insecto), "escarabajo";)

Si tiene algún comentario sobre JOOQ, su rendimiento y demás, por favor, comparta. Enlaces a blogs sobre JOOQ también son bienvenidos.

Answer 1

Creo que debería responder aquí también porque empecé a usar jooq hace un mes y medio, así que tengo algo de experiencia con eso.

Quería usar una herramienta como jooq porque:

• ORM es una exageración en mi proyecto actual (plataforma de cálculos distribuidos para clúster) ya que necesito leer y escribir solo campos separados de db, no completar filas de la tabla y algunas de mis consultas son lo suficientemente complejas como para no ser ejecutadas por ORM simples y ligeros.
• Quería autocompletar la sintaxis de mis consultas para no tener que tener en cuenta todo mi DB
• Quería poder escribir consultas directamente en Java para que el compilador pudiera verificar la sintaxis básica de las consultas en la compilación.
• Quería que mis consultas fueran de tipo seguro para que no pudiera pasar accidentalmente una variable de un tipo, donde se espera otra.
• Quería SQL, pero lo quería muy conveniente y fácil de usar

Bueno, con jooq pude lograr todo eso. Mi principal requisito era que jooq manejara consultas suficientemente complejas (anidadas, con agrupación, etc.). Eso se cumplió.

También quería poder ejecutar consultas utilizando la menor cantidad de líneas de código posible y pude alcanzar esto con la API jooq fluida que permite que las llamadas de tipo jquery realicen SELECT.

En mi camino usando jooq informé uno o dos errores y debo decir que se solucionaron sorprendentemente rápido.

También me perdí algunas características y, una vez más, debo decir que ya tengo casi todas.

Lo que me gustó mucho es que jooq ahora usa SLF4J para informar algunos datos muy interesantes sobre su rendimiento, así como para generar las consultas reales que ha creado. Realmente me ayudó con la depuración.

Jooq incluso genera artefactos de Java para procedimientos almacenados, UDF y conjuntos de registros actualizables, que no uso actualmente, sin embargo.

Lo que es importante, jooq es compatible de forma transparente con DB2, Derby, H2, HSQLDB, MySQL, Oracle, PostGreSQL, SQLite, SQL Server, Sybase SQL Anywhere. Lista bastante extensa, creo.

Jooq tiene un foro de soporte en grupos de Google donde Lukas está día y noche listo para responder incluso a las preguntas más estúpidas.

Jooq es compatible con Maven y eso es un gran alivio para mí, ya que todos mis proyectos de Java están basados ​​en Maven. Todavía extrañamos el complemento de Maven para el generador, pero eso no es importante ya que el funcionamiento del generador es muy sencillo.

Al escribir mis consultas con jooq, de repente descubrí que se volvieron realmente portátiles porque casi nunca usé ninguna característica específica de MySQL en el código, ya que jooq trata de ser lo más portátil posible. Para aquellos que no pueden vivir con tales peculiaridades, ya sé que el soporte para las extensiones SQL también está en camino.

¿Qué le falta a jooq por un momento desde mi punto de vista?

Bueno, no hay una API fluida para declaraciones que no sean SELECT. Esto complica un poco el código y hace que las sentencias UPDATE / DELETE sean un poco más complicadas de escribir. Pero creo que esto se añadirá pronto. Recién implementado en 1.5.9! ¡Decir ah! Demasiado rápido para mí;)

Y una cosa más. Jooq tiene un buen manual, pero ... No lo sé. Quizás no entiendo su estructura o arquitectura ... Cuando comencé a usar jooq por primera vez, abrí una página tras otra en busca de una característica que necesito. Por ejemplo, intente adivinar, en qué parte del manual de jooq UPDATE y DELETE se describen, mirando los contenidos ... Pero creo que eso es realmente subjetivo. Tampoco puedo explicar lo que está mal con el manual desde mi punto de vista. Cuando pueda, voy a publicar un boleto o dos;)

El manual tampoco es realmente navegable, ya que Trac no tiene enlaces automáticos como "aquí, allá y atrás".

Bueno, para mí en Moscú (Rusia), las páginas de Trac no se abren rápidamente, así que leer el manual es un poco aburrido.

Manual también pierde una buena descripción de la arquitectura de jooq para los colaboradores. Jooq sigue el principio de diseño por contrato que parece, y cuando quise saber cómo se implementa cierta característica en el interior utilizando mi Ctrl-Click habitual en algún nombre de método en IDE, terminé dentro de una interfaz aburrida sin implementación;) No es eso Soy demasiado inteligente para comenzar a mejorar jooq de inmediato, pero sin duda me encantaría entender cómo se diseña exactamente jooq de principio a fin.

Es una pena también que no podamos contribuir al manual de jooq. Esperaba que estuviera en algún tipo de wiki.

Lo que también me gustaría mejorar es la forma en que se informan las noticias . Preferiría un enlace al manual o ejemplos de cómo funciona esta o aquella nueva característica.

El enlace de las notas de la versión en el manual es solo una hoja de ruta. Creo que lo haré yo mismo mañana ...

Jooq también tiene una comunidad relativamente pequeña en la actualidad, pero me complace informar que no afecta la calidad del código ni la forma en que se presentan las nuevas funciones.

Jooq es realmente un buen proyecto. Me apegaré también a mis futuros proyectos. Me gusta mucho.

Answer 2

Si usted está buscando sólo una solución de generador de SQL. Tengo un proyecto que es un framework ORM para Java pero aún es prematuro y en desarrollo continuo, sin embargo, maneja muchos usos primitivos de bases de datos. https://github.com/ahmetalpbalkan/orman

No hay documentación en esta etapa; sin embargo, puede generar consultas seguras utilizando solo métodos de cadena Java y puede manejar muchas operaciones SQL. También puede asignar clases-campos a tablas-columnas respectivamente.

Aquí hay una operación de construcción de consulta de ejemplo para consulta

SELECT COUNT(*) FROM sailors WHERE
rating>4 AND rating<9 GROUP BY rating HAVING AVG(age)>20;

Código de Java:

 QueryBuilder qb = QueryBuilder.getBuilder(QueryType.SELECT);
System.out.println(qb
.from("sailors")
.where(
C.and(
C.gt("rating", 5),
C.lt("rating", 9)))
.groupBy("rating")
.having(
C.gt(
new OperationalField(QueryFieldOperation.AVG,
"age").toString(), 20)
).getQuery());

(LOL simplemente renunciar a desarrollar ese marco!)

Probablemente eso no funcionará para ti, pero solo quería anunciar mi proyecto: P

Answer 3

También puedes echarle un vistazo a MentaBean , un ORM ligero y SQL Builder que te permite estar lo más cerca posible de SQL ofreciendo mucha ayuda con el código de la plantilla. Aquí hay un ejemplo:

Configuración programática:

private BeanConfig getUserBeanConfig() {
// programmatic configuration for the bean... (no annotation or XML)
BeanConfig config = new BeanConfig(User.class, "Users");
config.pk("id", DBTypes.AUTOINCREMENT);
config.field("username", DBTypes.STRING);
config.field("birthdate", "bd", DBTypes.DATE); // note that the database column name is different
config.field("status", new EnumValueType(User.Status.class));
config.field("deleted", DBTypes.BOOLEANINT);
config.field("insertTime", "insert_time", DBTypes.TIMESTAMP).defaultToNow("insertTime");
return config;
}
// create table Users(id integer primary key auto_increment,
// username varchar(25), bd datetime, status varchar(20),
// deleted tinyint, insert_time timestamp)

Una simple consulta de unión SQL:

Post p = new Post(1);
StringBuilder query = new StringBuilder(256);
query.append("select ");
query.append(session.buildSelect(Post.class, "p"));
query.append(", ");
query.append(session.buildSelect(User.class, "u"));
query.append(" from Posts p join Users u on p.user_id = u.id");
query.append(" where p.id = ?");
stmt = conn.prepareStatement(query.toString());
stmt.setInt(1, p.getId());
rset = stmt.executeQuery();
if (rset.next()) {
session.populateBean(rset, p, "p");
u = new User();
session.populateBean(rset, u, "u");
p.setUser(u);
}