Código para BBDD Oracle - Archivo Digital UPMoa.upm.es/39878/1/PFC_Javier_Blazquez_Chaves.pdf ·...
Transcript of Código para BBDD Oracle - Archivo Digital UPMoa.upm.es/39878/1/PFC_Javier_Blazquez_Chaves.pdf ·...
Generador de Código para BBDD Oracle
PROYECTO FIN DE CARRERA
INGENIERÍA TÉCNICA DE GESTIÓN
2014/2015
GENERADOR DE CÓDIGO PARA BBDD ORACLE
Autor: Javier Blázquez Chaves
Director: Fernando Arroyo Montoro
1
Generador de Código para BBDD Oracle
2
Generador de Código para BBDD Oracle
Índice
Índice ................................................................................................................................................... 3
Índice ilustraciones .............................................................................................................................. 7
Índice Tablas ........................................................................................................................................ 9
Resumen ............................................................................................................................................ 13
Abstract .............................................................................................................................................. 14
Introducción ....................................................................................................................................... 15
Objetivo ............................................................................................................................................. 16
Definición de metodología ................................................................................................................ 17
Metodología ágil ............................................................................................................................ 22
Scrum ............................................................................................................................................. 25
Tecnología aplicada al desarrollo ...................................................................................................... 28
Java ................................................................................................................................................ 28
StringTemplate .............................................................................................................................. 29
Group file ................................................................................................................................... 31
Templates .................................................................................................................................. 32
Definición formal de StringTemplate ......................................................................................... 39
Oracle Database Express Edition ................................................................................................... 40
ALL_TABLES ................................................................................................................................ 42
ALL_TAB_COLUMNS .................................................................................................................. 46
ALL_CONSTRAINTS ..................................................................................................................... 48
ALL_CONS_CONSTRAINT ........................................................................................................... 50
3
Generador de Código para BBDD Oracle
Herramientas utilizadas ..................................................................................................................... 51
Google Drive .................................................................................................................................. 51
Draw.io ........................................................................................................................................... 52
Web sequence diagrams................................................................................................................ 53
Eclipse ............................................................................................................................................ 54
Desarrollo........................................................................................................................................... 55
Primera iteración ........................................................................................................................... 55
Reunión de planificación (Sprint Planning) ................................................................................ 55
Pruebas unitarias ....................................................................................................................... 59
T4 Pruebas de integración ......................................................................................................... 60
Segunda iteración .......................................................................................................................... 62
Reunión de planificación (Sprint Planning) ................................................................................ 62
Pruebas unitarias ....................................................................................................................... 67
T8 Pruebas de integración ......................................................................................................... 68
Tercera iteración ............................................................................................................................ 71
Reunión de planificación (Sprint Planning) ................................................................................ 71
Pruebas unitarias ....................................................................................................................... 80
T11 Pruebas de integración ....................................................................................................... 82
Cuarta iteración ............................................................................................................................. 84
Reunión de planificación (Sprint Planning) ................................................................................ 84
Pruebas unitarias ....................................................................................................................... 94
T14 Pruebas de integración ....................................................................................................... 95
4
Generador de Código para BBDD Oracle
Sprint Backlog Final ........................................................................................................................ 98
Trabajo Futuro ........................................................................................................................... 100
Conclusiones .................................................................................................................................... 102
Referencias ...................................................................................................................................... 103
5
Generador de Código para BBDD Oracle
6
Generador de Código para BBDD Oracle
Índice ilustraciones
Ilustración 1 ................................................................................................................................. 18
Ilustración 2 ................................................................................................................................. 18
Ilustración 3 ................................................................................................................................. 19
Ilustración 4 ................................................................................................................................. 20
Ilustración 5 ................................................................................................................................. 21
Ilustración 6 ................................................................................................................................. 41
Ilustración 7 ................................................................................................................................. 52
Ilustración 8 ................................................................................................................................. 53
Ilustración 9 ................................................................................................................................. 57
Ilustración 10 ............................................................................................................................... 58
Ilustración 11 ............................................................................................................................... 66
Ilustración 12 ............................................................................................................................... 73
Ilustración 13 ............................................................................................................................... 78
7
Generador de Código para BBDD Oracle
8
Generador de Código para BBDD Oracle
Índice Tablas
Tabla 1 ......................................................................................................................................... 30
Tabla 2 ......................................................................................................................................... 30
Tabla 3 ......................................................................................................................................... 31
Tabla 4 ......................................................................................................................................... 31
Tabla 5 ......................................................................................................................................... 31
Tabla 6 ......................................................................................................................................... 32
Tabla 7 ......................................................................................................................................... 33
Tabla 8 ......................................................................................................................................... 33
Tabla 9 ......................................................................................................................................... 34
Tabla 10 ....................................................................................................................................... 35
Tabla 11 ....................................................................................................................................... 35
Tabla 12 ....................................................................................................................................... 35
Tabla 13 ....................................................................................................................................... 35
Tabla 14 ....................................................................................................................................... 36
Tabla 15 ....................................................................................................................................... 36
Tabla 16 ....................................................................................................................................... 38
Tabla 17 ....................................................................................................................................... 39
Tabla 18 ....................................................................................................................................... 45
Tabla 19 ....................................................................................................................................... 47
Tabla 20 ....................................................................................................................................... 49
9
Generador de Código para BBDD Oracle
Tabla 21 ....................................................................................................................................... 50
Tabla 22 ....................................................................................................................................... 55
Tabla 23 ....................................................................................................................................... 56
Tabla 24 ....................................................................................................................................... 61
Tabla 25 ....................................................................................................................................... 62
Tabla 26 ....................................................................................................................................... 63
Tabla 27 ....................................................................................................................................... 64
Tabla 28 ....................................................................................................................................... 65
Tabla 29 ....................................................................................................................................... 70
Tabla 30 ....................................................................................................................................... 71
Tabla 31 ....................................................................................................................................... 71
Tabla 32 ....................................................................................................................................... 72
Tabla 33 ....................................................................................................................................... 75
Tabla 34 ....................................................................................................................................... 77
Tabla 35 ....................................................................................................................................... 77
Tabla 36 ....................................................................................................................................... 83
Tabla 37 ....................................................................................................................................... 84
Tabla 38 ....................................................................................................................................... 84
Tabla 39 ....................................................................................................................................... 87
Tabla 40 ....................................................................................................................................... 90
Tabla 41 ....................................................................................................................................... 97
Tabla 42 ....................................................................................................................................... 99
10
Generador de Código para BBDD Oracle
11
Generador de Código para BBDD Oracle
12
Generador de Código para BBDD Oracle
Resumen
Las empresas tienen programas que acceden a sus bases de datos, estos programas pueden
quedarse obsoletos o dejar de serles útiles por alguna razón y deben ser actualizados o
reemplazados. Sin embargo la base de datos se suele mantener, ya que la estructura de la
información no cambia. Llegado el momento de actualizar o migrar ese software que accede a
la base de datos, se puede recurrir a una estructura de clases, las cuales están basadas en la
metainformación de la base de datos, y así facilitar el desarrollo del nuevo software.
La herramienta desarrollada en este proyecto accede a la metainformación de la base de
datos, obtiene la estructura de las tablas y a través de plantillas genera las clases necesarias
para empezar el nuevo software. Al estar la herramienta basada en plantillas, adaptar éstas a
un nuevo lenguaje es sencillo, haciendo la herramienta mucho más polivalente.
En conclusión, una herramienta de este tipo puede facilitar el desarrollo de un nuevo software
siempre que la estructura de la base de datos se mantenga intacta haciendo que el nuevo
proyecto se desarrolle de forma más rápida.
13
Generador de Código para BBDD Oracle
Abstract
Companies have software that access their databases, this software can become obsolete or
fail to be useful for some reason and must be upgraded or replaced. However the database is
usually maintained as the information does not change. It is for this reason that when you
migrate the software that accesses the database can use a class structure based on
information in the database to facilitate the development of new software.
The tool developed in this project accesses the metadata of the database to obtain the
structure of the tables and through templates generate the necessary classes to start the new
software. Being template‐based tool, adapt these to a new language is simple, making a more
versatile tool.
In conclusion, a tool of this kind can facilitate the development of a new software provided
that the structure of the database is intact making the new project develops more quickly.
14
Generador de Código para BBDD Oracle
Introducción
En los últimos años el avance en las tecnologías de presentación de información al usuario,
front end, ha avanzado de forma muy significativa, sobre todo en las tecnologías web, pasando
de unas páginas web estáticas en las que el usuario apenas podía interactuar con ellas a webs
dinámicas, que se asemejan más a una aplicación de escritorio. Pero en el campo de
almacenamiento de datos esos avances han sido menores. Han existido avances como las
bases de datos orientadas a objetos o las bases de datos orientadas a documentos (mongodb)
pero el sistema más extendido de almacenamiento de datos, las bases de datos relacionales,
ha avanzado muy poco, los cimientos en los que se basa no han cambiado en los últimos 40
años.
Por estas razones muchas empresas se encuentran en la situación de que su modelo de datos
actual le es totalmente válido pero es necesario actualizar las aplicaciones que acceden a él,
bien porque son aplicaciones que están hechas para un sistema operativo concreto y éste debe
ser cambiado, bien porque la empresa quiere que esa aplicación sea accesible desde cualquier
entorno por lo que decide hacer una aplicación web, etc.
En general, las razones por las que se puede decidir el cambio pueden ser muy diversas pero
por norma general el modelo de datos se mantiene igual y únicamente cambia el front end.
Ante esta situación, la solución habitual es empezar de cero, diseñando toda la aplicación
desde el principio pero manteniendo tan sólo el modelo de datos.
15
Generador de Código para BBDD Oracle
Objetivo
El objetivo de este proyecto es crear una herramienta que facilite el desarrollo de un nuevo
software que permita facilitar la migración de las aplicaciones de negocio de una empresa
manteniendo la metainformación de sus bases de datos. Para facilitar el desarrollo de ese
nuevo software, la herramienta creará un esqueleto básico de clases, que es el punto de
partida sobre el que comenzar a desarrollar, facilitando así el trabajo al programador.
Para poder crear esa estructura se deberá obtener información de la única parte que aún
permanece del antiguo sistema y es la base de datos. Se accederá a los metadatos de esa base
de datos para poder determinar las tablas, columnas, tipos de datos, constraint… y así crear las
diferentes partes de la estructura que permitirá realizar una migración fácil.
Estas partes serán:
� Bean por cada tabla en él estarán todas las columnas de esa tabla con sus respectivos
tipos de datos.
� Un XSD (XML Schema Definition) en el cual se definirá la estructura de esa tabla con
sus columnas, sus tipo de datos y sus PK.
16
Generador de Código para BBDD Oracle
Metodologías
La metodología de desarrollo de software se define como un conjunto de procedimientos,
herramientas y técnicas que se usan para el desarrollo de software. Estas técnicas están
pensadas para que el desarrollo del proyecto esté más estructurado, planeado y controlado y
como consecuencia de esto la calidad del mismo es mayor.
Las metodologías tienen diferentes enfoques para tratar de resolver los problemas a los que se
enfrentan los miembros de un equipo de desarrollo por lo que algunas son adecuadas para un
tipo de proyectos y otras son más adecuadas para otro tipo de proyectos. No hay una norma
que indique cuál es la más adecuada para cada tipo de proyecto ya que hay muchos factores
que pueden influir, experiencia del equipo en esa metodología, tipo de proyecto, tipo de
cliente, etc. por lo que hay que analizar cada caso en particular para poder tomar una decisión.
Los diferentes tipos de enfoque de las metodologías son [1]:
� Modelo en cascada:
El modelo en cascada, es la metodología de desarrollo más clásica. Su forma de
trabajar es secuencial sin que haya ninguna iteración, la primera fase es la toma de
requisitos, para seguir con el diseño, implementación, verificación y por último el
mantenimiento. Con el paso del tiempo se ha demostrado que este tipo de
metodología no es el más adecuado para muchos proyectos ya que los requisitos
pueden cambiar y no está pensada para desde una fase volver a otra anterior, otra de
sus desventajas es que el cliente no ve el producto final hasta que el proyecto está
completamente acabado.
17
Generador de Código para BBDD Oracle
Ilustración 1
� Modelo de Procesos Incrementales
El modelo incremental es una variación del modelo en cascada, aplica este modelo
repetidamente y solapa sus ejecuciones, produciendo en cada repetición una entrega
de software. En cada iteración el equipo adquiere más experiencia provocando que en
cada entrega el software tenga mejor calidad. La primera entrega es lo denominado el
núcleo y en el que se basará el resto del software. Este modelo tiene las ventajas del
modelo en cascada y evita uno de sus inconvenientes, el cliente va viendo en cada
iteración como evoluciona el producto.
Ilustración 2
18
Generador de Código para BBDD Oracle
� Espiral
El modelo en espiral consta de varias fases que se ejecutan de forma cíclica hasta
obtener un producto terminado. En cada iteración se deben tener en cuenta los
objetivos a conseguir en esa iteración, las diferentes alternativas para conseguir los
objetivos marcados para esa iteración analizando sus posibles riesgos, una
planificación detallada y por último el desarrollo y pruebas del software a entregar.
Éste fue definido por Boehm en 1986 tras escribir su artículo "A Spiral Model of
Software Development and Enhancement" [19].
Ilustración 3
19
Generador de Código para BBDD Oracle
� Construcción de Prototipos
El modelo de prototipos consiste en un modelo en el equipo de desarrollo debe
construir pequeños prototipos en poco tiempo para mostrárselos al cliente, éste a su
vez dará su opinión sobre el software entregado y las nuevas características que quiere
para la siguiente entrega. De esta forma, el cliente ve las evoluciones del producto
evitando así que el producto entregado al final del desarrollo no sea lo que el cliente
quiere. Con este modelo también se consigue que los requisitos sean más exactos ya
que si algún requisito no ha sido entendido correctamente el cliente se dará cuenta de
forma rápida y corregirá el error.
Cada entrega de cada prototipo consta de cinco fases:
• Plan rápido
• Modelado de diseño rápido
• Construcción del prototipo
• Desarrollo, entrega y retroalimentación
• Comunicación
Ilustración 4
20
Generador de Código para BBDD Oracle
� Metodología ágil
Las metodologías ágiles son un conjunto de buenas prácticas para la gestión de
proyectos que destacan por su rapidez y flexibilidad en la producción [2].
Ilustración 5 [3]
21
Generador de Código para BBDD Oracle
Metodología ágil
Como se ha dicho antes, la metodología ágil es un conjunto de buenas prácticas para el
desarrollo de un proyecto software con el que se consigue mejorar la productividad del
equipo, mejorar la calidad del producto final, en caso de que los requisitos del proyecto
cambien la respuesta a estos cambios es rápida y sobre todo se consigue que el cliente esté
satisfecho con el producto [4].
Para conseguir los objetivos descritos se crean pequeños grupos de trabajo que se
autogestionan ellos mismos y así son más ágiles a la hora de tomar decisiones o reaccionar a
cambios drásticos en el producto. También se hacen pequeñas entregas de software de forma
iterativa, cada una de estas iteraciones es de un periodo de tiempo corto, no más de cuatro
semanas, y cada iteración tiene las fases típicas del desarrollo de software. Al ser entregado el
software al cliente de forma constante, se consigue que éste retroalimente al equipo de
desarrollo y observe fallos de concepto en las fases tempranas del proyecto.
Esta metodología es muy válida para proyectos en los que los requisitos son muy volátiles y se
deben hacer cambios en el software de manera constante. La comunicación con el cliente es
fundamental en este tipo de metodologías pero dando mucha más prioridad a la comunicación
cara a cara que a la documentación.
El origen de esta metodología se remonta al año 2001 cuando un grupo de expertos de la
industria del software se reúnen en Utah. Su objetivo fue esbozar los valores y principios que
deberían permitir a los equipos desarrollar software rápidamente y respondiendo a los
cambios que puedan surgir a lo largo del proyecto.
22
Generador de Código para BBDD Oracle
Tras esta reunión se creó The Agile Alliance, una organización sin ánimo de lucro, dedicada a
fomentar la utilización de la metodología de desarrollo ágil y a ayudar a las empresas y
organizaciones a que adopten dicha metodología. También se creó tras aquella reunión lo que
se conoce como el manifiesto ágil, cuyos fundamentos son:
� Valorar más a los individuos y su interacción que a los procesos y las herramientas.
Uno de los pilares en los que se apoya una metodología ágil es que las personas son el
factor principal para que un proyecto salga adelante. Hay que anteponer las personas
a las herramientas, primero se debe elegir el equipo y que sea éste el que decide qué
herramientas va a utilizar para realizar el proyecto, y no elegir primero las
herramientas y que sean las personas las que se adaptan a las herramientas.
� Valorar más el software que funciona que la documentación exhaustiva. No se deben
generar documentos a no ser que sean realmente necesarios y éstos deben ser cortos
y concisos, sin añadir información que no es realmente relevante.
� Valorar más la colaboración con el cliente que la negociación contractual. El desarrollo
del proyecto se va a realizar con la colaboración constante del cliente por lo que es
fundamental que la interacción entre las dos partes sea fluida ya que esto marcará
buena marcha del proyecto y asegure su éxito.
� Valorar más la respuesta al cambio que el seguimiento de un plan. El equipo debe
estar preparado para cualquier cambio en el proyecto, ya sea un cambio de requisito o
bien un cambio de tecnología, por lo que la planificación debe ser flexible.
23
Generador de Código para BBDD Oracle
Manifiesto [5]
1. Nuestra mayor prioridad es satisfacer al cliente mediante la entrega temprana y
continua de software con valor.
2. Aceptamos que los requisitos cambien, incluso en etapas tardías del desarrollo. Los
procesos Ágiles aprovechan el cambio para proporcionar ventaja competitiva al
cliente.
3. Entregamos software funcional frecuentemente, entre dos semanas y dos meses, con
preferencia al periodo de tiempo más corto posible.
4. Los responsables de negocio y los desarrolladores trabajamos juntos de forma
cotidiana durante todo el proyecto.
5. Los proyectos se desarrollan en torno a individuos motivados. Hay que darles el
entorno y el apoyo que necesitan, y confiarles la ejecución del trabajo.
6. El método más eficiente y efectivo de comunicar información al equipo de desarrollo
y entre sus miembros es la conversación cara a cara.
7. El software funcionando es la medida principal de progreso.
8. Los procesos Ágiles promueven el desarrollo sostenible. Los promotores,
desarrolladores y usuarios debemos ser capaces de mantener un ritmo constante de
forma indefinida.
9. La atención continua a la excelencia técnica y al buen diseño mejora la Agilidad.
10. La simplicidad, o el arte de maximizar la cantidad de trabajo no realizado, es esencial.
11. Las mejores arquitecturas, requisitos y diseños emergen de equipos auto‐
organizados.
12. A intervalos regulares el equipo reflexiona sobre cómo ser más efectivo para, a
continuación, ajustar y perfeccionar su comportamiento en consecuencia.
24
Generador de Código para BBDD Oracle
Scrum
El origen de Scrum se remonta a 1986 cuando en el ámbito industrial necesitan sacar al
mercado nuevos productos, cuyos requisitos son muy generales a la vez que innovadores y
deben estar en el mercado en un periodo de tiempo muy corto [6].
¿Qué es Scrum?
Scrum es una metodología de desarrollo software en el que se aplican un conjunto de buenas
prácticas para desarrollar un proyecto de forma colaborativa y conseguir de esta forma el
mejor resultado posible. Estas prácticas se apoyan unas a otras y su selección tiene origen en
un estudio de la manera de trabajar de equipos altamente productivos.
Al igual que en otras metodologías, Scrum hace entregas de software de forma periódica. Las
entregas se priorizan en función de los beneficios que le aportan al cliente, siendo los más
prioritarios los primeros en ser entregados.
Scrum está especialmente indicado para proyectos cuyos requisitos son muy volátiles ya que la
capacidad de reacción es muy alta y se pueden atajar los problemas rápidamente.
25
Generador de Código para BBDD Oracle
Fundamentos
� El desarrollo incremental
� Priorización de los requisitos por valor y coste
� El control empírico del proyecto.
● La potenciación del equipo
� Colaboración y comunicación entre el equipo y con el cliente
● El timeboxing
El desarrollo incremental
Scrum está basado en pequeñas entregas de software que se realizan de forma periódica e
iterativa. La ejecución de esta iteración, también llamado sprint, debe realizarse en un corto
periodo de tiempo, entre dos semanas y dos meses, y debe entregar un software al cliente
que sea funcional. Cada iteración debe contener todas las partes de un proyecto, análisis,
diseño, documentación y pruebas pero sólo lo necesario. Con cada sprint el producto va siendo
más complejo consiguiendo que el desarrollo se ejecute de forma incremental.
Priorización de los requisitos por valor y coste
Al inicio del proyecto se crea una lista de tareas (Product Backlog) y se ordenan estableciendo
una prioridad a cada una de ellas, teniendo en cuenta el valor que aportan al proyecto y su
coste en desarrollo. Estas prioridades pueden ir variando según avanza el proyecto, en cada
inicio de sprint se analizan las tareas que quedan por realizar y se restablece su prioridad. En
las reuniones de cada inicio de sprint pueden aparecer nuevas tareas que son añadidas al
Product Backlog.
26
Generador de Código para BBDD Oracle
El control empírico del proyecto.
A diferencia de los proyectos tradicionales que se basan en predicciones para controlar las
variables de los proyectos, Scrum basa su control del proyecto en la experiencia, adaptando las
variables del proyecto (tiempos de entrega, valoraciones, coste de cada requisito) en las
experiencias de los sprints anteriores.
La potenciación del equipo
Otro de los fundamentos de Scrum es el equipo. A diferencia de los proyectos tradicionales
donde el jefe de proyecto es el que toma las decisiones importantes, en Scrum las decisiones
las toman todo el equipo. Con esto se consigue que el equipo este más comprometido con el
proyecto y, a la vez, más motivado.
Colaboración y comunicación entre el equipo, y con el cliente
En Scrum, la colaboración con el cliente es fundamental, debe estar presente durante la
creación de la lista de objetivos del producto, en la reunión de planificación de cada iteración
para que el equipo pueda preguntar cualquier duda al cliente y al final de cada iteración para
poder hacerle una demostración de lo realizado en esa iteración.
El timeboxing
Las tareas que se realizan (pueden ser de cualquier tipo, toma de decisiones, una reunión, etc.)
deben tener un tiempo máximo para que sean realizadas. De esta forma se priorizan los
objetivos, se consigue ser más productivo y las personas trabajan más enfocadas en su tarea.
27
Generador de Código para BBDD Oracle
Tecnología aplicada al desarrollo
Java
En la actualidad existen gran cantidad de lenguajes de programación, todos con sus ventajas e
inconvenientes. Para este proyecto se decidió utilizar Java por varias razones [7]:
� Alto conocimiento del lenguaje. Como indica la metodología de desarrollo Scrum, el
individuo prevalece sobre las herramientas y en este caso el equipo tenía un gran
conocimiento sobre el lenguaje de desarrollo java por lo que la evolución del proyecto
sería más rápida y ágil, evitando así el cuello de botella que provocaría la curva de
aprendizaje de un nuevo lenguaje de programación.
� Independencia de SO y arquitectura hardware. Al ser un lenguaje interpretado es
independiente, tanto al sistema operativo como a la arquitectura hardware, tan sólo
es necesario que exista una máquina virtual que, bien puede ser la proporcionada por
Oracle, por otra empresa que haya desarrollado su propia máquina virtual
manteniendo los estándares o utilizando la máquina virtual de código abierto
OpenJDK.
� Lenguaje orientado a objetos. Una de las ventajas de la orientación a objetos es que el
código fuente es más fácil de reutilizar, evitando que se tenga que programar la misma
tarea varias veces. Otras de las ventajas son abstracción, encapsulamiento, herencia,
etc.
� Numerosos drivers de conexión a BBDD. Al estar tan extendido este lenguaje, existe
una gran variedad de drivers de conexión a BBDD por lo que, en caso de querer
ampliar el alcance del proyecto y dar cabida a otros de tipos de BBDD, será mucho más
sencillo.
� Garbage collector. Otra de las ventajas consiste en la liberación de memoria. Java tiene
la característica que no es necesario gestionar la memoria, el lenguaje tiene un
mecanismo que se encarga de liberar la memoria que ya no se está utilizando por lo
que para el programador es transparente. Esta característica está presente en la
mayoría de lenguajes de programación modernos.
� IDE. Java dispone de varios entornos de desarrollo integrado, llamado también IDE
(sigla en inglés de Integrated Development Environment). Varios de ellos muy
avanzados que facilitan la labor del desarrollador en gran medida evitando tener que
realizar tareas tediosas.
28
Generador de Código para BBDD Oracle
StringTemplate
Los motores de plantillas son programas de software que generan un resultado a partir de
unos datos estáticos y unos datos dinámicos. Los datos estáticos son una estructura que viene
proporcionada por la plantilla, esta estructura carece de sentido y debe ser completada con
datos dinámicos. Los resultados obtenidos pueden ser de todo tipo, páginas web, código
fuente, correos electrónicos, etc [8].
StringTemplate es un motor de plantillas que rompe las plantillas en trozos de texto y en
expresiones, las cuales vienen delimitadas, por defecto, entre los símbolos de mayor y menor.
El motor ignora todo lo que se encuentre fuera de las expresiones y lo escupe sin evaluarlo
tratando sólo las expresiones.
El creador de StringTemplate es Terence Parr, profesor de la universidad de San Francisco y
cofundador de http://www.jguru.com/ [20]. Ante la necesidad de crear una web dinámica,
decidieron crear un motor de plantillas. Este motor de plantillas se desarrolló originalmente en
java pero posteriormente se hizo un fork para c# y python por lo que está presente en varios
de los lenguajes más extendidos de la actualidad.
La última versión del motor sufrió grandes cambios respecto a la anterior, provocando que
fuera aproximadamente dos veces más rápida y el uso de memoria mucho menor. El problema
es que no es compatible con las aplicaciones que hayan usado la versión anterior por lo que es
necesaria una migración.
Una de las principales razones para usar este motor de plantillas es que cambiar los formatos a
los que se quiere exportar los datos de la bbdd es bastante sencillo, tan sólo se debe cambiar
la plantilla sin necesidad de tocar nada de código. Imagínense que una vez terminado el
proyecto, el cliente decide que el código fuente que desea no es java, que han decidido
cambiar de tecnología en la que van a desarrollar el nuevo front‐end y que lo quieren
desarrollar en c#. Para cambiar la sintaxis de las clases resultante y adaptarlas al nuevo
lenguaje sólo se deberían modificar las plantillas y volver a ejecutar el generador de código
dando como resultado una nueva estructura de clases pero en un lenguaje distinto.
29
Generador de Código para BBDD Oracle
Plantilla para una clase Java:
class(package,entity, sup)::= << package <package>; public class <entity> extends <sup> { } >>
Tabla 1
Plantilla para una clase c#:
class(package,entity, sup)::= << namespace <package> {
public class <entity> : <sup> { }
} >>
Tabla 2
En este grupo de templates se puede ver que contiene tan sólo un template (class) el cual
tiene tres parámetros de entrada, uno el paquete o namespace en el que se va a ubicar la clase
generada (package), otro, el nombre de la clase (entity) y por último la clase padre (sup). Estos
parámetros sustituyen a las expresiones de igual nombre que vienen delimitadas por los
símbolos de mayor y menor. En este caso, las expresiones simplemente son sustituidas por los
parámetros pero estas expresiones pueden ser otros templates, funciones u otros posibles
valores que serán explicados más adelante.
Como se puede ver, la migración de un lenguaje a otro ha sido bastante sencillo, aunque
evidentemente, éste es un ejemplo bastante básico y los templates pueden ser bastante más
complejos, dificultando mucho más su modificación.
30
Generador de Código para BBDD Oracle
Group file
StringTemplate organiza toda su estructura a través de los llamados group file que son un
conjunto de template y de diccionarios que están agrupados en un solo fichero con la
extensión stg. El formato de estos ficheros es el siguiente.
delimitadores imports diccionarios templates
Tabla 3
Delimitadores
Los delimitadores indican el símbolo de inicio y de fin de una expresión, pudiendo ser estos
diferentes. Se definen mediante la palabra reservada delimiters y vienen precedidos por dichos
símbolos entre comillas.
delimiters "<" ">"
Tabla 4
Imports
En esta parte se puede indicar al group file que importe bien otros group files, otros templates
u otros directorios con templates. Al importar estos ficheros se podrá acceder desde este
group file a lo definido en ellos.
import "/template.st" // importa un template
import "/groupfile.stg" // importa un group file import "/test/dir" // importa el directorio dir
Tabla 5
31
Generador de Código para BBDD Oracle
Diccionarios
Este apartado contiene la definición de diccionarios de datos. Estos diccionarios de datos son
muy útiles para la traducción de palabras. Por ejemplo, se está generando el código java y se
quiere crear una variable de tipo entero, a la plantilla se le indicará que la variable es de tipo
entero y a través del diccionario de datos, ésta sabrá que las variables de tipo entero deben ser
definidas con la palabra int. La definición de un diccionario de datos se realiza mediante el
nombre del diccionario y posteriormente viene un conjunto de pares de valores en los que el
primero es la clave y el segundo el valor. Por último, tiene que definirse un valor por defecto
que será el usado en caso de no encontrar la clave. Este último par se define mediante la clave
default y el valor que será usado por defecto.
tipoDatos ::= [
"entero":"int", "decimal":"double", "cadena":"String" "default":"String", ]
Tabla 6
Para poder utilizar el diccionario simplemente se deberá escribir su nombre y posteriormente
poner la clave del valor que se quiere obtener, esta clave puede escribirse literalmente o
utilizarse un atributo que contenga la clave del valor a obtener.
Templates
En esta zona del group file se definen los templates que serán explicados más adelante con
mayor profundidad.
Templates
Un template es una secuencia de textos y expresiones que definen la estructura del resultado
que se quiere obtener. Las expresiones son las que son sustituidas por otros valores dando
lugar a diferentes resultados. Estas expresiones pueden ser:
� Atributo.
� Inclusión de otro template.
� Una operación condicional.
� Ejecución de otro template.
32
Generador de Código para BBDD Oracle
Expresiones literales
Syntax Discussion
true Tipo de dato lógico de valor verdadero
false Tipo de dato lógico de valor verdadero
char char → space | \n | \r | \t | \uXXXX
\\ Ignora toda la línea hasta que haya un salto de línea
"string" Una cadena de caracteres de salida
{template} Un subtemplate anónimo
{args | template} Un subtemplate anónimo con argumentos
[ ] Una lista vacía
[expr1, expr2, ..., exprN] Una lista con N valores. Se comporta como una matriz o lista
inyectado desde código del controlador.
Tabla 7
Expresiones de atributos
Syntax Discussion
a Busca a y la convierte en una cadena mediante la función de conversión del
lenguaje de implementación tal como toString (), ToString (), o _str (). Si no se
define localmente como un argumento, StringTemplate mira en la plantilla que
invoca la plantilla actual, y así sucesivamente. Evalúa a la cadena vacía si a no
existe.
(expr) Evalúa expr para convertirlo en una cadena. Esto es útil para calcular el nombre
de la plantilla o la propiedad.
exp.p Obtiene la propiedad p de exp. exp típicamente debe ser un atributo. Por
ejemplo, en la expresión <user.name>, exp es usuario y p es nombre. Más
adelante se explicarán las propiedades
expr1.(
expr2)
Evalúa expr2 para convertirlo en una cadena y usa el resultado como una
propiedad de expr1
Tabla 8
33
Generador de Código para BBDD Oracle
Funciones
String template tiene integradas una serie de funciones. Estas funciones tienen tan sólo un
argumento y devuelven un sólo valor. Son las siguientes:
Syntax Description
<first(attr)> Devuelve el primer o único elemento de attr.
<length(attr)> Devuelve la longitud del atributo en caso de ser un atributo de varios
valores (listas) o uno si sólo es un solo valor. Si es nulo, devuelve 0.
<strlen(attr)> Devuelve la longitud de la cadena.
<last(attr)> Devuelve el último elemento de attr.
<rest(attr)> Devuelve todos los elementos menos el primer elemento de attr.
<reverse(attr)> Devuelve una lista con los mismos elementos que attr pero en orden
inverso.
<trunc(attr)> Devuelve todos los elementos menos el último
<strip(attr)> Devuelve una nueva lista sin valores nulos.
<trim(attr)> Elimina los espacios en blanco del inicio y final de la cadena.
Tabla 9
Palabras reservadas
StringTemplate hay varias palabras que están reservadas y no pueden ser usadas en los
nombres de los atributos o de los templates, son las siguientes:
true, false, import, default, key, group, implements, first, last, rest, trunc, strip, trim, length,
strlen, reverse, if, else, elseif, endif, delimiters
34
Generador de Código para BBDD Oracle
Propiedades
StringTemplate proporciona un mecanismo para que los propios templates tengan acceso a las
propiedades de un objeto que sea pasado al propio template como atributo. Las plantillas
tendrán acceso a los atributos que sean públicos o que tenga un método get en caso de que el
atributo no sea boolean, si es boolean el método deberá ser is o has.
Observemos el siguiente ejemplo de una clase java
public static class User {
public int id; private String name; public String getName() { return name; } public User(int id, String name) { this.id = id; this.name = name;
} public boolean isManager() { return true; } public boolean hasParkingSpot() { return true; } public String toString() { return id+":"+name; } }
Tabla 10
Empezaremos por el atributo id:
public int id;
Tabla 11
Como se puede ver, es público, por lo que la plantilla podrá acceder a él sin ninguna
restricción. Ahora observaremos el atributo name:
private String name; public String getName() { return name; }
Tabla 12
El atributo es privado, por lo que en principio la plantilla no podrá tener acceso a él, pero al
disponer de un método get, si la plantilla intenta acceder al atributo name StringTemplate,
hará una llamada al método get y devolverá su valor.
public boolean isManager() { return true; }
public boolean hasParkingSpot() { return true; }
Tabla 13
35
Generador de Código para BBDD Oracle
Estos dos métodos no devuelven ningún atributo de la clase, pero sí siguen la nomenclatura
establecida por StringTemplate para devolver un boolean por lo que, si en la plantilla se
intenta acceder a ellos como si fueran un atributo:
u.manager u.parkingSpot
Tabla 14
éstos devolverán el valor y será tratado como si fuera un atributo. Por último, vemos el
método toString. Este método será llamado cuando se acceda directamente al objeto, en
nuestro ejemplo, cada vez que en la plantilla pongamos u, se ejecutará el método toString en
la plantilla y devolverá el id más el nombre.
public String toString() { return id+":"+name; }
Tabla 15
Definición formal de template
template : element* ; element : INDENT? COMMENT NEWLINE | INDENT singleElement | singleElement | compoundElement ; singleElement : exprTag | TEXT | NEWLINE | COMMENT ; compoundElement : ifstat | region ; exprTag : LDELIM expr ( ';' exprOptions )? RDELIM ; region : INDENT? LDELIM '@' ID RDELIM template INDENT? LDELIM '@end' RDELIM NEWLINE? ; subtemplate : '{' ( ID ( ',' ID )* '|' )? template INDENT? '}' ; ifstat : INDENT? LDELIM 'if' '(' conditional ')' RDELIM template ( INDENT? LDELIM 'elseif' '(' conditional ')' RDELIM template )* ( INDENT? LDELIM 'else' RDELIM template )?
36
Generador de Código para BBDD Oracle
INDENT? LDELIM 'endif' RDELIM NEWLINE? ; conditional : andConditional ( '||' andConditional )* ; andConditional : notConditional ( '&&' notConditional )* ; notConditional : '!' notConditional | memberExpr ; notConditionalExpr : ID ( '.' ID | '.' '(' mapExpr ')' )* ; exprOptions : option ( ',' option )* ; option : ID ( '=' exprNoComma )? ; exprNoComma : memberExpr ( ':' mapTemplateRef )? ; expr : mapExpr ; mapExpr : memberExpr ( ( ',' memberExpr )+ ':' mapTemplateRef )? ( ':' mapTemplateRef ( ',' mapTemplateRef )* )* ; mapTemplateRef : ID '(' args ')' | subtemplate | '(' mapExpr ')' '(' argExprList? ')' ; memberExpr : includeExpr ( '.' ID | '.' '(' mapExpr ')' )* ; includeExpr : ID '(' expr? ')' | 'super' '.' ID '(' args ')' | ID '(' args ')' | '@' 'super' '.' ID '(' ')' | '@' ID '(' ')' | primary ; primary : ID | STRING | 'true' | 'false' | subtemplate | list | '(' conditional ')' | '(' expr ')' ( '(' ( argExprList )? ')' )? ; args: argExprList | namedArg ( ',' namedArg )* |
37
Generador de Código para BBDD Oracle
; argExprList : arg ( ',' arg )* ; arg : exprNoComma ; namedArg : ID '=' arg ; list: '[' ']' | '[' listElement ( ',' listElement )* ']' ; listElement : exprNoComma | ;
Tabla 16
38
Generador de Código para BBDD Oracle
Definición formal de StringTemplate
group : delimiters? ('import' STRING)* ( template | dict )+ ; delimiters : 'delimiters' STRING ',' STRING ; template : ( '@' ID '.' ID '(' ')' | ID '(' formalArgs ')' ) '::'= ( STRING // "..." | BIGSTRING // <<...>> | BIGSTRING_NO_NL // <%...%> ) | ID "::=" ID // alias one template to another ; formalArgs : formalArg ( ',' formalArg )* ( ',' formalArgWithDefaultValue )* | formalArgWithDefaultValue ( ',' formalArgWithDefaultValue )* | ; formalArg : ID ; formalArgWithDefaultValue : ID ( '=' STRING | '=' ANONYMOUS_TEMPLATE | '=' 'true' | '=' 'false' ) ; arg : ID '=' STRING // x="..." | ID '=' ANONYMOUS_TEMPLATE // x={...} | ID ; dict: ID '::=' '[' pairs ']' ; pairs : keyValuePair ( ',' keyValuePair )* ( ',' defaultValuePair )? | defaultValuePair ; keyValuePair : STRING ':' keyValue ; keyValue : BIGSTRING | ANONYMOUS_TEMPLATE | STRING | TRUE | FALSE | 'key' ; defaultValuePair : 'default' ':' keyValue ;
Tabla 17
39
Generador de Código para BBDD Oracle
Oracle Database Express Edition
Oracle Database Express Edition es un gestor de base de datos desarrollado por Oracle. Esta
versión, es la versión gratuita dirigida a desarrolladores, estudiantes y pequeñas empresas por
lo que está capada para ordenadores con un sólo procesador y hasta 1 Gb de RAM. A pesar de
las restricciones, el motor es el mismo que las versiones superiores por lo que es
recomendable para desarrollo y uso educativo como es nuestro caso [9].
Oracle fue fundada en 1977 con el nombre Software Development Laboratories, poco después
obtiene un contrato con la CIA para el desarrollo de una base de datos, ese proyecto recibió el
nombre de “Oracle”. Así es como surge el gestor de base de datos.
Oracle ha ido creando un gran número de versiones de su gestor de base de datos añadiendo
características y mejorando su funcionamiento hasta llegar a la última versión que existe en la
actualidad, Oracle 12c.
Como la mayoría de los gestores de base de datos actuales, guarda la información relativa a las
bases de datos que gestiona en la propia base de datos, esas tablas donde está guardada la
información son únicamente accesibles para el administrador o los usuarios a los que haya
dado permisos.
40
Generador de Código para BBDD Oracle
El diagrama de las tablas y sus relaciones sería el siguiente (se han omitido varias columnas en
el diagrama dejando sólo los más importantes) [10]:
Ilustración 6
41
Generador de Código para BBDD Oracle
ALL_TABLES
Esta tabla contiene todas las tablas de las bases de datos. Sus columnas son:
Columna Tipo dato NULL Descripción
OWNER VARCHAR2(30) NOT
NULL
Propietario de la tabla
TABLE_NAME VARCHAR2(30) NOT
NULL
Nombre de la tabla
TABLESPACE_NAME VARCHAR2(30) Nombre del tablespace que contiene la
tabla
CLUSTER_NAME VARCHAR2(30) Nombre del cluster al que pertenece la
tabla
IOT_NAME VARCHAR2(30) Nombre del index‐organized tables
STATUS VARCHAR2(8) Indica el estado de la tabla, si se ejecutó un
DROP TABLE anteriormente el estado de la
tabla será UNUSABLE, en caso contrario
VALID
PCT_FREE NUMBER Porcentaje de espacio libre
PCT_USED NUMBER Porcentaje de espacio usado
INI_TRANS NUMBER Número inicial de transacciones
MAX_TRANS NUMBER Número máximo de transacciones
INITIAL_EXTENT NUMBER Tamaño inicial de la extensión.
NEXT_EXTENT NUMBER Tamaño de la siguiente extensión
MIN_EXTENTS NUMBER Número mínimo de extensiones
MAX_EXTENTS NUMBER Máximo número de extensiones
PCT_INCREASE NUMBER Porcentaje del incremento del tamaño de
la extensión
42
Generador de Código para BBDD Oracle
FREELISTS NUMBER Número de procesos freelist asignados al
segmento
FREELIST_GROUPS NUMBER Número de grupos de freelist asignados al
segmento
LOGGING VARCHAR2(3) Indica si deben ser registrados o no los
cambios de la tabla.
BACKED_UP VARCHAR2(1) Indica si la tabla ha sido respaldada desde
la última modificación
NUM_ROWS NUMBER Número de filas de la tabla
BLOCKS NUMBER Número de bloques de datos usados por la
tabla
EMPTY_BLOCKS NUMBER Número de bloques vacíos
AVG_SPACE NUMBER Media de espacio libre de la tabla
CHAIN_CNT NUMBER Número de filas que se han encadenado de
un bloque a otro.
AVG_ROW_LEN NUMBER Tamaño medio en bytes de las filas
AVG_SPACE_
FREELIST _BLOCKS
NUMBER La media del espacio vacío de todos los
bloques
NUM_FREELIST_
BLOCKS
NUMBER Número de bloques de la freelist
DEGREE VARCHAR2(10) Número de hilos que escanean la tabla
INSTANCES VARCHAR2(10) Número de instancias a través de las cuales
va a ser escaneada la tabla
CACHE VARCHAR2(5) Indica si la tabla va a ser cacheada o no
TABLE_LOCK VARCHAR2(8) Indica si la tabla está bloqueada o no
43
Generador de Código para BBDD Oracle
SAMPLE_SIZE NUMBER Tamaño de la muestra utilizado para el
análisis
LAST_ANALYZED DATE Fecha de la última sincronización
PARTITIONED VARCHAR2(3) Indica si la tabla está particionada o no
IOT_TYPE VARCHAR2(12) Si la tabla es un tabla index‐organizated,
esta columna indica el tipo de IOT_TYPE
TEMPORARY VARCHAR2(1) Indica si la tabla es temporal o no
SECONDARY VARCHAR2(1) Indica si la tabla es secundaria o no
NESTED VARCHAR2(3) Indica si la tabla es anidada
BUFFER_POOL VARCHAR2(7) Indica el tipo de buffer:
● DEFAULT
● KEEP
● RECYCLE
● NULL
ROW_MOVEMENT VARCHAR2(8) Indica si el partitioned row movement está
activo
GLOBAL_STATS VARCHAR2(3) Para tablas particionadas indica si las
estadísticas son globales o se estimaron
sobre las particiones y subparticiones
USER_STATS VARCHAR2(3) Indica si las estadísticas son introducidas
por el usuario
DURATION VARCHAR2(15) Indica la duración de la tabla en caso de ser
temporal
SKIP_CORRUPT VARCHAR2(8) Indica si el gestor de base de datos debe
ignorar los bloques corruptos o de generar
un error
MONITORING VARCHAR2(3) Indica si la tabla debe ser monitorizada o
no
CLUSTER_OWNER VARCHAR2(30) Propietario del cluster donde se encuentra
44
Generador de Código para BBDD Oracle
alojada la tabla
DEPENDENCIES VARCHAR2(8) Indica si row‐level dependency tracking
está activo
COMPRESSION VARCHAR2(8) Indica si la compresión está activa o no
COMPRESS_FOR VARCHAR2(18) Indica las operaciones sobre las que se
realiza la compresión:
● DIRECT LOAD ONLY
● FOR ALL OPERATIONS
● NULL
DROPPED VARCHAR2(3) Indica si la tabla ha sido borrada
Tabla 18
45
Generador de Código para BBDD Oracle
ALL_TAB_COLUMNS
Esta tabla contiene todas las columnas de las tablas de la base de datos:
Column Datatype NULL Description
OWNER VARCHAR2(30) NOT NULL
Dueño de la vista
TABLE_NAME VARCHAR2(30) NOT NULL
Nombre de la tabla
COLUMN_NAME VARCHAR2(30) NOT NULL
Nombre de la columna
DATA_TYPE VARCHAR2(106) Tipo de dato de la columna
DATA_TYPE_MOD VARCHAR2(3) Modificador del tipo de dato de la columna
DATA_TYPE_OWNER VARCHAR2(30) Propietario del tipo de dato de la columna
DATA_LENGTH NUMBER NOT NULL
Tamaño de la columna en bytes
DATA_PRECISION NUMBER Número de dígitos totales que admite la columna cuyo tipo de datos sea NUMBER
DATA_SCALE NUMBER Dígitos a la derecha a partir de la coma
NULLABLE VARCHAR2(1) Indica si la columna puede ser NULL o no
COLUMN_ID NUMBER Identificador de la columna
DEFAULT_LENGTH NUMBER Tamaño del valor por defecto
DATA_DEFAULT LONG Valor por defecto
NUM_DISTINCT NUMBER Número de los posibles diferentes valores
LOW_VALUE RAW(32) Valor mínimo de la columna
HIGH_VALUE RAW(32) Valor máximo de la columna
DENSITY NUMBER Densidad de la columna
NUM_NULLS NUMBER Número de nulos en la columna
NUM_BUCKETS NUMBER Número de buckets de la columna
LAST_ANALYZED DATE Fecha del último analyze
46
Generador de Código para BBDD Oracle
SAMPLE_SIZE NUMBER Tamaño de la muestra utilizada para el analyze
CHARACTER_SET_NAME VARCHAR2(44) Nombre del character set: CHAR_CS o NCHAR_CS
CHAR_COL_DECL_LENGTH
NUMBER Longitud
GLOBAL_STATS VARCHAR2(3) Para tablas particionadas indica si las estadísticas de la columna son globales o se estimaron sobre las particiones y subparticiones
USER_STATS VARCHAR2(3) Indica si las estadísticas son introducidas por el usuario
AVG_COL_LEN NUMBER Tamaño medio de la columna
CHAR_LENGTH NUMBER Longitud de la cadena. Este valor sólo es válido para estos tipos de datos:
● CHAR
● VARCHAR2
● NCHAR
● NVARCHAR
CHAR_USED VARCHAR2(1) Indica si la longitud es en bytes o en
carateres
V80_FMT_IMAGE VARCHAR2(3) Indica si la imagen tiene el formato de imagen 8.0
DATA_UPGRADED VARCHAR2(3) Indica si los datos de la columna están actualizados a la última versión del formato.
HISTOGRAM VARCHAR2(15) Indica el tipo de histogram: ● NONE
● FREQUENCY
● HEIGHT BALANCED
Tabla 19
47
Generador de Código para BBDD Oracle
ALL_CONSTRAINTS
Tabla que contiene las constraint de la base de datos:
Column Datatype NULL Description
OWNER VARCHAR2(30) NOT
NULL
Propietario de la restricción
CONSTRAINT_NAME VARCHAR2(30) NOT
NULL
Nombre de la restricción
CONSTRAINT_TYPE VARCHAR2(1) Tipo de restricción::
● C (check constraint)
● P (clave primaria)
● U (clave única)
● R (integridad referencial)
● V (con check option, en una
vista)
● O (sólo lectura en una vista)
TABLE_NAME VARCHAR2(30) NOT
NULL
Nombre de la tabla a la que hace
referencia la restricción
SEARCH_CONDITION LONG Texto de la condición de búsqueda de la
restricción de check
R_OWNER VARCHAR2(30) Propietario de la tabla a la que hace
referencia la restricción
R_CONSTRAINT_NAME VARCHAR2(30) Nombre de la restricción única que hace
referencia a la tabla
DELETE_RULE VARCHAR2(9) Regla de borrado de la restricción
referencial (CASCADE o NO ACTION)
STATUS VARCHAR2(8) Estado de la restricción (ENABLED o
DISABLED)
DEFERRABLE VARCHAR2(14) Indica si la restricción es diferible
DEFERRED VARCHAR2(9) Indica si la restricción inicialmente está
48
Generador de Código para BBDD Oracle
diferida
VALIDATED VARCHAR2(13) Indica si todos los datos cumplen la
restricción (VALIDATED o NOT
VALIDATED)
GENERATED VARCHAR2(14) Indica si la restricción fue creada por el
usuario o por el sistema
BAD VARCHAR2(3) Indica que la restricción está escrita de
forma ambigua
RELY VARCHAR2(4)
LAST_CHANGE DATE Fecha de último cambio de la restricción
INDEX_OWNER VARCHAR2(30) Nombre del dueño del índice
INDEX_NAME VARCHAR2(30) Nombre del índice
INVALID VARCHAR2(7) Indica si la restricción es inválida
VIEW_RELATED VARCHAR2(14) Indica si la restricción depende de una
vista
Tabla 20
49
Generador de Código para BBDD Oracle
ALL_CONS_CONSTRAINT
Tabla que contiene las columnas de cada constraint.
Column Datatype NULL Description
OWNER VARCHAR2(30) NOT
NULL
Dueño de la restricción
CONSTRAINT_NAME VARCHAR2(30) NOT
NULL
Nombre de la restricción
TABLE_NAME VARCHAR2(30) NOT
NULL Nombre de la tabla
COLUMN_NAME VARCHAR2(4000) Nombre de la columna a la que le afecta la
restricción
POSITION NUMBER Posición de la columna en la restricción
Tabla 21
50
Generador de Código para BBDD Oracle
Herramientas utilizadas
Google Drive
Google Drive es un servicio de almacenamiento de archivos en internet, el cual es accesible
desde casi cualquier plataforma (Android, Windows, Mac, Linux…), siendo tan sólo necesario
una conexión a internet [11].
Dentro de esta herramienta desarrollada por Google, se encuentra Google Docs, que es un
procesador de texto online y gratuito, que guarda los documentos generados en el propio
Google Drive siendo posible acceder a ellos al igual que con Google Drive desde cualquier
plataforma. Estos documentos pueden ser compartidos y observar los cambios entre
diferentes versiones.
Para el desarrollo del proyecto se va a utilizar Google Drive, tanto para almacenar el código
fuente de la herramienta a desarrollar, como para guardar y editar los diferentes documentos
necesarios del trabajo fin de carrera, como son la memoria, el sprint backlog, pruebas de
integración, etc.
51
Generador de Código para BBDD Oracle
Draw.io
Es un programa de dibujo desarrollado por JGraph que se integra en Google Docs que permite
hacer de diagramas tipo UML, diagramas de flujo, diagramas de entidad relación, etc [12].
Ilustración 7
Debido a su buena integración con Google Drive en el proyecto va a utilizar para realizar los
diferentes diagramas y así integrarlos dentro de los documentos.
52
Generador de Código para BBDD Oracle
Web sequence diagrams
Al igual que las anteriores herramientas, esta herramienta también es una herramienta
gratuita y online que se utiliza, como indica su nombre, para la generación de diagramas de
secuencia. La utilización de esta herramienta es sencilla, tan sólo se debe escribir en la parte
izquierda de la pantalla los diferentes pasos del diagrama de secuencia utilizando una
nomenclatura propia y el diagrama se va generando en la parte de la derecha de la pantalla
[13].
Ilustración 8
Se decidió utilizar esta herramienta debido a su facilidad de uso, que se podía utilizar en
cualquier plataforma y que los datos estaban guardados en la nube por lo que se podía utilizar
en cualquier momento.
53
Generador de Código para BBDD Oracle
Eclipse
Un entorno de desarrollo integrador o IDE (sigla en inglés de integrated Development
Environment) es un programa compuesto por diferentes herramientas de programación que
las centralizan en el mismo programa facilitando así la programación. Normalmente está
compuesto como mínimo por un editor de texto, un compilador y depurador, aunque en la
actualidad los IDEs han ido añadiendo muchas más funcionalidades desde la generación de un
web service a través de un wsdl como la creación de la interfaz gráfica de una página web [14].
Para este proyecto se ha decidido usar como IDE Eclipse, que es un entorno de desarrollo de
propósito general.
Desarrollado por IBM, en sus orígenes nació como el sucesor de Visual Age, pero al cabo de los
años se creó una organización sin ánimo de lucro para que se encargara de ella y a la vez
promoviera el software libre.
Actualmente está bajo la licencia Eclipse Public License, que es una licencia de software libre
aunque incompatible con GPL.
Posiblemente sea el IDE más extendido en la actualidad, debido a que ya no es sólo un entorno
de desarrollo para Java sino que también existe la posibilidad de desarrollar en otros lenguajes
como C, Ruby, PHP, etc.
Una de sus principales características son los plugins, que son complementos independientes
que se acoplan a Eclipse para darle una funcionalidad extra que antes no tenía. Esto hace que
Eclipse sea muy versátil pudiéndose adaptar a cualquier circunstancia con tan sólo instalar los
plugins necesarios para ese desarrollo.
54
Generador de Código para BBDD Oracle
Desarrollo
Como se indicó anteriormente se va a utilizar la metodología de desarrollo Scrum, pero al ser
un trabajo fin de carrera, los diferentes actores que intervienen en esta metodología no están
presentes, por lo que todos serán representados por la misma persona.
Primera iteración
Reunión de planificación (Sprint Planning)
En esta primera reunión el Product Owner define el product backlog que indicará los requisitos
iniciales del producto:
Requisito Descripción Estado
REQ1 Recolección de los metadatos de la BBDD Pendiente
REQ2 Creación de la clase de negocio Pendiente
REQ3 Generación de xsd de una tabla Pendiente
REQ4 Generación de un bean java Pendiente
Tabla 22
� REQ1: Se deberá generar una estructura en memoria que almacene toda la
información de la antigua base de datos, sus tablas, sus columnas, los tipos de éstas,
sus claves primarias y sus claves foráneas.
� REQ2: Se deberá generar una clase de negocio, por cada tabla. Esta clase de negocio
estará vacía de contenido y se generará para que las personas que vayan a utilizar toda
esta estructura de clases metan ahí la lógica de su negocio.
� REQ3: Se deberá generar un xsd por cada tabla que representará a esta. Estos xsd
definirán las columnas con sus tipos de datos y sus claves.
� REQ4: Se deberá de generar una clase java que represente a cada una de las tablas.
Esa clase tendrá como atributos las columnas y claves, y serán del tipo
correspondiente con la Base de datos.
55
Generador de Código para BBDD Oracle
Después de definir el product backlog se procede a decidir con el product owner qué requisitos
se realizarán en este primer sprint.
El primer requisito que se debe realizar es la obtención de los metadatos de la base de datos
ya que los demás requisitos dependen de él.
En esta segunda parte de la reunión, el equipo tiene que definir las diferentes tareas que serán
necesarias para poder realizar el requisito antes de finalizar el sprint. Estas tareas quedarán
plasmadas en el sprint backlog.
Tarea Descripción Fecha prevista de fin Fecha de fin Estado
T1
Creación de Máquina
Virtual con una BBDD
Oracle 1/11/2013 1/11/2013 Finalizado
T2
Creación de la estructura
de clases donde van a ser
almacenados los
metadatos 7/11/2013 7/11/2013 Finalizado
T3
Obtención de los datos de
las tablas 15/11/2013 15/11/2013 Finalizado
T4 Pruebas de integración 17/11/2013 18/11/2013
Tabla 23
T1 ‐ Máquina Virtual Windows XP y Oracle Database Express Edition
Debido a que entorno en el que se va a trabajar es un ordenador MAC y no existe para ése
sistema operativo Oracle Database Express Edition, es necesario crear una máquina virtual
para poder virtualizar una máquina con el sistema operativo Windows XP y en él instalado esa
base de datos. El primer paso es instalar el sistema operativo para posteriormente, instalar la
base de datos. Al no necesitar ninguna opción especial la base de datos, ya que su uso va a ser
simplemente para consultar su catálogo de datos, se dejan todas las opciones que vienen por
defecto en el wizard. Una vez instalada, se procede a instalar el SQL Developer y a activar la
base de datos que viene de ejemplo, ya que inicialmente está deshabilitada.
56
Generador de Código para BBDD Oracle
T2 ‐ Creación de la estructura de clases donde van a ser almacenados los metadatos
Diagrama de clases donde se almacenarán los metadatos de la base de datos:
Ilustración 9
Table
La clase Table representará a las tablas de la base de datos y tendrá como atributos tanto sus
columnas como sus constraint.
Constraint
Representa a las constraint. Contendrá su nombre, alias y tipo, también el nombre de la
columna a la que pertenece la constraint.
Column
Representa a las columnas. Contiene el nombre de la columna, alias, tipo de dato, precisión del
dato, escala, longitud y si puede ser nulo o no.
57
Generador de Código para BBDD Oracle
T3 Obtención de los datos de las tablas
En esta tarea se deberá diseñar y desarrollar el módulo que obtenga los datos de la base de
datos y los guarde en la estructura de clases diseñada en la tarea anterior. El diagrama de
secuencia a alto nivel es el siguiente:
Ilustración 10
58
Generador de Código para BBDD Oracle
Los pasos serán los siguientes:
1. El Generador obtendrá la configuración de éste. Entre los datos obtenidos, uno de
ellos será las tablas que se quieren tratar.
2. El generador por cada tabla llamará al GeneradorTablas para obtener todos los datos
de esa tabla.
3. El GeneradorTablas en primer lugar obtendrá las columnas.
4. Éste consultará en la tabla ALL_TAB_COLUMNS, las columnas de la tabla.
5. Devolverá un Resultset con los datos de todas las columnas.
6. Se creará un objeto Column por cada fila del Resulset y se devolverá una lista de
columnas.
7. Ahora el GeneradorTablas obtendrá las constraint.
8. Éste consultará la tabla ALL_CONSTRAINTS para obtener todas las constraint
de esa tabla.
9. Devolverá un Resultset con las constraint.
10. Se creará un objeto Constraint por cada fila del Resulset y se devolverá una
lista de constraint.
11. Devolverá un objeto Table con todos sus datos.
Pruebas unitarias
Para las pruebas unitarias se utilizará el framework junit como se indicó anteriormente,
creando las siguiente pruebas con sus resultados:
� Test de configuración:
� Arrancar la aplicación con unos argumentos de configuración correctos.
� Arrancar la aplicación con unos argumentos de configuración incorrectos.
� Arrancar la aplicación sin argumentos de configuración.
� Test de obtención de datos de una tabla.
� Obtención de datos de una tabla con una columna de tipo numérico.
� Obtención de datos de una tabla con una columna de tipo texto.
� Obtención de datos de una tabla con una columna de tipo fecha.
� Obtención de datos de una tabla con varias columna de tipo numérico, texto y
fecha.
� Obtención de datos de una tabla con una constraint.
� Obtención de datos de una tabla con varias constraints.
59
Generador de Código para BBDD Oracle
T4 Pruebas de integración
Para las pruebas de integración se generaron los siguientes test.
ID Titulo Descripción Resultado esperado
1 Configuración correcta
Arrancar la aplicación con la configuración:
‐properties /Users/prueba/Google\\ Drive/TFC/JCelsig/properties/generador.properties ‐fileTables /Users/prueba/Google\\ Drive/TFC/JCelsig/plantillas/ListadoTablas.txt
Siendo los path correctos
La aplicación arranque y se paresin producir ningún error
2 Configuración incorrecta
Arrancar la aplicación con la configuración:
‐propert iuasdiuf
La aplicación al arrancar muestra un error indicando que la configuración es incorrecta y se detiene
3 Configuración vacía
Arrancar la aplicación sin ningún argumento. La aplicación al arrancar muestra un mensaje indicando que es necesaria indicar una configuración y se detiene
4 Obtención de datos de una tabla
Arrancar la aplicación indicando en el fichero de las tablas a exportar que se deben extraer los datos de la tabla COUNTRIES de la base de datos de test.
La aplicación obtendrá los datos de la tabla y mostrará por el log las columnas y sus constraint:
COUNTRY_ID
COUNTRY_NAME
REGION_ID
COUNTRY_C_ID_PK
60
Generador de Código para BBDD Oracle
5 Obtención de datos de varias tabla
Arrancar la aplicación indicando en el fichero de las tablas a exportar que se deben extraer los datos de las tablas COUNTRIES y EMPLOYEES de la base de datos de test.
La aplicación obtendrá los datos de las tablas y mostrará por el log las columnas y sus constraint:
COUNTRIES:
COUNTRY_ID
COUNTRY_NAME
REGION_ID
COUNTRY_C_ID_PK
EMPLOYEES:
EMPLOYEE_ID
FIRST_NAME
LAST_NAME
PHONE_NUMBER
HIRE_DATE
JOB_ID
SALARY
COMMISSION_PCT
MANAGER_ID
DEPARTMENT_ID
Tabla 24
61
Generador de Código para BBDD Oracle
Segunda iteración
Reunión de planificación (Sprint Planning)
En esta segunda reunión, el Product Owner da por terminado el primer requisito y decide cuál
es el siguiente requisito a realizar según sus prioridades, y como ya todos son independientes y
no dependen unos de otros, no hay ningún tipo de restricción. Se decide que el siguiente
requisito será el REQ2 ya que parece el más sencillo de los tres y así será más fácil comenzar
con la generación de archivos.
Requisito Descripción Estado
REQ1 Recolección de los metadatos de la BBDD Realizado
REQ2 Creación de la clase de negocio Pendiente
REQ3 Generación de xsd de una tabla Pendiente
REQ4 Generación de un bean java Pendiente
Tabla 25
62
Generador de Código para BBDD Oracle
En la segunda parte de la reunión el equipo discute cuáles son las tareas a realizar en este
segundo sprint para poder tener terminado el requisito al finalizar el mismo. Estas tareas
quedarán plasmadas en el sprint backlog como se hizo anteriormente.
Tarea Descripción Fecha prevista de fin Fecha de fin Estado
T5
Búsqueda de una librería
de templates para la
generación de los
diferentes formatos de
salida 12/20/2013 12/20/2103 Finalizado
T6
Utilización de templates en
la generación de las clases
de business object 1/9/2014 1/14/2014 Finalizado
T7
Generación de las
plantillas para las clases
business object 1/15/2014 1/21/2014 Finalizado
T8 Pruebas de integración 1/17/2014 1/31/2014 Finalizado
Tabla 26
63
Generador de Código para BBDD Oracle
T5 ‐ Búsqueda de una librería de templates para la generación de los diferentes formatos de
salida
La tarea consiste en elegir una librería java que genere ficheros de texto plano, los cuales serán
la salida de nuestro programa (xsd, java, …). Se tienen diferentes opciones con sus pros y sus
contras que se resumen en la siguiente tabla.
Librería Pros Contras Licencia
Ninguna � Control total sobre el código� No dependencia de ningún
software de terceros.
� Mayor tiempo de desarrollo � Menor estabilidad � Menor testeo del software
Velocity � Proyecto muy estable� Apache está detrás del
proyecto � Motor muy potente
� Lleva años sin ser evolucionado.
� Es algo más lento que los demás templates.
Apache License 2.0
StringTemplate � El equipo de desarrollo ya conoce esta librería
� Ligero � Multiplataforma
� Menor documentación� La comunidad que lo
mantiene es pequeña
BSD
FreeMaker � Motor de propósito general� Proyecto vivo, su última
versión estable es del 2013 � Muy rápido procesando los
templates
� El tamaño del motor es bastante grande para las pretensiones del proyecto
BSD
Tabla 27
Teniendo en cuenta los pros y contras de cada uno de los motores de plantillas se elige
StringTemplate, ya que para el propósito de este proyecto no se necesita un motor muy
potente y el equipo de desarrollo ya conoce ese motor, por lo que no será necesario aprender
el funcionamiento de uno nuevo y será más eficiente.
64
Generador de Código para BBDD Oracle
T6 ‐ Utilización de templates en la generación de las clases de business object
Esta plantilla tendrá los siguientes parámetros de entrada:
� package: este parámetro indica en qué paquete se encuentra la clase. Esto sería en
caso de java, pero si el lenguaje que se va a generar es c# por ejemplo, el package sería
su namespace. En caso de que el lenguaje a generar no tuviera package, simplemente
con dejarlo vacío sería suficiente. Este parámetro se proporcionaría a través del fichero
de configuración ya que es decisión de la persona que ejecuta el programa a qué
package quiere que pertenezca.
� entity: este parámetro es el nombre de la clase. Este nombre será el nombre de la
tabla siguiendo las guías de estilo de java, primera letra en mayúsculas, en caso de ser
varias palabras, la primera letra de la siguiente palabra será también en mayúsculas,
etc [15].
� imports: este parámetro es una lista de clases o paquetes a importar. Al igual que el
package, esto también vendrá definido por el fichero de configuración, ya que el
encargado de generar el código sabrá qué clases son necesarias importar en su clase
de negocio. En caso de generar el código para otro lenguaje como c#, en ese
parámetro irán los namespace que se vayan a usar con la directiva using.
� sup: este último parámetro es la clase padre. Al igual que el package y los imports, será
definido en el fichero de configuración.
Plantilla
class(package,entity, imports, sup="Object")::= <<package <package>; <imports:generateImports()> public class <entity> extends <sup> { } >> generateImports(paquete)::= "import <paquete>; <\n>"
Tabla 28
Ésta sería la plantilla para generar la clase de negocio. A continuación explico cada una de sus partes:
class(package,entity, imports, sup="Object")::=
En esta parte se define el template y sus parámetros, como particularidad el parámetro sup tiene un valor por defecto que sería “Object”. <<package <package>;
65
Generador de Código para BBDD Oracle
<imports:generateImports()> public class <entity> extends <sup> { } >>
A continuación se define el template, donde se sustituyen las palabras que vienen entre los
símbolos de < y > por sus parámetros. Este template también tiene una llamada a otro
template, generateImports. La forma de llamar a este template es diferente, es una
operación map, por cada elemento del array se llama al template generateImports
pasando como primer argumento ese elemento del array, formando así los imports de la clase.
generateImports(paquete)::= "import <paquete>; <\n>"
T7 Generación de las plantillas para las clases business object
En esta tarea se deberá diseñar y desarrollar el módulo que generará las clases de negocio de
cada tabla, llamando al motor de templates y posteriormente guardando la clase generada en
un fichero aparte. El diagrama de secuencia a alto nivel es el siguiente:
Ilustración 11
66
Generador de Código para BBDD Oracle
Los pasos serán los siguientes:
1. El Generador obtendrá la configuración de éste. Entre los datos obtenidos, uno de
ellos será las tablas que se quieren tratar.
2. Se obtienen los datos de las tablas a exportar (como se indicó en el diagrama de
secuencia anterior).
3. El objeto tabla es devuelto.
4. Se llama al generador de clases para que generé el Business Object.
5. Éste a su vez, llama al GeneradorBusiness para que cree la clase.
6. El GeneradorBusiness rellena el template con los valores obtenidos de la bbdd y llama
al renderizado del motor de templates para que genere la clase.
7. La clase es devuelta.
Pruebas unitarias
� Test del GeneradorBusiness:
� Crear una clase Business Object sin imports ni clase padre.
� Crear una clase Business Object con imports pero sin clase padre.
� Crear una clase Business Object sin imports pero con clase padre.
� Crear una clase Business Object con imports y con clase padre.
67
Generador de Código para BBDD Oracle
T8 Pruebas de integración
Para las pruebas de integración se generaron los siguientes test.
ID Titulo Descripción Resultado esperado
6 Creación clases Business Object de una tabla
Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:
business.imports=com.tmp.*;org.apache.*
business.package=tmp
business.parent=Object
business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg
pathBusinessObjects=/Users/prueba/tmp/
Y en el fichero de las tablas a exportar que se exportará la tabla COUNTRIES
La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*
7 Creación clases Business Object de varias tabla
Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:
business.imports=com.tmp.*;org.apache.*
business.package=tmp
business.parent=Object
business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg
pathBusinessObjects=/Users/prueba/tmp/
Y en el fichero de las tablas a exportar que se exportarán las tablas COUNTRIES, EMPLOYEES Y DEPARTMENTS
La aplicación creará un fichero Countries.java, otro Employess.java y otro Departments.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*
68
Generador de Código para BBDD Oracle
8 Creación clases Business Object de una tabla sin clase padre
Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:
business.imports=com.tmp.*
business.package=tmp
business.parent=
business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg
pathBusinessObjects=/Users/prueba/tmp/
Y en el fichero de las tablas a exportar que se exportará la tabla COUNTRIES
La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, paquete tmp, imports com.tmp.*. La clase padre será Object porque en caso de no venir ninguna clase padre se pone ésa por defecto
9 Creación clases Business Object de una tabla con una clase padre diferente a Object
Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:
business.imports=com.tmp.*
business.package=tmp
business.parent=String
business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg
pathBusinessObjects=/Users/prueba/tmp/
Y en el fichero de las tablas a exportar que se exportará la tabla COUNTRIES
La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, paquete tmp, imports com.tmp.*. La clase padre será String como viene indicado en el fichero de configuración.
10 Creación clases Business Object de una tabla que importar dos paquetes
Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:
business.imports=com.tmp.*;org.apache.*
business.package=tmp
business.parent=Object
business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg
pathBusinessObjects=/Users/prueba/tmp/
Y en el fichero de las tablas a exportar que se exportará la tabla COUNTRIES
La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*
69
Generador de Código para BBDD Oracle
11 Creación clases Business Object de una tabla que importar varios paquetes
Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:
business.imports=com.tmp.*;org.apache.*;java.util.List;java.util.ArrayList
business.package=tmp
business.parent=Object
business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg
pathBusinessObjects=/Users/prueba/tmp/
Y en el fichero de las tablas a exportar que se exportará la tabla COUNTRIES
La aplicación creará un fichero Countries.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*, java.util.List, java.util.ArrayList
12 Creación clases Business Object de varias tablas que importar varios paquetes
Arrancar la aplicación indicando en el fichero de configuración que la clase Business Object tendrá las siguientes propiedades:
business.imports=com.tmp.*;org.apache.*;java.util.List;java.util.ArrayList
business.package=tmp
business.parent=Object
business.template=/Users/prueba/Dropbox/tfc/plantillas/PlantillaBusinessObject.stg
pathBusinessObjects=/Users/prueba/tmp/
Y en el fichero de las tablas a exportar que se exportará las tablas COUNTRIES, EMPLOYEES Y DEPARTMENTS
La aplicación creará un fichero Countries.java, otro Employess.java y otro Departments.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects y teniendo las propiedades indicadas ese fichero, clase padre Object, paquete tmp, imports com.tmp.*, org.apache.*, java.util.List, java.util.ArrayList
Tabla 29
70
Generador de Código para BBDD Oracle
Tercera iteración
Reunión de planificación (Sprint Planning)
En la tercera reunión el Product Owner cierra el segundo requisito. Y propone que se haga en
la siguiente iteración el tercer requisito, la creación del xsd que represente a la tabla.
Requisito Descripción Estado
REQ1 Recolección de los metadatos de la BBDD Realizado
REQ2 Creación de la clase de negocio Realizado
REQ3 Generación de xsd de una tabla Pendiente
REQ4 Generación de un bean java Pendiente
Tabla 30
En la segunda parte de la reunión se deciden las tareas a realizar para poder completar el
requisito.
Tarea Descripción Fecha prevista de fin Fecha de fin Estado
T9
Desarrollo de un template
para poder crear el xsd
representativo de la tabla 2/13/2014 2/13/2014 Finalizado
T10
Creación de los xsd a
través de una plantilla 2/20/2014 2/20/2014 Finalizado
T11 Pruebas de integración 2/28/2014 2/28/2014 Finalizado
Tabla 31
71
Generador de Código para BBDD Oracle
T9 ‐ Desarrollo de un template para poder crear el xsd representativo de la tabla
Una de las características de StringTemplate es que se pueden añadir subplantillas dentro de
una plantilla. Para el desarrollo de esta plantilla se ha utilizado esa característica ya que era
mucho más sencillo desarrollarla de esta forma.
Plantilla
xsd(type, namespace)::= <<<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:m="%nameSpace%" targetNamespace="%nameSpace%" elementFormDefault="qualified" attributeFormDefault="unqualified"> %type% </xs:schema> >> simpleType(name, restriction)::= << <xs:simpleType name="%name%"> %restriction% </xs:simpleType> >> restrictionType(type, condition="")::= << <xs:restriction base="%type%"> %condition; separator={%\n%}% </xs:restriction> >> minLenghCondition(min)::= << <xs:minLength value="%min%"/> >> maxLenghCondition(max)::= << <xs:maxLength value="%max%"/> >> totalDigitsCondition(total)::= << <xs:totalDigits value="%total%"/> >> fractionDigitsCondition(fraction)::= << <xs:fractionDigits value="%fraction%"/> >> complexType(name, elements)::= << <xs:complexType name="%name%"> <xs:sequence> %elements%; separator={%\n%}% </xs:sequence> </xs:complexType> >> elementType(name, type)::= << <xs:element name="%name%" type="%type%" minOccurs="0"/> >>
Tabla 32
72
Generador de Código para BBDD Oracle
Para la definición de la plantilla del xsd se ha dividido la plantilla en dos subplantillas al igual que lo hace un xsd, la plantilla de tipos simples y la plantilla de tipos complejos. A su vez el tipo complejo tiene otra subplantilla, que es la plantilla elements en la cual se definen los elementos del tipo complejo. La plantilla de tipos simples se compone de otra plantilla para las restricciones del tipo simple y ésta también tiene otras subplantillas para las condiciones de la restricción.
Ilustración 12
73
Generador de Código para BBDD Oracle
Para la generación de los tipos simples se ha hecho una relación entre los tipos de datos de
SQL con los tipos de datos xsd más las restricciones necesarias, la tabla siguiente indica la
correlación entre los tipos [18]:
SQL XSD Facet used
VARCHAR xsd:string xs:minLength o xs:maxLength
VARCHAR2 xsd:string xs:minLength o xs:maxLength
CHAR xsd:string xs:minLength o xs:maxLength
NCHAR xsd:string xs:minLength o xs:maxLength
NVARCHAR2 xsd:string xs:minLength o xs:maxLength
NUMBER (entero) xsd:integer xs:totalDigits
NUMBER (decimal) xsd:decimal xs:totalDigits y xs:fractionDigits
DATE xsd:date
TIMESTAMP
xsd:dateTime
LONG xsd:long
BFILE xsd:base64Binary
BINARY_INTEGER xsd:integer
INTERVAL DAY xsd:string
INTERVAL YEAR xsd:string
LONG RAW xsd:base64Binary
74
Generador de Código para BBDD Oracle
Tabla 33
Para la generación de un tipo simple primero se deberán definir sus condiciones, para luego
ser añadidas a la restricción y esa restricción a su vez se añadirá al tipo simple. Esto en caso de
tener alguna condición, porque puede darse el caso que el tipo de dato no tenga ninguna
condición.
Vamos a explicarlo con un ejemplo. Hay que transformar esta columna a un tipo simple xsd. Su
definición en la tabla oracle sería la siguiente:
poblacion NUMBER (9,2)
Al ser un tipo numérico pero con decimal se va a definir como tipo xsd:decimal con dos
condiciones, xs:totalDigits y xs:fractionDigits. En primer lugar se llamará al template:
totalDigitsCondition(total)::= << <xs:totalDigits value="%total%"/> >> Este template definirá la condición del número total de dígitos que tendrá el tipo simple. Se le
pasará como parámetro ese número total de dígitos que puede tener el tipo, en este caso 9.
Posteriormente se llamará al template que creará la condición del número de decimales del
tipo de dato:
fractionDigitsCondition(fraction)::= << <xs:fractionDigits value="%fraction%"/> >> Como parámetro se le pasará el número de decimales que puede tener el tipo, en este caso 2.
Una vez definidas las dos condiciones, se le añadirán al template de la restricción.
restrictionType(type, condition="")::= << <xs:restriction base="%type%"> %condition; separator={%\n%}% </xs:restriction> >> Este template tiene dos parámetros de entrada, uno es el tipo que es obligatorio, en este caso
sería de tipo decimal y las condiciones, que para nuestro ejemplo serían dos, fractionDigits y
totalDigits. En caso de que no se añada ninguna condición, como puede ser para los tipos de
datos DATE, la condición tendrá como valor por defecto una cadena vacía.
Para terminar de definir el tipo simple se deberá llamar al template:
simpleType(name, restriction)::= << <xs:simpleType name="%name%"> %restriction% </xs:simpleType> >>
75
Generador de Código para BBDD Oracle
Esta plantilla tiene como parámetros la restricción definida previamente, no tiene valor por
defecto porque es necesaria su inserción, y el nombre del tipo simple, que será el nombre de la
tabla más el nombre del tipo.
Para la generación de un tipo complejo se seguirá la misma técnica que para los tipos simples,
primero se llamará a los templates de los elementos que formarán parte del tipo complejo,
para luego ser añadidos al tipo complejo. La plantilla de los elementos del tipo complejo es la
siguiente:
elementType(name, type)::= << <xs:element name="%name%" type="%type%" minOccurs="0"/> >>
Esta plantilla tiene dos parámetros de entrada, name que es el nombre del elemento del tipo
complejo que en nuestro caso será el nombre de la columna, y el segundo parámetro es el
nombre del tipo. Si el elemento es un tipo simple, el nombre del tipo será el definido en la
plantilla de tipos simples, en caso de que el elemento sea otro tipo complejo, su nombre de
tipo será el de ese tipo complejo. Para terminar, todos los elementos serán añadidos a la
plantilla del tipo complejo:
complexType(name, elements)::= << <xs:complexType name="%name%"> <xs:sequence> %elements%; separator={%\n%}% </xs:sequence> </xs:complexType> >>
Como se ha dicho anteriormente, el parámetro elements será la lista de elementos definida
previamente y el parámetro name el nombre del tipo complejo. En nuestro caso tendremos
dos tipos complejos que serán la PK de la tabla y la definición del tipo de la tabla que
contendrá los tipos simples que no estén definidos en la PK más el tipo complejo PK.
Para terminar, se añadirán tanto los tipos simples como los tipos complejos a la plantilla del
xsd.
xsd(type, namespace)::= << <?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:m="%nameSpace%" targetNamespace="%nameSpace%" elementFormDefault="qualified" attributeFormDefault="unqualified"> %type% </xs:schema> >>
76
Generador de Código para BBDD Oracle
La plantilla tendrá como parámetros la lista de tipos, tanto simples como complejos y el
namespace del xsd. Éste será el último paso para la generación del xsd.
A continuación muestro la definición de una tabla en SQL y su resultado en xsd:
CREATE TABLE "COUNTRIES" ( "COUNTRY_ID" CHAR(2 BYTE), "COUNTRY_NAME" VARCHAR2(40 BYTE), "REGION_ID" NUMBER, CONSTRAINT "COUNTRY_C_ID_PK" PRIMARY KEY ("COUNTRY_ID") )
Tabla 34
<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:m="http://celsig.tme.es/jcelsig/JCELSIG/maestros" targetNamespace="http://celsig.tme.es/jcelsig/JCELSIG/maestros" elementFormDefault="qualified" attributeFormDefault="unqualified"> <xs:simpleType name="FieldCountries_CountryIdType"> <xs:restriction base="xs:string"> <xs:minLength value="0"/> <xs:maxLength value="2"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="FieldCountries_CountryNameType"> <xs:restriction base="xs:string"> <xs:minLength value="0"/> <xs:maxLength value="40"/> </xs:restriction> </xs:simpleType> <xs:simpleType name="FieldCountries_RegionIdType"> <xs:restriction base="xs:integer"> <xs:totalDigits value="38"/> </xs:restriction> </xs:simpleType> <xs:complexType name="CountriesType"> <xs:sequence> <xs:element name="pk" type="m:CountriesPkType"/> <xs:element name="regionId" type="m:FieldCountries_RegionIdType" minOccurs="0"/> <xs:element name="countryName" type="m:FieldCountries_CountryNameType" minOccurs="0"/> </xs:sequence> </xs:complexType> <xs:complexType name="CountriesPkType"> <xs:sequence> <xs:element name="countryId" type="m:FieldCountries_CountryIdType" minOccurs="0"/> </xs:sequence> </xs:complexType> </xs:schema>
Tabla 35
77
Generador de Código para BBDD Oracle
T10 Creación de los xsd a través de una plantilla
En esta tarea se diseñará y desarrollará el software para la generación de un xsd como
resultado de utilizar la plantilla diseñada en la tarea anterior y los datos obtenidos de cada
tabla. El diagrama de secuencia a alto nivel es el siguiente:
Ilustración 13
78
Generador de Código para BBDD Oracle
Los pasos serán los siguientes:
1. El Generador obtendrá la configuración de éste. Entre los datos obtenidos, uno de
ellos será las tablas que se quieren tratar.
2. Se obtienen los datos de las tablas a exportar (como se indicó en el diagrama de la
tarea T3).
3. El objeto tabla es devuelto.
4. Se llama al generador del esquema para que generé el xsd.
5. Por cada columna de la tabla se llamará al generador de tipos simples y creará el tipo
simple de esa columna empezando por crear la restricción de ese tipo simple
(template restricciotionType) indicando el tipo de dato de esa columna.
6. En caso de que la columna sea de tipo carácter (VARCHAR2, CHAR, ...) se creará la
condición de caracteres mínimos (template minLenghCondition).
7. Si la columna sigue siendo de tipo carácter y tiene un número máximo de caracteres se
creará la condición de caracteres máximos (template maxLenghCondition).
8. Si la columna es de tipo numérico se creará la condición de cantidad máxima de dígitos
dependiendo del tipo de dato, si en la base de datos la columna está definida como 9
dígitos máximos así será definida en el xsd (template totalDigitsCondition).
9. Si la columna sigue siendo numérica y, además tiene una parte decimal, se creará una
condición para indicar el número de decimales del número (template
fractionDigitsCondition).
10. A la restricción se le añaden las condiciones creadas previamente y se crea el tipo
simple y éste se añade al template padre que va a almacenar todos los datos.
11. Ahora se crea el elemento del tipo complejo independiente de si se trata de una
columna que pertene a la PK o no (template elementType).
12. En caso de que la columna pertenezca a la PK, se añade el elemento al tipo complejo
de la PK.
13. En caso contrario, que no pertenezca a la PK, se añade al elemento complejo que
representará toda la tabla.
14. En este punto ya se han tratado todas las columnas de la tabla por lo que el tipo
complejo que representa la PK está completo, entonces se procede a añadirlo al tipo
complejo que representa a toda la tabla y al template padre. También se añade el tipo
complejo que representa a toda la tabla al template padre.
15. Se llama al renderizado del motor de templates para que genere xsd.
16. El xsd es devuelto.
79
Generador de Código para BBDD Oracle
Pruebas unitarias
� Test del GeneradorSimple:
� Generar la condición minLenghCondition.
� Generar la condición maxLenghCondition.
� Generar la condición totalDigitsCondition.
� Generar la condición fractionDigitsCondition.
� Generar un tipo simple para una columna de tipo VARCHAR
� Generar un tipo simple para una columna de tipo VARCHAR2
� Generar un tipo simple para una columna de tipo CHAR
� Generar un tipo simple para una columna de tipo NCHAR
� Generar un tipo simple para una columna de tipo NVARCHAR2
� Generar un tipo simple para una columna de tipo NUMBER (entero)
� Generar un tipo simple para una columna de tipo NUMBER (decimal)
� Generar un tipo simple para una columna de tipo DATE
� Generar un tipo simple para una columna de tipo TIMESTAMP
� Generar un tipo simple para una columna de tipo LONG
� Generar un tipo simple para una columna de tipo BFILE
� Generar un tipo simple para una columna de tipo BINARY_INTEGER
� Generar un tipo simple para una columna de tipo INTERVAL DAY
� Generar un tipo simple para una columna de tipo INTERVAL YEAR
� Generar un tipo simple para una columna de tipo LONG RAW
� Test del GeneradorComplex:
� Generar un elemento.
� Generar un tipo complejo con una tabla de una columna de tipo VARCHAR
� Generar un tipo complejo con una tabla de una columna de tipo VARCHAR2
� Generar un tipo complejo con una tabla de una columna de tipo CHAR
� Generar un tipo complejo con una tabla de una columna de tipo NCHAR
� Generar un tipo complejo con una tabla de una columna de tipo NVARCHAR2
� Generar un tipo complejo con una tabla de una columna de tipo NUMBER
(entero)
� Generar un tipo complejo con una tabla de una columna de tipo NUMBER
(decimal)
� Generar un tipo complejo con una tabla de una columna de tipo DATE
� Generar un tipo complejo con una tabla de una columna de tipo TIMESTAMP
80
Generador de Código para BBDD Oracle
� Generar un tipo complejo con una tabla de una columna de tipo LONG
� Generar un tipo complejo con una tabla de una columna de tipo BFILE
� Generar un tipo complejo con una tabla de una columna de tipo
BINARY_INTEGER
� Generar un tipo complejo con una tabla de una columna de tipo INTERVAL DAY
� Generar un tipo complejo con una tabla de una columna de tipo INTERVAL
YEAR
� Generar un tipo complejo con una tabla de una columna de tipo LONG RAW
� Generar un tipo complejo con dos tipos de datos simples
� Generar un tipo complejo con otro tipo complejo
� Generar un tipo complejo con un tipo simple y un tipo complejo
� Test Generador Esquemas:
� Generar un esquema de una tabla con una columna de tipo VARCHAR
� Generar un esquema de una tabla con una columna de tipo VARCHAR2
� Generar un esquema de una tabla con una columna de tipo CHAR
� Generar un esquema de una tabla con una columna de tipo NCHAR
� Generar un esquema de una tabla con una columna de tipo NVARCHAR2
� Generar un esquema de una tabla con una columna de tipo NUMBER (entero)
� Generar un esquema de una tabla con una columna de tipo NUMBER (decimal)
� Generar un esquema de una tabla con una columna de tipo DATE
� Generar un esquema de una tabla con una columna de tipo TIMESTAMP
� Generar un esquema de una tabla con una columna de tipo LONG
� Generar un esquema de una tabla con una columna de tipo BFILE
� Generar un esquema de una tabla con una columna de tipo BINARY_INTEGER
� Generar un esquema de una tabla con una columna de tipo INTERVAL DAY
� Generar un esquema de una tabla con una columna de tipo INTERVAL YEAR
� Generar un esquema de una tabla con una columna de tipo LONG RAW
� Generar un esquema de una tabla con una columna de tipo LONG
� Generar un esquema de una tabla con una PK de una columna
� Generar un esquema de una tabla con una PK de dos columnas
� Generar un esquema de una tabla sin PK.
81
Generador de Código para BBDD Oracle
T11 Pruebas de integración
Para las pruebas de integración se generaron los siguientes test.
ID Titulo Descripción Resultado esperado
13 Creación de un esquema de una tabla sin PK y una columna
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE test13
( column1 NUMBER );
Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test13.
La aplicación generará un fichero test13.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest13_Column1Type y un tipo complejo con un solo elemento que será del tipo anterior.
14 Creación de un esquema de una tabla con PK de un solo campo y sin más columnas
Primero se crea una tabla con PK de una y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST14 ( COLUMN1 NUMBER, CONSTRAINT "TEST14_COLUMN_PK" PRIMARY KEY (COLUMN1) );
Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test14.
La aplicación generará un fichero test14.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest14_Column1Type y dos tipos complejos uno será la PK y otro será el tipo de la tabla con un solo elemento que será la PK
15 Creación de un esquema de una tabla con PK de dos campos y sin más columnas
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST15 ( COLUMN1 NUMBER, COLUMN2 NUMBER, CONSTRAINT "TEST15_COLUMN_PK" PRIMARY KEY (COLUMN1, COLUMN2) );
Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test15.
La aplicación generará un fichero test15.xsd en el que habrá dos tipos simples de tipo integer y cuyo nombre será FieldTest15_Column1Type y FieldTest15_Column2Type y dos tipos complejos uno será la PK que estará compuesto de dos elementos, los dos tipos simples y otro será el tipo de la tabla con un solo elemento que será la PK
82
Generador de Código para BBDD Oracle
16 Creación de un esquema de una tabla con PK de un solo campo y con más columnas
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST16 ( COLUMN1 NUMBER, COLUMN2 NUMBER, CONSTRAINT "TEST16_COLUMN_PK" PRIMARY KEY (COLUMN1) );
Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test16.
La aplicación generará un fichero test16.xsd en el que habrá dos tipos simples de tipo integer y cuyo nombre será FieldTest16_Column1Type y FieldTest16_Column2Type y dos tipos complejos uno será la PK que estará compuesto de un elemento, el tipo simple FieldTest16_Column1Type y otro será el tipo de la tabla con dos elementos, uno será la PK y otro será FieldTest16_Column2Type.
17 Creación de un esquema de una tabla con PK de dos campos y con más columnas
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST17 ( COLUMN1 NUMBER, COLUMN2 NUMBER, COLUMN3 NUMBER, CONSTRAINT "TEST17_COLUMN_PK" PRIMARY KEY (COLUMN1, COLUMN2) );
Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test17.
La aplicación generará un fichero test17.xsd en el que habrá tres tipos simples de tipo integer y cuyo nombres serán FieldTest17_Column1Type, FieldTest17_Column2Type y FieldTest17_Column3Type y dos tipos complejos uno será la PK que estará compuesto de dos elementos, los tipos simples FieldTest17_Column1Type y FieldTest17_Column2Type y otro será el tipo de la tabla con dos elementos, uno será la PK y otro será FieldTest17_Column3Type.
Tabla 36
83
Generador de Código para BBDD Oracle
Cuarta iteración
Reunión de planificación (Sprint Planning)
En la cuarta reunión el Product Owner da por terminado el tercer requisito. Para el siguiente
requisito, no hay ninguna discusión ya que solo queda uno por realizar, por lo tanto se decide
empezarlo.
Requisito Descripción Estado
REQ1 Recolección de los metadatos de la BBDD Realizado
REQ2 Creación de la clase de negocio Realizado
REQ3 Generación de xsd de una tabla Realizado
REQ4 Generación de un bean java Pendiente
Tabla 37
El requisito se divide en tareas similares a los anteriores requisitos ya que sólo cambia el tipo
de fichero que se generará, pero la mecánica será parecida.
Tarea Descripción Fecha prevista de fin Fecha de fin Estado
T12
Desarrollo de un template
para crear un bean java 3/28/2014 3/30/2014 Finalizado
T13
Creación de los bean java a
través de una plantilla 4/20/2014 4/20/2014 Finalizado
T14 Pruebas de integración 4/28/2014 4/28/2014 Finalizado
Tabla 38
84
Generador de Código para BBDD Oracle
T12 ‐ Desarrollo de un template para crear un bean java
Para el desarrollo de esta plantilla se ha seguido la premisa de que sólo tendrían como
parámetros de entrada, el nombre de la clase, los atributos de ésta y su paquete o localización,
a diferencia de la plantilla anterior que se utilizaban subtemplates para la construcción del xsd.
La razón de hacerlo de esta manera es para que en el código del generador no se integrará con
el lenguaje de programación de la clase a generar. En nuestro caso se va a generar un bean
java, pero si se quisiera generar una clase de este tipo para un lenguaje en el que el acceso a
los atributos fuera directo y no a través de un método, tendríamos un problema, ya que no se
podría resolver a través de la plantilla porque estaría muy integrado en el código. Por esta
razón, la lógica de cómo crear la clase se encuentra en la plantilla y el generador sólo se
encarga de proporcionarle los datos para construirla (nombre, atributos con sus tipos de datos
y paquete).
La plantilla se dividirá en cuatro partes, una para la generación de los atributos de la clase, otra
para el constructor de la clase, otra, los métodos de acceso de los atributos y, por último, la
zona en la que se llamarán a todos los subtemplates anteriores.
85
Generador de Código para BBDD Oracle
Plantilla
typeMap ::= [ "BFILE":"oracle.sql.BFILE", "BINARY_INTEGER":"int", "CHAR":"String", "DATE":"java.sql.Timestamp", "INTERVAL DAY":"String", "INTERVAL YEAR":"String", "LONG":"String", "LONG RAW":"byte[]", "NCHAR":"oracle.sql.NString", "NUMBER":"java.math.BigDecimal", "NVARCHAR2":"String", "RAW":"byte[]", "ROWID":"oracle.sql.ROWID", "TIMESTAMP":"java.sql.Timestamp", "UROWID":"oracle.sql.ROWID", "VARCHAR":"String", "VARCHAR2":"String" ] typeInitMap ::= [ "int":"0", "long":"0", "float":"0.0", "double":"0.0", "boolean":"false", "byte":"0", "short":"0", "char":"0", default:"null" ] class(package,nameClass, atributes, sup="Object")::= <<package <package>; public class <nameClass> extends <sup> { <atributes:atribute(); separator="\n"> <constructor(nameClass, atributes)> <atributes:generateMethods(); separator="\n"> } >> atribute(parameter)::= << <typeMap.(parameter.type)> <parameter.name> = <typeInitMap.(typeMap.(parameter.type))>; >> generateMethods(parameter)::= << <getMethod(parameter)> <setMethod(parameter)> >>
86
Generador de Código para BBDD Oracle
getMethod(parameter)::= << public <typeMap.(parameter.type)> get<parameter.name; format="cap"> (){ return <parameter.name>; } >> setMethod(parameter)::= << public void set<parameter.name;format="cap"> (<typeMap.(parameter.type)> <parameter.name>){ this.<parameter.name> = <parameter.name>; } >> constructor(nameClass, parameters)::= << public <nameClass>(<parameters:generateParameter(); separator=", ">){ <parameters:generateAssign(); separator="\n"> } >> generateParameter(parameter)::= << <typeMap.(parameter.type)> <parameter.name> >> generateAssign(parameter)::= << this.<parameter.name> = <parameter.name>; >>
Tabla 39
Al inicio de la plantilla se definen dos diccionarios de datos. El primero de ellos define la
compatibilidad de tipos de datos entre la BBDD y Java [16]:
typeMap ::= [ "BFILE":"oracle.sql.BFILE", "BINARY_INTEGER":"int", "CHAR":"String", "DATE":"java.sql.Timestamp", "INTERVAL DAY":"String", "INTERVAL YEAR":"String", "LONG":"String", "LONG RAW":"byte[]", "NCHAR":"oracle.sql.NString", "NUMBER":"java.math.BigDecimal", "NVARCHAR2":"String", "RAW":"byte[]", "ROWID":"oracle.sql.ROWID", "TIMESTAMP":"java.sql.Timestamp", "UROWID":"oracle.sql.ROWID", "VARCHAR":"String", "VARCHAR2":"String" ]
87
Generador de Código para BBDD Oracle
Como se puede ver, a la izquierda se define el tipo de datos de Oracle y, a la derecha, su
correspondencia con Java. Este diccionario permitirá pasarle al template el tipo de dato
original de la tabla que se quiere exportar y, de forma sencilla, obtener el tipo de datos usado
dentro de la clase.
El segundo diccionario define los datos inicialización de cada tipo de dato.
typeInitMap ::= [ "int":"0", "long":"0", "float":"0.0", "double":"0.0", "boolean":"false", "byte":"0", "short":"0", "char":"0", default:"null" ]
Este diccionario de datos se le pasa como parámetro el tipo del dato y devuelve el valor con el
que se debe inicializar. Todos los tipos primitivos de java son inicializados a 0 o a false y en
caso de ser un objeto se inicializa a null.
La siguiente parte de la plantilla es la plantilla principal, la cual será llamada desde el código del
generador.
class(package,nameClass, atributes, sup="Object")::= << package <package>; public class <nameClass> extends <sup> { <atributes:atribute(); separator="\n"> <constructor(nameClass, atributes)> <atributes:generateMethods(); separator="\n"> } >> Esta plantilla será el único punto de comunicación entre el generador de código y las plantillas
por lo que se ha explicado previamente. Por lo tanto debe recibir toda la información necesaria
para la generación de la clase. Sus parámetros son el nombre de la clase, el paquete de la clase
y una lista de atributos. También tiene un atributo más, que es la clase padre de la clase a
generar, pero tiene un valor por defecto que es object, por lo que no se rellena desde el
generador. La primera línea simplemente genera la línea de código que indica el paquete al
que pertenece la clase. La siguiente línea es la definición de la clase con su nombre de clase y
su clase padre.
88
Generador de Código para BBDD Oracle
En esta parte de la plantilla es donde se va a definir:
� atributos
� constructor
� getter y setter de los atributos
Cada una de estas partes tiene su propia plantilla para que sea más sencillo el desarrollo y más
modular.
Stringtemplate proporciona un mecanismo para facilitar la llamada a un método n veces,
siendo n el número de elementos de una lista y a su vez se le pasa como argumento ese
elemento de la lista. Para generar los atributos se ha utilizado esa característica, haciendo que
por cada elemento de la lista de atributos sea llamado el subtemplate atribute que recibe
como parámetro ese elemento de la lista. Además Stringtemplate te permite elegir el
separador que se introducirá entre cada una de las llamadas al subtemplate, en nuestro caso
se ha introducido un salto de línea.
Ahora vamos a explicar el subtemplate atribute que es el encargado de generar cada
atributo.
atribute(parameter)::= << <typeMap.(parameter.type)> <parameter.name> =
<typeInitMap.(typeMap.(parameter.type))>;
>>
89
Generador de Código para BBDD Oracle
Este subtemplate recibe como parámetro el atributo a generar. Como se explicó previamente
Stringtemplate puede pasar objetos bean a las plantillas y, éstas acceder a los atributos de ese
objeto siempre que tengan un método getter público. En nuestro caso recibe un bean.
package org.generador.services; public class Parameter { private String type; private String name; public Parameter (String name, String type) { this.name = name; this.type = type; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getType() { return type; } public void setType(String type) { this.type = type; } }
Tabla 40
Que como se puede ver tiene dos atributos, uno el tipo Oracle al que pertenece el atributo y
otro su nombre. El tipo de datos de Oracle es pasado al diccionario de datos de la plantilla para
obtener su tipo de dato de java <typeMap.(parameter.type)> y posteriormente, se
obtiene el nombre del atributo <parameter.name>. Para finalizar se debe inicializar el
atributo, por lo que se debe recurrir a los dos diccionarios de datos. En primer lugar se obtiene
el tipo de datos para posteriormente, ir al segundo diccionario de datos y obtener su valor de
inicialización <typeInitMap.(typeMap.(parameter.type))>.
90
Generador de Código para BBDD Oracle
El siguiente subtemplate generateMethods genera un método get y set para obtener y
asignar el valor de cada atributo respectivamente.
generateMethods(parameter)::= << <getMethod(parameter)> <setMethod(parameter)> >> getMethod(parameter)::= << public <typeMap.(parameter.type)> get<parameter.name; format="cap"> (){ return <parameter.name>; } >> setMethod(parameter)::= << public void set<parameter.name;format="cap"> (<typeMap.(parameter.type)> <parameter.name>){ this.<parameter.name> = <parameter.name>; } >>
Al igual que el anterior subtemplate, éste es llamado una vez por cada atributo de la clase. El
subtemplate consta de dos otros dos subtemplates que son llamados consecutivamente, uno
para el método get y otro del método set.
El subtemplate getMethod tiene como parámetro de entrada un objeto de la clase
Parameter que representa el atributo que se quiere obtener. El código generado será un
método público que devuelve el tipo de dato del atributo que se obtiene a través del
diccionario de datos typeMap. El siguiente elemento del subtemplate es el nombre del
método. Éste se genera concatenando la palabra get con el nombre del atributo, siendo la
primera letra del atributo una mayúscula. Para conseguir que la primera letra sea mayúscula se
recurre a una característica de StringTemplate format="cap", la cual hace que la primera
letra de la expresión sea mayúscula. Posteriormente van los parámetros del método que al ser
un método get están vacíos. Por último, dentro del cuerpo del método simplemente se
devuelve el atributo.
El subtemplate setMethod al igual que el anterior subtemplate tiene como parámetro de
entrada un objeto de la clase Parameter que representa el atributo que se quiere asignar. Este
subtemplate construye el método set de forma muy similar al anterior, con la diferencia que
no devuelve nada y, por lo tanto, su valor de retorno es void y que sí tiene un parámetro de
entrada, que es el valor a asignar al atributo. Ya en el cuerpo del método se asigna el valor al
atributo de la clase.
91
Generador de Código para BBDD Oracle
Por último está el subtemplate que genera el constructor de la clase constructor:
constructor(nameClass, parameters)::= << public <nameClass>(<parameters:generateParameter(); separator=", ">){ <parameters:generateAssign(); separator="\n"> } >> generateParameter(parameter)::= << <typeMap.(parameter.type)> <parameter.name> >> generateAssign(parameter)::= << this.<parameter.name> = <parameter.name>; >>
Este subtemplate recibe como parámetros el nombre de la clase y todos los atributos que la
forman. Al igual que el resto de métodos de la clase el constructor también será público y su
nombre, como obliga el lenguaje Java, será el nombre de la clase. Para la creación de los
parámetros de entrada del constructor se llamará a otro subtemplate generateParameter,
que es llamado una vez por cada parámetro e introduce como separación entre cada uno de
ellos, una coma separator=", ". Este subtemplate simplemente obtiene el tipo del dato del
parámetro a través del diccionario de datos y pone el nombre. El siguiente y último elemento
del subtemplate del constructor es la llamada por cada uno de los parámetros a otro
subtemplate que genera la asignación del parámetro de entrada con el atributo.
92
Generador de Código para BBDD Oracle
T13 Creación de los bean java a través de una plantilla
En esta tarea se diseñará y desarrollará el software para la generación del bean como
resultado de utilizar la plantilla diseñada en la tarea anterior y los datos obtenidos de cada
tabla. Este módulo del software será bastante sencillo ya que el peso de la generación del
código fuente recae en su mayoría en la plantilla, el software tan sólo le deberá proporcionar
los datos. El diagrama de secuencia a alto nivel es el siguiente:
Ilustración 14
93
Generador de Código para BBDD Oracle
Los pasos serán los siguientes:
1. El Generador obtendrá la configuración de éste. Entre los datos obtenidos uno
de ellos será las tablas que se quieren tratar.
2. Se obtienen los datos de las tablas a exportar (como se indicó en el diagrama
de la tarea T3).
3. El objeto tabla es devuelto.
4. Se llama al generador de clases java para que genere bean Java.
5. Por cada columna de la tabla se crea un objeto de tipo Parameter con el
nombre de columna y el tipo de dato Oracle.
6. Se llama al renderizado del motor de templates para que genere bean,
pasándole como parámetros el nombre de la tabla, la lista de objetos Parameter
creada anteriormente y el paquete al que va a pertenecer que se obtendrá del fichero
de configuración.
7. El bean es devuelto.
Pruebas unitarias
� Test del GeneradorJavaClass:
� Generar una clase con un atributo cuya columna sea de tipo VARCHAR
� Generar una clase con un atributo cuya columna sea de tipo VARCHAR2
� Generar una clase con un atributo cuya columna sea de tipo CHAR
� Generar una clase con un atributo cuya columna sea de tipo NCHAR
� Generar una clase con un atributo cuya columna sea de tipo NVARCHAR2
� Generar una clase con un atributo cuya columna sea de tipo NUMBER (entero)
� Generar una clase con un atributo cuya columna sea de tipo NUMBER
(decimal)
� Generar una clase con un atributo cuya columna sea de tipo DATE
� Generar una clase con un atributo cuya columna sea de tipo TIMESTAMP
� Generar una clase con un atributo cuya columna sea de tipo LONG
� Generar una clase con un atributo cuya columna sea de tipo BFILE
� Generar una clase con un atributo cuya columna sea de tipo BINARY_INTEGER
� Generar una clase con un atributo cuya columna sea de tipo INTERVAL DAY
� Generar una clase con un atributo cuya columna sea de tipo INTERVAL YEAR
� Generar una clase con un atributo cuya columna sea de tipo LONG RAW
94
Generador de Código para BBDD Oracle
T14 Pruebas de integración
Para las pruebas de integración se generaron los siguientes test.
ID Titulo Descripción Resultado esperado
18 Creación de un bean java con un atributo
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST18 ( COLUMN1 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test18.
La aplicación generará un fichero Test18.java con un atributo column1 de tipo java.math.BigDecimal y el constructor tendrá solo un parámetro.
A parte del constructor tendrá dos métodos públicos get y set del atributo column1.
19 Creación de un bean java con dos atributo
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST19 ( COLUMN1 NUMBER, COLUMN2 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test19.
La aplicación generará un fichero Test19.java con dos atributos column1 y column2 de tipo java.math.BigDecimal y el constructor tendrá dos parámetros.
A parte del constructor tendrá un método público get y otro set por cada atributo.
20 Creación de un bean java con dos atributo
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST20 ( COLUMN1 VARCHAR, COLUMN2 VARCHAR ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test20.
La aplicación generará un fichero Test20.java con dos atributos column1 y column2 de tipo String y el constructor tendrá dos parámetros.
A parte del constructor tendrá un método público get y otro set por cada atributo.
21 Creación de un bean java con dos atributo
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST21 ( COLUMN1 VARCHAR, COLUMN2 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test21.
La aplicación generará un fichero Test21.java con dos atributos column1 de tipo String y column2 de tipo java.math.BigDecimal y el constructor tendrá dos parámetros.
A parte del constructor tendrá un método público get y otro set por cada atributo.
95
Generador de Código para BBDD Oracle
22 Creación de un bean java con varios atributos
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST22 ( COLUMN1 VARCHAR, COLUMN2 NUMBER, COLUMN3 BFILE, COLUMN4 BINARY_INTEGER, COLUMN5 CHAR, COLUMN6 DATE", COLUMN7 INTERVAL DAY, COLUMN8 INTERVAL YEAR, COLUMN9 LONG, COLUMN10 LONG RAW, COLUMN11 NCHAR, COLUMN12 NUMBER, COLUMN13 NVARCHAR2, COLUMN14 RAW, COLUMN15 ROWID, COLUMN16 TIMESTAMP, COLUMN17 UROWID, COLUMN18 VARCHAR2 ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test22.
La aplicación generará un fichero Test22.java con los atributos column1‐18 siendo cada uno del tipo indicado en el diccionario de datos.
"BFILE":"oracle.sql.BFILE"
"BINARY_INTEGER":"int"
"CHAR":"String"
"DATE":"java.sql.Timestamp"
"INTERVAL DAY":"String"
"INTERVAL YEAR":"String"
"LONG":"String"
"LONG RAW":"byte[]"
"NCHAR":"oracle.sql.NString"
"NUMBER":"java.math.BigDecimal"
"NVARCHAR2":"String"
"RAW":"byte[]"
"ROWID":"oracle.sql.ROWID"
"TIMESTAMP":"java.sql.Timestamp"
"UROWID":"oracle.sql.ROWID"
"VARCHAR":"String"
"VARCHAR2":"String"
A parte del constructor tendrá un método público get y otro set por cada atributo.
23 Ejecución completa de la generación de código
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST23 ( COLUMN1 NUMBER ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test23.
La aplicación creará un fichero Test23.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects.
La aplicación generará un fichero test23.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest13_Column1Type y un tipo complejo con un solo elemento que será del tipo anterior.
La aplicación generará un fichero Test23.java con un atributo column1 de tipo java.math.BigDecimal y el constructor tendrá solo un parámetro.
A parte del constructor tendrá dos métodos públicos get y set del atributo column1.
96
Generador de Código para BBDD Oracle
24 Ejecución completa de la generación de código
Primero se crea una tabla con PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST24 ( COLUMN1 NUMBER, CONSTRAINT "TEST24_COLUMN_PK" PRIMARY KEY (COLUMN1) ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test24.
La aplicación creará un fichero Test24.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects.
La aplicación generará un fichero test24.xsd en el que habrá un tipo simple de tipo integer y cuyo nombre será FieldTest24_Column1Type y dos tipos complejos uno será la PK y otro será el tipo de la tabla con un solo elemento que será la PK
La aplicación generará un fichero Test24.java con un atributo column1 de tipo java.math.BigDecimal y el constructor tendrá solo un parámetro.
A parte del constructor tendrá dos métodos públicos get y set del atributo column1.
25 Creación de un bean java con dos atributo
Primero se crea una tabla sin PK y con una columna en la bbdd ejecutando el siguiente comando:
CREATE TABLE TEST25 ( COLUMN1 NUMBER, COLUMN2 VARCHAR ); Arrancar la aplicación indicando en el fichero de tablas a exportar que se debe exportar la tabla test25.
La aplicación creará un fichero Test25.java en el directorio indicado en el fichero de configuración en la propiedad pathBusinessObjects.
La aplicación generará un fichero test25.xsd en el que habrá dos tipos simples, uno de tipo integer y cuyo nombre será FieldTest25_Column2Type y otro de tipo string y cuyo nombre será FieldTest25_Column2Type, y exisitrá un tipo complejo con dos elementos que serán de los tipos anteriores.
La aplicación generará un fichero Test25.java con dos atributos column2 de tipo String y column1 de tipo java.math.BigDecimal y el constructor tendrá dos parámetros.
A parte del constructor tendrá un método público get y otro set por cada atributo.
Tabla 41
97
Generador de Código para BBDD Oracle
Sprint Backlog Final
Tarea Descripción Fecha prevista de fin Fecha de fin Estado
T1
Creación de Máquina
Virtual con una BBDD
Oracle 11/1/2013 11/1/2013 Finalizado
T2
Creación de la estructura
de clases donde van a
ser almacenados los
metadatos 11/7/2013 11/7/2013 Finalizado
T3
Obtención de los datos
de las tablas 11/15/2013 11/15/2013 Finalizado
T4
Pruebas de integración 11/17/2013 11/18/2013 Finalizado
Sprint 1 17/11/2013
T5
Búsqueda de una librería
de templates para la
generación de los
diferentes formatos de
salida 12/20/2013 12/20/2103 Finalizado
T6
Utilización de templates
en la generación de las
clases de business object 1/9/2014 1/14/2014 Finalizado
T7
Generación de las
plantillas para las clases
business object 1/15/2014 1/21/2014 Finalizado
T8 Pruebas de integración 1/17/2014 1/31/2014 Finalizado
Sprint 2 1/20/2014
98
Generador de Código para BBDD Oracle
T9
Generación de las
plantillas para los xsd 2/13/2014 2/13/2014 Finalizado
T10
Creación de los xsd a
través de una plantilla
con datos simples sin
añadir restricciones 2/20/2014 2/20/2014 Finalizado
T11 Pruebas de integración 2/28/2014 2/28/2014 Finalizado
Sprint 3 3/03/2014
T12
Desarrollo de un
template para crear un
bean java 3/28/2014 3/30/2014 Finalizado
T13
Creación de los bean
java a través de una
plantilla 4/20/2014 4/20/2014 Finalizado
T14 Pruebas de integración 4/28/2014 4/28/2014 Finalizado
Sprint 4 4/30/2014
Tabla 42
99
Generador de Código para BBDD Oracle
Trabajo Futuro
En trabajos futuros este proyecto se podría ampliar siguiendo varias líneas de trabajo
diferentes:
� Una opción para seguir el desarrollo sería ampliar los gestores de bases de datos
soportados, ya que en este momento el único gestor que es soportado es Oracle,
pudiendo añadir nuevos gestores como MySQL, Postgresql, SQLServer, etc. ya que
todos guardan en su propia base de datos el catálogo de las tablas que la componen.
Por ejemplo Postgresql guarda la información de las columnas en la tabla pg_attribute,
tan sólo se debería modificar la query que obtenía la información de las columnas
utilizando esta nueva tabla.
� Otra forma de ampliar el proyecto podría ser añadir nuevos lenguajes a los que
exportar la base de datos y no sólo a java. Esto sería más sencillo de realizar, ya que el
software ha sido separado en diferentes capas, separando la parte de obtención de los
datos de la base de datos de la generación del código, dejando la responsabilidad de la
generación del código a las plantillas por lo que, para generar el código en un nuevo
lenguaje, sólo habría que preparar una plantilla nueva para ese lenguaje en concreto.
� Por último, otra opción a seguir para ampliar el proyecto sería crear una interfaz
gráfica para la ejecución de la herramienta ya que su ejecución es a través de línea de
comandos, por lo que es una interfaz poco amigable. También toda su configuración se
basa en ficheros de configuración que hay que modificar manualmente accediendo a
ellos, por lo que sería más recomendable que la modificación de estos ficheros se
realizara a través de la propia interfaz gráfica.
100
Generador de Código para BBDD Oracle
� Para esta tarea existen diferentes librerías en java que facilitarían el trabajo de crear la
interfaz, como pueden ser:
� AWT, es la librería en la que se basa Swing, sus componentes son bastante
básicos pero, si la interfaz no va a ser muy elaborada, puede ser válida.
� Swing, como se dijo anteriormente se basa en AWT, tiene componentes para
generar una interfaz gráfica muy compleja aunque en sus inicios era algo lento
y consumía muchos recursos, pero en las últimas actualizaciones eso ha
cambiado, siendo una de las opciones más recomendables ya que es parte del
estándar de Java.
� SWT, creado por IBM para Eclipse. En un principio pensaron que Swing no era
adecuado para Eclipse por cual decidieron crear esta librería que,
posteriormente liberaron bajo una licencia de código abierto.
� QT Jambi, JavaFx, etc., existen multitud de librerías para la construcción de la
interfaz gráfica pero las más utilizadas son las anteriormente mencionadas.
101
Generador de Código para BBDD Oracle
Conclusiones
Tras finalizar el proyecto, podemos llegar a la conclusión que la actualización del software que
accede a una base de datos por otro puede ser menos traumática si se utilizan herramientas
como la desarrollada en el proyecto, que facilitan el desarrollo y proporcionan una estructura
para que el desarrollo del nuevo software sea más rápido.
A su vez, también hemos visto cómo un gestor de base de datos tiene una base de datos de sí
mismo, en el cual se almacenan todos los datos de las bases de datos que gestiona, tablas,
columnas, foreign key, constraints, etc. por lo que es fácil acceder a la metainformación de las
bases de datos gestionadas, que servirá como es nuestro caso de generar el código fuente,
para el acceso a ella, pero también puede servir para la migración de la base de datos a otro
gestor distinto, para informes, etc.
También hemos visto las bondades de las plantillas, exactamente StringTemplate, cómo nos
permiten una flexibilidad a la hora de generar nuestro resultado, permitiendo que con tan sólo
cambiar la plantilla se pueda generar una clase de un lenguaje totalmente distinto. Esta
característica puede ser usada en otras situaciones como puede ser el desarrollo web,
generación de informes, etc.
102
Generador de Código para BBDD Oracle
Referencias
[1] http://es.wikipedia.org/wiki/Metodolog%C3%ADa_de_desarrollo_de_software
(23/04/2014)
[2] http://es.wikipedia.org/wiki/Desarrollo_%C3%A1gil_de_software (23/04/2014)
[3]
http://commons.wikimedia.org/wiki/File:Esquema_general_de_una_metodologia_agil_para_d
esarrollo_de_software.png, Licencia Creative Commons
[4] http://www.proyectosagiles.org/ (26/03/2014)
[5] http://www.agilemanifesto.org/ (26/03/2014)
[6] http://www.proyectosagiles.org/que‐es‐Scrum (01/04/2014)
[7] https://www.java.com/es/download/whatis_java.jsp (15/09/2014)
[8] http://www.stringtemplate.org/ (10/10/2014)
[9] http://www.oracle.com/technetwork/es/database/express‐edition/overview/index.html
(05/05/2014)
[10] http://docs.oracle.com/cd/B19306_01/server.102/b14237/statviews_2094.htm
(05/05/2014)
[11] https://www.google.com/drive/ (05/05/2014)
[12] https://www.draw.io/ (05/05/21014)
[13] http://www.websequencediagrams.com (05/05/21014)
[14] https://eclipse.org/ (05/05/21014)
[15] http://www.oracle.com/technetwork/java/codeconvtoc‐136057.html (01/06/21014)
[16] http://docs.oracle.com/cd/B28359_01/java.111/b31226/datamap.htm#CHDCAECG
(07/05/2014)
[17] http://www.w3.org/TR/xmlschema‐2/#datatype (17/04/21014)
103
Generador de Código para BBDD Oracle
104
[18]
http://www.w3.org/2001/sw/rdb2rdf/wiki/Mapping_SQL_datatypes_to_XML_Schema_dataty
pes (17/04/2014)
[19] http://dl.acm.org/citation.cfm?doid=12944.12948 (23/05/2015)
[20] http://www.cs.usfca.edu/parrt.html (23/05/2015)