CodeIgniter-Datenbank: Daten konfigurieren, bearbeiten, aktualisieren, löschen
Fiona Braun
Codeigniter-Datenbank
Im vorherigen Tutorial haben wir die Grundlagen des aktiven CodeIgniter-Datensatzes und das Einfügen, Aktualisieren, Löschen und Lesen von Datensätzen aus der Datenbank behandelt. In diesem Tutorial erstellen wir Datenbankmodelle und verwenden Formulare zum Erstellen und Aktualisieren von Datenbankdatensätzen. Wenn Sie mit der Arbeit mit Datenbanken in CodeIgniter völlig neu sind, empfehlen wir Ihnen, das vorherige Tutorial zu lesen
Konfiguration der Codeigniter-Datenbank
Wir beginnen mit der Erstellung der Tutorial-Projektdatenbank. Wir erstellen eine einfache Datenbank zur Verwaltung von Kontaktdaten. Wir erstellen eine einfache Datenbank mit zwei (2) Tabellen mit den Namen „pals“ und den Städten, in denen sie leben. Die Beziehung zwischen „pals“ und „citys“ ist eins zu eins mit „id“ in „citys“ als Primärschlüssel und „city_id“ als Fremdschlüssel in „pals“-Tabellen.
Führen Sie die folgenden Skripts aus, um die Datenbank zu erstellen:
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`) );
Lassen Sie uns nun die Städtetabelle erstellen
CREATE TABLE `cities` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(245) DEFAULT NULL, PRIMARY KEY (`id`) ) ;
CodeIgniter-Datenbankmodelle
Wir werden nun Modelle für unsere Datenbank erstellen. Das Modell ist der M-Teil des MVC. Das Modell befasst sich mit Datenzugriff, Datenmanipulation und Geschäftslogik.
In CodeIgniter muss jedes Modell die Methoden definieren, die es unterstützen wird. Anstatt denselben Code in jedem Modell zu wiederholen, nutzen wir die Vererbung in der objektorientierten Programmierung und erstellen eine übergeordnete Modellklasse, die die grundlegenden Methoden definiert, die unsere Modelle unterstützen sollen.
Die folgende Tabelle zeigt die Methoden, die wir definieren werden, und wie auf Daten zugegriffen wird.
| S / N | Methodik | Beschreibung |
|---|---|---|
| 1 | __bauen | Definiert die Konstruktormethode, die die übergeordnete Konstruktormethode aufruft |
| 2 | Nimm alle | Ruft alle Felder und Datensätze ohne Bedingungen aus der Datenbank ab |
| 3 | get_by_id | Ruft eine einzelne Zeile aus der Datenbank unter Verwendung des Primärschlüssels vom Typ INT namens id ab |
| 4 | get_where | Ruft alle Felder aus der Datenbank basierend auf den Kriterien ab |
| 5 | einfügen | Fügt einen neuen Datensatz in die Datenbank ein |
| 6 | Aktualisierung | Aktualisiert einen vorhandenen Datenbankeintrag basierend auf dem Primärschlüssel vom Typ INT namens id |
| 7 | löschen | Löscht einen vorhandenen Datensatz aus der Datenbank basierend auf dem Primärschlüssel vom Typ INT namens id |
Das folgende Bild zeigt das Klassendiagramm und wie sich die untergeordneten Modelle „Pals“ und „Cities“ auf das übergeordnete Modell „BaseModel“ beziehen.
Wir werden zwei Modelle erstellen, wie im obigen Bild beschrieben
Erstellen Sie eine neue Klasse BaseModel in application/models/BaseModel.php
Fügen Sie den folgenden Code hinzu
<?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);
}
}
HIER,
- protected $table = ”; definiert eine geschützte Variable namens table. Dies wird von der jeweiligen untergeordneten Klasse ausgefüllt, um anzugeben, mit welcher Tabelle unsere Basismodellklassenmethoden interagieren sollen.
- Die öffentliche Funktion __construct() {…} definiert die Konstruktormethode und führt die Konstruktormethode der übergeordneten Klasse CI_Model aus.
- get_all() {…} verwendet die Datenbankbibliothek und den Wert der Variablen $table, um die SELECT-Abfrage für unsere Datenbank auszuführen.
- get_by_id($id) {…} definiert die Methode zum Abrufen einer einzelnen Zeile aus der Datenbank und akzeptiert einen Parameter $id, der vom Datentyp INT sein sollte.
- get_where($where) {…} definiert die Get-Methode, mit der Sie eine Where-Klausel festlegen können.
- insert($data) {…} definiert die Einfügemethode und akzeptiert den Array-Parameter $data, der die in die Datenbank zu schreibenden Werte enthält.
- update($id, $data) {…} definiert die Update-Methode und akzeptiert den Array-Parameter $data, der die in der Datenbank zu aktualisierenden Werte enthält.
- delete($id) {…} definiert die Löschmethode, die einen Parameter von $id akzeptiert, der vom Datentyp INT sein sollte.
Nachdem wir nun mit der übergeordneten Modellklasse fertig sind, erstellen wir unsere Pals-Modelle
Erstellen Sie eine neue Datei in application/models/Pals.php
Fügen Sie den folgenden Code hinzu
<?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();
}
}
HIER,
- Klasse Pals erweitert BaseModel {…} erweitert das übergeordnete Modell BaseModel und stellt automatisch alle im BaseModel definierten Methoden zur Verfügung, auf die auf die untergeordnete Klasse zugegriffen wird.
- protected $table = 'pals'; definiert den Tabellennamen, der unserem übergeordneten Modell zugeordnet ist
- __construct() {…} initialisiert den übergeordneten Konstruktor
- Die öffentliche Funktion get_by_id($id) {…} überschreibt get_by_id, um eine benutzerdefinierte Implementierung speziell für das Pals-Modell bereitzustellen. Die Abfrage für get_by_id verwendet einen Join, um den Stadtnamen aus der Städtetabelle abzurufen
- Die öffentliche Funktion get_all() {…} überschreibt die Methode get_all, um eine Join-Abfrage zwischen der Tabelle „pals“ und „citys“ zu implementieren
Erstellen Sie eine neue Datei in application/models/Cities.php
<?php
class Cities extends BaseModel {
protected $table = 'cities';
public function __construct() {
parent::__construct();
}
}
HIER,
protected $table = 'Städte'; definiert die Modelldatenbanktabelle.
Wie Sie dem oben angegebenen Code entnehmen können, spart uns Inheritance viel Zeit bei der Arbeit mit Modellen in CodeIgniter. Im nächsten Abschnitt werden wir es lernen
Kontakte Manager Controller
Nachdem wir nun die Modelle erstellt haben, erstellen wir die Controller für unsere Anwendung. Wir werden zwei Controller haben, nämlich Kontakte und Städte
Beginnen wir mit den Städten
Erstellen Sie eine neue Datei Cities.php im Verzeichnis application/controllers
Fügen Sie den folgenden Code hinzu
<?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'));
}
}
HIER,
Der obige Code implementiert alle Methoden, die zum Erstellen, Aktualisieren, Löschen und Lesen von Zeilen aus der Datenbank erforderlich sind.
Erstellen Sie eine weitere Datei Contacts.php in application/controllers
Fügen Sie den folgenden Code hinzu
<?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'));
}
}
Kontakte-Manager-Ansichten
In den vorherigen Tutorials haben wir uns bereits mit Formularen und Validierung in CodeIgniter befasst. Wir werden den Code verwenden, den wir in den vorherigen Tutorials entwickelt haben. Der Vollständigkeit halber reproduzieren wir den Code, den wir in den vorherigen Tutorials erstellt haben.
Die Ansichten unserer Bewerbung werden wie folgt sein
Sie können den Code für die oben genannten Ansichten herunterladen, indem Sie auf den Link unten klicken
CodeIgniter Contacts Manager-Ansichten herunterladen
Zusammenfassung
In diesem Tutorial erfahren Sie, wie Sie Modelle erstellen CodeIgniter. Wir haben die Vererbung in der objektorientierten Programmierung ausgenutzt, um die Wiederverwendbarkeit von Code zu fördern, indem wir ein Basismodell erstellt haben, das die vier wichtigsten Datenbankoperationen Einfügen, Lesen, Aktualisieren und Löschen implementiert.
Wir haben die Konzepte anhand einer praktischen Anwendung demonstriert und werden dies in den nächsten Tutorials fortsetzen, indem wir der Anwendung weitere Funktionen hinzufügen.
