jOOQ/jOOQ

Features

• Schema-to-Code Generators - Generates type-safe Java classes from live database schemas, mapping tables, views, and routines to compile-time objects.
• SQL Query Builders - Assembles SQL statements programmatically from independent expression objects to compose queries at runtime.
• CRUD Operations - Maps database rows to generated active records for direct create, read, update, and delete operations.
• Updatable Records - Provides UpdatableRecord objects that automatically generate UPDATE statements when modified and stored back to the database.
• Dynamic SQL Generators - Assembles SQL statements programmatically from independent expression objects to compose queries at runtime with type safety.
• SQL Syntax Tree Construction - Constructs SQL statements using a Java DSL that mirrors SQL syntax and enforces correct query structure at compile time.
• SQL Dialect Adapters - Translates the same DSL into vendor-specific SQL for over 30 database dialects automatically.
• Type-Safe - Validates SQL syntax and data types at compile time through a fluent Java API that mirrors SQL structure.
• Type-Safe Client Generators - Generates type-safe Java classes from live database schemas, mapping tables, views, and routines to compile-time objects.
• Stored Procedure Method Generations - Call database functions and procedures with full type safety, including support for packages and procedural logic.
• DDL and DML Executions - Runs DDL and DML statements through a type-safe API that validates schema operations at compile time.
• DDL Executions - Executes CREATE, ALTER, and DROP operations through a type-safe API abstracting dialect differences.
• Type-Safe Query Builders - Construct SQL queries with a fluent Java API that validates syntax and data types at compile time to prevent runtime errors.
• Schema-Driven Code Generators - Produces type-safe Java classes from existing database schemas for compile-time checking of table and column references.
• Active Record Patterns - Provides generated active records that directly map database rows to Java objects for CRUD operations.
• SQL Query Validators - Rejects malformed query chains like missing ON clauses or mismatched subselect degrees during compilation.
• Custom Type Converters - Attaches user-defined converters to generated column fields for automatic transformation between database and domain types.
• Expression-Level Type Converters - Attaches custom data type converters to individual column expressions or plain SQL templates for type-safe querying.
• DTO Mappings - Maps database records to plain Java objects using constructor references and ad-hoc conversions.
• Database Type Mappings - Maps between built-in database types and custom Java types using two-way converters for domain types in SQL expressions.
• Implicit Join Resolvers - Automatically generates JOIN clauses from foreign key relationships in generated table classes.
• Dot-Notation Join Paths - Ships implicit join resolution via dot-notation path expressions on generated table classes.
• Placeholder-Based SQL Templates - Constructs SQL fragments by embedding numbered placeholders replaced with type-safe query parts at runtime.
• MULTISET Nested Collection Fetching - Uses the MULTISET operator to retrieve hierarchical data structures with nested lists in a single round trip.
• Query Condition Builders - Combines optional conditions at runtime with logical operators to filter query results based on application state.
• R2DBC Streams - Runs queries non-blocking on R2DBC connections for reactive stream pipelines.
• R2DBC Query Executors - Executes queries as non-blocking Publishers on R2DBC connections for reactive stream pipelines.
• Dialect Transformers - Rewrites SQL constructs between dialects, converting vendor-specific syntax into standard equivalents.
• SQL Construct Emulations - Automatically rewrites SQL constructs like INSERT..RETURNING for databases that lack native support, using generated metadata about keys and identities.
• Pre-Emulation Transformations - Provides pre-rendering query model transformations for dialect compatibility.
• SQL Parsers - Parses SQL strings into an editable model and applies pattern-based transformations for refactoring or dialect conversion.
• IDE Auto-Completion Providers - Provides a BNF-based interface hierarchy that enables IDE auto-completion for valid SQL clauses and operators.
• SQL Query Object Models - Parses SQL into an editable model and applies pattern-based transformations for refactoring or dialect conversion.
• JDBC Proxy Diagnostics - Detects inefficient SQL patterns like duplicate statements, unnecessary columns, and excessive row fetching through JDBC monitoring.
• JDBC Proxy Profilers - Detects inefficient queries, duplicate statements, and unnecessary column projections by proxying JDBC connections.
• SQL Statement Parsing - Parses SQL strings into a type-safe query object model for programmatic inspection and transformation.
• Transformations - Provides SQL parsing and transformation capabilities for refactoring and dialect conversion.
• Embedded Calls - Embeds stored procedure calls directly inside type-safe query statements for seamless integration.
• Scala Query DSLs - Provides Scala-specific implicit conversions and traits for writing type-safe SQL queries without boilerplate.
• Foreign Key Path Navigators - Accesses parent table columns from child tables using dot-notation path expressions with automatic JOIN generation.
• SQL Query Extensions - Provides Kotlin-specific extensions for writing type-safe SQL queries with idiomatic Kotlin syntax.
• SQL Anti-pattern Analyzers - Detects problems like fetching too many rows, duplicate statements, or unused columns by proxying JDBC connections and analyzing SQL patterns.
• R2DBC Query Executors - Executes queries as a Publisher for non-blocking consumption in reactive stream pipelines.
• JDBC Diagnostics Proxies - Provides a JDBC proxy that detects inefficient SQL patterns like duplicate statements and unnecessary columns.
• Reactive Data Streams - Executes queries as a Publisher for non-blocking consumption in reactive stream pipelines.
• JDBC Interaction Monitors - Intercepts JDBC calls through a proxy connection to collect diagnostics on API-level, JDBC-level, and SQL-level issues.
• JDBC Proxy Diagnostics - Wraps a real database connection with a diagnostics layer that inspects SQL and JDBC calls without requiring jOOQ API usage.
• Database Interaction Mocking - Provides a mock JDBC connection with a custom data provider for unit testing without a real database.
• DAO Persistence Generators - Generates DAO classes that insert, update, delete, and retrieve POJOs for single-primary-key tables.
• Operator-Based Query DSLs - Overloads standard Scala operators on field types so queries read like native Scala expressions.
• Object Relational Mapping - Type-safe SQL query construction and database integration.
• SQL Parsers - Translates SQL dialects and performs expression tree transformations.

Star 历史