24-all

History Key

  • New content
  • Removed content

Recent Versions

Choose two versions to compare, or click the link to view it.

  1. 13. over 4 years by anthemfor182
  2. 12. over 4 years by phillipo
  3. 11. over 4 years by phillipo
  4. 10. over 4 years by phillipo
  5. 9. over 4 years by phillipo
  6. 8. over 4 years by phillipo
  7. 7. over 4 years by phillipo
  8. 6. over 4 years by phillipo
  9. 5. over 4 years by phillipo
  10. 4. over 4 years by phillipo
  11. 3. over 4 years by phillipo
  12. 2. over 4 years by phillipo
  13. 1. over 4 years by phillipo
 

24 ActiveRecord

Es la principal clase para la administración y funcionamiento de modelos. ActiveRecord es una implementación de este patrón de programación y esta muy influenciada por la funcionalidad de su análoga en Ruby disponible en Rails. ActiveRecord proporciona la capa objeto-relacional que sigue rigurosamente el estándar ORM: Tablas en Clases, Campos en Atributos y Registros en Objetos. Facilita el entendimiento del código asociado a base de datos y encapsula la lógica especifica haciéndola más fácil de usar para el programador.

Ejemplo

  1. ?php<?php
  2. $Clientes->nit = “808111827-2”;
  3. $Clientes->razon_social = “EMPRESA DE TELECOMUNICACIONES ETB”
  4. $Clientes->save();
  5. ?>

    24.1 Ventajas del Active Record

    • Se trabajan las entidades del Modelo más Naturalmente como objetos.
    • Las acciones como Insertar, Consultar, Actualizar, Borrar, etc. de una entidad del Modelo están encapsuladas así que se reduce el código y se hace más fácil de mantener.
    • Código más fácil de Entender y Mantener
    • Reducción del uso del SQL en un 80%, con lo que se logra un alto porcentaje de independencia del motor de base de datos.
    • Menos “detalles” más practicidad y utilidad
    • ActiveRecord protege en un gran porcentaje de ataques de SQL inyection que puedan llegar a sufrir tus aplicaciónes escapando caracteres que puedan facilitar estos ataques.

    24.2 Crear un Modelo en Kumbia

    Lo primero es crear un archivo en el directorio models con el mismo nombre de la relación en la base de datos. Por ejemplo: models/clientes.php Luego creamos una clase con el nombre de la tabla extendiendo alguna de las clases para modelos. Ejemplo:

    Ejemplo

    1. ?php<?php
    2. class Clientes extends ActiveRecord {
    3. }
    4. ?>

    24.3. Columnas y Atributos

    Objetos ActiveRecord corresponden a registros en una tabla de una base de datos. Los objetos poseen atributos que corresponden a los campos en estas tablas. La clase ActiveRecord automáticamente obtiene la definición de los campos de las tablas y los convierte en atributos de la clase asociada. A esto es lo que nos referíamos con mapeo objeto relacional.

    Miremos la tabla Album:

    Ejemplo

    1. CREATE TABLE album (
    2. id INTEGER NOT NULL AUTO_INCREMENT,
    3. nombre VARCHAR(100) NOT NULL,
    4. fecha DATE NOT NULL,
    5. valor DECIMAL(12,2) NOT NULL,
    6. artista_id INTEGER NOT NULL,
    7. estado CHAR(1),
    8. PRIMARY KEY(id)
    9. )

    Podemos crear un ActiveRecord que mapee esta tabla:

    Ejemplo

    1. ?php<?php
    2. class Album extends ActiveRecord {
    3. }
    4. ?>

    Una instancia de esta clase será un objeto con los atributos de la tabla album:

    Ejemplo

    1. $Album = new Album();
    2. $Album->id = 2;
    3. $Album->nombre = “Going Under”;
    4. $Album->save();

    24.4 Llaves Primarias y el Uso de IDs

    En los ejemplos mostrados de Kumbia siempre se trabaja una columna llamada id como llave primaria de nuestras tablas. Talvez, esto no siempre es práctico a su parecer, de pronto al crear la tabla clientes la columna de numero de identificación sería una excelente elección, pero en caso de cambiar este valor por otro tendría problemas con el dato que este replicado en otras relaciones (ejemplo facturas), además de esto tendría que validar otras cosas relacionadas con su naturaleza. Kumbia propone el uso de ids como llaves primarias con esto se automatiza muchas tareas de consulta y proporciona una forma de referirse unívocamente a un registro en especial sin depender de la naturaleza de un atributo específico. Usuarios de Rails se sentirán familiarizados con esta característica.

    Esta particularidad también permite a Kumbia entender el modelo entidad relación leyendo los nombres de los atributos de las tablas. Por ejemplo en la tabla álbum del ejemplo anterior la convención nos dice que id es la llave primaria de esta tabla pero además nos dice que hay una llave foránea a la tabla artista en su campo id.


    24.5 CRUD: Create (Crear), Read (Leer), Update (Actualizar), Delete (Borrar)

    ActiveRecord implementa automáticamente las cuatro operaciones básicas sobre una tabla: Crear, Leer, Actualizar y Borrar.


    24.5.1 Creando Registros

    Manteniendo la idea del Objeto-Relacional podemos pensar que crear registros es lo mismo que crear objetos, entonces podríamos estar en lo cierto. Asignar a un objeto valores y ejecutar el método create o save es todo lo que tenemos que hacer.

    Ejemplo

    1. $Album = new Album();
    2. $Album->nombre = “Take Off Your Pants and Jacket”;
    3. $Album->valor = 40000;
    4. $Album->save();

    Adicionalmente a esto puede utilizar el método ‘create’ así como los métodos como ‘create_from_request’ para crear nuevos registros.

    Ejemplo

    1. $Album = new Album();
    2. $Album->nombre = “Take Off Your Pants and Jacket”;
    3. $Album->valor = 40000;
    4. $Album->create();
    6. $Album = new Album();
    7. $Album->create(
    8. “nombre: Take Off Your Pants and Jacket”,
    9. “valor: 40000”
    10. );
    11.  
    12. $Album = new Album();
    13. $Album->create(array(
    14. “nombre” => “Take Off Your Pants and Jacket”,
    15. “valor” => 40000
    16. ));

    También podemos crear un Nuevo registro a partir de los valores de $_REQUEST

    Ejemplo

    1. $Album = new Album();
    2. $Album->create_from_request();

    24.5.2 Consultando Registros

    Para consultar en una base de datos tenemos que tener claro qué vamos a buscar, es decir definir un criterio de búsqueda. Este criterio le permite a ActiveRecord devolver el conjunto de objetos que coincidan con este y así poder trabajar esa información.

    El camino más sencillo para encontrar determinado registro en una tabla es especificar su llave primaria. En Kumbia los modelos soportan el método ‘find’, así como otros métodos complementarios para consultas. Este método permite consultar registros a partir de sus llaves primarias así como con parámetros. Nótese que este método devuelve el valor boolean false en caso de no encontrar registros que coincidan con la búsqueda.

    Ejemplo

    1. # Buscar el Producto con id = 38
    2. $producto = $Productos->find(38);
    3. print $producto->nombre; # Imprime el nombre del producto id=38

    Igualmente necesitamos hacer consultas a partir de otros atributos del modelo no solamente a partir de su llave primaria. ActiveRecord proporciona una serie de parámetros para crear consultas especializadas que nos permitan acceder a los registros que necesitamos. Para ilustrar esto veamos:

    Ejemplo

    1. # Buscar los Productos en estado = ‘C’ y cuyo valor sea menor a 15000
    2. foreach($Productos->find(“estado=’C’ and valor
    3. print $producto->nombre;
    4. }
    5.  
    6. #Buscar el primer producto en estado = ‘C’ ordenado por fecha
    7. foreach($Productos->find_first(“conditions: estado=’C’”,
    8. “order: fecha desc”) as $producto){
    9. print $producto->nombre;
    10. }
    11.  
    12. #Buscar el primer producto en estado = ‘$estado’ ordenado por fecha
    13. $producto = $Productos->find_first(“conditions: estado=’$estado’”,
    14. “order: fecha desc”);
    15. print $producto->nombre;

    Cabe destacar que el uso de ‘find_first’ devuelve el primer registro que coincida con la búsqueda y ‘find’ todos los registros.


    24.5.3 El poderoso Find

    Aunque aparentemente ActiveRecord elimina el uso del SQL en un gran porcentaje, realmente no lo es, simplemente crea una capa de abstracción superior que puede llegar a limitarse en determinados momentos cuando las búsquedas se empiezan a volver complejas. Kumbia permite el uso del lenguaje SQL ya sea utilizando una instancia de ActiveRecord o accediendo a la capa de abstracción de datos como ultimo recurso (lo cual no es recomendado). El lenguaje SQL es una poderosa herramienta que no podemos dejar de usar y que debemos tener a la mano en uno de esos casos extremos en lo demás ActiveRecord se encargará de facilitarnos la vida en gran medida.

    Sin parámetros extra ActiveRecord convierte una consulta en un select from estándar pero podemos agregar otras opciones para especializar la búsqueda y obtener más detalladamente lo que buscamos.

    El parámetro conditions: permite especificar un conjunto de condiciones que van a actuar como el ‘where’ de nuestra consulta. Igualmente ActiveRecord no garantiza que los registros sean devueltos en el orden requerido asi que podemos utilizar order: para realizar el ordenamiento. El parámetro limit: nos permite especificar el número máximo de registros a ser devueltos.

    Ejemplo

    1. #Buscar los productos en estado = ‘$estado’ ordenado por fecha y valor
    2. foreach($Productos->find_first(“conditions: estado=’$estado’”,
    3. “order: fecha Desc, valor”,
    4. “limit: 30”) as $prod){
    5. print $prod->nombre;
    6. }

    Advertencia: En Oracle la funcionalidad limit podria no funcionar como se espera. Utilice la condición rownum < numero_filas para hacer esto.


    24.5.4 Promedio, Contando, Sumando, Mínimo y Máximo

    Una de las tareas más comunes es el uso de contadores y sumadores de registros en consultas, así como el uso de otras funciones de agrupación. El método de conteo de registros se llama count y puede recibir como parámetros condiciones de este.

    Ejemplo

    1. #Cuantos productos hay?
    2. print Productos->count();
    3.  
    4. #Cuantos productos hay con estado = 'A'?
    5. print Productos->count(“estado='A'”);

    Las funciones de agrupación suma, mínimo, promedio y máximo, son utilizadas de esta forma:

    Ejemplo

    1. #Cuantos suma el valor de todos los productos?
    2. print Productos->sum(“valor”);
    3.  
    4. #Cuantos suma el valor de los productos activos?
    5. print Productos->sum(“valor”, “conditions: estado='A'”);
    6.  
    7. #Promedio del valor de los productos activos?
    8. print Productos->average(“valor”, “conditions: estado='A'”);
    9.  
    10. #El valor mínimo de los productos activos?
    11. print Productos->minumum(“valor”, “conditions: estado='A'”);
    12.  
    13. #El valor máximo de los productos activos?
    14. print Productos->maximum(“valor”, “conditions: estado='A'”);

    24.5.5 Actualizando Registros existentes

    Realmente no hay mucho que decir acerca de cómo actualizar registros. Si tienes un objeto ActiveRecord (por ejemplo un producto de la base de datos), puedes actualizar llamando su método save(). Si este objeto ha sido leído de la base de datos puedes actualizar el registro correspondiente mediante save, en caso de que no exista se insertará el un registro nuevo.

    Ejemplo

      1. $producto = $Productos->find(123); 2. $producto->nombre = "Televisor"; 3. $producto->save();

    Otra forma de actualizar registros es utilizar el método update() de esta forma:

    Ejemplo

      1. $producto = $Productos->find(456); 2. $producto->update(“nombre: Televisor”, “cantidad: 2”); 3. $producto->save();

    24.5.6 Borrando Registros

    Realmente no hay mucho que decir acerca de cómo eliminar registros. Si tienes un objeto ActiveRecord (por ejemplo un producto de la base de datos), puedes eliminarlo llamando a su método delete().

    Ejemplo

      1. $Productos->delete(123);

    24.4.7 Propiedades Soportadas

    Propiedad Descripción
    $fields Listado de Campos de la tabla que han sido mapeados
    $count Conteo del ultimo Resultado de un Select
    $primary_key Listado de columnas que conforman la llave primaria
    $non_primary Listado de columnas que no son llave primaria
    $not_null Listado de campos que son not_null
    $attributes_names Nombres de todos los campos que han sido mapeados

    24.5 Convenciones en ActiveRecord

    ActiveRecord posee una serie de convenciones que le sirven para asumir distintas cualidades y relacionar un modelo de datos. Las convenciones son las siguientes:


    24.5.1 Convenciones Generales


    24.5.2 Id

    Si ActiveRecord encuentra un campo llamado Id, ActiveRecord asumirá que se trata de la llave primaría de la entidad y que es autonumérica.


    24.5.3 campo_id

    Los campos terminados en _id indican relaciones foráneas a otras tablas, de esta forma se puede definir fácilmente las relaciones entre las entidades del modelo:

    Un campo llamado clientes_id en una tabla indica que existe otra tabla llamada clientes y esta contiene un campo id que es foránea a este.


    24.5.4 campo_at

    Los campos terminados en _at indican que son fechas y posee la funcionalidad extra que obtienen el valor de fecha actual en una inserción

    created_at es un campo fecha

    24.5.5 campo_in

    Los campos terminados en _in indican que son fechas y posee la funcionalidad extra que obtienen el valor de fecha actual en una actualización

    modified_in es un campo fecha

    24.6 Convenciones para RDBMs

    24.6.1 Convenciones Especiales para PostgreSQL

    Los campos autonuméricos en PostgreSQL deben ser definidos con una columna de tipo serial.

    24.6.2 Convenciones Especiales para Oracle

    Los campos autonuméricos en Oracle no existen y las inserciones deben ser realizadas utilizando una "sequencia" auxiliar que debe ser creada utilizando la convención tabla_sequence