FuelPHP - Modèles et base de données

Le modèle joue un rôle important dans le cadre Web FuelPHP. Il représente les entités commerciales de l'application. Ils sont soit fournis par les clients, soit extraits de la base de données backend, manipulés selon les règles métier et réintégrés dans la base de données. Découvrons les modèles et comment ils interagissent avec le système back-end dans ce chapitre.

Créer un modèle

Dans FuelPHP, model est simplement une classe PHP simple étendant la classe Model intégrée. Par défaut, les modèles peuvent être préfixés avec Model_ similaire aux contrôleurs et doivent être placés dansfuel/app/classes/model/dossier. Créons un modèle d'employé de base et étendons-le au fur et à mesure.

fuel / app / classes / model / employee.php

<?php 
   namespace Model; 

   class Model_Employee extends \Model { 
      public static function fetchAll() { 
         // Code to fetch employee from database 
      } 
   }

Accéder à un modèle

Une fois qu'un modèle est défini, il peut être librement utilisé dans n'importe quel contrôleur simplement en l'incluant dans le contrôleur comme suit.

use \Model\Employee; 

class Controller_Employee extends Controller { 
   public function action_index() { 
      $employees = Employee::fetchAll(); 
   } 
}

Aperçu de la base de données

FuelPHP fournit sa propre couche d'abstraction de base de données pour récupérer les données de la base de données. Il fournit à la fois un outil basé sur ORM de base et avancé. La boîte à outils de base se compose de classes basées sur DB, DBUtil et Query_Builer. La boîte à outils avancée est Orm. La boîte à outils Orm est dérivée de la boîte à outils de base et intégrée dans un package séparé.

Configuration de la base de données

FuelPHP sépare les paramètres de la base de données du fichier de configuration principal et le fichier est fuel/app/config/db.php. Il prend en charge un paramètre distinct pour chaque environnement. Actuellement, FuelPHP prend en charge les pilotes MySQL, MySQLi et PDO. Le réglage de l'échantillon est le suivant -

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'    => 'localhost', 
            'port'        => '3306', 
            'database'    => 'tutorialspoint_fueldb', 
            'username'    => 'root', 
            'password'    => 'password', 
            'persistent'  => false, 
            'compress'    => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   )

Boîte à outils basée sur la base de données

le DB classest l'option la plus simple pour accéder à la base de données depuis l'application. Il fournit des options pour créer la requête de base de données, l'exécuter sur la base de données cible et enfin récupérer le résultat. La classe DB interagit avec les classes suivantes et fournit une API de base de données complète.

  • Database_Connection - Singleton et classe principale pour interagir avec la base de données

  • Database_Query - Base, classe concrète pour exécuter la requête SQL et récupérer le résultat

  • Database_Query_Builder - Classe abstraite de base pour créer une requête SQL

  • Database_Query_Builder_Join - Classe pour créer des jointures SQL

  • Database_Query_Builder_Where - Classe abstraite pour créer des conditions de requête SQL

  • Database_Query_Builder_Select - Classe concrète pour créer une requête de sélection SQL

  • Database_Query_Builder_Insert - Classe abstraite pour créer une requête d'insertion SQL

  • Database_Query_Builder_Update - Classe abstraite pour créer une requête de mise à jour SQL

  • Database_Query_Builder_Delete - Classe abstraite pour créer une requête de suppression SQL

Le diagramme suivant décrit la relation entre les classes et les méthodes fournies par les classes.

API DB

Apprenons les méthodes les plus importantes disponibles dans la classe DB dans cette section.

exemple

  • Purpose- Crée et renvoie la nouvelle instance Database_Connection .

  • Parameter -

    • $db - Nom de connexion à la base de données défini dans le fichier de configuration, facultatif.

  • Returns- Renvoie l' objet Database_Connection

Par exemple,

$db = DB::instance(); 
$db = DB::instance('test');

requete

  • Purpose - Préparez l'instruction SQL fournie et renvoie l'objet Database_Query, qui peut être utilisé pour insérer, mettre à jour, supprimer ou récupérer les données de la base de données.

  • Parameter -

    • $query - Instruction SQL, peut contenir des espaces réservés;

    • $type - Type SQL, facultatif (DB :: SELECT, DB :: INSERT, DB :: UPDATE et DB :: DELETE)

  • Returns- Renvoie l' objet Database_Query

Par exemple,

$query = DB::query('SELECT * FROM 'employees'');

last_query

  • Purpose - Pour obtenir la dernière requête exécutée

  • Parameter - Aucun

  • Returns - Renvoie la dernière requête exécutée

Par exemple,

$employees = DB::Select('Select * from 'employee''); 
$sql = DB::last_query();

sélectionner

  • Purpose - Générer la partie sélectionnée de la requête

  • Parameter -

    • $columns - Liste des noms de colonnes de la base de données

  • Returns - Renvoie l'objet Database_Query_Builder_Select

Par exemple,

$query = DB::select();              // Select *
$query = DB::select('id', 'name'); // Select id, name

select_array (DB)

C'est similaire à select sauf que nous pouvons envoyer des colonnes sous forme de tableau.

$query = DB::select_array(array('id', 'name')); // Select id, name

insérer

  • Purpose - Générer la partie insert de la requête

  • Parameter -

    • $table_name - nom de la table de base de données;

    • $columns - tableau de colonnes de table

  • Returns - Renvoie l'objet Database_Query_Builder_Insert

Par exemple,

$query = DB::insert('employee');  // Insert into employee 
$query = DB::insert('employee', array('id', 'name')); // Insert into employee (id, name)

mettre à jour

  • Purpose - Générer la partie mise à jour de la requête

  • Parameter -

    • $table_name - nom de la table de base de données

  • Returns - Renvoie l'objet Database_Query_Builder_Update

Par exemple,

$query = DB::update('employee'); // update `employee`

effacer

  • Purpose - Générer la partie suppression de la requête

  • Parameter -

    • $table_name - nom de la table de base de données

  • Returns - Renvoie l'objet Database_Query_Builder_Delete

Par exemple

$query = DB::delete('employee');  // delete from 'employee'

API de requête

Database_Queryfournit une option pour définir la connexion à la base de données, exécuter la requête et récupérer le résultat sous forme de tableau ou d'objet associatif. Voyons les méthodes fournies par la classe Database_Query.

set_connection

  • Purpose - Pour définir la base de données (détails de connexion à la base de données) sur laquelle exécuter la requête

  • Parameter - $ db - nom de connexion à la base de données

  • Returns- Renvoie l' objet Database_Query

Par exemple,

$query = DB::query('DELETE * FROM employee', DB::DELETE); 
$query->set_connection('2nd-db');

param

  • Purpose - Pour définir la valeur du paramètre défini dans l'objet Query

  • Parameter -

    • $param - nom du paramètre;

    • $value - valeur du paramètre

  • Returns- Renvoie l' objet Database_Query

Par exemple,

// set some variables
$table = 'employee';
$id = 1;
$name = 'Jon';

// don't use
$query = DB::query('SELECT * FROM '.$table.'. WHERE id = '.$id.' AND name = "'.$name.'"');

// but use
$query = DB::query('SELECT * FROM :tablename WHERE id = :id AND name = :name');
$query->param('tablename', 'employee');
$query->param('id', $id);
$query->param('name', $name);

Méthodes similaires

parameters est un objet similaire sauf qu'il offre l'option de donner plusieurs valeurs à la fois.

$query->parameters (array( 
   'tablename' => $table, 
   'id' => $id, 
   'name' => $name 
});

lier

  • Purpose - Pour définir une variable sur le paramètre défini dans l'objet Query

  • Parameter -

    • $param - nom du paramètre

    • $var - la variable à laquelle lier le paramètre

  • Returns- Renvoie l' objet Database_Query

Par exemple,

// bind a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->bind('tablename', $table);  

// update the variable 
$table = 'employee_salary'; 

// DELETE * FROM `employee_salary`; 
$sql = $query->compile();

compiler

  • Purpose - Pour compiler l'objet de requête défini en requête SQL

  • Parameter -

    • $db - chaîne de connexion, en option

  • Returns -

Par exemple,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);

// compile the query, returns: DELETE * FROM employee 
$sql = $query->compile();

exécuter

  • Purpose - Pour exécuter la requête définie dans l'objet Query et renvoyer le résultat

  • Parameter -

    • $db - nom de connexion à la base de données

  • Returns - Renvoie le résultat

Par exemple,

// assign a value to a query parameter 
$table = 'employee'; 
$query = DB::query('DELETE * FROM :tablename', DB::DELETE); 
$query->param('tablename', $table);  

// execute the query 
$query->execute();

as_assoc

  • Purpose - Pour définir le type de retour comme tableau associatif au lieu d'objets

  • Parameter - Aucun

  • Returns - Renvoie l'objet courant

Par exemple,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_assoc()->execute(); 
foreach ($result as $row) { 
   echo $row['id']; 
}

as_object

  • Purpose - Pour définir le type de retour comme objet au lieu d'un tableau associatif

  • Parameter - Aucun

  • Returns - Renvoie l'objet courant

Par exemple,

$query = DB::query('SELECT * FROM employee', DB::SELECT); 
$result = $query->as_object()->execute(); 
foreach ($result as $row) { 
   echo $row->id; 
}  

// have ORM model objects return instead 
$result = $query->as_object('Model_Employee')->execute();

API Query Builder

Les classes basées sur Query Builder (Query_Builder) fournissent des options pour créer des requêtes SQL de manière dynamique. Il comporte quatre classes, chacune permettant de sélectionner (Query_Builder_Select) , d'insérer (Query_Builder_Insert) , de mettre à jour (Query_Builder_Update) et de supprimer (Query_Builder_Delete) les requêtes. Ces classes sont dérivées de la classe Query_Builder_Where (option pour générer des conditions), elle-même dérivée de Query_Builder , base de toutes les classes.

Regardons les méthodes fournies par la classe Query_Builder.

sélectionner

  • Purpose - Pour générer les colonnes de requêtes de sélection.

  • Parameter -

    • $columns - liste des colonnes, facultative

  • Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')  // select `name` 
$query = DB::select(array('first_name', 'name')) // select `first_name` as `name`

de

  • Purpose - Pour générer les détails du tableau des requêtes sélectionnées

  • Parameter -

    • $tables - liste des tableaux

  • Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee') // select `name` from `employee`

où

  • Purpose - Pour générer les conditions de sélection, d'insertion et de mise à jour des requêtes

  • Parameters -

    • $column - nom de colonne ou tableau ($ colonne, $ alias);

    • $op - opérateurs logiques, =,! =, IN, BETWEEN et LIKE, facultatifs;

    • $value - valeur de la colonne

  • Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee')  
$query = $query->where('name', '=', 'Jon'); 
// select `name` from `employee` where `name` = `Jon`;

Méthodes similaires

Les méthodes similaires sont where_open (), and_where_open (), or_where_open (), where_close (), and_where_close (), or_where_close (). Elles sont similaires aux méthodes where () sauf qu'elles ajoutent des mots clés et des crochets supplémentaires autour des conditions. Voici un exemple de code.

$query = DB::select('*')->from('employee');  
$query->where('email', 'like', '%@gmail.com'); 
$query->or_where_open(); 
$query->where('name', 'Jon'); 
$query->and_where('surname', 'Peter');
$query->or_where_close();  
// SELECT * FROM `employee` WHERE `email` LIKE "%gmail.com" OR 
   (`name` = "Jon" AND `surname` = "Peter")

joindre

  • Purpose - Pour générer les jointures de table des requêtes sélectionnées

  • Parameters -

    • $table - nom de table ou tableau ($ table, $ alias);

    • $type - type de jointure (GAUCHE, DROITE, INTÉRIEUR, etc.,)

  • Returns - Renvoie l'instance actuelle

Exemple

$query = DB::select('name')->from('employee')->join('employee_salary') 
// select `name` from `employee` JOIN `employee_salary`

sur

  • Purpose - Pour générer la condition des jointures dans les requêtes sélectionnées

  • Parameters -

    • $c1 - nom de table ou nom de table avec alias dans le tableau;

    • $op - opérateur logique;

    • $c2 - nom de table ou nom de table avec alias dans le tableau

  • Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee')->join('employee_salary') 
$query = $query->on('employee.employee_id', '=', 'employee_salary.employee_id') 
// select `name` from `employee` JOIN `employee_salary` on 
// `employee.employee_id` = `employee_salary.employee_id`

Méthodes similaires

Les méthodes associées sont and_on () et or_on (). Ils sont similaires à on (), sauf qu'ils ajoutent des mots clés et des crochets supplémentaires autour des jointures.

par groupe

  • Purpose - Pour générer des requêtes group by

  • Parameter - $columns - Nom de la colonne par laquelle regrouper le résultat

  • Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee')  
$query = $query->group_by('name'); 
// select `name` from `employee` group by `name`

ayant

  • Purpose - Pour générer le groupe par conditions de requêtes SQL

  • Parameter - $column - nom de colonne ou tableau ($ colonne, $ alias); $op - opérateurs logiques, =,! =, IN, BETWEEN et LIKE, facultatifs; $value - valeur de la colonne

  • Returns - Renvoie l'instance actuelle

Exemple

$query = DB::select('name')->from('employee')
$query = $query->group_by('name');
$query = $query->having('name', '!=', 'Jon');
// select `name` from `employee` group by `name` having `name` != `Jon`

Méthodes similaires

Les méthodes similaires sont had_open (), and_having_open (), or_having_open (), having_close (), and_having_close () ou_having_close (). Elles sont similaires aux méthodes Have (), sauf qu'elles ajoutent des mots clés et des crochets supplémentaires autour des conditions.

réinitialiser

  • Purpose - Pour réinitialiser la requête

  • Parameter - Aucun

  • Returns - Renvoie l'instance actuelle

Par exemple,

$query = DB::select('name')->from('employee')  
$query->reset() 
$query = DB::select('name')->from('employee_salary') 
// select `name` from `employee_salary`

Classe DBUtil

La classe DBUtil fournit une option pour gérer et exécuter des opérations de base de données de routine. Certaines des méthodes importantes sont les suivantes -

  • set_connection - Définit la connexion par défaut
DBUtil::set_connection('new_database');
  • create_database - Crée une base de données.
DBUtil::create_database('my_database');
  • drop_database - Supprime une base de données.
DBUtil::drop_database('my_database');
  • table_exists - Vérifie si une table donnée existe.
if(DBUtil::table_exists('my_table')) { 
   // Table exists 
} else { 
   // Table does NOT exist, create it! 
}
  • drop_table - Supprime une table.
DBUtil::drop_table('my_table');
  • create_table - Crée une table.
\DBUtil::create_table ( 
   'users', 
   array ( 
      'id' => array('type' => 'int', 'auto_increment' => true), 
      'name' => array('type' => 'text'), 
   ), 
);

Boîte à outils Orm

FuelPHP fournit une couche de base de données avancée utilisant le concept ORM basé sur le populaire Active record pattern. La boîte à outils est incluse dans l'application mais n'est pas configurée par défaut. Il est fourni sous forme de package et le nom du package est orm. Nous pouvons ajouter la configuration suivante dans le fichier de configuration principal,fuel/app/config/config.php pour charger la boîte à outils orm.

'always_load' => array ( 
   'packages' => array (
      'orm', 
   ), 
),

Créer des modèles

Orm fournit la classe de modèle de base Orm \ Model. Nous devons étendre nos modèles avec le modèle orm pour utiliser les fonctionnalités ORM. Voici un exemple de code.

class Model_Employee extends Orm\Model {}

Configuration

Orm fournit un ensemble de paramètres pour configurer le modèle pour utiliser les fonctionnalités ORM. Ils sont les suivants -

connection- Définissez une propriété _connection statique dans le modèle pour spécifier le nom de la connexion.

class Model_Employee extends Orm\Model { 
   protected static $_connection = "production"; 
}

table name- Définissez une propriété statique _table_name dans le modèle pour spécifier le nom de table de la table backend.

class Model_Employee extends Orm\Model { 
   protected static $_table_name = 'employee'; 
}

primary key- Définissez une propriété statique _primary_key dans le modèle pour spécifier la clé primaire de la table backend.

class Model_Employee extends Orm\Model { 
   protected static $_primary_key = array('id'); 
}

Columns- Définissez une propriété _properties statique dans le modèle pour spécifier les colonnes de la table principale. Il prend en charge data_type, label, validation, elememts de formulaire, etc.

class Model_Employee extends Orm\Model { 
   protected static $_properties = array ( 
      'id',  
      'name' => array ( 
         'data_type' => 'varchar', 
         'label' => 'Employee Name', 
         'validation' => array ( 
            'required',  
            'min_length' => array(3),  
            'max_length' > array(80) 
         ), 
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  

      'age' => array ( 
         'data_type' => 'int', 
         'label' => 'Employee Age', 
         'validation' => array ( 
            'required',  
         ),  
         
         'form' => array ( 
            'type' => 'text' 
         ), 
      ),  
   ); 
}

Conditions- Définissez une propriété _conditions statique pour définir les conditions et classer par options.

class Model_Employee extends Orm\Model { 
   protected static $_conditions = array ( 
      'order_by' => array('id' => 'desc'), 
      'where' => array ( 
         array('is_active', > true), 
      ), 
   ); 
}

Observers- Orm fournit un système d'événements basé sur l'observateur pour ajouter un comportement à des événements spécifiques. Pour ajouter un comportement, définissez d'abord une propriété _observers dans le modèle. Ensuite, définissez le comportement en tant que classe et définissez-le dans la propriété _observers avec les événements. Si aucun événement n'est spécifié, le comportement sera appelé pour tous les événements. Nous pouvons également spécifier plusieurs comportements.

class Model_Employee { 
   protected static $_observers = array ( 
      'example',  // will call Observer_Example class for all events 
      'Orm\\Observer_CreatedOn' => array ( 
         'events' => array('before_insert'),  
         // will only call Orm\Observer_CreatedOn at before_insert event 
      ) 
   ); 
}

Créer

Une fois que nous avons configuré le modèle, nous pouvons commencer à utiliser les méthodes immédiatement. ORM fournit une sauvegarde méthode pour enregistrer l'objet dans la base de données. Nous pouvons définir les données en utilisant les propriétés configurées comme suit -

// option 1 
$new = new Model_Employee(); 
$new->name = 'Jon'; 
$new->save();  

// option 2, use forge instead of new 
$new = Model_Employee::forge();
$new->name = 'Jon'; 
$new->save();  

// option 3, use array for properties 
$props = array('name' => 'Jon'); 
$new = Model_Employee::forge($props); 
$new>save();

Lis

Orm fournit une méthode, find pour récupérer les données de la base de données et se lier à l'objet. La méthode find fonctionne en fonction du paramètre d'entrée. Regardons les différentes options -

by primary key - La spécification de la clé primaire renvoie l'enregistrement en faisant correspondre la clé primaire de la table configurée.

$employee = Model_Employee::find(1);

first / last record- Spécifier «premier» ou «dernier» récupérera respectivement le premier ou le dernier enregistrement. Nous pouvons également passer la commande par option.

$entry = Model_Employee::find('first'); 
$entry = Model_Article::find('last', array('order_by' => 'id'));

All- Spécifier «tous» récupérera tous les enregistrements de la table configurée. Nous pouvons spécifier une commande par option ainsi que des conditions.

$entry = Model_Employee::find('all');  
$entry = Model_Article::find ('all', array ( 
   'where' => array ( 
      array ('name', 'Jon'), 
   ), 
   'order_by' => array ('id' => 'desc'), 
));

Nous pouvons utiliser l'API de requête de la boîte à outils de base de données de base avec le modèle pour l'option de recherche avancée comme suit.

$query = Model_Employee::query()->where('category_id', 1)->order_by('date', 'desc');
$number_of_employees = $query->count(); 
$latest_employee = $query->max('id'); 
$young_employee = $query->min('age'); 
$newest_employee = $query->get_one(); 
$employees = $query->limit(15)->get();

Mettre à jour

La mise à jour du modèle est identique à la création, sauf qu'au lieu de créer un nouveau modèle, récupérez simplement le modèle à mettre à jour à l'aide de la méthode find, mettez à jour la propriété, puis appelez la méthode save comme suit.

$entry = Model_Employee:find(4);
$entry->name = 'Peter'; 
$entry->save();

Effacer

Orm fournit une méthode de suppression pour supprimer le modèle. Récupérez simplement l'objet et appelez la méthode de suppression.

$entry = Model_Employee:find(4); 
$entry->delete();

Exemple de travail

Créons un exemple de travail dans ce chapitre pour comprendre le modèle et la base de données.

Créer une base de données

Créez une nouvelle base de données sur le serveur MySQL à l'aide de la commande suivante.

create database tutorialspoint_fueldb

Ensuite, créez une table dans la base de données à l'aide de la commande suivante.

create table employee(id int primary key, name varchar(20), age int not null);

Configurer la base de données

Configurons la base de données à l'aide du fichier de configuration de la base de données, * fuel / app / config / db.php. Ajoutez les modifications suivantes pour connecter le serveur MySQL.

<?php  
   return array ( 
      'development' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ),  
      
      'production' => array ( 
         'type'           => 'mysqli', 
         'connection'     => array ( 
            'hostname'       => 'localhost', 
            'port'           => '3306', 
            'database'       => 'tutorialspoint_fueldb', 
            'username'       => 'root', 
            'password'       => 'pass', 
            'persistent'     => false, 
            'compress'       => false, 
         ), 
         
         'identifier'     => '`', 
         'table_prefix'   => '', 
         'charset'        => 'utf8', 
         'enable_cache'   => true, 
         'profiling'      => false, 
         'readonly'       => false, 
      ), 
   );

Inclure le package ORM

Mettre à jour le fichier de configuration principal, fuel/app/config/config.php pour inclure le package ORM en ajoutant la configuration suivante.

'always_load' => array ( 
   'packages' => array ( 
      'orm' 
   ), 
),

Désormais, ORM est activé dans votre application

Créer un modèle d'employé

Créer un nouveau modèle, Employé sous le dossier modèle “fuel/app/classes/model”. Il est défini comme suit.

Employee.php

<?php  
   class Model_Employee extends Orm\Model { 
      protected static $_connection = 'production'; 
      protected static $_table_name = 'employee'; 
      protected static $_primary_key = array('id'); 
      protected static $_properties = array ( 
         'id',  
         'name' => array ( 
            'data_type' => 'varchar', 
            'label' => 'Employee Name', 
            'form' => array (
               'type' => 'text' 
            ), 
         ),  
         
         'age' => array ( 
            'data_type' => 'int', 
            'label' => 'Employee Age', 
            'form' => array ( 
               'type' => 'text' 
            ), 
         ),  
      ); 
   }

Créer une action

Créer une nouvelle action, action_model dans le contrôleur des employés situé à fuel/app/classes/controller/employee.php comme suit.

class Controller_Employee extends Controller { 
   public function action_model() { 
      
      // db based sql command to delete all employees 
      $query = db::query('delete from `employee`'); 
      $query->execute('production');  
      
      // orm based query to add new employees 
      $model = new model_employee(); 
      $model->name = "john"; 
      $model->age = 25; 
      $model->save();  
      $model = new model_employee(); 
      $model->name = "peter"; 
      $model->age = 20; 
      $model->save(); 
      
      // orm based query to fetch all employee data 
      $data = array(); 
      $data['emps'] = model_employee::find('all');  
      return response::forge(view::forge('employee/model', $data)); 
   } 
}

Créer une vue

Maintenant, créez un fichier de vue model.php situé à “fuel/app/views/employee”. Ajoutez les modifications suivantes dans le fichier.

<ul> 
   <?php 
      foreach($emps as $emp) {  
   ?> 
   <li><?php echo $emp['name']; ?></li> 
   
   <?php 
   } 
   ?> 
</ul>

Maintenant, demandez l'URL, http://localhost:8080/employee/model et cela produira le résultat suivant.

Résultat

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved