querydsl/querydsl

Features

• Fluent Query Construction - Provides a method-chaining fluent API to build complex logical expressions and projections without manual string concatenation.
• Type-Safe Query Construction - Provides a fluent API for constructing database queries with compile-time type safety and IDE autocompletion.
• Fluent Query APIs - Uses a fluent API to ensure compile-time validation of database queries and eliminate manual string concatenation.
• Filter Expression Builders - Provides programmatic builders for constructing complex boolean expressions and data filters at runtime.
• Dialect Translation - Translates a unified internal query syntax into specific dialects for backends including SQL, MongoDB, Lucene, and JDO.
• Multi-Backend Query Generators - Translates a unified query syntax into specific dialects for SQL, MongoDB, and Lucene backends.
• Relational Mappings - Transforms raw database result sets into type-safe Java Beans or DTOs.
• Dialect Transformers - Converts a unified internal query representation into the specific syntax required by different database engines.
• Type-Safe Client Generators - Mirrors a database schema into generated classes to enable query construction via a fluent API.
• DDL and DML Executions - Performs type-safe DML operations including insert, update, and delete with compile-time schema validation.
• Domain Model Mirror Generators - Generates type-safe mirror classes from domain models to enable compile-time validation of database queries.
• Logical Predicate Composition - Builds complex data filters by cascading boolean expressions and logical operators into a single executable predicate.
• Bean Result Mapping - Populates Java Beans using setters or direct field access based on query result columns.
• Constructor Result Mapping - Transforms query rows into objects by passing result columns into a specified class constructor.
• Type-Safe Query Object Generators - Creates type-safe query objects using persisted domain models, annotations, or configuration files.
• Query Field Projections - Restricts the fields returned by a database query to minimize data transfer and improve performance.
• Common Table Expressions - Supports creating reusable temporary result sets using the WITH clause to simplify complex query structures.
• Constructor Result Projections - Transforms raw database rows into strongly typed Java objects by mapping columns to class constructors.
• Batch Insert, Update, or Delete Operations - Bundles multiple consecutive insert, update, or delete operations into a single database round trip.
• JavaBean DTO Generators - Creates JavaBean classes based on database tables to simplify data transfer and the population of data clauses.
• Multi-Source Queries - Executes select queries with support for filtering across multiple data sources, subqueries, and various join types.
• Data Type Mappings - Defines specific type mappings for database columns or numeric precisions to control data I/O.
• Dynamic Query Generation - Provides programmatic generation of query logic and filters that adapt based on runtime criteria.
• Dynamic Predicate Composers - Builds and combines boolean expression predicates dynamically using logical operators to create complex data filters.
• Geospatial Query Engines - Executes geospatial operations including proximity searches and geometric calculations using a standardized object model.
• Dynamic Expression Definition - Enables creating query paths, constants, and operations programmatically when static type-safe classes are unavailable.
• In-Memory Result Aggregation - Groups query results into maps or collections to handle parent-child relations and multi-column aggregations.
• In-Memory State Querying - Enables filtering and projecting data from in-memory collections using a type-safe fluent API.
• Proximity Queries - Implements geospatial query methods to locate documents based on proximity to specific coordinates.
• Conditional Expressions - Implements conditional logic like CASE statements within database queries using when-then-else structures.
• Record Deletion - Implements methods for removing database rows based on conditional criteria through a fluent interface.
• Search Query Construction - Constructs searchable Lucene queries using a fluent API for range, prefix, and fuzzy matching.
• Dialect-Specific SQL Generation - Allows customizing SQL serialization for specific database engines by subclassing the query implementation.
• Subquery Execution - Nests queries within other queries to filter results based on aggregated or related data sets.
• Subquery Support - Provides capabilities for embedding secondary queries within primary operations for nested data lookups.
• Type-Safe Query Builders - Offers a type-safe query builder for MongoDB document databases to retrieve data based on specific criteria.
• Scala Query DSLs - Provides a domain language for Scala that leverages operator overloading for concise, type-safe query syntax.
• Bulk Update Utilities - Provides utilities for performing batch modifications on database records using type-safe set and where clauses.
• Window Functions - Implements SQL window functions to calculate values over a specific set of table rows using partitioning and ordering.
• Tuple Return Types - Returns multiple columns from a query as a type-safe tuple for structured data access.
• Classpath Component Scanners - Scans the project classpath for annotated classes to automatically identify entities for query type generation.
• Spatial Queries - Performs geometric operations like distance filtering and containment checks using a standardized object model.
• Meta-Model Path Mappings - Maps object property paths to database columns using generated metadata classes that represent the schema.
• Object Relational Mapping - Framework for building type-safe queries across multiple backends.

Istoric stele