Codeigniter, parte 6: Modelos

7 Ago

Bueno, ahora que ya sabemos cómo funcionan los controladores y las vistas, podemos completar la parte que nos falta: los modelos.

Como dije en un principio, los modelos son los encargados de realizar las consultas a la base de datos, estos no son más que clases, en donde cada modelo representa a una tabla en la base de datos, y por ende, estas clases tendrán métodos que tendrán una suerte de consultas.

Codeigniter por su parte nos provee de una serie de métodos para armar consultas, que tienen una ventaja, y es que si en algún momento decidimos cambiar de tipo de base de datos (por ejemplo de MySQL a Oracle) no tendremos que cambiar la consulta, ya que el propio framework se hace cargo de definir el formato de la consulta.

Para esta ocasión haremos un ejemplo simple con una tabla y vamos a ver algunas consultas.

En primer lugar deberíamos crear una base de datos, y una tabla para probar lo que veremos en esta publicación. Yo creé una tabla con este aspecto:

CREATE TABLE informes(
 id int(10) unsigned not null auto_increment primary key,
 titulo varchar(50) not null,
 descripcion text not null,
 prioridad tinyint(1) not null
)ENGINE=innoDB;

Bien, muy simple, tenemos una tabla llamada informes, ésta tiene tres campos, una para guardar un título de un informe, una descripción y una prioridad, que será un valor numérico.

 

Creando nuestro primer modelo

Vamos a application -> models y creamos un archivo php con el siguiente nombre: informe_model.php. Este archivo será una clase con el siguiente formato:

<?php
class Informe_model extends CI_Model { 
   public function __construct() {
      parent::__construct();
   }
}

Notar que al igual que los controladores que deben heredar de la clase de Codeigniter CI_Controller, los modelos deben heredar de otra clase llamada CI_Model.

 

Insertar y modificar registros

Para insertar registros simplemente debemos llamar al objeto db y al método insert(). Este método recibirá dos parámetros, el nombre de la tabla y un array asociativo en donde los índices serán los nombre de las tablas y los valores son los datos a guardar:

$data = array(
   'titulo' => 'Título del informe',
   'descripcion' => 'Descripción del informe',
   'prioridad' => 3
);
$this->db->insert('informes', $data);

Lo propio podemos hacer para modificar un informe, sólo que en lugar de usar el método insert() usamos update(). Sin embargo, normalmente cuando se realiza un update en la base de datos suele venir acompañado por una condición, por ejemplo podemos modificar un registro cuando su id sea un valor x. Por ejemplo:

$data = array(
   'titulo' => 'Título del informe',
   'descripcion' => 'Descripción del informe',
   'prioridad' => 3
);
$this->db->where('id', 1);
$this->db->update('informes', $data);

Sabiendo esto, podemos crear el primer método de nuestro modelo, al que yo llamaré guardar():

public function guardar($titulo, $descripcion, $prioridad, $id=null){
   $data = array(
      'titulo' => $titulo,
      'descripcion' => $descripcion,
      'prioridad' => $prioridad
   );
   if($id){
      $this->db->where('id', $id);
      $this->db->update('informes', $data);
   }else{
      $this->db->insert('informes', $data);
   } 
 }

Este método recibirá cuatro datos, el título, descripción, prioridad y id de un informe, sin embargo el último valor será opcional. En caso de que no ingresemos un id, se insertará un valor nuevo en la base de datos, de lo contrario se va a modificar el registro con el id pasado como parámetro.

Recuperar id de último registro insertado

Algo que nos puede ser útil es recuperar un id de un registro que acabamos de insertar. Para ello sólo debemos llamar al método insert_id():

$id = $this->db->insert_id();

 

Eliminar registros 

Al igual que cuando modificábamos registros, un proceso similar podemos hacer para eliminar, mediante una condición y el método delete():

$this->db->where('id', 1);
$this->db->delete('informes');

Entonces con esto podemos agregar un nuevo método a nuestra clase modelo:

public function eliminar($id){
   $this->db->where('id', $id);
   $this->db->delete('informes');
}

 

Listar registros

Bien, para hacer un select simplemente debemos hacer una combinación entre el método select() y el método from():

$this->db->select('id, titulo, descripcion, prioridad');
$this->db->from('informes');
$consulta = $this->db->get();
$resultado = $consulta->result();

Con el método get(), recuperamos la consulta, y luego mediante el método result() podemos obtener un array en donde cada posición será un objeto con los datos del registro.

Aunque también se puede obtener la consulta mediante un array asociativo, en ese caso en lugar de result(), se usa result_array():

$this->db->select('id, titulo, descripcion, prioridad');
$this->db->from('informes');
$consulta = $this->db->get();
$resultado = $consulta->result_array();

También podemos recuperar la cantidad de registros encontrados:

$this->db->select('id, titulo, descripcion, prioridad');
$this->db->from('informes');
$consulta = $this->db->get();
$cantidad_encontrados = $consulta->num_rows();

Entonces ya que más o menos tenemos una idea de cómo recuperar registros podemos crear un nuevo método, el cual, nos devuelva todos los informes ordenados por prioridad y luego por título:

public function obtener_todos(){
   $this->db->select('id, titulo, descripcion, prioridad');
   $this->db->from('informes');
   $this->db->order_by('prioridad, titulo', 'asc');
   $consulta = $this->db->get();
   $resultado = $consulta->result();
   return $resultado;
}

 

Recuperar un registro específico

También podemos hacer un select en la base de datos, pero en lugar de recuperar varios registros, hacerlo con uno en particular, esto gracias al método row():

$consulta = $this->db->get();
$resultado = $consulta->row();

Por ejemplo, podemos crear un nuevo método que nos devuelva un objeto con los datos de un registro con un id específico:

public function obtener_por_id($id){
   $this->db->select('id, titulo, descripcion, prioridad');
   $this->db->from('informes');
   $this->db->where('id', $id);
   $consulta = $this->db->get();
   $resultado = $consulta->row();
   return $resultado;
}

 

Finalmente nuestro modelo va a quedar así:

<?php
class Informe_model extends CI_Model { 
   public function __construct() {
      parent::__construct();
   }
   public function guardar($titulo, $descripcion, $prioridad, $id=null){
      $data = array(
         'titulo' => $titulo,
         'descripcion' => $descripcion,
         'prioridad' => $prioridad
      );
      if($id){
         $this->db->where('id', $id);
         $this->db->update('informes', $data);
      }else{
         $this->db->insert('informes', $data);
      } 
   }
   public function eliminar($id){
      $this->db->where('id', $id);
      $this->db->delete('informes');
   }
   public function obtener_por_id($id){
      $this->db->select('id, titulo, descripcion, prioridad');
      $this->db->from('informes');
      $this->db->where('id', $id);
      $consulta = $this->db->get();
      $resultado = $consulta->row();
      return $resultado;
   }
   public function obtener_todos(){
      $this->db->select('id, titulo, descripcion, prioridad');
      $this->db->from('informes');
      $this->db->order_by('prioridad, titulo', 'asc');
      $consulta = $this->db->get();
      $resultado = $consulta->result();
      return $resultado;
   }
}

 

Unión de tablas

También podemos unir dos tablas. Podemos hacer algo como esto:

$this->db->select('*');
$this->db->from('publicaciones');
$this->db->join('comentarios', 'comentarios.publicacion_id = publicaciones.id');
$consulta = $this->db->get();
$resultado = $consulta->result();

En este caso obtendremos una lista de publicaciones con sus respectivos comentarios.

 

Consulta simple

También podemos escribir nuestra consulta de forma tradicional de la siguiente forma:

$consulta = $this->db->query("SELECT * FROM informes"); 
$resultado = $consulta->result();

 

Conectar con la base de datos

Ahora que ya tenemos una idea de cómo realizar consultas, falta la parte principal para que nuestra aplicación pueda conectarse a la base de datos.

Primero debemos ir a  application -> config -> autoload.php, y buscamos la siguiente línea:

$autoload['libraries'] = array();

Y debemos agregar una librería llamada database:

$autoload['libraries'] = array('database');

Las librerías al igual que los helpers son extensiones que nos provee Codeigniter.

Y finalmente debemos agregar los datos para que PHP pueda conectarse a la base de datos, en mi caso MySQL. Entonces abrimos application -> config -> database.php, y buscamos las siguientes líneas:

$db['default']['hostname'] = 'localhost';
$db['default']['username'] = '';
$db['default']['password'] = '';
$db['default']['database'] = '';

Ahí debemos ingresar los valores para conectar a nuestra base de datos.

 

Cargando nuestro modelo

Dijimos que los controladores son los encargados de comunicarse con los modelos para realizar consultas a la base de datos. Para cargar un modelo debemos hacer algo similar a cuando cargamos una vista, usando el método model():

$this->load->model('informe_model');

Por ejemplo, aquí cargamos el modelo que habíamos creado antes. Esto inmediatamente creará un objeto, y desde el mismo podremos llamar a sus métodos:

$informe = $this->informe_model->obtener_por_id($id);

 

En la próxima publicación veremos cómo trabajan el MVC en conjunto.

Saludos!

 

Anterior: Codeigniter, parte 5: Vistas

Siguiente: Codeigniter, parte 7: CRUD

Redes sociables

    6 thoughts on “Codeigniter, parte 6: Modelos

      • Si el cliente te pide que una vez que se inserte un producto, en la base de datos, y luego te redireccione a una página con el producto que acabas de crear, cómo harías entonces? Cuando vos insertás simplemente estás mandando fruta a la base de datos, estás creando un registro. El recuperar ese último id, te permite recuperarlo una vez que lo terminás de insertar.

        Saludos!

    1. hola, me sirvió mucho el tutorial, soy nueva en codeigniter,
      te queria consultar, ¿cómo mostrar los datos que especifica el modelo listar registros en la vista?
      se haría con foreach o mysql_fetch_array?

    2. Hola Ferchu, sigo realizando su tutorial, me siento un poco newbie en este entorno MVC y en algunos conceptos me pierdo, me surge la duda si existe la posibilidad de compaginar PDO con Codeigniter, por ejemplo algo así:

      public function eliminar($id) {
      try {
      $query = $this->db->prepare(‘delete from informes where id = ?’);
      $query->bindParam(1, $id);
      $query->execute();
      $this->db = null;
      }
      catch (PDOException $e) {
      $e->getMessage();
      }
      }

      Me imagino que debe de existir algún tipo de opción de combinarlos aunque seguramente sea mejor aprender el sistema propio de consultas de CI.

      Gracias!!

    Deja un comentario

    Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *


    *