Database CodeIgniter: configurazione, modifica, aggiornamento, eliminazione dati
Fiona Marrone
Database di Codeigniter
Nel tutorial precedente, abbiamo trattato le basi del record attivo di CodeIgniter e come inserire, aggiornare, eliminare e leggere i record dal database. In questo tutorial creeremo modelli di database e utilizzeremo moduli per creare e aggiornare i record del database. se sei completamente nuovo nel lavorare con i database in CodeIgniter, ti consigliamo di leggere il tutorial precedente
Configurazione del database Codeigniter
Inizieremo creando il database del progetto tutorial. Creeremo un database semplice per gestire i dettagli dei contatti. Creeremo un database semplice con due (2) tabelle denominate pals e cities in cui vivono. La relazione tra pals e cities è uno a uno con id in cities come chiave primaria e city_id come chiave esterna nelle tabelle pals.
Eseguire i seguenti script per creare il database:
CREATE TABLE `pals` ( `id` int(11) NOT NULL AUTO_INCREMENT, `city_id` int(11) DEFAULT NULL, `contact_name` varchar(245) DEFAULT NULL, `contact_number` varchar(245) DEFAULT NULL, `email_address` varchar(245) DEFAULT NULL, PRIMARY KEY (`id`) );
Creiamo ora la tabella delle città
CREATE TABLE `cities` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(245) DEFAULT NULL, PRIMARY KEY (`id`) ) ;
Modelli di database CodeIgniter
Ora creeremo modelli per il nostro database. Il Modello è la parte M del MVC. Il modello si occupa dell'accesso ai dati, della manipolazione dei dati e della logica aziendale.
In CodeIgniter, ciascun modello deve definire i metodi che supporterà. Invece di ripetere lo stesso codice in ogni modello, sfrutteremo l'ereditarietà nella programmazione orientata agli oggetti e creeremo una classe del modello genitore che definirà i metodi di base che desideriamo che i nostri modelli supportino.
Nella tabella seguente sono riportate le modalità che definiremo e le modalità di accesso ai dati.
| S / N | Metodo | Descrizione |
|---|---|---|
| 1 | __costruire | Definisce il metodo del costruttore che chiama il metodo del costruttore padre |
| 2 | prendi tutto | Recupera tutti i campi e i record dal database senza alcuna condizione |
| 3 | get_by_id | Recupera una singola riga dal database utilizzando la chiave primaria di tipo INT denominata id |
| 4 | arrivare_dove | Recupera tutti i campi dal database in base ai criteri di base |
| 5 | insert | Inserisce un nuovo record nel database |
| 6 | update | Aggiorna un record del database esistente in base alla chiave primaria di tipo INT denominata id |
| 7 | delete | Elimina un record esistente dal database in base alla chiave primaria di tipo INT denominata id |
L'immagine seguente mostra il diagramma delle classi e il modo in cui i modelli figlio Pals e Cities si relazionano al modello padre BaseModel.
Creeremo due modelli come descritto nell'immagine sopra
Crea una nuova classe BaseModel in application/models/BaseModel.php
Aggiungere il seguente codice
<?php
class BaseModel extends CI_Model {
protected $table = '';
public function __construct() {
parent::__construct();
}
public function get_all() {
return $this->db->get($this->table)
->result();
}
public function get_by_id($id) {
return $this->db->get_where($this->table, array('id' => $id))
->row();
}
public function get_where($where) {
return $this->db->where($where)
->get($this->table)
->result();
}
public function insert($data) {
return $this->db->insert($this->table, $data);
}
public function update($id, $data) {
$this->db->where('id', $id);
$this->db->update($this->table, $data);
}
public function delete($id) {
$this->db->where('id', $id);
$this->db->delete($this->table);
}
}
QUI,
- protetta $tabella = "; definisce una variabile protetta denominata tabella. Questo verrà popolato dalla rispettiva classe figlia per specificare con quale tabella i nostri metodi della classe del modello base dovrebbero interagire.
- la funzione pubblica __construct() {…} definisce il metodo di costruzione ed esegue il metodo di costruzione della classe genitore CI_Model.
- get_all() {…} utilizza la libreria del database e il valore della variabile $table per eseguire la query SELECT sul nostro database.
- get_by_id($id) {…} definisce il metodo per recuperare una singola riga dal database e accetta un parametro $id che dovrebbe essere di tipo dati INT.
- get_where($where) {…} definisce il metodo get che consente di impostare una clausola where.
- insert($data) {…} definisce il metodo insert e accetta il parametro dell'array $data che contiene i valori da scrivere nel database.
- update($id, $data) {…} definisce il metodo di aggiornamento e accetta il parametro dell'array $data che contiene i valori da aggiornare nel database.
- delete($id) {…} definisce il metodo delete che accetta un parametro di $id che dovrebbe essere di tipo dati INT.
ora che abbiamo finito con la classe del modello genitore, creiamo i nostri modelli Pals
Crea un nuovo file in application/models/Pals.php
Aggiungere il seguente codice
<?php
class Pals_model extends BaseModel {
protected $table = 'pals';
public function __construct() {
parent::__construct();
}
public function get_by_id($id) {
$this->db->where('pals.id', $id);
$this->db->select('pals.*,cities.name');
$this->db->from('pals');
$this->db->join('cities', 'pals.city_id = cities.id');
$query = $this->db->get();
return $query->row();
}
public function get_all() {
$this->db->select('pals.*,cities.name');
$this->db->from('pals');
$this->db->join('cities', 'pals.city_id = cities.id');
$query = $this->db->get();
return $query->result();
}
}
QUI,
- class Pals extends BaseModel {...} estende il modello genitore BaseModel e rende automaticamente accessibili tutti i metodi definiti nel BaseModel alla classe figlia.
- protetto $tabella = 'amici'; definisce il nome della tabella associata al nostro modello principale
- __construct() {…} inizializza il costruttore genitore
- la funzione pubblica get_by_id($id) {…} sovrascrive get_by_id per fornire un'implementazione personalizzata specifica per il modello Pals. La query per get_by_id utilizza un join per recuperare il nome della città dalla tabella delle città
- la funzione pubblica get_all() {…} sovrascrive il metodo get_all per implementare una query di join tra la tabella pals e city
Crea un nuovo file in application/models/Cities.php
<?php
class Cities extends BaseModel {
protected $table = 'cities';
public function __construct() {
parent::__construct();
}
}
QUI,
protetta $tabella = 'città'; definisce la tabella del database modello.
Come puoi vedere dal codice sopra indicato, l'ereditarietà ci fa risparmiare molto tempo quando lavoriamo con i modelli in CodeIgniter. Nella prossima sezione impareremo
Responsabile Contatti Controller
Ora che abbiamo creato i modelli, creiamo i controller per la nostra applicazione. Avremo due controller: Contatti e Città
Cominciamo dalle città
Crea un nuovo file Cities.php nella directory application/controllers
Aggiungere il seguente codice
<?php
defined('BASEPATH') OR exit('No direct script access allowed');
class Cities extends CI_Controller {
public function __construct() {
parent::__construct();
$this->load->helper('url', 'form');
$this->load->library('form_validation');
$this->load->model('cities_model');
}
public function index() {
$header['title'] = 'Cities Listing';
$data['pals'] = $this->cities_model->get_all();
$this->load->view('header',$header);
$this->load->view('cities/index', $data);
$this->load->view('footer');
}
public function create() {
$header['title'] = 'Create City';
$this->load->view('header',$header);
$this->load->view('cities/create');
$this->load->view('footer');
}
public function store() {
$rules = array(
array(
'field' => 'name',
'label' => 'City Name',
'rules' => 'required'
)
);
$this->form_validation->set_rules($rules);
if ($this->form_validation->run() == TRUE) {
$data = array('name' => $this->input->post('name'));
$this->cities_model->insert($data);
redirect(base_url('cities'));
} else {
$header['title'] = 'Create City';
$this->load->view('header',$header);
$this->load->view('cities/create');
$this->load->view('footer');
}
}
public function edit($id) {
$header['title'] = 'Edit City';
$data['city'] = $this->cities_model->get_by_id($id);
$this->load->view('header', $header);
$this->load->view('cities/edit', $data);
$this->load->view('footer');
}
public function update($id) {
$rules = array(
array(
'field' => 'name',
'label' => 'City Name',
'rules' => 'required'
)
);
$this->form_validation->set_rules($rules);
if ($this->form_validation->run() == TRUE) {
$data = array('name' => $this->input->post('name'));
$this->cities_model->update($id,$data);
redirect(base_url('cities'));
} else {
$header['title'] = 'Edit City';
$data['city'] = $this->cities_model->get_by_id($id);
$this->load->view('header',$header);
$this->load->view('cities/create',$data);
$this->load->view('footer');
}
}
public function delete($id) {
$header['title'] = 'Delete City';
$data['city'] = $this->cities_model->get_by_id($id);
$this->load->view('header', $header);
$this->load->view('cities/delete', $data);
$this->load->view('footer');
}
public function destroy($id) {
$this->cities_model->delete($id);
redirect(base_url('cities'));
}
}
QUI,
Il codice precedente implementa tutti i metodi necessari per creare, aggiornare, eliminare e leggere righe dal database.
Crea un altro file CONTACTs.php in application/controllers
Aggiungere il seguente codice
<?php
defined('BASEPATH') OR exit('No direct script access allowed');
class Contacts extends CI_Controller {
public function __construct() {
parent::__construct();
$this->load->helper('url', 'form');
$this->load->library('form_validation');
$this->load->model('pals_model');
}
public function index() {
$header['title'] = 'Contacts List';
$data['pals'] = $this->pals_model->get_all();
$this->load->view('header', $header);
$this->load->view('contacts/index', $data);
$this->load->view('footer');
}
public function create() {
$this->load->model('cities_model');
$header['title'] = 'Create Contact';
$data['cities'] = $this->cities_model->get_all();
$this->load->view('header', $header);
$this->load->view('contacts/create', $data);
$this->load->view('footer');
}
public function store() {
$rules = array(
array(
'field' => 'contact_name',
'label' => 'Contact Name',
'rules' => 'required'
),
array(
'field' => 'contact_number',
'label' => 'Contact Number',
'rules' => 'required',
'errors' => array(
'required' => 'You must provide a %s.',
),
),
array(
'field' => 'email_address',
'label' => 'Email Address',
'rules' => 'required'
),
array(
'field' => 'city_id',
'label' => 'City',
'rules' => 'required'
)
);
$this->form_validation->set_rules($rules);
if ($this->form_validation->run() == FALSE) {
$this->load->model('cities_model');
$header['title'] = 'Create Contact';
$data['cities'] = $this->cities_model->get_all();
$this->load->view('header', $header);
$this->load->view('contacts/create', $data);
$this->load->view('footer');
} else {
$data = array(
'city_id' => $this->input->post('city_id'),
'contact_name' => $this->input->post('contact_name'),
'contact_number' => $this->input->post('contact_number'),
'email_address' => $this->input->post('email_address'),
);
$this->pals_model->insert($data);
redirect(base_url('contacts'));
}
}
public function edit($id) {
$this->load->model('cities_model');
$header['title'] = 'Edit Contact';
$data['cities'] = $this->cities_model->get_all();
$data['pal'] = $this->pals_model->get_by_id($id);
$this->load->view('header', $header);
$this->load->view('contacts/edit', $data);
$this->load->view('footer');
}
public function update($id) {
$rules = array(
array(
'field' => 'contact_name',
'label' => 'Contact Name',
'rules' => 'required'
),
array(
'field' => 'contact_number',
'label' => 'Contact Number',
'rules' => 'required',
'errors' => array(
'required' => 'You must provide a %s.',
),
),
array(
'field' => 'email_address',
'label' => 'Email Address',
'rules' => 'required'
),
array(
'field' => 'city_id',
'label' => 'City',
'rules' => 'required'
)
);
$this->form_validation->set_rules($rules);
if ($this->form_validation->run() == FALSE) {
$this->load->model('cities_model');
$header['title'] = 'Create Contact';
$data['cities'] = $this->cities_model->get_all();
$data['pal'] = $this->pals_model->get_by_id($id);
$this->load->view('header', $header);
$this->load->view('contacts/edit', $data);
$this->load->view('footer');
} else {
$data = array(
'city_id' => $this->input->post('city_id'),
'contact_name' => $this->input->post('contact_name'),
'contact_number' => $this->input->post('contact_number'),
'email_address' => $this->input->post('email_address'),
);
$this->pals_model->update($id, $data);
redirect(base_url('contacts'));
}
}
public function delete($id) {
$this->load->model('cities_model');
$header['title'] = 'Delete Contact';
$data['cities'] = $this->cities_model->get_all();
$data['pal'] = $this->pals_model->get_by_id($id);
$this->load->view('header',$header);
$this->load->view('contacts/delete',$data);
$this->load->view('footer');
}
public function destroy($id){
$this->pals_model->delete($id);
redirect(base_url('contacts'));
}
}
Visualizzazioni Gestione contatti
Abbiamo già esaminato i moduli e la convalida in CodeIgniter nei tutorial precedenti. Utilizzeremo il codice che abbiamo sviluppato nei tutorial precedenti. Per completezza, riprodurremo il codice che abbiamo creato nei tutorial precedenti.
Le visualizzazioni della nostra applicazione saranno le seguenti
Puoi scaricare il codice per le visualizzazioni sopra facendo clic sul collegamento in basso
Download delle visualizzazioni della gestione contatti di CodeIgniter
Sommario
In questo tutorial imparerai come creare modelli in CodeIgniterAbbiamo sfruttato l'ereditarietà nella programmazione orientata agli oggetti per promuovere la riutilizzabilità del codice creando un modello base che implementa le quattro principali operazioni di database: inserimento, lettura, aggiornamento ed eliminazione.
Abbiamo dimostrato i concetti utilizzando un'applicazione pratica e continueremo a farlo nei prossimi tutorial aggiungendo ulteriori funzionalità all'applicazione.
