Query API

How each ORM lets you build and run database queries.

Active Record (Ruby on Rails)

A fluent, chainable query interface directly on the model class (User.where(active: true).order(:name)), reading close to natural Ruby.

Eloquent (Laravel)

A fluent, chainable query builder on the model class (User::where('active', true)->orderBy('name')->get()), closely mirroring Active Record’s style in PHP.

Django ORM

A chainable QuerySet API accessed through a model’s manager (User.objects.filter(active=True).order_by('name')), lazily evaluated until the data is actually needed.

Prisma

A generated, fully-typed client with methods like prisma.user.findMany({ where: { active: true } }), using structured objects rather than method chaining for filters.

Drizzle

A SQL-like, chainable query builder (db.select().from(users).where(eq(users.active, true))) designed so the code’s shape closely mirrors the SQL it produces.

TypeORM

Supports both a repository-based query API (userRepository.find({ where: { active: true } })) and a lower-level QueryBuilder for more complex, hand-tuned queries.

Sequelize

A method-based query API (User.findAll({ where: { active: true } })) using plain option objects for filters, ordering, and includes.

SQLAlchemy

Offers both a high-level ORM query API and a lower-level Core expression language for building SQL directly, giving a deliberate choice between abstraction and raw control.

Entity Framework Core

Uses LINQ, C#’s built-in query syntax, so queries are written as ordinary, statically-checked C# expressions (users.Where(u => u.Active).OrderBy(u => u.Name)).

Hibernate (JPA)

Supports JPQL (an SQL-like object query language), the Criteria API for programmatic query building, and native SQL when needed.

GORM

A method-chaining API similar in spirit to Active Record (db.Where("active = ?", true).Order("name").Find(&users)), while still requiring explicit struct destinations for results.

Diesel

A strongly-typed query builder where the Rust compiler verifies at compile time that your query’s types match your schema, catching many mistakes before the code ever runs.