Query Builder என்றால் என்ன மற்றும் அது Eloquent உடன் எவ்வாறு தொடர்புடையது?

Question

Accepted Answer

Laravel-ன் **Query Builder** என்பது raw SQL எழுதாமல் database queries-ஐ build செய்து run செய்ய ஒரு fluent, chainable interface ஆகும். **Eloquent Query Builder-ன் மேல் built** — Eloquent models இதை under the hood பயன்படுத்துகின்றன, மற்றும் Eloquent queries அனைத்து Query Builder methods-ஐ பயன்படுத்த முடியும்.

## The Query Builder (database-level, via DB facade)

```php
use Illuminate\Support\Facades\DB;

DB::table('users')
    ->where('active', true)
    ->where('age', '>', 18)
    ->orderBy('name')
    ->limit(10)
    ->get();                          // returns generic objects (not models)

DB::table('users')->where('id', 1)->update(['name' => 'X']);
DB::table('users')->insert(['name' => 'Ann']);
```

Query Builder நேரடியாக tables-ஐ வேலை செய்கிறது (plain objects return செய்கிறது, Eloquent models அல்ல). இது chainable மற்றும் **automatically parameter binding பயன்படுத்துகிறது** — SQL injection-ஐ தடுக்கிறது.

## Eloquent same fluent methods பயன்படுத்துகிறது

```php
// Eloquent queries support ALL Query Builder methods (it's built on top)
User::where('active', true)
    ->where('age', '>', 18)
    ->orderBy('name')
    ->get();                          // returns User MODELS (with relationships, etc.)
```

Nethum methods-ஐ Eloquent model-ல் chain செய்யும் போது, நீங்கள் underneath Query Builder-ஐ பயன்படுத்துகிறீர்கள் — ஆனால் நீங்கள் **models** (relationships, accessors, மற்றும் methods உடன்) return பெறுகிறீர்கள் plain objects க்கு பதிலாக.

## Advanced queries (இரண்டும் support செய்கின்றன)

```php
DB::table('orders')
    ->join('users', 'orders.user_id', '=', 'users.id')   // joins
    ->select('orders.*', 'users.name')
    ->where('orders.total', '>', 100)
    ->groupBy('users.id')
    ->havingRaw('SUM(orders.total) > 1000')
    ->get();

User::where('role', 'admin')
    ->orWhere('role', 'editor')
    ->whereIn('status', ['active', 'pending'])
    ->get();
```

Both joins, aggregates, subqueries, மற்றும் complex conditions support செய்கின்றன.

## எதை எப்போது பயன்படுத்த வேண்டும்

```text
Eloquent (Model::...) → the default — get models with relationships/accessors/methods.
                        Best for most application logic.
Query Builder (DB::table) → when you want lightweight queries without model overhead,
                            complex reporting/aggregations, or to avoid loading models.
```

## இது ஏன் முக்கியம்

Query Builder மற்றும் Eloquent உடனான அதன் relationship-ஐ புரிந்துகொள்வது Laravel-ல் databases-உடன் திறம்பட வேலை செய்ய மற்றும் ஒவ்வொரு situation-க்கு சரியான tool-ஐ தேர்ந்தெடுக்க முக்கியமாகும்.

முக்கியமான insight என்னவென்றால் **Eloquent Query Builder-ன் மேல் built** — எனவே fluent, chainable methods-ஐ நீங்கள் Eloquent models-ல் பயன்படுத்துகிறீர்கள் (`where`, `orderBy`, `join`, முதலியன) Query Builder-ன் ஆகும், அதாவது ஒன்றை learning செய்வது இரண்டையும் கற்பிக்கிறது.

Query Builder clean, SQL-injection-safe (automatic parameter binding via) way provide செய்கிறது raw SQL எழுதாமல் queries build செய்ய, மற்றும் Eloquent model functionality (relationships, accessors, methods) மேலே layer செய்கிறது.

**எதை எப்போது பயன்படுத்த வேண்டும் என்பதை knowing** என்பது practical skill ஆகும்: **Eloquent** most application logic-க்கு (நீங்கள் relationships மற்றும் behavior உடன் rich model objects பெறுகிறீர்கள்), மற்றும் **Query Builder directly** (`DB::table`) model overhead இல்லாமல் lightweight queries-க்கு, complex reporting/aggregations-க்கு, அல்லது full models தேவை இல்லாதபோது — இது certain cases-ல் மிகவும் efficient-ஆக இருக்கலாம்.

Both safely complex queries (joins, aggregates, subqueries) handle செய்கின்றன same fluent API-உடன்.

Query Builder-ஐ understanding செய்வது, Eloquent எவ்வாறு அதை build செய்கிறது என்பது, shared safe parameter binding (SQL injection தடுக்க), மற்றும் அவற்றுக்கு இடையே choice என்பது Laravel-ல் efficient, secure database code எழுத முக்கியமான knowledge ஆகும், database access most applications-க்கு central ஆக இருக்கும் போது மற்றும் appropriate level (model-rich Eloquent vs lightweight Query Builder) தேர்ந்தெடுப்பது both clarity மற்றும் performance-ஐ பாதிக்கிறது.