डेटाबेस उपयोग (Laravel डेटाबेस घटक पर आधारित)

सभी पंक्तियाँ प्राप्त करें

<?php
namespace app\controller;

use support\Request;
use support\Db;

class UserController
{
    public function all(Request $request)
    {
        $users = Db::table('users')->get();
        return view('user/all', ['users' => $users]);
    }
}

निर्दिष्ट कॉलम प्राप्त करें

$users = Db::table('user')->select('name', 'email as user_email')->get();

एक पंक्ति प्राप्त करें

$user = Db::table('users')->where('name', 'John')->first();

एक कॉलम प्राप्त करें

$titles = Db::table('roles')->pluck('title');

निर्दिष्ट id फ़ील्ड के मान को इंडेक्स के रूप में उपयोग करें

$roles = Db::table('roles')->pluck('title', 'id');

foreach ($roles as $id => $title) {
    echo $title;
}

एकल मान (फ़ील्ड) प्राप्त करें

$email = Db::table('users')->where('name', 'John')->value('email');

अद्वितीय मान प्राप्त करें

$email = Db::table('user')->select('nickname')->distinct()->get();

परिणामों को भागों में प्राप्त करें

यदि आपको हजारों डेटाबेस रिकॉर्ड 처리 करने की आवश्यकता है, तो एक बार में इन डेटा को पढ़ना बहुत समय लेने वाला हो सकता है और आसानी से मेमोरी ओवरफ्लो का कारण बन सकता है, इस समय आप chunkById मेथड का उपयोग करने पर विचार कर सकते हैं। यह मेथड परिणाम सेट का एक छोटा हिस्सा एक बार में प्राप्त करता है और इसे क्लोजर फंक्शन को प्रोसेस करने के लिए भेजता है। उदाहरण के लिए, हम सभी users टेबल डेटा को एक बार में 100 रिकॉर्ड्स के छोटे हिस्से में काट सकते हैं:

Db::table('users')->orderBy('id')->chunkById(100, function ($users) {
    foreach ($users as $user) {
        //
    }
});

आप क्लोजर में false लौटाकर आगे बढ़ने से रोक सकते हैं।

Db::table('users')->orderBy('id')->chunkById(100, function ($users) {
    // रेकॉर्ड्स प्रोसेस करें...

    return false;
});

ध्यान दें: कॉल बैक में डेटा को न हटाएँ, इससे कुछ रिकॉर्ड्स परिणाम सेट में शामिल नहीं हो सकते हैं

समेकन

क्वेरी बिल्डर विभिन्न समेकन विधियाँ भी प्रदान करता है, जैसे count, max, min, avg, sum आदि।

$users = Db::table('users')->count();
$price = Db::table('orders')->max('price');
$price = Db::table('orders')->where('finalized', 1)->avg('price');

रिकॉर्ड के अस्तित्व की जांच करें

return Db::table('orders')->where('finalized', 1)->exists();
return Db::table('orders')->where('finalized', 1)->doesntExist();

मूल अभिव्यक्तियाँ

प्रारूप

selectRaw($expression, $bindings = [])

कभी-कभी आपको क्वेरी में मूल अभिव्यक्तियाँ उपयोग करने की आवश्यकता हो सकती है। आप selectRaw() का उपयोग करके एक मूल अभिव्यक्ति बना सकते हैं:

$orders = Db::table('orders')
                ->selectRaw('price * ? as price_with_tax', [1.0825])
                ->get();

इसी तरह, whereRaw() orWhereRaw() havingRaw() orHavingRaw() orderByRaw() groupByRaw() मूल अभिव्यक्ति विधियाँ भी प्रदान की गई हैं।

Db::raw($value) भी एक मूल अभिव्यक्ति बनाने के लिए उपयोग किया जाता है, लेकिन यह बंधित पैरामीटर कार्यक्षमता नहीं है, उपयोग करने पर SQL इंजेक्शन समस्याओं के प्रति सावधान रहना होगा।

$orders = Db::table('orders')
                ->select('department', Db::raw('SUM(price) as total_sales'))
                ->groupBy('department')
                ->havingRaw('SUM(price) > ?', [2500])
                ->get();

जॉइन कथन

// join
$users = Db::table('users')
            ->join('contacts', 'users.id', '=', 'contacts.user_id')
            ->join('orders', 'users.id', '=', 'orders.user_id')
            ->select('users.*', 'contacts.phone', 'orders.price')
            ->get();

// leftJoin            
$users = Db::table('users')
            ->leftJoin('posts', 'users.id', '=', 'posts.user_id')
            ->get();

// rightJoin
$users = Db::table('users')
            ->rightJoin('posts', 'users.id', '=', 'posts.user_id')
            ->get();

// crossJoin    
$users = Db::table('sizes')
            ->crossJoin('colors')
            ->get();

यूनियन कथन

$first = Db::table('users')
            ->whereNull('first_name');

$users = Db::table('users')
            ->whereNull('last_name')
            ->union($first)
            ->get();

जहां कथन

प्रारूप

where($column, $operator = null, $value = null)

पहला पैरामीटर कॉलम नाम है, दूसरा पैरामीटर किसी भी डेटाबेस प्रणाली द्वारा समर्थित ऑपरेटर है, तीसरा पैरामीटर वह मान है जिसके लिए कॉलम की तुलना की जानी है।

$users = Db::table('users')->where('votes', '=', 100)->get();

// जब ऑपरेटर बराबर हो तो इसे छोड़ भी सकते हैं, इसलिए यह अभिव्यक्ति पिछले के समान है
$users = Db::table('users')->where('votes', 100)->get();

$users = Db::table('users')
                ->where('votes', '>=', 100)
                ->get();

$users = Db::table('users')
                ->where('votes', '<>', 100)
                ->get();

$users = Db::table('users')
                ->where('name', 'like', 'T%')
                ->get();

आप शर्तों का NSArray भी where फंक्शन में पास कर सकते हैं:

$users = Db::table('users')->where([
    ['status', '=', '1'],
    ['subscribed', '<>', '1'],
])->get();

orWhere मेथड और where मेथड के पैरामीटर समान होते हैं:

$users = Db::table('users')
                    ->where('votes', '>', 100)
                    ->orWhere('name', 'John')
                    ->get();

आप orWhere मेथड को पहले पैरामीटर के रूप में एक क्लोजर भी पास कर सकते हैं:

// SQL: select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
$users = Db::table('users')
            ->where('votes', '>', 100)
            ->orWhere(function($query) {
                $query->where('name', 'Abigail')
                      ->where('votes', '>', 50);
            })
            ->get();

whereBetween / orWhereBetween मेथड यह सत्यापित करते हैं कि फ़ील्ड का मान दिए गए दो मूल्यों के बीच है:

$users = Db::table('users')
           ->whereBetween('votes', [1, 100])
           ->get();

whereNotBetween / orWhereNotBetween मेथड यह सत्यापित करते हैं कि फ़ील्ड का मान दिए गए दो मूल्यों के बाहर है:

$users = Db::table('users')
                    ->whereNotBetween('votes', [1, 100])
                    ->get();

whereIn / whereNotIn / orWhereIn / orWhereNotIn मेथड यह सत्यापित करते हैं कि फ़ील्ड का मान निर्दिष्ट एरे में होना चाहिए:

$users = Db::table('users')
                    ->whereIn('id', [1, 2, 3])
                    ->get();

whereNull / whereNotNull / orWhereNull / orWhereNotNull मेथड यह सत्यापित करते हैं कि निर्दिष्ट फ़ील्ड NULL होनी चाहिए:

$users = Db::table('users')
                    ->whereNull('updated_at')
                    ->get();

whereNotNull मेथड यह सत्यापित करता है कि निर्दिष्ट फ़ील्ड NULL नहीं होनी चाहिए:

$users = Db::table('users')
                    ->whereNotNull('updated_at')
                    ->get();

whereDate / whereMonth / whereDay / whereYear / whereTime मेथड का उपयोग फ़ील्ड के मान की तुलना दिए गए दिनांक के साथ किया जाता है:

$users = Db::table('users')
                ->whereDate('created_at', '2016-12-31')
                ->get();

whereColumn / orWhereColumn मेथड का उपयोग दो फ़ील्डों के मानों की तुलना करने के लिए किया जाता है कि क्या वे समान हैं:

$users = Db::table('users')
                ->whereColumn('first_name', 'last_name')
                ->get();

// आप एक तुलना ऑपरेटर भी पास कर सकते हैं
$users = Db::table('users')
                ->whereColumn('updated_at', '>', 'created_at')
                ->get();

// whereColumn मेथड एरे भी पास कर सकता है
$users = Db::table('users')
                ->whereColumn([
                    ['first_name', '=', 'last_name'],
                    ['updated_at', '>', 'created_at'],
                ])->get();

पैरामीटर समूह

// select * from users where name = 'John' and (votes > 100 or title = 'Admin')
$users = Db::table('users')
           ->where('name', '=', 'John')
           ->where(function ($query) {
               $query->where('votes', '>', 100)
                     ->orWhere('title', '=', 'Admin');
           })
           ->get();

whereExists

// select * from users where exists ( select 1 from orders where orders.user_id = users.id )
$users = Db::table('users')
           ->whereExists(function ($query) {
               $query->select(Db::raw(1))
                     ->from('orders')
                     ->whereRaw('orders.user_id = users.id');
           })
           ->get();

orderBy

$users = Db::table('users')
                ->orderBy('name', 'desc')
                ->get();

यादृच्छिक क्रम

$randomUser = Db::table('users')
                ->inRandomOrder()
                ->first();

यादृच्छिक क्रम सर्वर के प्रदर्शन पर बहुत प्रभाव डाल सकता है, इसका उपयोग नहीं करने की सलाह दी जाती है।

groupBy / having

$users = Db::table('users')
                ->groupBy('account_id')
                ->having('account_id', '>', 100)
                ->get();
// आप groupBy मेथड को कई पैरामीटर पास कर सकते हैं
$users = Db::table('users')
                ->groupBy('first_name', 'status')
                ->having('account_id', '>', 100)
                ->get();

offset / limit

$users = Db::table('users')
                ->offset(10)
                ->limit(5)
                ->get();

सम्मिलित करें

एकल पंक्ति सम्मिलित करें

Db::table('users')->insert(
    ['email' => 'john@example.com', 'votes' => 0]
);

बहु-पंक्तियाँ सम्मिलित करें

Db::table('users')->insert([
    ['email' => 'taylor@example.com', 'votes' => 0],
    ['email' => 'dayle@example.com', 'votes' => 0]
]);

स्वचालित वृद्धि ID

$id = Db::table('users')->insertGetId(
    ['email' => 'john@example.com', 'votes' => 0]
);

ध्यान दें: PostgreSQL का उपयोग करते समय, insertGetId मेथड id को स्वचालित वृद्धि फ़ील्ड के नाम के रूप में डिफ़ॉल्ट रूप से मानता है। यदि आप अन्य "क्रम" से ID प्राप्त करना चाहते हैं, तो आप फ़ील्ड का नाम insertGetId मेथड के दूसरे पैरामीटर के रूप में पास कर सकते हैं।

अपडेट करें

$affected = Db::table('users')
              ->where('id', 1)
              ->update(['votes' => 1]);

अपडेट या सम्मिलित करें

कभी-कभी आप डेटाबेस में मौजूदा रिकॉर्ड को अपडेट करना चाहेंगे, या यदि कोई मेल खाते हुए रिकॉर्ड नहीं हैं तो इसे बनाना चाहेंगे:

Db::table('users')
    ->updateOrInsert(
        ['email' => 'john@example.com', 'name' => 'John'],
        ['votes' => '2']
    );

updateOrInsert मेथड पहले मौजूदा डेटाबेस रिकॉर्ड को पहले पैरामीटर के कुंजी-मूल्य जोड़े से खोजने का प्रयास करती है। यदि रिकॉर्ड उपस्थित है, तो दूसरे पैरामीटर के मानों का उपयोग करके रिकॉर्ड को अपडेट करती है। यदि रिकॉर्ड नहीं मिलता है, तो एक नया रिकॉर्ड सम्मिलित किया जाएगा, नया रिकॉर्ड के डेटा के दोनों एरे का एक संग्रह होगा।

स्वचालित वृद्धि और स्वचालित कमी

ये दोनों विधियाँ कम से कम एक पैरामीटर स्वीकार करती हैं: जिस कॉलम को संशोधित करना है। दूसरा पैरामीटर वैकल्पिक है, जो कॉलम की वृद्धि या कमी की मात्रा को नियंत्रित करने के लिए होता है:

Db::table('users')->increment('votes');

Db::table('users')->increment('votes', 5);

Db::table('users')->decrement('votes');

Db::table('users')->decrement('votes', 5);

आप क्रिया के दौरान अपडेट करने के लिए वैकल्पिक फ़ील्ड भी निर्दिष्ट कर सकते हैं:

Db::table('users')->increment('votes', 1, ['name' => 'John']);

हटाएँ

Db::table('users')->delete();

Db::table('users')->where('votes', '>', 100)->delete();

यदि आपको तालिका को साफ करने की आवश्यकता है, तो आप truncate मेथड का उपयोग कर सकते हैं, जो सभी पंक्तियों को हटा देगा और स्वचालित वृद्धि ID को शून्य पर रीसेट कर देगा:

Db::table('users')->truncate();

लेनदेन

डेटाबेस लेनदेन देखें

निराशावादी लॉक

क्वेरी बिल्डर कुछ फ़ंक्शन भी शामिल करता है जो आपको select सिंटैक्स पर "निराशावादी लॉकिंग" लागू करने में मदद कर सकते हैं। यदि आप क्वेरी में एक "साझा लॉक" लागू करना चाहते हैं, तो आप sharedLock मेथड का उपयोग कर सकते हैं। साझा लॉक चयनित डेटा कॉलम को संशोधित करने से रोकता है, जब तक कि लेनदेन को पेश नहीं किया जाता है:

Db::table('users')->where('votes', '>', 100)->sharedLock()->get();

या, आप lockForUpdate मेथड का उपयोग कर सकते हैं। "अपडेट" लॉक का उपयोग अन्य साझा लॉक द्वारा पंक्तियों को संशोधित या चयनित करने से बचा सकता है:

Db::table('users')->where('votes', '>', 100)->lockForUpdate()->get();

डिबगिंग

आप क्वेरी परिणामों या SQL स्टेटमेंट को आउटपुट करने के लिए dd या dump मेथड का उपयोग कर सकते हैं। dd मेथड डिबगिंग जानकारी प्रदर्शित करती है और फिर अनुरोध का निष्पादन रोक देती है। dump मेथड भी डिबगिंग जानकारी प्रदर्शित करती है, लेकिन अनुरोध का निष्पादन नहीं रोकती:

Db::table('users')->where('votes', '>', 100)->dd();
Db::table('users')->where('votes', '>', 100)->dump();

ध्यान दें
डिबगिंग के लिए symfony/var-dumper स्थापित करना आवश्यक है, कमांड composer require symfony/var-dumper है।