tessl/maven-org-jooq--jooq

jOOQ is an internal DSL and source code generator, modelling the SQL language as a type safe Java API to help you write better SQL

—

Pending

Overview

Eval results

Files

Query Execution and Contexts

Name: tessl/maven-org-jooq--jooq
Author: tessl

Core functionality for creating database contexts, executing queries, and managing connections. The DSLContext serves as the primary entry point for all database operations with support for both JDBC and R2DBC.

Capabilities

DSL Factory Methods

Static factory methods in the DSL class for creating DSLContext instances with various connection types and configurations.

/**
 * Create a DSLContext for a specific SQL dialect without connection
 * @param dialect The SQL dialect to use
 * @return DSLContext instance for query building without execution
 */
public static DSLContext using(SQLDialect dialect);

/**
 * Create a DSLContext with custom settings
 * @param dialect The SQL dialect to use
 * @param settings Configuration settings
 * @return DSLContext instance with custom configuration
 */
public static DSLContext using(SQLDialect dialect, Settings settings);

/**
 * Create a closeable DSLContext from URL string
 * @param url JDBC connection URL
 * @return CloseableDSLContext that manages its own connection
 */
public static CloseableDSLContext using(String url);

/**
 * Create a closeable DSLContext with credentials
 * @param url JDBC connection URL
 * @param username Database username
 * @param password Database password
 * @return CloseableDSLContext that manages its own connection
 */
public static CloseableDSLContext using(String url, String username, String password);

/**
 * Create a closeable DSLContext with Properties
 * @param url JDBC connection URL
 * @param properties Connection properties
 * @return CloseableDSLContext that manages its own connection
 */
public static CloseableDSLContext using(String url, Properties properties);

/**
 * Create a DSLContext from existing JDBC connection
 * @param connection JDBC connection (dialect auto-detected)
 * @return DSLContext using the provided connection
 */
public static DSLContext using(Connection connection);

/**
 * Create a DSLContext from JDBC connection with specific dialect
 * @param connection JDBC connection
 * @param dialect SQL dialect to use
 * @return DSLContext using the provided connection and dialect
 */
public static DSLContext using(Connection connection, SQLDialect dialect);

/**
 * Create a DSLContext from JDBC connection with settings
 * @param connection JDBC connection
 * @param settings Configuration settings
 * @return DSLContext using the provided connection and settings
 */
public static DSLContext using(Connection connection, Settings settings);

/**
 * Create a DSLContext from JDBC connection with dialect and settings
 * @param connection JDBC connection
 * @param dialect SQL dialect to use
 * @param settings Configuration settings
 * @return DSLContext using the provided connection, dialect and settings
 */
public static DSLContext using(Connection connection, SQLDialect dialect, Settings settings);

/**
 * Create a DSLContext from DataSource
 * @param datasource JDBC DataSource
 * @param dialect SQL dialect to use
 * @return DSLContext using the provided DataSource
 */
public static DSLContext using(DataSource datasource, SQLDialect dialect);

/**
 * Create a DSLContext from DataSource with settings
 * @param datasource JDBC DataSource
 * @param dialect SQL dialect to use
 * @param settings Configuration settings
 * @return DSLContext using the provided DataSource, dialect and settings
 */
public static DSLContext using(DataSource datasource, SQLDialect dialect, Settings settings);

/**
 * Create a DSLContext from ConnectionProvider
 * @param connectionProvider Custom connection provider
 * @param dialect SQL dialect to use
 * @return DSLContext using the provided ConnectionProvider
 */
public static DSLContext using(ConnectionProvider connectionProvider, SQLDialect dialect);

/**
 * Create a DSLContext from ConnectionProvider with settings
 * @param connectionProvider Custom connection provider
 * @param dialect SQL dialect to use
 * @param settings Configuration settings
 * @return DSLContext using the provided ConnectionProvider, dialect and settings
 */
public static DSLContext using(ConnectionProvider connectionProvider, SQLDialect dialect, Settings settings);

/**
 * Create a DSLContext from R2DBC ConnectionFactory
 * @param connectionFactory R2DBC ConnectionFactory for reactive access
 * @return DSLContext for reactive database operations
 */
public static DSLContext using(ConnectionFactory connectionFactory);

/**
 * Create a DSLContext from R2DBC ConnectionFactory with dialect
 * @param connectionFactory R2DBC ConnectionFactory for reactive access
 * @param dialect SQL dialect to use
 * @return DSLContext for reactive database operations
 */
public static DSLContext using(ConnectionFactory connectionFactory, SQLDialect dialect);

/**
 * Create a DSLContext from R2DBC ConnectionFactory with dialect and settings
 * @param connectionFactory R2DBC ConnectionFactory for reactive access
 * @param dialect SQL dialect to use
 * @param settings Configuration settings
 * @return DSLContext for reactive database operations
 */
public static DSLContext using(ConnectionFactory connectionFactory, SQLDialect dialect, Settings settings);

/**
 * Create a DSLContext from R2DBC Connection
 * @param connection R2DBC Connection for reactive access
 * @return DSLContext for reactive database operations
 */
public static DSLContext using(io.r2dbc.spi.Connection connection);

/**
 * Create a DSLContext from R2DBC Connection with dialect
 * @param connection R2DBC Connection for reactive access
 * @param dialect SQL dialect to use
 * @return DSLContext for reactive database operations
 */
public static DSLContext using(io.r2dbc.spi.Connection connection, SQLDialect dialect);

/**
 * Create a DSLContext from R2DBC Connection with dialect and settings
 * @param connection R2DBC Connection for reactive access
 * @param dialect SQL dialect to use
 * @param settings Configuration settings
 * @return DSLContext for reactive database operations
 */
public static DSLContext using(io.r2dbc.spi.Connection connection, SQLDialect dialect, Settings settings);

/**
 * Create a DSLContext from Configuration
 * @param configuration Complete jOOQ configuration
 * @return DSLContext using the provided configuration
 */
public static DSLContext using(Configuration configuration);

Usage Examples:

import static org.jooq.impl.DSL.*;
import org.jooq.*;
import java.sql.*;

// Simple dialect-only context for query building
DSLContext create = using(SQLDialect.POSTGRES);
String sql = create.select().from("users").getSQL();

// JDBC connection with auto-detected dialect
Connection conn = DriverManager.getConnection("jdbc:h2:mem:test");
DSLContext create = using(conn);

// Managed connection from URL
try (CloseableDSLContext create = using("jdbc:h2:mem:test", "sa", "")) {
    Result<Record> result = create.select().from("users").fetch();
}

// DataSource with specific dialect
DataSource ds = new HikariDataSource();
DSLContext create = using(ds, SQLDialect.MYSQL);

DSLContext Interface

Primary interface for executing queries and accessing database functionality.

public interface DSLContext extends Scope {
    /**
     * Access the SQL parser API for parsing SQL strings
     * @return Parser instance for this context
     */
    Parser parser();
    
    /**
     * Get a JDBC connection that parses SQL through jOOQ first
     * @return Connection wrapper with jOOQ parsing
     */
    Connection parsingConnection();
    
    /**
     * Access database metadata information
     * @return Meta instance for schema introspection
     */
    Meta meta();
    
    /**
     * Execute a query and return affected row count
     * @param query Query to execute
     * @return Number of affected rows
     */
    int execute(Query query);
    
    /**
     * Fetch all records from a table
     * @param table Table to fetch from
     * @return Result containing all records
     */
    <R extends Record> Result<R> fetch(Table<R> table);
    
    /**
     * Fetch records matching a condition
     * @param table Table to fetch from
     * @param condition WHERE condition
     * @return Result containing matching records
     */
    <R extends Record> Result<R> fetch(Table<R> table, Condition condition);
    
    /**
     * Execute code within a transaction, returning a result
     * @param transactional Code to execute in transaction
     * @return Result from the transactional code
     */
    <T> T transactionResult(ContextTransactionalCallable<T> transactional);
    
    /**
     * Execute code within a transaction
     * @param transactional Code to execute in transaction
     */
    void transaction(ContextTransactionalRunnable transactional);
}

Query Interface

Base interface for all executable SQL statements.

public interface Query extends QueryPart, Attachable {
    /**
     * Execute the query synchronously
     * @return Number of affected rows
     */
    int execute();
    
    /**
     * Execute the query asynchronously
     * @return CompletionStage with number of affected rows
     */
    CompletionStage<Integer> executeAsync();
    
    /**
     * Bind a named parameter to a value
     * @param param Parameter name
     * @param value Parameter value
     * @return Query with bound parameter
     */
    Query bind(String param, Object value);
    
    /**
     * Set query timeout in seconds
     * @param seconds Timeout in seconds
     * @return Query with timeout set
     */
    Query queryTimeout(int seconds);
    
    /**
     * Check if query can be executed
     * @return true if query is executable
     */
    boolean isExecutable();
    
    /**
     * Get the SQL string for this query
     * @return SQL string representation
     */
    String getSQL();
    
    /**
     * Get the SQL string with parameter placeholders
     * @param paramType Parameter placeholder type
     * @return SQL string with specified parameter format
     */
    String getSQL(ParamType paramType);
}

Connection Management

Interfaces for managing database connections and connection pooling.

public interface ConnectionProvider {
    /**
     * Acquire a connection from the provider
     * @return JDBC Connection
     */
    Connection acquire() throws DataAccessException;
    
    /**
     * Release a connection back to the provider
     * @param connection Connection to release
     */
    void release(Connection connection) throws DataAccessException;
}

public interface CloseableDSLContext extends DSLContext, AutoCloseable {
    /**
     * Close the context and release any managed resources
     */
    void close() throws DataAccessException;
}

Usage Examples:

// Transaction with result
Integer bookCount = create.transactionResult(configuration -> {
    DSLContext txCreate = using(configuration);
    
    // Insert author
    AuthorRecord author = txCreate.newRecord(AUTHOR);
    author.setFirstName("John");
    author.setLastName("Doe");
    author.store();
    
    // Insert books
    return txCreate.insertInto(BOOK)
        .set(BOOK.TITLE, "My Book")
        .set(BOOK.AUTHOR_ID, author.getId())
        .execute();
});

// Async execution
CompletionStage<Integer> future = create
    .insertInto(USER)
    .set(USER.NAME, "Alice")
    .executeAsync();

// Parameter binding
Query query = create.query("INSERT INTO users (name, age) VALUES (?, ?)")
    .bind(1, "Bob")
    .bind(2, 25);
int rows = query.execute();

Install with Tessl CLI