awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
querydsl avatar

querydsl/querydsl

0
View on GitHub↗
4,964 stars·878 forks·Java·Apache-2.0·47 viewsquerydsl.com↗

Querydsl

Querydsl is a framework for the construction of type-safe queries. It uses a fluent API and annotation-based code generation to create mirror classes from domain models, enabling compile-time validation of database queries and removing the need for manual string concatenation.

The project provides a unified query syntax that translates into specific dialects for multiple backends, including SQL, MongoDB, Lucene, and JDO. It supports advanced query capabilities such as common table expressions, window functions, geospatial operations, and complex nested subqueries.

Beyond data retrieval, the framework covers type-safe DML execution for bulk updates and deletions, as well as result mapping into Java Beans, constructors, or tuples. It includes support for in-memory collection querying and integrates with the Spring Framework for transaction management and connection handling.

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.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • 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.

    • Star history

    Star history chart for querydsl/querydslStar history chart for querydsl/querydsl

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does querydsl/querydsl do?

    Querydsl is a framework for the construction of type-safe queries. It uses a fluent API and annotation-based code generation to create mirror classes from domain models, enabling compile-time validation of database queries and removing the need for manual string concatenation.

    What are the main features of querydsl/querydsl?

    The main features of querydsl/querydsl are: Fluent Query Construction, Type-Safe Query Construction, Fluent Query APIs, Filter Expression Builders, Dialect Translation, Multi-Backend Query Generators, Relational Mappings, Dialect Transformers.

    Which projects share features with querydsl/querydsl?

    Projects with overlapping indexed features include: jooq/jooq — jOOQ is a type-safe SQL query builder for Java that generates code from live database schemas, enabling compile-time… uptrace/bun — Bun is a type-safe object relational mapper for Go that prioritizes SQL-first query construction and result mapping.… mybatis-flex/mybatis-flex — MyBatis-Flex is an object-relational mapping framework for Java that extends MyBatis with a fluent API and automated… stephenafamo/bob — This project is a database toolkit for Go that provides schema-to-object mapping, fluent query construction, and… go-pg/pg — pg is a PostgreSQL object-relational mapper (ORM) for Go that maps Go structs to database tables and provides a fluent… prestodb/presto — Presto is a distributed SQL query engine designed for high-performance analytical processing across heterogeneous data…

    Projects sharing features with Querydsl

    These projects share indexed features with Querydsl. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • jooq/jooqjOOQ avatar

      jOOQ/jOOQ

      6,666View on GitHub↗

      jOOQ is a type-safe SQL query builder for Java that generates code from live database schemas, enabling compile-time validation of SQL syntax and data types. Its core identity is built around a fluent DSL that mirrors SQL structure, a code generator that maps tables, views, and routines to Java objects, and a multi-dialect engine that translates the same DSL into vendor-specific SQL for over 30 databases. The project also includes a SQL parser and transformer for refactoring or dialect conversion, reactive stream integration for non-blocking query execution, and a JDBC proxy diagnostics tool f

      Javacode-generatordatabasedb2
      View on GitHub↗6,666
    • uptrace/bunuptrace avatar

      uptrace/bun

      4,867View on GitHub↗

      Bun is a type-safe object relational mapper for Go that prioritizes SQL-first query construction and result mapping. It functions as a programmable SQL query builder, a database connection manager, and a tool for mapping database tables to Go structs. The project distinguishes itself through a multi-dialect SQL support system, allowing a single codebase to interact with different database engines via a consistent interface. It includes a built-in database observability tool for query interception, distributed tracing, and logging, as well as a schema migration tool for versioning structural c

      Godatabasegogolang
      View on GitHub↗4,867
    • mybatis-flex/mybatis-flexmybatis-flex avatar

      mybatis-flex/mybatis-flex

      2,554View on GitHub↗

      MyBatis-Flex is an object-relational mapping framework for Java that extends MyBatis with a fluent API and automated CRUD operations. It provides a data access suite featuring an automatic CRUD data mapper, a type-safe SQL query builder, and a row-based query engine for manipulating records without predefined entity classes. The framework includes a multi-dialect SQL translator that converts generated syntax across different database engines, such as MySQL, PostgreSQL, and Oracle. It further distinguishes itself by offering annotation-free entity mapping using runtime reflection and naming co

      Javajavamybatismysql
      View on GitHub↗2,554
    • stephenafamo/bobstephenafamo avatar

      stephenafamo/bob

      1,739View on GitHub↗

      This project is a database toolkit for Go that provides schema-to-object mapping, fluent query construction, and automated code generation. It functions as a framework for type-safe database access, enabling developers to interact with relational databases by generating models and interfaces directly from existing database schemas. The toolkit distinguishes itself through a workflow that parses hand-written SQL files to generate type-safe functions, allowing for the integration of custom SQL while maintaining consistent result mapping. It supports modular customization through a plugin-based

      Godatabasegolanghacktoberfest
      View on GitHub↗1,739
    Compare all 30 related projects→