ಲಾರಾವೆಲ್ ಎಲೋಕ್ವೆಂಟ್ ಎಂದರೇನು, ಅದನ್ನು ಹೇಗೆ ಬಳಸುವುದು, ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಟ್ಯುಟೋರಿಯಲ್

Laravel PHP ಫ್ರೇಮ್‌ವರ್ಕ್ ಎಲೋಕ್ವೆಂಟ್ ಆಬ್ಜೆಕ್ಟ್ ರಿಲೇಶನಲ್ ಮ್ಯಾಪರ್ (ORM) ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ಡೇಟಾಬೇಸ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಅತ್ಯಂತ ಸುಲಭವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. 

ಲಾರಾವೆಲ್ ಮತ್ತು ಎಲೋಕ್ವೆಂಟ್ ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ವೇಗಗೊಳಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಹೆಚ್ಚಿನ ಸಮಸ್ಯೆಗಳಿಗೆ ಸಾಕಷ್ಟು ಪರಿಹಾರವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅಗತ್ಯತೆಗಳನ್ನು ವೇಗವಾದ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ ತಿಳಿಸಲಾಗುತ್ತದೆ, ಜೊತೆಗೆ ಸುಸಂಘಟಿತ, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ, ನಿರ್ವಹಿಸಬಹುದಾದ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಕೋಡ್. 

ಎಲೋಕ್ವೆಂಟ್ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ

ಡೆವಲಪರ್‌ಗಳು ಕೆಲಸ ಮಾಡಬಹುದು Eloquent ಆಕ್ಟಿವ್‌ಮೆಥಡ್ ಅನುಷ್ಠಾನವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಳಸಿಕೊಂಡು ಬಹು ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ. ಇದು ವಾಸ್ತುಶಿಲ್ಪದ ಮಾದರಿಯಾಗಿದ್ದು, ಮಾದರಿ-ವೀಕ್ಷಣೆ-ನಿಯಂತ್ರಕ (MVC) ರಚನೆಯಲ್ಲಿ ರಚಿಸಲಾದ ಮಾದರಿಯು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿನ ಕೋಷ್ಟಕಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ. ದೀರ್ಘ SQL ಪ್ರಶ್ನೆಗಳನ್ನು ಕೋಡಿಂಗ್ ಮಾಡದೆಯೇ ಮಾದರಿಗಳು ಸಾಮಾನ್ಯ ಡೇಟಾಬೇಸ್ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದು ಪ್ರಯೋಜನವಾಗಿದೆ. ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಪ್ರಶ್ನಿಸಲು ಮತ್ತು ಹೊಸ ದಾಖಲೆಗಳನ್ನು ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಸೇರಿಸಲು ಟೆಂಪ್ಲೇಟ್‌ಗಳು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ವಿವಿಧ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಹು ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸಲಾಗಿದೆ. ನೀವು SQL ಪ್ರಶ್ನೆಗಳನ್ನು ಬರೆಯುವ ಅಗತ್ಯವಿಲ್ಲ. ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ಇಷ್ಟೇ defiಡೇಟಾಬೇಸ್ ಕೋಷ್ಟಕಗಳು ಮತ್ತು ಅವುಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ಮುಗಿಸಿ, ಮತ್ತು ಎಲೋಕ್ವೆಂಟ್ ಉಳಿದ ಕೆಲಸವನ್ನು ಮಾಡುತ್ತದೆ.

ಲಾರಾವೆಲ್ ತಯಾರಿಕೆ

ಎಲೋಕ್ವೆಂಟ್ ORM ನ ಉಪಯುಕ್ತತೆಯನ್ನು ಶ್ಲಾಘಿಸುವುದು ಮತ್ತು ಪರಿಸರ ವ್ಯವಸ್ಥೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ಪ್ರಾರಂಭಿಸಲು ಹಂತಗಳು:

1. Getcomposer.org ನಿಂದ Laravel ಅನ್ನು ಸ್ಥಾಪಿಸಿ, ಇದನ್ನು ಮಾಡಲು ಇಲ್ಲಿ ಸೂಚನೆಗಳನ್ನು ಅನುಸರಿಸಿ
2. ರಚಿಸಿ migration ಕನ್ಸೋಲ್ ಬಳಸಿ Artisan
3. ಟೆಂಪ್ಲೆಟ್ಗಳನ್ನು ರಚಿಸಿ eloquent
4. ರನ್ ಐ seed ಡೇಟಾಬೇಸ್ ನ

Artisan Console ಲಾರಾವೆಲ್‌ನಲ್ಲಿ ಸೇರಿಸಲಾದ ಆಜ್ಞಾ ಸಾಲಿನ ಇಂಟರ್‌ಫೇಸ್‌ನ ಹೆಸರು. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವಾಗ ಬಳಸಲು ಉಪಯುಕ್ತ ಆಜ್ಞೆಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಶಕ್ತಿಯುತ ಘಟಕದಿಂದ ನಡೆಸಲ್ಪಡುತ್ತದೆ Symfony Console.

ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಕುಶಲಕರ್ಮಿ ಆಜ್ಞೆಗಳ ಪಟ್ಟಿಯನ್ನು ನೋಡಲು, ನೀವು ಪಟ್ಟಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು:

php artisan list

ಎಲ್ಲಾ ಆಜ್ಞೆಗಳು ಅದರ ವಾದಗಳು ಮತ್ತು ಆಯ್ಕೆಗಳ ಸಂಕ್ಷಿಪ್ತ ವಿವರಣೆಯೊಂದಿಗೆ ಬರುತ್ತವೆ. ಇದನ್ನು "ಸಹಾಯ" ಪರದೆಯಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ. ಸಹಾಯ ಪರದೆಯನ್ನು ಪ್ರದರ್ಶಿಸಲು, ತೋರಿಸಿರುವಂತೆ "ಸಹಾಯ" ನೊಂದಿಗೆ ಆಜ್ಞೆಯ ಹೆಸರನ್ನು ಸರಳವಾಗಿ ಮೊದಲು ಮಾಡಿ:

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ಮಾದರಿಗಳ tion 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

ಇಲ್ಲಿ ನೀವು ಡಿಬಿಯಲ್ಲಿ ನಮೂದುಗಳನ್ನು ಅಳಿಸುವುದು, ಸೇರಿಸುವುದು, ಮಾರ್ಪಡಿಸುವುದು, ನಂತರ ಅವುಗಳನ್ನು ಸರಳ ಆಜ್ಞೆಯೊಂದಿಗೆ ಮರುಸ್ಥಾಪಿಸಬಹುದು.

ಲಾರಾವೆಲ್ ಎಲೋಕ್ವೆಂಟ್ ಜೊತೆ CRUD

Laravel Eloquent object-relational mapper (ORM) ನೊಂದಿಗೆ CRUD ಕಾರ್ಯಾಚರಣೆಗಳು Laravel ಡೆವಲಪರ್‌ಗಳಿಗೆ ಬಹು ಡೇಟಾಬೇಸ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಸುಲಭಗೊಳಿಸುತ್ತದೆ. ಇದು ರಚಿಸಲು, ಓದಲು, ನವೀಕರಿಸಲು ಮತ್ತು ಅಳಿಸಲು (CRUD) ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಡೇಟಾಬೇಸ್ ಕೋಷ್ಟಕಗಳಿಗೆ ವಸ್ತು ಮಾದರಿಗಳನ್ನು ನಕ್ಷೆ ಮಾಡುತ್ತದೆ. CRUD ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಡೇಟಾಬೇಸ್ ಸಂವಹನಗಳನ್ನು ನಿಭಾಯಿಸುತ್ತದೆ.

ದಾಖಲೆಗಳ ರಚನೆ

ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಹೊಸ ದಾಖಲೆಯನ್ನು ಸೇರಿಸಲು ನೀವು ::create ವಿಧಾನವನ್ನು ಬಳಸಬಹುದು.

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

ಮೇಲೆ ತೋರಿಸಿರುವ ಸರಳ ರಚನೆಯ ವಿಧಾನದ ಜೊತೆಗೆ, ನೀವು ಹೊಸ ವಸ್ತುವನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅದಕ್ಕೆ ವಿಭಿನ್ನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ನೀಡಬಹುದು. ನಂತರ, ನೀವು ಸೇವ್ () ಕಾರ್ಯವನ್ನು ಕರೆಯಬಹುದು ಮತ್ತು ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಬಹುದು. ಮುಂತಾದ ವಿಧಾನಗಳು firstOrCreate() ಅಥವಾ firstOrNew() ದಾಖಲೆಗಳನ್ನು ರಚಿಸಲು ಇತರ ಆಯ್ಕೆಗಳು. ಇವುಗಳು ಕೆಲವು ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ವಿದ್ಯಾರ್ಥಿಯನ್ನು ಹುಡುಕಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ; ಆ ವಿದ್ಯಾರ್ಥಿಯು ಕಂಡುಬಂದಿಲ್ಲವಾದರೆ, ನೀವು ಅದನ್ನು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ರಚಿಸುತ್ತೀರಿ ಅಥವಾ ಹೊಸ ನಿದರ್ಶನವನ್ನು ಸ್ಥಾಪಿಸುತ್ತೀರಿ.

ದಾಖಲೆಗಳನ್ನು ಓದುವುದು

ಎಲೋಕ್ವೆಂಟ್ ORM ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಿಮ್ಮ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ನೀವು ದಾಖಲೆಗಳನ್ನು ಕಾಣಬಹುದು. ಪ್ರಶ್ನೆಗಳನ್ನು ಸರಳವಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ ಮತ್ತು ಮೃದುವಾದ ಹರಿವನ್ನು ನೀಡುತ್ತದೆ. ಹೇಳಿಕೆಗಳನ್ನು ರಚಿಸಲು::where, ನೀವು ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತೀರಿ get() ಮತ್ತು first() ವಿಧಾನ first() ವಿಧಾನವು ಕೇವಲ ಒಂದು ದಾಖಲೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ get() ಲೂಪ್ ಮಾಡಬಹುದಾದ ದಾಖಲೆಗಳ ಶ್ರೇಣಿಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅಲ್ಲದೆ, ವಿಧಾನ find() ಪ್ರಾಥಮಿಕ ಕೀಗಳ ಒಂದು ಶ್ರೇಣಿಯೊಂದಿಗೆ ಬಳಸಬಹುದು, ಇದು ಹೊಂದಾಣಿಕೆಯ ದಾಖಲೆಗಳ ಸಂಗ್ರಹವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

$student = Students::all();

ಈ ಕೋಡ್ ಎಲ್ಲಾ ವಿದ್ಯಾರ್ಥಿಗಳನ್ನು ಪಡೆಯುತ್ತದೆ. ಈ ಕೆಳಗಿನ ಕೋಡ್ ನಿರ್ದಿಷ್ಟ ವಿದ್ಯಾರ್ಥಿಯನ್ನು ID ಮೂಲಕ ಹುಡುಕುತ್ತದೆ:

$ ವಿದ್ಯಾರ್ಥಿ = ವಿದ್ಯಾರ್ಥಿಗಳು:: ಹುಡುಕಿ(1);

ಅಲ್ಲದೆ, ಕೆಳಗೆ ತೋರಿಸಿರುವಂತೆ, ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣದ ಆಧಾರದ ಮೇಲೆ ವಿದ್ಯಾರ್ಥಿಯನ್ನು ಹುಡುಕುವುದನ್ನು ಕೋಡ್ ವಿವರಿಸುತ್ತದೆ.

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

get() ವಿಧಾನಕ್ಕಾಗಿ, 5 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಹಂತವನ್ನು ಹೊಂದಿರುವ ವಿದ್ಯಾರ್ಥಿಯನ್ನು ಹೇಗೆ ಕಂಡುಹಿಡಿಯುವುದು ಎಂಬುದನ್ನು ಈ ಕೋಡ್ ತೋರಿಸುತ್ತದೆ.

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

ರೆಕಾರ್ಡ್ ನವೀಕರಣ

ಎಲೋಕ್ವೆಂಟ್ ಬಳಸಿ ದಾಖಲೆಗಳನ್ನು ನವೀಕರಿಸುವುದು ಅಷ್ಟೇ ಸುಲಭ. ದಾಖಲೆಯನ್ನು ನವೀಕರಿಸಲು, ನೀವು ನವೀಕರಿಸಲು ಬಯಸುವ ದಾಖಲೆಯನ್ನು ಹುಡುಕಿ, ಗುಣಲಕ್ಷಣಗಳನ್ನು ಸಂಪಾದಿಸಿ ಮತ್ತು ಉಳಿಸಿ. ಉದಾಹರಣೆಗೆ, ಜಾನ್ ಡೋ ವಿದ್ಯಾರ್ಥಿಯ ಗ್ರೇಡ್ ಮಟ್ಟವನ್ನು 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