The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Laravel queries are built as structured PHP objects, then compiled for a database connection and executed with bound values. Query Builder exposes that process directly; Eloquent layers model behavior on top. The distinction matters when you need to understand generated SQL, keep user input safe, or know whether a bulk update will trigger model events.
What happens when you build a Laravel query?
Laravel provides three common levels for database work: raw SQL, the fluent Query Builder, and Eloquent. With Query Builder, a call such as DB::table('orders') starts a query for a table. Further calls describe operations such as selecting columns, joining tables, filtering rows, grouping, ordering, and limiting results. The builder is a way to construct and run queries; it is not itself the database.
As an Amazon Associate I earn from qualifying purchases.
Conceptually, the lifecycle is:
- Choose a starting point. Use
DB::table(...)for Query Builder, or begin with an Eloquent model or model query. - Describe the operation. Chain methods to express the query’s clauses and values.
- Compile and execute. Laravel’s database grammar represents the query for the relevant driver, while the connection handles execution. Exact SQL can vary by database driver and query.
- Receive results or an execution outcome. Query Builder returns database-oriented results; Eloquent works with model instances for model-oriented operations.
This is a useful mental model, not a promise that every fluent call follows an identical internal path. Laravel’s documentation describes Query Builder as a fluent interface for creating and running database queries. Laravel 13.x Query Builder documentation
What does the Query Builder hold?
The builder is more than a string of SQL. Its API reference exposes separate concepts for the connection, grammar, processor, bindings, and query state. State can include columns, joins, where clauses, groupings, orderings, limits, offsets, and unions. These pieces let Laravel compose a query before it is sent to the database.
#1 Best Overall
The grammar is associated with representing the query for a database driver, and the connection is responsible for query execution. The processor participates in handling results. Keeping these roles distinct helps explain why the same chain of PHP calls may be compiled differently for different supported databases. The API reference documents the builder’s structure, but should not be read as a guarantee about every method’s exact call sequence. Laravel 13.x Query Builder API reference
How does Laravel turn a query into SQL?
Most fluent methods add or modify a query component and, where appropriate, its associated values. When the query is run, Laravel uses the driver-associated grammar to produce SQL and keeps values in bindings. The connection executes the statement. This separates the statement’s structure from values supplied to it, rather than requiring the application to concatenate every value into an SQL string.
For example, a filter expressed with a value uses Laravel’s parameter-binding approach. PDO bindings protect values in their intended parameter positions; they do not make arbitrary SQL fragments safe. Laravel specifically warns that PDO cannot bind column names. An input value therefore must not determine an identifier such as the column in an orderBy clause. Choose identifiers from a fixed, validated allowlist instead.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchRaw expressions are SQL strings, not safely bound fragments. Construct them from trusted, fixed SQL or validate their components carefully; value bindings do not sanitize an expression. Laravel 13.x Query Builder documentation: parameter binding and raw expressions
Rank #3
How do raw SQL, Query Builder, and Eloquent differ?
| Approach | Abstraction and composition | Result or behavior | Control over SQL |
|---|---|---|---|
| Raw SQL | Lowest-level choice; SQL is written directly. Reusable composition depends on how the application organizes its SQL. | Database-oriented results or outcomes; no Eloquent model lifecycle merely because SQL was executed. | Most direct control over statement text; the application must handle safe value binding and SQL correctness. |
| Query Builder | Fluent, composable PHP API for query clauses, writes, joins, aggregates, locks, and related operations. | Database-oriented results rather than Eloquent model instances by default. | Laravel constructs SQL from query components; driver-specific output may differ. |
| Eloquent | Model-oriented layer built around application models and their tables. | Model retrieval and persistence can participate in Eloquent’s model lifecycle events. | Higher-level model semantics; queries can still be expressed through Eloquent’s query interface. |
This is an abstraction comparison, not a performance ranking: the cited Laravel documentation describes their roles and behavior, not a benchmark establishing that one is universally faster. Laravel’s database documentation covers the available interaction approaches, and its Eloquent documentation explains models and lifecycle behavior. Laravel 13.x database documentation · Laravel 13.x Eloquent documentation
What does Eloquent add to a query?
Eloquent connects database operations to models. A model represents a corresponding table in the application’s model-oriented approach, and retrieving or persisting models can involve lifecycle events. That behavior is distinct from simply issuing a set-based database statement.
In particular, mass updates and deletes do not retrieve each affected model. Since those model instances are not retrieved, Laravel does not dispatch per-model saved, updated, deleting, or deleted events for those affected rows. If application logic depends on those events, use an approach that retrieves and processes models, or arrange the required work explicitly. Laravel 13.x Eloquent documentation: mass updates and deletes
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →How can you see SQL that Laravel executes?
For executed statements, Laravel supports database query listeners. The Laravel 13.x connection source shows that a QueryExecuted event records SQL, bindings, elapsed time, and whether the query used a read or write connection. Elapsed time is execution context; a single timing does not by itself establish that a query is fast or slow.
Register a listener where it is appropriate for your application, such as a service provider, and inspect the event without exposing sensitive bindings in production logs:
use IlluminateDatabaseEventsQueryExecuted;
use IlluminateSupportFacadesDB;
DB::listen(function (QueryExecuted $query) {
logger()->debug('Database query executed', [
'sql' => $query->sql,
'bindings' => $query->bindings,
'time_ms' => $query->time,
'read_write_type' => $query->readWriteType,
]);
});Bindings can contain personal or otherwise sensitive data, so treat them as sensitive when logging, sharing, or retaining diagnostic output. Laravel also documents cumulative query-time monitoring for watching total database time during a request. For a builder you are inspecting before execution, the API exposes SQL-and-bindings inspection and debugging support; these facilities help inspect the statement and parameters without confusing inspection with proof of what a database actually executed.
Laravel 13.x database documentation: query listeners and cumulative query time · Laravel 13.x Query Builder API reference · Laravel framework Connection source, 13.x branch
Which layer should you use?
- Use Query Builder when you want composable database operations without model lifecycle behavior, or when a query does not naturally map to model instances.
- Use Eloquent when model semantics and model-oriented retrieval or persistence are useful, while accounting for the difference between per-model work and mass statements.
- Use raw SQL or raw expressions when direct SQL control is needed, and take responsibility for correct binding of values and safe construction of SQL structure.
Laravel 13.x documentation is the reference for the APIs described here. Laravel’s database documentation lists first-party support for five database families; minimum database versions and feature compatibility depend on the release and driver in use, so check those requirements for the database you deploy rather than assuming identical behavior across drivers. Laravel 13.x database documentation
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
