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

Question

Tengo stumbled en un buen marco de trabajo del generador de SQL, llamado JOOQ. Por cierto, en ruso JOOQ suena como sustantivo que significa "error" (como un insecto), "escarabajo";)

Si tiene algún comentario sobre JOOQ, es el rendimiento y tal, por favor, comparta. Los enlaces a blogs sobre JOOQ también son bienvenidos.

Answer 1

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

yo quería herramienta a utilizar como jooq porque:

• ORM es una exageración en mi proyecto actual (plataforma cálculos distribuidos para clúster) ya que necesito para leer y escribir sólo los campos separados de db, no tabla completa las filas y algunas de mis consultas son lo suficientemente complejas como para no ser ejecutadas por ORM simples y livianas.
• Quería que la sintaxis se completara automáticamente para que no tuviera que tener todo mi DB en mente
• Quería poder escribir consultas directamente en Java para que el compilador pudiera verificar la sintaxis básica de la consulta en la compilación.
• Quería que mis consultas tuvieran seguridad de tipo para que no pudiera pasar accidentalmente una variable de un tipo, donde se esperaba otra.
• yo quería SQL, pero quería que sea muy conveniente y fácil de usar

Bueno, con jooq yo era capaz de lograr todo eso. Mi requisito principal era que jooq manejara consultas suficientemente complejas (anidadas, con agrupamiento, etc.). Eso fue cumplido.

También quería poder ejecutar consultas utilizando el menor número posible de líneas de código y pude lograr esto con una API fluida jooq que permite a las llamadas similares a jquery realizar SELECT.

En mi camino usando de jooq informé de one or two bugs y debo decir que se arreglaron sorprendentemente rápido.

Yo también missed some features y nuevamente debo decir que ya tengo casi todos.

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

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

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

Jooq tiene support forum in Google groups donde Lukas está listo día y noche para responder hasta la más estúpida de mis preguntas.

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

Escribiendo 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 intenta ser lo más portátil posible. Para aquellos que no pueden vivir con tales peculiaridades, como sé, el soporte para extensiones de 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 sentencias que no sean SELECCIONAR. Esto complica un poco el código y hace que las instrucciones UPDATE/DELETE sean un poco más complicadas de escribir. Pero creo que esto se agregará pronto. ¡Acaba de implementarse en 1.5.9! ¡Decir ah! Demasiado rápido para mí;)

Y una cosa más. Jooq tiene un buen manual, pero ... no sé. Puede ser que simplemente no entiendo su estructura o arquitectura ... Cuando comencé a usar jooq por primera vez, abrí una página tras otra buscando una característica que necesitaba. Por ejemplo, intente adivinar, donde en jooq manual se describen las instrucciones UPDATE y DELETE, mirando los contenidos ... Pero eso es realmente subjetivo, creo. Tampoco puedo explicar, qué pasa con el manual desde mi punto de vista. Cuando puedo, voy a publicar un ticket o dos;)

Manual tampoco es realmente bien navegable ya que Trac no tiene enlaces automáticos "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 echa de menos una buena descripción de la arquitectura de jooq para los contribuyentes. Jooq sigue el principio de diseño por contrato y cuando quise saber cómo se implementaba cierta función en el interior al usar mi Ctrl-Click habitual en algún nombre de método en IDE, terminé dentro de una interfaz aburrida sin implementación;) No es que Soy demasiado listo para comenzar a mejorar jooq de inmediato, pero sin duda me encantaría entender cómo exactamente se construye jooq desde cero hasta arriba.

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 the waynews are reported. Preferiría un enlace al manual allí o ejemplos de cómo funciona esta o aquella nueva función.

Release notes link in manual es en realidad una hoja de ruta. Creo que lo haré yo mismo mañana ...

Jooq también tiene una comunidad relativamente pequeña actualmente, pero me complace informar que no afecta la calidad del código o la forma en que se introducen las nuevas características.

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

Answer 2

Si solo está buscando una solución de generador de SQL. Tengo un proyecto que es un marco ORM para Java, pero aún es prematuro y en desarrollo continuo 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 la 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 la consulta

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

código 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 dan por vencidos desarrollar ese marco)

Lo más probable es que no va a funcionar para usted pero solo quería anunciar mi proyecto: P

Answer 3

También puede tomar una mira en MentaBean, un ligero ORM y SQL Builder que te permite estar lo más cerca posible de SQL y ofrece mucha ayuda con el código repetitivo. He aquí 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); 
}