Laravel Eloquent શું છે, તેનો ઉપયોગ કેવી રીતે કરવો, ઉદાહરણો સાથેનું ટ્યુટોરીયલ

Laravel PHP ફ્રેમવર્કમાં Eloquent Object Relational Mapper (ORM)નો સમાવેશ થાય છે, જે ડેટાબેઝ સાથે વાતચીત કરવાની અત્યંત સરળ રીત પ્રદાન કરે છે. 

Laravel અને Eloquent એપ્લિકેશન અને પ્લેટફોર્મ ડેવલપમેન્ટને ઝડપી બનાવવામાં મદદ કરે છે, જે મોટાભાગની સમસ્યાઓનો પર્યાપ્ત ઉકેલ પૂરો પાડે છે. જરૂરીયાતો ઝડપી વિકાસ, તેમજ સુવ્યવસ્થિત, ફરીથી વાપરી શકાય તેવી, જાળવણી કરી શકાય તેવા અને માપી શકાય તેવા કોડ સાથે સંબોધવામાં આવે છે. 

કેવી રીતે છટાદાર કામ કરે છે

વિકાસકર્તાઓ કામ કરી શકે છે Eloquent ActiveMethod અમલીકરણનો અસરકારક રીતે ઉપયોગ કરીને બહુવિધ ડેટાબેસેસ સાથે. તે એક આર્કિટેક્ચરલ પેટર્ન છે જ્યાં મોડલ-વ્યૂ-કંટ્રોલર (MVC) સ્ટ્રક્ચરમાં બનાવેલ મોડલ ડેટાબેઝમાંના કોષ્ટકને અનુરૂપ છે. ફાયદો એ છે કે મોડલ લાંબી SQL ક્વેરીઝ કોડિંગ કર્યા વિના સામાન્ય ડેટાબેઝ કામગીરી કરે છે. નમૂનાઓ તમને કોષ્ટકોમાં ડેટા ક્વેરી કરવાની અને કોષ્ટકોમાં નવા રેકોર્ડ દાખલ કરવાની મંજૂરી આપે છે. વિવિધ સિસ્ટમો પર ચાલતા બહુવિધ ડેટાબેઝને સિંક્રનાઇઝ કરવાની પ્રક્રિયાને સરળ બનાવવામાં આવી છે. તમારે SQL ક્વેરીઝ લખવાની જરૂર નથી. તમારે ફક્ત એટલું જ કરવાનું છે defiડેટાબેઝ કોષ્ટકો અને તેમની વચ્ચેના સંબંધોને સમાપ્ત કરો, અને Eloquent બાકીનું કામ કરશે.

લારેવેલ તૈયારી

Eloquent ORM ની ઉપયોગિતાની પ્રશંસા કરવી અને ઇકોસિસ્ટમને સમજવી આવશ્યક છે. પ્રારંભ કરવાનાં પગલાં:

1. getcomposer.org પરથી Laravel ઇન્સ્ટોલ કરો, આ કરવા માટે અહીં આપેલી સૂચનાઓને અનુસરો
2. બનાવો migration કન્સોલનો ઉપયોગ કરીને Artisan
3. નમૂનાઓ બનાવો eloquent
4. હું ચલાવો seed ડેટાબેઝના

Artisan Console લારાવેલમાં સમાવિષ્ટ કમાન્ડ લાઇન ઇન્ટરફેસનું નામ છે. તમારી એપ્લિકેશન વિકસાવતી વખતે ઉપયોગમાં લેવા માટે ઉપયોગી આદેશોનો સમૂહ પ્રદાન કરે છે. તે શક્તિશાળી ઘટક દ્વારા ચલાવવામાં આવે છે Symfony Console.

બધા ઉપલબ્ધ આર્ટિસન આદેશોની સૂચિ જોવા માટે, તમે સૂચિ આદેશનો ઉપયોગ કરી શકો છો:

php artisan list

બધા આદેશો તેની દલીલો અને વિકલ્પોના સંક્ષિપ્ત વર્ણન સાથે આવે છે. આ "સહાય" સ્ક્રીનમાં બતાવવામાં આવે છે. હેલ્પ સ્ક્રીન પ્રદર્શિત કરવા માટે, બતાવ્યા પ્રમાણે ફક્ત "help" સાથે આદેશના નામની આગળ જાઓ:

php artisan help migrate

Migration

સ્થળાંતર એ તેના બદલે PHP લખીને ડેટાબેઝ મેનેજમેન્ટ પ્રક્રિયા છે SQL. ડેટાબેઝમાં સંસ્કરણ નિયંત્રણ ઉમેરવાનો માર્ગ પૂરો પાડે છે. 

સ્થળાંતર બનાવવા માટે, ફક્ત નીચેનો આદેશ ચલાવો:

php artisan make:migration create_student_records

આ સ્થાનાંતરણ ફાઇલ બનાવે છે. તમારા ટેક્સ્ટ એડિટરમાં, તમે હમણાં જ ફોલ્ડરમાં બનાવેલી ફાઇલ ખોલો database\migrations:

<?php
use IlluminateSupportFacadesSchema;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateDatabaseMigrationsMigration;

class CreateStudentRecordsTable extends Migration
{
    /**
    * Run the migrations.
    *
    * @return void
    */
    public function up()
    {
        Schema::create('student__records', function (Blueprint $table) {
            $table->increments('id');
            $table->timestamps();
        });
    }

    /**
    * Reverse the migrations.
    *
    * @return void
    */
    public function down()
    {
        Schema::dropIfExists('student__records');
    }
}

કોડ એ સમાન નામનો વર્ગ છે 'create student records', અને તેની બે પદ્ધતિઓ છે: ઉપર અને નીચે. અપ પદ્ધતિએ ડેટાબેઝમાં ફેરફારો કરવા જોઈએ; તેથી જ્યારે પણ તમે તમારા ડેટાબેઝને સ્થાનાંતરિત કરો છો, ત્યારે અપ પદ્ધતિમાંનો કોઈપણ કોડ એક્ઝિક્યુટ કરવામાં આવશે. બીજી બાજુ, ડાઉન પદ્ધતિએ તે ડેટાબેઝ ફેરફારોને રોલ બેક કરવા જોઈએ; તેથી જ્યારે પણ તમે ચલાવો છો rollback ડેલ્લા migration, ડાઉન મેથડ એ પૂર્વવત્ કરવું જોઈએ જે અપ મેથડ કરે છે. પદ્ધતિની અંદર up ત્યાં સ્કીમા બિલ્ડર છે જેનો ઉપયોગ કોષ્ટકો બનાવવા અને ચાલાકી કરવા માટે થાય છે. જો તમે તમારું અમુક સ્થળાંતર રદ કરો તો શું થશે? તમારે ફક્ત નીચેના આદેશને અમલમાં મૂકવાનો છે:

php artisan migrate:rollback

અને તે છેલ્લું એકત્રિત કરશે migration જેનો અમલ કરવામાં આવ્યો છે. ઉપરાંત, તમે ચલાવીને ડેટાબેઝને સંપૂર્ણપણે પુનઃસ્થાપિત કરી શકો છો:

php artisan migrate:reset

આ તમારા બધા સ્થળાંતરને રદ કરશે.

Defiના મોડલ્સ Eloquent

ડેટાબેઝ સ્થળાંતર પૂર્ણ થયા પછી, આગળની પ્રક્રિયા છે seeding. Eloquent થી રમતમાં આવે છે seeding અમારા ડેટાબેઝમાં રેકોર્ડ દાખલ કરી રહ્યું છે. તેથી તમારે ડેટાબેઝની રચના કરતા પહેલા નમૂનાઓ બનાવવાની જરૂર પડશે. દરેક ડેટાબેઝ કોષ્ટકમાં અનુરૂપ મોડેલ હોય છે જેનો ઉપયોગ તે કોષ્ટક સાથે ક્રિયાપ્રતિક્રિયા કરવા માટે થાય છે. નમૂનાઓ તમને તમારા કોષ્ટકોમાંના ડેટાની ક્વેરી કરવાની તેમજ કોષ્ટકમાં નવા રેકોર્ડ દાખલ કરવાની મંજૂરી આપે છે. મોડેલને ઇન્સ્ટન્ટ કરવાનો સૌથી સહેલો રસ્તો એ નીચેના આદેશનો ઉપયોગ કરવાનો છે:

php artisan make:model Student

નમૂનાનું ઉદાહરણ નીચે બતાવેલ છે Student, જેનો ઉપયોગ અમારા વિદ્યાર્થીના ડેટાબેઝ કોષ્ટકમાંથી માહિતી મેળવવા અને સંગ્રહ કરવા માટે થઈ શકે છે:

<?php
namespace App;
use IlluminateDatabaseEloquentModel;

class Student extends Model
{
    //
}

જ્યારે તમે મોડેલ જનરેટ કરો છો અને તે જ સમયે તમે ડેટાબેઝ સ્થળાંતર જનરેટ કરવા માંગો છો, ત્યારે તમે વિકલ્પનો ઉપયોગ કરી શકો છો –migration o -m:

php artisan make:model Student --migration

php artisan make:model Student -m

સીડર્સ

એકંદરે સીડર્સ એ વર્ગોનો એક વિશિષ્ટ સમૂહ છે જે અમને અમારા ડેટાબેઝને ચોક્કસ સમાન ડેટા સાથે ફરીથી અને ફરીથી બનાવવા દે છે. અમે નીચેનો આદેશ અમલમાં મૂકીએ છીએ:

php artisan make:seeder StudentsRecordSeeder

ટેક્સ્ટ એડિટરમાં, બીજ ફોલ્ડર હેઠળ, નવી બનાવેલી ફાઇલને ફાઇલનામ સાથે ખોલો: StudentsRecordSeeder.php. જેમ તમે જોઈ શકો છો કે આ ફક્ત એક જ પદ્ધતિ સાથેનો એક ખૂબ જ સરળ વર્ગ છે run().

<?php
use IlluminateDatabaseSeeder;

class StudentsRecordSeeder extends Seeder
{
    /**
    * Run the database seeds
    * @return void
    */

    public function run()
    {
        //
    }
}

કોડ એ કન્સોલ કમાન્ડ ક્લાસની આસપાસ માત્ર એક આવરણ છે, ખાસ કરીને ના કાર્યમાં મદદ કરવા માટે બનાવવામાં આવેલ છે seeding. કોડ એડિટ કરો અને પછી તેને સેવ કરો.

public function run()
{
    echo 'Seeding!';
}

અને ટર્મિનલ પર જવું:

php artisan db:seed --class=StudentsRecordSeeder

હવે તમે કોષ્ટકને કેટલીક એન્ટ્રીઓ સાથે બનાવી શકો છો અને ચલાવી શકો છો:

php artisan db:seed --class=class=StudentsRecordSeeder

અહીં તમે ડીબીમાં એન્ટ્રીઓને ડિલીટ કરવાનું, ઉમેરવાનું, સંશોધિત કરવાનું ચાલુ રાખી શકો છો, પછી તેને સરળ આદેશ વડે પુનઃસ્થાપિત કરી શકો છો.

Laravel Eloquent સાથે CRUD

Laravel Eloquent object-relational mapper (ORM) સાથે CRUD ઑપરેશન્સ Laravel વિકાસકર્તાઓ માટે બહુવિધ ડેટાબેસેસ સાથે કામ કરવાનું સરળ બનાવે છે. તે બનાવો, વાંચો, અપડેટ કરો અને કાઢી નાખો (CRUD) ઑપરેશન કરે છે અને ઑબ્જેક્ટ મૉડલને ડેટાબેઝ કોષ્ટકો પર નકશા કરે છે. CRUD કામગીરી માટે જરૂરી તમામ ડેટાબેઝ ક્રિયાપ્રતિક્રિયાઓનું સંચાલન કરે છે.

રેકોર્ડની રચના

ડેટાબેઝમાં નવો રેકોર્ડ દાખલ કરવા માટે તમે ::ક્રિએટ પદ્ધતિનો ઉપયોગ કરી શકો છો.

student_record::create(array(
    'first_name' => 'John',
    'last_name'  => 'Doe',
    'student_rank' => 1
));

ઉપર દર્શાવેલ સરળ સર્જન પદ્ધતિ ઉપરાંત, તમે એક નવો ઑબ્જેક્ટ પણ બનાવી શકો છો અને તેને વિવિધ વિશેષતાઓ આપી શકો છો. પછી, તમે save() ફંક્શનને કૉલ કરી શકો છો અને કોડ ચલાવી શકો છો. જેવી પદ્ધતિઓ firstOrCreate() અથવા firstOrNew() રેકોર્ડ બનાવવા માટેના અન્ય વિકલ્પો છે. આ તમને ચોક્કસ વિશેષતાઓ સાથે વિદ્યાર્થી શોધવાની મંજૂરી આપશે; જો તે વિદ્યાર્થી ન મળે, તો તમે તેને ડેટાબેઝમાં બનાવશો અથવા નવો દાખલો બનાવશો.

રેકોર્ડ વાંચન

Eloquent ORM નો ઉપયોગ કરીને, તમે તમારા ડેટાબેઝમાં રેકોર્ડ્સ શોધી શકો છો. પ્રશ્નો સરળ રીતે બનાવવામાં આવે છે અને સરળ પ્રવાહ પ્રદાન કરે છે. નિવેદનો બનાવવા માટે::where, તમે પદ્ધતિઓનો ઉપયોગ કરશો get() અને first(). પદ્ધતિ first() માત્ર એક રેકોર્ડ પરત કરશે, જ્યારે પદ્ધતિ get() રેકોર્ડ્સની લૂપેબલ એરે પરત કરશે. પણ, પદ્ધતિ find() પ્રાથમિક કીની એરે સાથે ઉપયોગ કરી શકાય છે, જે મેળ ખાતા રેકોર્ડનો સંગ્રહ પરત કરશે. અહીં કેટલાક ઉદાહરણો છે:

$student = Students::all();

આ કોડ તમામ વિદ્યાર્થીઓને મળે છે. જ્યારે નીચેના કોડ ચોક્કસ વિદ્યાર્થીને ID દ્વારા શોધે છે:

$student = વિદ્યાર્થીઓ::શોધો(1);

ઉપરાંત, નીચે બતાવ્યા પ્રમાણે, કોડ ચોક્કસ વિશેષતાના આધારે વિદ્યાર્થીની શોધનું વર્ણન કરે છે.

$JohnDoe = Students::where('name', '=', 'John Doe')->first();

get() પદ્ધતિ માટે, આ કોડ બતાવે છે કે 5 થી ઉપરના સ્તરવાળા વિદ્યાર્થીને કેવી રીતે શોધવો.

$rankStudents = Student::where('student_rank', '>', 5)->get();

રેકોર્ડ અપડેટ

Eloquent નો ઉપયોગ કરીને રેકોર્ડ્સ અપડેટ કરવું એટલું જ સરળ છે. રેકોર્ડ અપડેટ કરવા માટે, તમે અપડેટ કરવા માંગો છો તે રેકોર્ડ શોધો, વિશેષતાઓને સંપાદિત કરો અને સાચવો. ઉદાહરણ તરીકે, જોન ડોના વિદ્યાર્થીના ગ્રેડ સ્તરને 5 માં બદલવા માટે, પ્રથમ વિદ્યાર્થીને શોધો અને પછી સાચવો પદ્ધતિ ચલાવો.

$JohnDoe = Bear::where('name', '=', 'John Doe')->first();
$JohnDoe->danger_level = 5;
$JohnDoe->save();

ડેટાબેઝમાં પહેલાથી જ અસ્તિત્વમાં છે તે મોડલ્સને અપડેટ કરવા માટે પણ સેવ પદ્ધતિનો ઉપયોગ કરી શકાય છે.

રેકોર્ડ્સ કાઢી નાખો

છટાદાર તેની સરળ રેકોર્ડ અપડેટ કરવાની પ્રક્રિયાને ગૌરવ આપે છે, પરંતુ તે કાઢી નાખવાની સાથે સમાન વાર્તા ધરાવે છે. ત્યાં બે વિકલ્પો છે: પુલ-આઉટ રેકોર્ડ્સ અને ડિલીટ પદ્ધતિનો અમલ કરો, અથવા ફક્ત નાશ પદ્ધતિનો ઉપયોગ કરો. રેકોર્ડ શોધવા અને કાઢી નાખવા માટે, ફક્ત નીચેના આદેશો ચલાવો:

$student = Students::find(1);
$student->delete();

રેકોર્ડ અને બહુવિધ રેકોર્ડ્સને કાઢી નાખવા માટે, આદેશો ચલાવવામાં આવે છે:

Students::destroy(1);
Students::destroy(1, 2, 3);

નોંધ કરો કે નાશના પરિમાણો એ ડિલીટ પદ્ધતિથી વિપરીત માત્ર પ્રાથમિક કી છે જે કોઈપણ ડેટાબેઝ કોલમને સ્વીકારી શકે છે.

લેવલ 10 થી ઉપરના તમામ વિદ્યાર્થીઓને શોધવા અને કાઢી નાખવા.

Students::where('student_rank', '>', 10)->delete();

Ercole Palmeri