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

↰ Previous page Next page ↱

FuelPHP - Modèles et base de données

Créer un modèle

fuel / app / classes / model / employee.php

Accéder à un modèle

Aperçu de la base de données

Configuration de la base de données

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

API DB

exemple

requete

last_query

sélectionner

select_array (DB)

insérer

mettre à jour

effacer

API de requête

set_connection

param

Méthodes similaires

lier

compiler

exécuter

as_assoc

as_object

API Query Builder

sélectionner

de

où

Méthodes similaires

joindre

sur

Méthodes similaires

par groupe

ayant

Méthodes similaires

réinitialiser

Classe DBUtil

Boîte à outils Orm

Créer des modèles

Configuration

Créer

Lis

Mettre à jour

Effacer

Exemple de travail

Créer une base de données

Configurer la base de données

Inclure le package ORM

Créer un modèle d'employé

Créer une action

Créer une vue

Résultat

Tutoriel FuelPHP