Manual de Symfony Objetivos: 1. Modelar correctamente nuestra base de datos en formato YML con sus respectivas relaciones 2.

Exportar la base de datos con informacin por defecto.

En la presente ficha aprenderemos a modelar nuestra base de datos en formato YML, luego a partir de la estructura que creemos construir su respectivo modelo, formularios y filtros y finalmente exportar la base de datos con datos iniciales. 1. Como observamos en el manual 1 de symfony para la creacin de un mantenimiento de la clase persona, primero generamos la definicin de la entidad Persona en el archivo config doctrine schema.yml, este archivo no slo sirve para definir una entidad sino que en realidad se deben definir todas las entidades de nuestro proyecto en formato YML. En esta parte del manual aprenderemos como definir varias entidades con sus respectivas relaciones. Para empezar, debemos definir la conexin que vamos a usar para conectarnos a nuestra base de datos, esto la hacamos en el fichero config databases.yml: all: doctrine: class: sfDoctrineDatabase param: dsn: mysql:host=localhost;dbname=bd_proyecto username: root password: attributes: default_table_charset: utf8 default_table_collate: utf8_spanish_ci Donde doctrine es el nombre de la conexin la cual vamos a usar para definir todas nuestras entidades. 2. Antes de construir nuestra entidades tenemos que centrarnos un poco en como hace symfony para reconocer una entidad, tomamos como ejemplo la siguiente la siguiente entidad Persona: Persona: connection: doctrine tableName: t_persona actAs: Sluggable: alias: slug_persona fields: [nombres, ape_paterno, ape_materno] canUpdate: true Timestampable: created: name: fec_crea updated: name: fec_modifica columns: nro_doc: { type: string(15), notnull: true } ape_paterno: { type: string(40), notnull: true } ape_materno: { type: string(40), notnull: true } nombres: { type: string(40), notnull: true } sexo: { type: enum, values: [M, F] } fec_nacimiento: { type: date(25), notnull: true } direccion: { type: string(80) } telefono: { type: string(20) } celular: { type: string(20) } correo: { type: string(60) }

Donde:

Persona: Es el nombre de la entidad y la clase que se va a generar despus. connection: doctrine Es la conexin que definimos anteriormente y la forma como symfony se conecta con nuestra base de datos fsica. tableName: t_persona Es el nombre de la tabla que se va a generar en nuestra base de datos fsica. actAs: Sluggable: alias: slug_persona fields: [nombres, ape_paterno, ape_materno] canUpdate: true Timestampable: created: name: fec_crea updated: name: fec_modifica Es el comportamiento particular que puede adoptar nuestra entidad: Sluggable Genera un campo slug que ser nico para cada registro de la entidad y que puede funcionar como una clave pero que toma valores ms comprensible para el usuario, por ejemplo el slug para: Jose Carlos Fernndez Gomez sera jose-carlos-fernandez-gomez. Timestampable Genera en este caso dos campos adicionales fec_crea y fec_modifica que tienen la funcin de registrar de forma automtica la fecha de creacin de un registro y la ltima fecha de modificacin del mismo. columns: nro_doc: { type: string(8), fixed: true, notnull: true } ape_paterno: { type: string(40), notnull: true } ape_materno: { type: string(40), notnull: true } nombres: { type: string(40), notnull: true } sexo: { type: enum, values: [M, F] } fec_nacimiento: { type: date(25), notnull: true } direccion: { type: string(80) } telefono: { type: string(20) } celular: { type: string(20) } correo: { type: string(60) } Aqu se describen todas las columnas de nuestra entidad, fjese que no se ha descrito la columna que corresponde a la clave primaria, esta se genera por defecto con el nombre de id. Primero se coloca el nombre de la columna y a continuacin los atributos de esta: type: Es el tipo de dato de nuestra columna, puede ser de varios tipos: boolean: que puede tomar solo dos valores 1 | 0. Test: columns: booltest: boolean integer: Test: columns: integertest: type: integer(4) unsigned: true

Campo de tipo entero, se define entre parntesis la longitud del entero y luego si ser un entero con o sin signo. float: Test: columns: floattest: float Campo de tipo real. decimal: Test: columns: decimaltest: type: decimal(18) scale: 2 Numero decimal con 18 nmeros enteros y 2 decimales

string: Test: columns: stringtest: type: string(200) Cadena de longitud 200 variable -> varchar(200) Test: columns: stringtest: type: string(20) fixed: true Cadena de longitud fija de 20 -> char(20) time: Test: columns: timetest: time date: Test: columns: datetest: date enum: Test: columns: enumtest: type: enum values: [php, java, python] Tipo de datos especial que solo acepta los valores enumerados en values. Relaciones:

3.

Algo importante al momento de disear nuestra base de datos es definir correctamente las relaciones de integridad referencial, lo cual podemos hacer perfectamente con YML, para ello veremos los tipos de relaciones que veremos con ms frecuencia, para ello tomaremos como ejemplo:

El anterior grfico representa una base de datos para foros. La representacin de sus entidades sera la siguiente: Foro: connection: doctrine tableName: t_foro columns: nombre: { type: string(100), notnull: true } descripcion: { type: string(5000) } # ---------------------------------HiloForo: Connection: doctrine tableName: t_hilo_foro columns: usuario_id: { type: integer, notnull: true } foro_id: { type: integer, notnull: true } titulo: { type: string(100), notnull: true } actualizado: { type: integer(4) } cerrado: { type: boolean } # -----------------------------------Usuario: Connection: doctrine tableName: t_usuario columns: nombre: { type: string(100) , notnull: true } login: { type: string(20) , notnull: true } password: { type: string(50) , notnull: true } activo: { type: boolean }

# -----------------------------------Correo:

Connection: doctrine tableName: t_correo columns: usuario_id: { type: integer, notnull: true } direccion: { type: string(60), notnull: true } # -----------------------------------Grupo: Connection: doctrine tableName: t_grupo columns: nombre: { type: string(50), notnull: true } # -----------------------------------UsuarioGrupo: Connection: doctrine tableName: t_usuario_grupo columns: usuario_id: { type: integer, notnull: true } grupo_id: { type: integer, notnull: true }

Ahora debemos definir la relacin entre ellos: Sabemos por definicin que tenemos 3 tipos de relaciones (ms frecuentes): Relacin de 1 a 1. Relacin de 1 a varios o varios a 1. Relacin de varios a varios. Observamos en nuestro diagrama que existen definidos los 3 tipos de relaciones: 1 foro tiene varios hilos (1 a varios). 1 usuarios est presente en varios hilos (1 a varios). 1 usuario slo tiene 1 correo (1 a 1). 1 usuario puede pertenecer a varios grupos y un grupo puede tener varios usuarios (varios a varios). La forma como debemos construir las relaciones es la siguiente:

1 a 1: # -----------------------------------Usuario: se crea automaticamente el id Connection: doctrine tableName: t_usuario columns: nombre: { type: string(100) , notnull: true } login: { type: string(20) , notnull: true } password: { type: string(50) , notnull: true } activo: { type: boolean }

atributos de la tabla

# -----------------------------------Correo: Connection: doctrine tableName: t_correo columns: atributos de la tabla usuario_id: { type: integer, notnull: true } direccion: { type: string(60), notnull: true } relations: Usuario: local: usuario_id foreign: id ## hace referencia a la clave primaria de usuario que es id foreignType: one ## el tipo de relacin es de 1 a 1

relacion que tiene con la tabla USUARIO

1 a varios | varios a 1: Foro: connection: doctrine tableName: t_foro columns: nombre: { type: string(100), notnull: true } descripcion: { type: string(5000) } relations: Hilos: ## un foro tiene varios hilos class: HiloForo local: id ## es la clave primaria de esta entidad id foreign: foro_id type: many ## la relacin de es de varios # ---------------------------------HiloForo: Connection: doctrine tableName: t_hilo_foro columns: usuario_id: { type: integer, notnull: true } foro_id: { type: integer, notnull: true } titulo: { type: string(100), notnull: true } actualizado: { type: integer(4) } cerrado: { type: boolean } relations: Foro: ## un hilo de un foro pertenece a un solo foro local: foro_id ## es la clave foranea de esta entidad foro_id foreign: id ## es la clave primaria de la entidad foro type: one ## la relacin en esta entidad es de 1 Usuario: ## un hilo de un foro pertenece a un solo usuario local: usuario_id ## es la clave foranea de esta entidad usuario_id foreign: id ## es la clave primaria de la entidad usuario type: one ## la relacin en esta entidad es de 1 # -----------------------------------Usuario: Connection: doctrine tableName: t_usuario columns: nombre: { type: string(100) , notnull: true } login: { type: string(20) , notnull: true } password: { type: string(50) , notnull: true } activo: { type: boolean } relations: Hilos: ## un usuario participa en varios hilos class: HiloForo local: id ## es la clave primaria de esta entidad id foreign: usuario_id type: many ## la relacin de es de varios

varios a varios: # -----------------------------------Usuario: Connection: doctrine tableName: t_usuario columns: nombre: { type: string(100) , notnull: true } login: { type: string(20) , notnull: true } password: { type: string(50) , notnull: true } activo: { type: boolean } relations: Grupos: ## un usuario esta en varios grupos class: Grupo ## la clase a la que se debe hacer referencia refClass: UsuarioGrupo ## es la clase que permite la definicin de varios a varios local: usuario_id ## la clave local de usuario en UsuarioGrupo foreign: grupo_id ## la clave fornea de grupo en UsuarioGrupo

# -----------------------------------Grupo: Connection: doctrine tableName: t_grupo columns: nombre: { type: string(50), notnull: true } relations: Usuarios: ## un grupo tiene varios usuarios class: Usuario ## la clase a la que se debe hacer referencia refClass: UsuarioGrupo ## es la clase que permite la definicin de varios a varios local: grupo_id ## la clave local de grupo en UsuarioGrupo foreign: usuario_id ## la clave fornea de usuario en UsuarioGrupo

# -----------------------------------UsuarioGrupo: Connection: doctrine tableName: t_usuario_grupo columns: usuario_id: { type: integer, notnull: true } grupo_id: { type: integer, notnull: true }

Entonces nuestro esquema de datos quedara de la siguiente forma: # -----------------------------------Usuario: Connection: doctrine tableName: t_usuario columns: nombre: { type: string(100) , notnull: true } login: { type: string(20) , notnull: true } password: { type: string(50) , notnull: true } activo: { type: boolean } Hilos: class: HiloForo local: id foreign: usuario_id type: many Grupos: class: Grupo refClass: UsuarioGrupo local: usuario_id foreign: grupo_id # -----------------------------------Correo: Connection: doctrine tableName: t_correo columns: usuario_id: { type: integer, notnull: true } direccion: { type: string(60), notnull: true } relations: Usuario: local: usuario_id foreign: id foreignType: one # -----------------------------------Foro: connection: doctrine tableName: t_foro columns: nombre: { type: string(100), notnull: true } descripcion: { type: string(5000) } relations: Hilos: class: HiloForo local: id foreign: foro_id type: many # ---------------------------------HiloForo: Connection: doctrine tableName: t_hilo_foro columns: usuario_id: { type: integer, notnull: true } foro_id: { type: integer, notnull: true } titulo: { type: string(100), notnull: true } actualizado: { type: integer(4) } cerrado: { type: boolean } relations: Foro: local: foro_id foreign: id type: one Usuario: local: usuario_id foreign: id type: one

# -----------------------------------Grupo: Connection: doctrine tableName: t_grupo columns: nombre: { type: string(50), notnull: true } relations: Usuarios: class: Usuario refClass: UsuarioGrupo local: grupo_id foreign: usuario_id # -----------------------------------UsuarioGrupo: Connection: doctrine tableName: t_usuario_grupo columns: usuario_id: { type: integer, notnull: true } grupo_id: { type: integer, notnull: true }

4.

Una vez aprendido esto modele el esquema para sus respectivas bases de datos.