Blog

La clase DATABASE en Codeigniter de 0 a 100

Clase Database

CodeIgniter viene con una clase de base de datos abstracta muy rápida y completa que soporta tanto las estructuras tradicionales como los patrones Active Record. Las funciones de base de datos ofrecen una sintaxis clara y sencilla.

Inicializar la Clase Database

El siguiente código carga e inicializa la clase database basado en los valores de su configuración:

$this->load->database();

Una vez cargada la clase, está lista para usarse.

Inicializar automáticamente la clase database

/*
| -------------------------------------------------------------------
|  Auto-load Libraries
| -------------------------------------------------------------------
| These are the classes located in the system/libraries folder
| or in your application/libraries folder.
|
| Prototype:
|
|	$autoload['libraries'] = array('database', 'session', 'xmlrpc');
*/
$autoload['libraries'] = array('database','session','xmlrpc');

Consultas

$this->db->query()

Para realizar una consulta, usar la siguiente función:

$this->db->query('PONER AQUI LA CONSULTA');

La función query() devuelve un objeto de resultado de base de datos cuando se ejecutan consultas tipo "leer", las cuales puede usar para mostrar sus resultados.

Cuando se ejecutan consultas tipo "escribir" la función simplemente devuelve TRUE o FALSE dependiendo del éxito o fracaso. Al devolver datos, normalmente asignará la consulta a una variable, así:

$query = $this->db->query('PONER AQUI LA CONSULTA');

Consulta estándar con resultados múltiples (Versión Objetos)

$query = $this->db->query('SELECT nombre, titulo, email FROM mi_tabla');
foreach ($query->result() as $row)
{
echo $row->titulo;
echo $row->nombre;
echo $row->email;
}
echo 'Resultados totales: ' . $query->num_rows();

Consulta estándar con resultados múltiples (Versión Array)

$query = $this->db->query('SELECT nombre, titulo, email FROM mi_tabla');
foreach ($query->result_array() as $row)
{
echo $row->titulo;
echo $row->nombre;
echo $row->email;
}
echo 'Resultados totales: ' . $query->num_rows();

Comprobar Resultados

Si ejecuta consultas que pueden no producir resultados, le aconsejamos probar primero con la función num_rows():

$query = $this->db->query("SU CONSULTA");
if ($query->num_rows() > 0)
{
    foreach ($query->result() as $row)
        {
        echo $row->titulo;
        echo $row->nombre;
        echo $row->cuerpo;
        }
}

Consulta Estándar con Resultado Simple (Versión Objetos)

$query = $this->db->query('SELECT nombre FROM mi_tabla LIMIT 1');
$row = $query->row();
echo $row->nombre;

La función row() anterior devuelve un objeto.
Ejemplo: $row->nombre.

Consulta Estándar con Resultado Simple (Versión Array)

$query = $this->db->query('SELECT nombre FROM mi_tabla LIMIT 1');
$row = $query->row_array();
echo $row->nombre;

La función row_array() anterior devuelve un array.
Ejemplo: $row[‘nombre’]

Consulta Active Record

El Patrón Active Record le da una forma simplificada de devolver los datos:

$query = $this->db->get('nombre_de_tabla');
foreach ($query->result() as $row)
{
echo $row->titulo;
}

La función get() anterior devuelve todos los resultados desde la tabla suministrada. La clase Active Record contiene un conjunto completo de funciones para trabajar con datos.

Inserción Active Record

$data = array(
'titulo' => $titulo,
'nombre' => $nombre,
'fecha' => $fecha
);
$this->db->insert('mi_tabla', $data);

Produce: INSERT INTO mi_tabla (titulo, nombre, fecha) VALUES ('{$titulo}', '{$nombre}', '{$fecha}')

Enlazado de Consultas

El enlazado le permite simplificar la sintaxis de las consultas, al permitir que el sistema junte las junte. Por ejemplo

    $sql = "SELECT * 
            FROM alguna_tabla 
            WHERE id = ? AND estado = ? AND autor = ?";
    $this->db->query($sql, array(3, 'vivo', 'Ricardo'));

Los signos de interrogación en la consulta se reemplazan automáticamente con los valores en el array en el segundo parámetro de la función query().

El beneficio secundario de usar enlazado es que los valores se escapan automáticamente, produciendo consultas más seguras. No tiene que recordar escapar manualmente los datos; el motor lo hace automáticamente por Ud.

Funciones Helper de Resultados

$query->num_rows()

Cantidad de filas devueltas por la consulta. Nota: En este ejemplo, $query es la variable a la que se le asigna el objeto de resultado de la consulta:

    $query = $this->db->query('SELECT * FROM mi_tabla');
    echo $query->num_rows();

$query->num_fields()

Cantidad de CAMPOS (columnas) devueltos por la consulta. Asegurarse de llamar la función usando su objeto de resultado de consulta:

$query = $this->db->query('SELECT * FROM mi_tabla');
echo $query->num_fields();

$query->free_result()

Libera la memoria asociada con el resultado y borra el ID del recurso de resultado. Ejemplo:

    $query = $this->db->query('SELECT title FROM mi_tabla');
    foreach ($query->result() as $row)
    {
        echo $row->title;
    }
        $query->free_result(); // El objeto de resultado $query no estará más disponible
    
    $query2 = $this->db->query('SELECT name FROM alguna_tabla');
        $row = $query2->row();
        echo $row->name;
    $query2->free_result(); // El objeto de resultado $query2 no estará más disponible

$this->db->insert_id()

El número ID de la inserción al ejecutar inserciones en la base de datos.

$this->db->affected_rows()

Muestra la cantidad de filas afectadas, al hacer una consulta tipo "escribir" (inserción, actualización, etc.).

$this->db->count_all()

Permite determinar la cantidad de filas en una tabla en particular. Envíe el nombre de la tabla en el primer parámetro. Ejemplo:

echo $this->db->count_all('mi_tabla');
// Produce un entero, como 25

$this->db->platform()

Imprime la plataforma de base de datos que está ejecutando (MySQL, MS SQL, Postgres, etc...)

echo $this->db->platform();

$this->db->version()

Imprime la versión de base de datos que está ejecutando:

echo $this->db->version();

$this->db->last_query()

Devuelve la última consulta que se ejecutó (la cadena de consulta, no su resultado). Ejemplo:

$str = $this->db->last_query();
// Produce: SELECT * FROM alguna_tabla....

$this->db->insert_string()

Esta función simplifica el proceso de escribir inserciones en la base de datos. Devuelve una cadena de inserción de SQL correctamente formateada. Ejemplo:

$data = array('name' => $name, 'email' => $email, 'url' => $url);
$str = $this->db->insert_string('nombre_de_tabla', $data);

El primer parámetro es el nombre de la tabla, el segundo es un array asociativo con los datos a insertarse. El ejemplo anterior produce:

INSERT INTO nombre_de_tabla (name, email, url) VALUES ('Ricardo',
'ricardo@ejemplo.com', 'ejemplo.com')

$this->db->update_string()

Esta función simplifica el proceso de escribir actualizaciones de base de datos. Devuelve un cadena de actualización de SQL correctamente formateada. Ejemplo:

    $data = array('name' => $name, 'email' => $email, 'url' => $url);
    $where = "autor_id = 1 AND estado = 'activo'";
    $str = $this->db->update_string('nombre_de_tabla', $data, $where);

El primer parámetro es el nombre de la tabla, el segundo es un array asociativo con los datos a actualizarse, y el tercer parámetro es la cláusula "where". El ejemplo anterior produce:

UPDATE nombre_de_tabla SET name = 'Ricardo', email = 'ricardo@ejemplo.com', url = 'ejemplo.com' 
       WHERE autor_id = 1 AND estado = 'activo'

La Clase Active Record

CodeIgniter usa una versión modificada del Patrón de Base de Datos Active Record. Este patrón permite que la información sea obtenida, insertada y actualizada en la base de datos con mínimo código. En algunos casos solamente son necesarias una o dos líneas de código para ejecutar una acción en la base de datos. CodeIgniter no necesita que cada tabla de base de datos tenga su propio archivo de clase. En lugar de eso, provee una interfaz más simplificada.

Más allá de la simplicidad, el mayor beneficio de usar las funcionalidades del Active Record es que le permite crear aplicaciones independientes de las bases de datos, ya que cada adaptador de base de datos genera la sintaxis de la consulta. Esto también permite consultas más seguras, ya que el sistema escapa automáticamente los valores.

Seleccionar Datos

Las siguientes funciones le permiten construir sentencias SELECT de SQL.

Seleccionar Datos

$this->db->get()

Ejecuta la consulta de selección y devuelve el resultado. Puede utilizarse por sí mismo para recuperar todos los registros de una tabla:

    $query = $this->db->get('mi_tabla');
    // Produce: SELECT * FROM mi_tabla

El segundo y tercer parámetros le permiten establecer una cláusula "limit" y "offset":

    $query = $this->db->get('mi_tabla', 10, 20);
    // Produce: SELECT * FROM mi_tabla LIMIT 20, 10 (en MySQL. Otras bases de datos
    // pueden tener sintaxis ligeramente diferentes)

$this->db->get_where()

Idéntica a la función anterior, excepto que le permite agregar una cláusula "where" en el segundo parámetro, en lugar de usar la función db->where():

$query = $this->db->get_where('mi_tabla', array('id' => $id), $limit, $offset);

$this->db->select()

Permite escribir la porción SELECT de una consulta:

$this->db->select('titulo, contenido, $fecha');
$query = $this->db->get('mi_tabla');
// Produce: SELECT titulo, contenido, $fecha FROM mi_tabla

$this->db->select() acepta un segundo parámetro opcional. Si lo establece como FALSE, CodeIgniter no intentará proteger sus nombres de campo o tabla con backticks. Esto es útil si necesita una sentencia compuesta de selección.

$this->db->select_max()

Escribe una porción "SELECT MAX(campo)" en su consulta.
Opcionalmente puede incluir un segundo parámetro para renombrar el campo de resultado.

    $this->db->select_max('edad');
    $query = $this->db->get('miembros');
    // Produce: SELECT MAX(edad) AS edad FROM miembros

    $this->db->select_max('edad', 'edad_miembro');
    $query = $this->db->get('miembros');
    // Produce: SELECT MAX(edad) AS edad_miembro FROM miembros

Otras funciones de agregado

$this->db->select_max()
$this->db->select_min()
$this->db->select_avg()
$this->db->select_sum()

$this->db->from()

Permite escribir la porción FROM de su consulta:

    $this->db->select('titulo, contenido, $fecha');
    $this->db->from('mi_tabla');
    $query = $this->db->get();
    // Produce: SELECT titulo, contenido, $fecha FROM mi_tabla

$this->db->join()

Permite escribir la porción JOIN de su consulta:

    $this->db->select('*');
    $this->db->from('blogs');
    $this->db->join('comentarios', 'comentarios.id = blogs.id');
    $query = $this->db->get();

    // Produce:
    // SELECT * FROM blogs
    // JOIN comentarios ON comentarios.id = blogs.id

Se pueden hacer varias llamadas de función si necesita varios joins en una consulta.

Si necesita un tipo específico de JOIN puede especificarlo mediante el tercer parámetro de la función. Las opciones son: left, right, outer, inner, left outer, y right outer.

$this->db->join('comentarios', 'comentarios.id = blogs.id', 'left');
// Produce: LEFT JOIN comentarios ON comentarios.id = blogs.id

$this->db->where()

Esta función le permite establecer cláusulas WHERE usando uno de los estos cuatro métodos:

1. Método simple de clave/valor:

    $this->db->where('nombre', $nombre);
    // Produce: WHERE nombre = 'Jose'

Advierta que se agrega el signo igual por Ud.

Si usa varias llamadas de función, se encadenarán todas juntas con AND entre ellas:

    $this->db->where('nombre', $nombre);
    $this->db->where('titulo', $titulo);
    $this->db->where('estado', $status);

    //Produce: WHERE nombre = 'Jose' AND titulo = 'jefe' AND estado = 'activo'

2. Método personalizado de clave/valor:

Puede incluir un operador en el primer parámetro para controlar la comparación:

    $this->db->where('nombre !=', $nombre);
    $this->db->where('id <', $id);

    // Produce: WHERE nombre != 'Jose' AND id < 45

3. Método del array asociativo:

    $array = array('nombre' => $nombre, 'titulo' => $titulo, 'estado' =>$status);
    $this->db->where($array);

    // Produce: WHERE nombre = 'Jose' AND titulo = 'jefe' AND estado = 'activo'

También puede incluir sus propios operadores usando este método:

    $array = array('nombre !=' => $nombre, 'id <' => $id, '$fecha >' => $fecha);
    $this->db->where($array);

4. Cadena personalizada:

Puede escribir sus propias cláusulas manualmente:

    $where = "nombre='Jose' AND estado='jefe' OR estado='activo'";
    $this->db->where($where);

$this->db->where() acepta un tercer parámetro opcional. Si se lo establece a FALSE, CodeIgniter no intentará proteger sus nombres de campos o tabla con backticks.

    $this->db->where('MATCH (campo) AGAINST ("valor")', NULL, FALSE);

$this->db->or_where()

Esta función es idéntica a la anterior, excepto que las instancias múltiples se unen con OR:

    $this->db->where('nombre !=', $nombre);
    $this->db->or_where('id >', $id);

    // Produce: WHERE nombre != 'Jose' OR id > 50

$this->db->where_in()

Genera una consulta SQL WHERE campo IN ('item', 'item') unida mediante AND si corresponde.

    $nombres = array('Federico', 'Tomas', 'Juan');
    $this->db->where_in('usuario', $nombres);
    // Produce: WHERE usuario IN ('Federico', 'Tomas', 'Juan')

$this->db->or_where_in()

Genera una consulta SQL WHERE campo IN ('item', 'item') unida mediante OR si corresponde.

    $nombres = array('Federico', 'Tomas', 'Juan');
    $this->db->or_where_in('usuario', $nombres);
    // Produce: OR usuario IN ('Federico', 'Tomas', 'Juan')

$this->db->where_not_in()

Genera una consulta SQL WHERE campo NOT IN ('item', 'item') unida mediante AND si corresponde.

    $nombres = array('Federico', 'Tomas', 'Juan');
    $this->db->where_not_in('usuario', $nombres);
    // Produce: WHERE usuario NOT IN ('Federico', 'Tomas', 'Juan')

$this->db->or_where_not_in()

Genera una consulta SQL WHERE campo NOT IN ('item', 'item') unida mediante OR si corresponde.

    $nombres = array('Federico', 'Tomas', 'Juan');
    $this->db->or_where_not_in('usuario', $nombres);
    // Produce: OR usuario NOT IN ('Federico', 'Tomas', 'Juan')

$this->db->like()

Esta función le permite generar cláusulas LIKE, útiles para hacer búsquedas.

1. Método simple de clave/valor:

    $this->db->like('titulo', 'match');
    // Produce: WHERE titulo LIKE '%match%‘
    

Si usa varias llamadas a la función, se encadenarán juntas con AND entre ellas:

    $this->db->like('titulo', 'match');
    $this->db->like('cuerpo', 'match');
    // WHERE titulo LIKE '%match%' AND cuerpo LIKE '%match%

2. Método del array asociativo:

    $array  =  array('titulo' => $match,
            'pagina1' => $match,
            'pagina2' => $match);
    $this->db->like($array);

    //Produce: WHERE titulo LIKE '%match%' AND pagina1 LIKE '%match%' AND pagina2 LIKE '%match%'

$this->db->or_like()

Esta función es idéntica a la anterior, excepto que las instancias múltiples se unen mediante OR:

    $this->db->like('titulo', 'match');
    $this->db->or_like('cuerpo', $match);

    // Produce: WHERE titulo LIKE '%match%' OR cuerpo LIKE '%match%'

$this->db->not_like()

Esta función es idéntica a like(), excepto que genera sentencias NOT LIKE:

    $this->db->not_like('titulo', 'match');
    //Produce: WHERE titulo NOT LIKE '%match%

$this->db->or_not_like()

Esta función es idéntica a not_like(), excepto que las instancias múltiples se unen mediante OR:

    $this->db->like('titulo', 'match');
    $this->db->or_not_like('cuerpo', 'match');
    // Produce: WHERE titulo LIKE '%match% OR cuerpo NOT LIKE '%match%'

$this->db->group_by()

Le permite escribir la porción GROUP BY de su consulta:

    $this->db->group_by("titulo");
    // Produce: GROUP BY titulo

También puede pasarle un array de múltiples valores:

    $this->db->group_by(array("titulo", "$fecha"));
    // Produce: GROUP BY titulo, $fecha

$this->db->distinct()

Agrega la palabra clave "DISTINCT" a la consulta.

    $this->db->distinct();
    $this->db->get('tabla');
    // Produce: SELECT DISTINCT * FROM tabla

$this->db->having()

Le permite escribir la porción HAVING de su consulta. Hay dos sintaxis posibles, uno o dos argumentos:

    $this->db->having('usuario_id = 45');
    // Produce: HAVING usuario_id = 45

    $this->db->having('usuario_id', 45);
    // Produce: HAVING usuario_id = 45

También puede pasarle un array de múltiples valores:

    $this->db->having(array('titulo =' => 'Mi Titulo', 'id <' => $id));
    // Produce: HAVING titulo = 'Mi Titulo', id < 45

this->db->order_by()

Le permite establecer una cláusula ORDER BY. El primer parámetro contiene el nombre de la columna por la que querría ordenar. El segundo parámetro le permite establcer la dirección del resultado. Las opciones son asc, desc,o random.

    $this->db->order_by("titulo", "desc");
    // Produce: ORDER BY titulo DESC

También puede pasar su propia cadena en el primer parámetro:

    $this->db->order_by('titulo desc, nombre asc');
    // Produce: ORDER BY titulo DESC, nombre ASC

O se pueden hacer varias llamadas a la función si necesita varios campos.

    $this->db->order_by("titulo", "desc");
    $this->db->order_by("nombre", "asc");
    // Produce: ORDER BY titulo DESC, nombre ASC

$this->db->limit()

Permite limitar la cantidad de filas que desea que la consulta devuelva:

    $this->db->limit(10);
    // Produce: LIMIT 10

El segundo parámetro le permite establecer un desplazamiento del resultado.

    $this->db->limit(10, 20);
    // Produce: LIMIT 20, 10 

$this->db->count_all_results()

Permite determinar la cantidad de filas en una consulta del Active Record. Las consultas aceptarán restrictores tales como where(), or_where(), like(), or_like(), etc. Ejemplo:

    echo $this->db->count_all_results('mi_tabla');
    // Produce un entero, como 25

    $this->db->like('titulo', 'match');
    $this->db->from('mi_tabla');
    echo $this->db->count_all_results();
    // Produce un entero, como 17

$this->db->count_all()

Le permite determinar la cantidad de filas en una tabla en particular. Presente el nombre de la tabla como primer parámetro. Ejemplo:

    echo $this->db->count_all('mi_tabla');
    // Produce un entero, como 25

$this->db->insert()

Genera una cadena insert de SQL basada en los datos que suministra, y ejecuta la consulta. Tanto puede pasar un array como un objeto a la función. Aquí hay un ejemplo usando un array:

    $data = array(
    'titulo' => 'Mi titulo' ,
    'nombre' => 'Mi nombre' ,
    '$fecha' => 'Mi $fecha'
    );
    $this->db->insert('mi_tabla', $data);
    
    //Produce: INSERT INTO mi_tabla (titulo, nombre, $fecha) VALUES ('Mi titulo', 'Mi nombre', 'Mi $fecha')

El primer parámetro contendrá el nombre de la tabla y el segundo un array asociativo de valores.

Aquí hay un ejemplo usando un objeto:

    class MiClase {
    var $titulo = 'Mi Titulo';
    var $contenido = 'Mi Contenido';
    var $$fecha = 'Mi $fecha';
        }

    $object = new MiClase;
    $this->db->insert('mi_tabla', $object);
    // Produce: INSERT INTO mi_tabla (titulo, contenido, $fecha) VALUES ('Mi Titulo', 'Mi Contenido', 'Mi $fecha')

El primer parámetro contendrá el nombre de la tabla y el segundo es un objeto.

$this->db->set()

Esta función le permite establecer valores para inserciones o actualizaciones. Se puede usar en lugar de pasar datos directamente a un array para las funciones de inserción o actualización:

    $this->db->set('nombre', $nombre);
    $this->db->insert('mi_tabla');
    // Produce: INSERT INTO mi_tabla (name) VALUES ('{$nombre}')

Si usa varias llamadas de función, se ensamblarán adecuadamente en función de si usted está haciendo una inserción o una actualización:

    $this->db->set('nombre', $nombre);
    $this->db->set('titulo', $titulo);
    $this->db->set('estado', $status);
    $this->db->insert('mi_tabla');

$this->db->update()

Genera una cadena update de SQL y ejecuta la consulta basada en los datos provistos. A la función puede pasarle un array o un objeto. Aquí hay un ejemplo usando un array:

$data = array(
'titulo' => $titulo,
'nombre' => $nombre,
'fecha' => $fecha
);
$this->db->where('id', $id);
$this->db->update('mi_tabla', $data);

//Produce:UPDATE mi_tabla  SET title = '{$titulo}', name = '{$nombre}', date = '{$fecha}' WHERE id = $id

this->db->delete()

Genera una cadena delete de SQL y ejecuta la consulta.

    $this->db->delete('mi_tabla', array('id' => $id));

    //Produce: DELETE FROM mi_tabla WHERE id = $id

El primer parámetro es el nombre de la tabla y el segundo la cláusula where. También puede usar las funciones where() u or_where() en lugar de pasarle los datos al segundo parámetro de la función:

Si quiere borrar más de una tabla, se puede pasar un array de nombres de tablas a delete().

    $tables = array('table1', 'table2', 'table3');
    $this->db->where('id', '5');
    $this->db->delete($tables);

Si quiere borrar todos los datos de una tabla, puede usar las funciones truncate() o empty_table().

$this->db->empty_table()

Genera una cadena delete de SQL y ejecuta la consulta.

$this->db->empty_table('mi_tabla');
// Produce:DELETE FROM mi_tabla

$this->db->truncate()

Genera una cadena truncate de SQL y ejecuta la consulta.

    $this->db->from('mi_tabla');
    $this->db->truncate();
    // o
    $this->db->truncate('mi_tabla');

    //Produce:TRUNCATE mi_tabla

Método de Encadenamiento

El Método de Encadenamiento le permite simplificar la sintaxis conectando varias funciones. Considere este ejemplo:

    $this->db->select('titulo')->from('mi_tabla')->where('id', $id)->limit(10, 20);
    $query = $this->db->get();