Guía del Usuario de CodeIgniter Versión 2.1.4


Clase Active Record

CodeIgniter usa una versión modificada del Patrón de Base de Datos Active Record. Este patrón permite obtener, insertar y actualizar información in tu base de datos con mínima codificación. En algunos casos, sólo una o dos líneas de código son necesarias para realizar una acción de base de datos. CodeIgniter no requiere que cada tabla de la base de datos sea un propio archivo de clase. Se permite una interface más simplificada

Más allá de la simplicidad, un beneficio mayor de usar la Active Record es que te permite crear una aplicación independiente de la base de datos que usa, ya que la sintaxis de consulta es generada por cada adaptador de base de datos. También permite queries más seguras, ya que los valores son escapadas automáticamente por el sistema.

Nota: Si tienes intenciones de usar tus propias consultas, puedese deshabilitar esta clase en tu archivo de configuración de base de datos, permitiendo a la librerí de la base de datos y adaptadores usar menos recursos



 

Seleccionar Datos

Las siguientes funciones permiten construir una sentencia SELECT SQL.

Nota: Si está usando PHP 5, puede usar métodos en cadena para una sintaxis más compacta. Esto es descripto al final de la página.

$this->db->get();

Ejecuta la consulta de selección y devuelve el resultado. Puede ser usado solo, para traer todos los registros de una tabla:

$consulta = $this->db->get('mitabla');

// Produce: SELECT * FROM mitabla

El segundo y tercer parámetro permiten establecer cláusulas de límite y principio:

$consulta = $this->db->get('mitabla', 10, 20);

// Produce: SELECT * FROM mitabla LIMIT 20, 10 (en MySQL. Otras bases de datos tienen pequeñas diferencias en la sintaxis)

Notará que la funcion de arriba es asignada a la variable llamada $consulta, que puede ser usada para mostrar los resultados:

$consulta = $this->db->get('mitabla');

foreach ($consulta->result() as $fila)
{
    echo $fila->titulo;
}

Por favor visite la página de funciones de resultados para una completa discusión acerca de la generación de resultados.

$this->db->get_where();

Identica a la función de arriba, excepto que permite agregar una cl´usula "where" en el segundo parámetro, en vez de usar la función db->where():

$consulta = $this->db->get_where('mitabla', array('id' => $id), $limite, $principio);

Por favor lea sobre la función where más abajo para más información

Nota: get_where() era anteriormente conocida como getwhere(), que ha sido eliminada

$this->db->select();

Permite escribir la porción de SELECT de tu consulta:

$this->db->select('titulo, contenido, fecha');

$consulta = $this->db->get('mitabla');

// Produce: SELECT titulo, contenido, fecha FROM mitabla

Nota: Si está seleccionando todo (*) de una tabla, no es necesario usar esta función. Cuando se omite, CodeIgniter asume que desa SELECT *

$this->db->select() acepta un opcional segundo parámetro. Si se establece como FALSE, CodeIgniter no intentará proteger los nombres de campos u tablas. Esto es útil si necesita una consulta de selección compuesta.

$this->db->select('(SELECT SUM(pagos.monto) FROM pagos WHERE pagos.factura_id=4') AS monto_pagado', FALSE);
$consulta = $this->db->get('mitabla');

$this->db->select_max();

Escribe una porción "SELECT MAX(campo)" de tu consulta. Opcionalmente, puedes incluir un segunda parámetro para renombrar el campo resultante.

$this->db->select_max('edad');
$consulta = $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

$this->db->select_min();

Escriba una porción "SELECT MIN(campo)" de tu consulta. Como en select_max(), puedes opcionalmente incluir un segundo parámetro para renombrar el campo resultante.

$this->db->select_min('edad');
$consulta = $this->db->get('miembros');
// Produce: SELECT MIN(edad) as edad FROM miembros

$this->db->select_avg();

Escriba una porción "SELECT AVG(campo)" de tu consulta. Como en select_max(), puedes opcionalmente incluir un segundo parámetro para renombrar el campo resultante.

$this->db->select_avg('edad');
$consulta = $this->db->get('miembros');
// Produce: SELECT AVG(edad) as edad FROM miembros

$this->db->select_sum();

Escriba una porción "SELECT SUM(campo)" de tu consulta. Como en select_max(), puedes opcionalmente incluir un segundo parámetro para renombrar el campo resultante.

$this->db->select_sum('edad');
$consulta = $this->db->get('miembros');
// Produce: SELECT SUM(edad) as edad FROM miembros

$this->db->from();

Permite escribir la porción FROM de la consulta:

$this->db->select('titulo, contenido, fecha');
$this->db->from('mitabla');

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

// Produce: SELECT titulo, contenido, fecha FROM mitabla

Nota: Como se mostró antes, la porción FROM de tu consulta puede ser especificada en la función $this->db->get(), así que use el método que prefiera

$this->db->join();

Permite escribir una porción JOIN de la 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

Multiples llamados a la función pueden ser hechos si necesita multiples joins en una consulta.

Si necesita algo distinto al natural JOIN puede especificarlo a través del tercer parámetro de la función. Las opciones son: left, right, outer, inner, left outer, and right outer.

$this->db->join('comentarios', 'comentarios.id = blogs.id', 'left');

// Produce: LEFT JOIN comentarios ON comentarios.id = blogs.id

$this->db->where();

Está función habilita establecer cláusulas WHERE usando uno de cuátro métodos:

Nota: Todos los valores pasados a esta función son escapados automáticamente, produciendo consultas más seguras.

  1. Método simpre de clave/valor: $this->db->where('nombre', $nombre);

    // Produce: WHERE nombre = 'Jose'

    Note que el signo igual es agregado para uested.

    Si utiliza multiples llamadas a la función, ellos serán encadenados juntos con un AND entre ellos:

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

    // WHERE nombre = 'Jose' AND titulo = 'jefe' AND estado = 'activo'
  2. Método especial de clave/valor:

    Se puede incluir un operador en el primer parámetro con el objeto de controlar la comparación:

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

    // Produce: WHERE nombre != 'Jose' AND id < 45
  3. Método de arreglo asociativo: $arreglo = array('nombre' => $nombre, 'titulo' => $titulo, 'status' => $status);

    $this->db->where($arreglo);

    // Produce: WHERE nombre = 'Joe' AND titulo = 'boss' AND status = 'active'

    Puede incluir operadores propios cuando se usa este método también:

    $array = array('nombre !=' => $nombre, 'id <' => $id, 'date >' => $date);

    $this->db->where($array);
  4. Cadena especial:

    Se puede escribir cláusulas propias manualmente:

    $where = "nombre='Jose' AND estado='jefe' OR estado='activo'";

    $this->db->where($where);

$this->db->or_where();

Está función es idéntica a la de arriba, excepto que multiples instancias son unidas por OR:

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

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

Nota: or_where() era anteriormente conocida como orwhere(), la cual ha sido deprecada.

$this->db->where_in();

Genera WHERE campo IN ('item', 'item') unido con AND si corresponde

$nombres = array('Frank', 'Todd', 'James');
$this->db->where_in('username', $nombres);
// Produce: AND WHERE username IN ('Frank', 'Todd', 'James')

$this->db->or_where_in();

Genera WHERE campo IN ('item', 'item') unido con OR si corresponde

$nombres = array('Frank', 'Todd', 'James');
$this->db->or_where_in('username', $nombres);
// Produce: OR WHERE username IN ('Frank', 'Todd', 'James')

$this->db->where_not_in();

Genera WHERE campo NOT IN ('item', 'item') unido con AND si corresponde

$nombres = array('Frank', 'Todd', 'James');
$this->db->where_not_in('username', $nombres);
// Produce: AND WHERE username NOT IN ('Frank', 'Todd', 'James')

$this->db->or_where_not_in();

Genera WHERE campo NOT IN ('item', 'item') unido con OR si corresponde

$nombres = array('Frank', 'Todd', 'James');
$this->db->or_where_not_in('username', $nombres);
// Produces: OR WHERE username NOT IN ('Frank', 'Todd', 'James')

$this->db->like();

Está función permite generar cláusulas LIKE, útiles para realizar búsquedas.

Nota: Todos los valores pasados a esta función son escapados automáticamente.

  1. Método simple de clave/valor: $this->db->like('titulo', 'match');

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

    Si utiliza múltiples llamados a la función, ellos serán encadenados con AND entre ellos:

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

    // WHERE titulo LIKE '%match%' AND body LIKE '%match%
    Si desea controlar donde la wildcard (%) es ubicada, puede utilizar un tercer parámetro opcional. Las opciones son 'before', 'after' y 'both' (por defecto). $this->db->like('titulo', 'match', 'before');
    // Produces: WHERE titulo LIKE '%match'

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

    $this->db->like('titulo', 'match', 'both');
    // Produces: WHERE titulo LIKE '%match%'
  2. Método de arreglo asociativo: $array = array('titulo' => $match, 'pagina1' => $match, 'pagina2' => $match);

    $this->db->like($array);

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

$this->db->or_like();

Está función es idéntica a la anterior, excepto que multiples instances son unidas por OR:

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

// WHERE titulo LIKE '%match%' OR body LIKE '%match%'

Nota: or_like() era anteriormente conocida como orlike(), la cual ha sido deprecada.

$this->db->not_like();

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

$this->db->not_like('titulo', 'match');

// WHERE titulo NOT LIKE '%match%

$this->db->or_not_like();

Esta función es idéntica a not_like(), excepto que muchas instancias son unidas por OR:

$this->db->like('titulo', 'match');
$this->db->or_not_like('body', 'match');

// WHERE titulo LIKE '%match% OR body NOT LIKE '%match%'

$this->db->group_by();

Permite escribir porciones GROUP BY de la consulta:

$this->db->group_by("titulo");

// Produces: GROUP BY titulo

También se puede pasar un arreglo de multiples valores:

$this->db->group_by(array("titulo", "fecha"));

// Produce: GROUP BY titulo, fecha

Nota: group_by() era anteriormente conocida como groupby(), la cual ha sido deprecada.

$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();

Permite escribir la porción HAVING de la consulta:

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

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

También puede pasar un arreglo de multiples valores:

$this->db->having(array('titulo =' => 'Mi titulo', 'id <' => $id));

// Produce: HAVING titulo = 'Mi titulo', id < 45

$this->db->or_having();

Idéntica a having(), sólo que separa múltiples cláusulas con "OR".

$this->db->order_by();

Permite establecer una cláusula de ORDER BY. El primer parámetro contiene el nombre de la columna por la que desea ordenar. El segundo parámetro establece la dirección del resultado. Las opciones son asc or desc, or 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 múltiples llamados a la función pueden ser hechos si necesita múltiples campos.

$this->db->order_by("titulo", "desc");
$this->db->order_by("nombre", "asc");

// Produces: ORDER BY titulo DESC, nombre ASC

Nota: order_by() era anteriormente conocida como orderby(), la cual a sido deprecada.

Note: ordernamiento aleatorio no es soportado actualmetne en los "drivers" Oracle o MSSQL. Estos serán predeterminados como 'ASC'.

$this->db->limit();

Permite limitar el número de filas que desea que devuelva la consulta:

$this->db->limit(10);

// Produce: LIMIT 10

El segundo parámetro permite establecer el inicio del resultado.

$this->db->limit(10, 20);

// Produce: LIMIT 20, 10 (in MySQL. Otras bases de datos tienen pequeñas diferencias de sintaxis.)

$this->db->count_all_results();

Permite determinar el número de filas de una consulta Active Record en particular. Las consultas aceptan las restricciones de Active Record 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();

Permite determinar el número de filas de una tabla en particular. Permits you to determine the number of rows in a particular table. Envíe el nombre de la tabla como primer parámetro. Por ejemplo:

echo $this->db->count_all('mi_tabla');

// Produce un entero, como 25

 

Insertar Datos

$this->db->insert();

Genera una cadena de inserción basado en los datos que se suministren, y ejectua la consulta. Se puede pasar un arreglo o un objeto a la función. Aquí hay un ejemplo, usando un arreglo:

$data = array(
               'titulo' => 'Mi titulo' ,
               'nombre' => 'Mi nombre' ,
               'fecha' => 'Mi fecha'
            );

$this->db->insert('mitabla', $data);

// Produces: INSERT INTO mitabla (titulo, nombre, fecha) VALUES ('Mi titulo', 'Mi nombre', 'Mi fecha')

El primer parámetro contiene el nombre de la table, la segunda es un arreglo de valores.

Aquí hay un ejemplo usando un objeto:

/*
    class Myclass {
        var $titulo = 'Mi titulo';
        var $contenido = 'Mi Contenido';
        var $fecha = 'Mi Fecha';
    }
*/

$objeto = new Myclass;

$this->db->insert('mitabla', $objeto);

// Produce: INSERT INTO mitabla (titulo, contenido, fecha) VALUES ('Mi titulo', 'Mi Contenido', 'Mi Fecha')

El primer parámetro contendrá el nombre de la tabla, el segundo es un arreglo asociativa de valores.

Nota: Todos los valores son escapados automáticamente produciendo consultas más seguras.

$this->db->insert_batch();

Genera una cadena insert de SQL basada en los datos provistos, y ejecuta la consulta. A la función se le puede pasar tanto un array como un objeto. Aquí hay un ejemplo usando un array:

$data = array(
   array(
      'title' => 'Mi titulo' ,
      'name' => 'Mi Nombre' ,
      'date' => 'Mi fecha'
   ),
   array(
      'title' => 'Otro titulo' ,
      'name' => 'Otro Nombre' ,
      'date' => 'Otra fecha'
   )
);

$this->db->update_batch('mi_tabla', $data);

// Produces: INSERT INTO mi_tabla (titulo, nombre, fecha) VALUES ('Mi titulo', 'Mi nombre', 'Mi fecha'), ('Otro titulo', 'Otro nombre', 'Otra fecha')

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

Nota: Todos los valores pasados a esta función se escapan, produciendo consultas más seguras.

$this->db->set();

Esta función habilita permite establecer valores para insertar o actualizar.

Puede ser usado en vez de pasar un arreglo de datos directamente a las funciones de insert o update:

$this->db->set('nombre', $nombre);
$this->db->insert('mitabla');

// Produce: INSERT INTO mitabla (nombre) VALUES ('{$nombre}')

Si utiliza múltiples llamados a la función, ellos serán ensamblados apropiadamente basados en si está insertando o actualizando:

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

set() también aceptará un opcional tercer parámetro ($escape), que prevendrá datos de ser escapado si es establecido como FALSE. Para ilustrar la diferencia, aquí está set() usado con y sin el parámetro de escape.

$this->db->set('campo', 'campo+1', FALSE);
$this->db->insert('mitabla');
// resulta INSERT INTO mitabla (campo) VALUES (campo+1)

$this->db->set('campo', 'campo+1');
$this->db->insert('mitabla');
// resulta INSERT INTO mitabla (campo) VALUES ('campo+1')

También puede pasar un arreglo asociativo a esta función:

$arreglo = array('nombre' => $nombre, 'titulo' => $titulo, 'estado' => $estado);

$this->db->set($arreglo);
$this->db->insert('mitabla');

O un objeto:

/*
    class Miclase {
        var $titulo = 'Mi titulo';
        var $content = 'Mi Content';
        var $date = 'Mi Date';
    }
*/

$objeto = new Miclase;

$this->db->set($objeto);
$this->db->insert('mitabla');

 

Actualizar Datos

$this->db->update();

Genera una cadena de actualización y corre la consulta basado en los datos suministrados. Puede pasar una arreglo o un objeto a la función. Aquí hay un ejemplo, usando un arreglo:

$data = array(
               'titulo' => $titulo,
               'nombre' => $nombre,
               'fecha' => $fecha
            );

$this->db->where('id', $id);
$this->db->update('mitabla', $data);

// Produces:
// UPDATE mitabla
// SET titulo = '{$titulo}', nombre = '{$nombre}', fecha = '{$fecha}'
// WHERE id = $id

O puede suministrar un objeto:

/*
    class Miclase {
        var $titulo = 'My titulo';
        var $contenido = 'My Contenido';
        var $fecha = 'My Fecha';
    }
*/

$objeto = new Miclase;

$this->db->where('id', $id);
$this->db->update('mitabla', $objeto);

// Produce:
// UPDATE mitabla
// SET titulo = '{$titulo}', nombre = '{$nombre}', fecha = '{$fecha}'
// WHERE id = $id

Nota: Todos los valores son escapados automáticamente produciendo consulta más seguras.

Notará el uso de la función $this->db->where(), permitiendo establecer una cláusula WHERE. Opcionalmente, puede pasar información directamente como una cadena:

$this->db->update('mitabla', $data, "id = 4");

O como un arreglo:

$this->db->update('mitabla', $data, array('id' => $id));

También se puede usar la función $this->db->set() descripta anteriormente, cuando se efectúan actializaciones.


 

Borrar Datos

$this->db->delete();

Genera una cadena de eliminación SQL y ejecuta la consulta.

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

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

El primer parámetro es el nombre de la tabla, el segundo la cláusula WHERE. También puede usar las funciones where() o or_where() en vez de pasar los datos como segundo parámetro de la función:

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

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

Un arreglo de nombres de tablas puede ser pasada a delete() si desea eliminar datos de más de una tabla.

$tablas = array('tabla1', 'tabla2', 'tabla3');
$this->db->where('id', '5');
$this->db->delete($tablas);

Si desea eliminar todos los datos de una tabla, puede usar la función truncate(), o empty_table().

$this->db->empty_table();

Genera una cadena SQL de eliminación y ejecuta la consulta.

$this->db->empty_table('mitabla');

// Produce:
// DELETE FROM mitabla

$this->db->truncate();

Genera una cadena SQL de truncado y ejecuta una consulta.

$this->db->from('mitabla');
$this->db->truncate();
// or
$this->db->truncate('mitabla');

// Produce:
// TRUNCATE mitabla

Nota: Si el comando TRUNCATE no está disponible, truncate() ejecutará "DELETE FROM tabla".


 Métodos en cadena

Métodos en cadena permite simplificar tu sintaxis conectando múltiples funciones. Considere este ejemplo:

$this->db->select('titulo')->from('mitabla')->where('id', $id)->limit(10, 20);

$query = $this->db->get();

Note: Métodos en cadena sólo funciona con PHP 5.


 Active Record Caching

Mientras no es un verdadero cacheo, Active Record permite salvar (o "cache") ciertas partes de tus consultas para reusar después. Normalmente, cuando una llamada a Active Record es completada, toda la información es reinizializada para el próximo llamado. Con cacheo, puede prevenir esta reinizialización, y reusar la información fácilmente.

Las llamadas a cache son acumulables. Si ejecuta 2 llamadas a cached select(), y luego 2 llamadas a no cached select(), esto ersultará en 4 llamadas a select(). Hay tres funciones de cacheo disponibles:

$this->db->start_cache()

Esta función debe ser llamada para comenzar a cachear. Todas las consultas Active Record del tipo correcto (ver debajo para las consultas soportadas) son guardadas para uso posterior.

$this->db->stop_cache()

Esta función puede ser llamada para parar el cacheo.

$this->db->flush_cache()

Esta función elimina todos los items cacheados por la Active Record.

Aquí hay un ejemplo de uso:

$this->db->start_cache();
$this->db->select('campo1');
$this->db->stop_cache();
$this->db->get('tabla');
// Results in:
// SELECT `campo1` FROM (`tabla`)

$this->db->select('campo2');
$this->db->get('tabla');
// Results in:
// SELECT `campo1`, `campo2` FROM (`tabla`)

$this->db->flush_cache();

$this->db->select('campo2');
$this->db->get('tabla');
// Results in:
// SELECT `campo2` FROM (`tabla`)

Nota: Los siguientes campos pueden ser cacheados: 'select', 'from', 'join', 'where', 'like', 'groupby', 'having', 'orderby', 'set'