Query builder అంటే ఏమిటి మరియు ఇది Eloquent కు ఎలా సంబంధించినది?

Question

Accepted Answer

Laravel యొక్క **Query Builder** అనేది raw SQL రాయకుండా డేటాబేస్ ప్రశ్నలను నిర్మించడం మరియు అమలు చేయడం కోసం ఒక fluent, chainable ఇంటర్‌ఫేస్. **Eloquent Query Builder పైన నిర్మితమైనది** — Eloquent మోడల్‌లు దీనిని అంతర్గతంగా ఉపయోగిస్తాయి, మరియు Eloquent ప్రశ్నలు అన్ని Query Builder పద్ధతులను ఉపయోగించవచ్చు.

## Query Builder (డేటాబేస్-స్థరం, 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 సరాసరి టేబుల్‌ల కోసం పనిచేస్తుంది (సాధారణ వస్తువులను అందించడం, Eloquent మోడల్‌లను కాదు). ఇది chainable మరియు **స్వయంచాలకంగా పారామీటర్ బైండింగ్ ఉపయోగిస్తుంది** — SQL ఇంజెక్షన్‌ను నిరోధిస్తుంది.

## Eloquent అదే fluent పద్ధతులను ఉపయోగిస్తుంది

```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.)
```

మీరు Eloquent మోడల్‌పై పద్ధతులను చేనవేసినప్పుడు, మీరు అంతర్గతంగా Query Builder ఉపయోగిస్తున్నారు — కానీ మీరు **మోడల్‌లను** (సంబంధాలు, accessors, మరియు పద్ధతులతో) సాధారణ వస్తువుల కంటే ఇష్టపడతారు.

## ఉన్నత ప్రశ్నలు (రెండూ ఇవన్నీ సమర్థిస్తాయి)

```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();
```

రెండూ joins, aggregates, subqueries, మరియు సంక్లిష్ట పరిస్థితులను సమర్థిస్తాయి.

## ఏది ఉపయోగించాలో

```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 కు సంబంధం గురించి అర్థం చేసుకోవడం Laravel లో డేటాబేస్‌ల తో సమర్థవంతంగా పనిచేయడానికి మరియు ప్రతిটి పరిస్థితికి సరైన సాధనాన్ని ఎంచుకోవడానికి ముఖ్యమైనది.

ముఖ్య అంతర్దృష్టి ఏమిటంటే **Eloquent Query Builder పైన నిర్మితమైనది** — కాబట్టి Eloquent మోడల్‌లపై ఉపయోగించే fluent, chainable పద్ధతులు (`where`, `orderBy`, `join`, మొదలైనవి) Query Builder లవారు, అంటే ఒకటి నేర్చుకోవడం వాటిరెండూ నేర్పుతుంది.

Query Builder ఒక శుభ్రమైన, SQL-ఇంజెక్షన్-సురక్షితమైన (స్వయంచాలక పారామీటర్ బైండింగ్ ద్వారా) విధానాన్ని అందిస్తుంది raw SQL రాయకుండా ప్రశ్నలను నిర్మించడానికి, మరియు Eloquent మోడల్ కార్యాచరణ (సంబంధాలు, accessors, పద్ధతులు) పైన పొర కలిపిస్తుంది.

**ఏది ఉపయోగించాలో తెలుసుకోవడం** ఆచరణాత్మక నైపుణ్యం: చాలా అప్లికేషన్ లాజిక్ కోసం **Eloquent** (మీరు సంబంధాలు మరియు ప్రవర్తనలతో సమృద్ధమైన మోడల్ వస్తువులను పొందుతారు), మరియు **Query Builder నేరుగా** (`DB::table`) తేలికపాటి ప్రశ్నల కోసం మోడల్ ఓవర్‌హెడ్ లేకుండా, సంక్లిష్ట రిపోర్టింగ్/aggrఆpations కోసం, లేదా మీకు పూర్ణ మోడల్‌లు అవసరం లేనప్పుడు — ఇది కొన్ని సందర్భాల కోసం మరింత సమర్థవంతంగా ఉంటుంది.

రెండూ సంక్లిష్ట ప్రశ్నలను (joins, aggregates, subqueries) అదే fluent API తో సురక్షితంగా నిర్వహిస్తాయి.

Query Builder, Eloquent దీన్ని నిర్మించే విధానం, భాగస్వామ్య సురక్షిత పారామీటర్ బైండింగ్ (SQL ఇంజెక్షన్ నిరోధించడం), మరియు వాటి మధ్య ఎంపిక గురించి అర్థం చేసుకోవడం Laravel లో సమర్థవంతమైన, సురక్షితమైన డేటాబేస్ కోడ్ రాయడానికి ముఖ్యమైన జ్ఞానం, ఎందుకంటే డేటాబేస్ యాక్సెస్ చాలా అప్లికేషన్‌లకు కేంద్రంగా ఉంది మరియు సరైన స్థరం ఎంచుకోవడం (మోడల్-సమృద్ధమైన Eloquent vs తేలికపాటి Query Builder) స్పష్టత మరియు పనితీరు రెండిటినీ ప్రభావితం చేస్తుంది.