Taller Bd Alum No

SEP SNEST DGEST

INSTITUTO TECNOLÓGICO DE CHIHUAHUA II

“TALLER DE BASES DE DATOS”

PRESENTA:

Alumno

Chihuahua, Chih., Enero 2009.

i

TABLA DE CONTENIDO

PORTADA ………………………………………………………………………………………………i

AGRADECIMIENTOS................................................................................................................ ii

DICTAMEN............................................................................................................................... iii

PREFACIO................................................................................................................................ iv

TABLA DE CONTENIDO...........................................................................................................v

ÍNDICE DE FIGURAS..............................................................................................................vii

TEMARIO OFICIAL..................................................................................................................xii

UNIDAD 1. GESTOR DE BASES DE DATOS...........................................................................1

1.1 Características del gestor................................................................................................2

1.2 Herramientas...................................................................................................................71.2.1 De creación de bases de datos.................................................................................71.2.2 De administración de bases de datos.....................................................................101.2.3 De edición para crear esquemas y consultas de bases de datos...........................151.2.4 De control, monitoreo y estadísticas de acceso a bases de datos..........................171.2.5 Utilerías diversas.....................................................................................................19

1.3 Instalación y configuración del entorno operativo..........................................................21

UNIDAD 2. ADMINISTRACIÓN DE BASES DE DATOS.........................................................35

2.1 Creación de bases de datos..........................................................................................352.1.1 Creación de la estructura de la base de datos........................................................36

2.1.1.1 Estructuras de almacenamiento.......................................................................362.1.1.2 Asignación de espacio en disco para diferentes estructuras de almacenamiento...........................................................................................................402.1.1.3 Espacio asignado en memoria principal para diferentes objetos de la base de datos.............................................................................................................................41

2.1.2 Creación de dominios definidos por el DBA............................................................432.1.3 Definir el esquema general de la base de datos (tablas, atributos, llaves primarias y llaves heredadas).............................................................................................................462.1.4 Creación de vistas de la base de datos (view)........................................................51

2.2 Definición del esquema de integridad............................................................................532.2.1 Validar y verificar integridad de entidad e integridad referencial.............................542.2.2 Creación de disparadores (trigger’s).......................................................................572.2.3 Creación de procedimientos almacenados.............................................................61

ii

2.3 Definición del esquema de seguridad............................................................................652.3.1 Creación de usuarios de la base de datos..............................................................672.3.2 Asignación de privilegios sobre los objetos de información....................................69

2.4 Definición del esquema de recuperación.......................................................................722.4.1 Diseño y creación de la bitácora.............................................................................742.4.2 Recuperación a partir de la bitácora.......................................................................792.4.3 Respaldar bases de datos......................................................................................802.4.4 Recuperar bases de datos......................................................................................86

2.5 Diseño y procesamiento de transacciones....................................................................902.5.1 Definición de transacciones en un lenguaje huésped.............................................922.5.2 Ejecución de transacciones planas en el gestor de bases de datos.......................962.5.3 Ejecución de transacciones anidadas.....................................................................97

UNIDAD 3. TECNOLOGÍAS DE CONECTIVIDAD A BASES DE DATOS.............................106

3.1 ODBC..........................................................................................................................1073.1.1 Terminología y conceptos......................................................................................1073.1.2 Administrador de orígenes de datos ODBC..........................................................1093.1.3 Instalación y configuración del driver acorde al gestor de bases de datos...........112

3.2 ADO.NET.....................................................................................................................1353.2.1 Terminología y conceptos......................................................................................1353.2.2 Componentes disponibles.....................................................................................137

3.2.2.1 Connection.....................................................................................................1403.2.2.2 Command.......................................................................................................1403.2.2.3 Recordsource.................................................................................................1413.2.2.4 Error................................................................................................................143

3.2.3 Prototipo de aplicaciones con conectividad a bases de datos..............................145

3.3 JDBC...........................................................................................................................1543.3.1 Terminología y conceptos......................................................................................1543.3.2 SQL y JDBC..........................................................................................................158

3.3.2.1 Jerarquía de clases java.sql.*.........................................................................1583.3.2.2 Interface java.sql.connection..........................................................................1623.3.2.3 Interface java.sql.statement............................................................................1633.3.2.4 Interface java.sql.resultset..............................................................................1643.3.2.5 Jerarquía de clases javax.sql.*.......................................................................166

3.3.3 Instalación y configuración del driver acorde al gestor de base de datos.............1693.3.4 Prototipo de aplicaciones con conectividad a bases de datos..............................171

BIBLIOGRAFÍA.....................................................................................................................193

iii

ÍNDICE DE FIGURAS

Figura 1. Información de "MySQL Network Monitoring"...................................................................3Figura 2. Ruta de acceso al "MySQL Query Browser".....................................................................8Figura 3. Datos para ingreso al "MySQL Query Browser"...............................................................8Figura 4. Base de datos y objetos en "MySQL Query Browser".....................................................9Figura 5. Crear base de datos ("Schema") en "MySQL Query Browser"......................................9Figura 6. Pantalla de información del servidor de MySQL.............................................................11Figura 7. Menú "Tools" de "MySQL Administrator".........................................................................12Figura 8. Opciones de administración en “Microsoft SQL Server Management Studio Express”..................................................................................................................................................13Figura 9. Opciones de administración de "Oracle Database Express Edition"...........................14Figura 10. Crear una tabla con "MySQL Table Editor"...................................................................15Figura 11. Editar datos de una tabla con "MySQL Query Browser".............................................16Figura 12. Consulta con "MySQL Query Browser"..........................................................................17Figura 13. Estadísticas del sistema en Oracle.................................................................................19Figura 14. Opción "Utilidades" en Oracle..........................................................................................20Figura 15. Archivos para instalar servidor y herramienta gráfica para MySQL 5.0....................22Figura 16. Instalando MySQL Server 5.0., pantalla de bienvenida.............................................23Figura 17. Instalando MySQL Server 5.0., tipo de instalación......................................................23Figura 18. Instalando MySQL Server 5.0., confirmar información................................................24Figura 19. Instalando MySQL Server 5.0., copiando archivos......................................................24Figura 20. Instalando MySQL Server 5.0., cuenta en MySQL.com..............................................25Figura 21. Instalando MySQL Server 5.0., pantalla para confirmar configuración....................25Figura 22. Configurando MySQL Server 5.0., pantalla de bienvenida.........................................26Figura 23. Configurando MySQL Server 5.0., seleccionar tipo de configuración.......................27Figura 24. Configurando MySQL Server 5.0., seleccionar tipo de servidor................................27Figura 25. Configurando MySQL Server 5.0., seleccionar uso de la base de datos.................28Figura 26. Configurando MySQL Server 5.0., seleccionar ruta para almacenar tablas............29Figura 27. Configurando MySQL Server 5.0., seleccionar número de conexiones...................30Figura 28. Configurando MySQL Server 5.0., opciones de conexión en red..............................30Figura 29. Configurando MySQL Server 5.0., seleccionar conjunto de caracteres...................31Figura 30. Configurando MySQL Server 5.0., opciones para Windows......................................32Figura 31. Configurando MySQL Server 5.0., opciones de seguridad.........................................32Figura 32. Configurando MySQL Server 5.0., preparado para ejecutar......................................33Figura 33. Configurando MySQL Server 5.0., fin de la configuración..........................................34Figura 34. Máquinas de almacenamiento en MySQL.....................................................................38Figura 35. Opciones para la máquina de almacenamiento InnoDB en MySQL.........................39Figura 36. Bases de datos del sistema de MySQL.........................................................................40Figura 37. Archivos de bitácora en MySQL......................................................................................41Figura 38. Configuración de memoria en Oracle.............................................................................42Figura 39. Diagrama de base de datos del ejemplo práctico........................................................50Figura 40. Creación de tabla con llave primaria y foránea en MySQL........................................50Figura 41. Menú para crear una vista en MySQL............................................................................52Figura 42. Crear una vista en MySQL...............................................................................................53Figura 43. Ejecutar una vista en MySQL..........................................................................................53Figura 44. Integridad de entidad en MySQL.....................................................................................55

iv

Figura 45. Comportamientos de borrado y actualización de llave foránea.................................57Figura 46. Acceso a la línea de comandos de MySQL...................................................................59Figura 47. Crear disparador de actualización desde la línea de comandos...............................60Figura 48. Crear disparador de inserción desde la línea de comandos......................................61Figura 49. Crear procedimiento almacenado, paso 1.....................................................................63Figura 50. Crear procedimiento almacenado, paso 2.....................................................................64Figura 51. Escribir procedimiento almacenado................................................................................64Figura 52. Ejecutar procedimiento almacenado..............................................................................65Figura 53. Opción para administrar usuarios en MySQL...............................................................68Figura 54. Crear usuario en MySQL..................................................................................................69Figura 55. Asignar privilegios en modo gráfico a usuarios en MySQL........................................70Figura 56. Asignar privilegios con la línea de comandos en MySQL...........................................71Figura 57. Asignar recursos a usuarios en MySQL.........................................................................72Figura 58. Pantalla para ver archivos de bitácora en MySQL.......................................................75Figura 59. Crear archivos de bitácora en MySQL...........................................................................76Figura 60. Ver archivos de bitácora creados en MySQL................................................................77Figura 61. Crear nuevos archivos de bitácora en MySQL.............................................................77Figura 62. Ver nuevos archivos de bitácora creados en MySQL..................................................78Figura 63. Vista parcial del contenido del archivo de bitácora “Query log" en MySQL.............78Figura 64. Pantalla para respaldar base de datos en SQL Server Express................................80Figura 65. Opciones de respaldo de base de datos en SQL Server............................................81Figura 66. Pantalla para respaldar base de datos en Oracle Database Express.....................82Figura 67. Pantalla para respaldar base de datos en MySQL......................................................82Figura 68. Opciones de respaldo en MySQL...................................................................................83Figura 69. Pantalla de avance de respaldo en MySQL..................................................................84Figura 70. Opciones de respaldo avanzadas en MySQL...............................................................84Figura 71. Calendarización de un respaldo en MySQL..................................................................85Figura 72. Pantalla para recuperar base de datos en MySQL......................................................87Figura 73. Seleccionar archivo para recuperación en MySQL......................................................88Figura 74. Pantalla para recuperación con información completa en MySQL............................89Figura 75. Pantalla de avance de recuperación en MySQL..........................................................90Figura 76. Escritura de una transacción plana en MySQL.............................................................94Figura 77. Contenido de la tabla "Cuentas"......................................................................................95Figura 78. Ejecutar la transacción en MySQL..................................................................................95Figura 79. Contenido de la tabla "Cuentas" después de ejecutar la transacción.......................96Figura 80. Estructura de una transacción anidada..........................................................................97Figura 81. Diseño de la base de datos para el ejemplo de transacciones anidadas...............100Figura 82. Crear un procedimiento almacenado en SQL Server Express................................101Figura 83. Ejecutar procedimiento con transacciones anidadas en SQL Server.....................104Figura 84. Página de descarga de conectores para MySQL.......................................................107Figura 85. Componentes básicos de ODBC..................................................................................109Figura 86. Ubicación del Administrador ODBC en Windows.......................................................110Figura 87. Pantalla principal del Administrador ODBC.................................................................110Figura 88. Vista de la ficha "Controladores" del Administrador ODBC......................................112Figura 89. Controladores ODBC adicionales a los preinstalados..............................................113Figura 90. Conector ODBC en la página de MySQL....................................................................114Figura 91. Seleccionar el conector ODBC adecuado al sistema operativo...............................115Figura 92. Seleccionar el tipo de archivo para el conector ODBC..............................................116

v

Figura 93. Seleccionar un servidor de descarga para el conector ODBC.................................116Figura 94. Instalación del conector ODBC, pantalla de inicio......................................................117Figura 95. Instalación del conector ODBC, seleccionar tipo de instalación..............................117Figura 96. Instalación del conector ODBC, aceptar opciones de instalación...........................118Figura 97. Instalación del conector ODBC, fin de instalación......................................................118Figura 98. Verificar controlador ODBC instalado...........................................................................119Figura 99. Crear una nueva conexión ODBC.................................................................................120Figura 100. Seleccionar controlador para conexión ODBC.........................................................120Figura 101. Proporcionar información para conexión ODBC......................................................121Figura 102. Ver conexión ODBC recién creada.............................................................................121Figura 103. Ventana "Server Explorer" de Microsoft Visual Studio .NET................................122Figura 104. Agregar una nueva conexión de datos en Visual Studio .NET..............................123Figura 105. Cambiar la fuente de datos de una conexión en Visual Studio .NET...................123Figura 106. Seleccionar la nueva fuente de datos de una conexión en Visual Studio .NET..124Figura 107. Seleccionar la conexión ODBC como fuente de datos en Visual Studio .NET.. 125Figura 108. Ver conexión de datos creada en Visual Studio .NET.............................................125Figura 109. Agregar un nuevo "DataSet" en Visual Studio .NET................................................126Figura 110. Configurar un "DataSet", seleccionar conexión de datos.......................................127Figura 111. Configurar un "DataSet", seleccionar tipo de comando para el "TableAdapter". 127Figura 112. Configurar un "DataSet", escribir la consulta SQL para el "TableAdapter".........128Figura 113. Configurar un "DataSet", seleccionar métodos a generar para el "TableAdapter"................................................................................................................................................................129Figura 114. Configurar un "DataSet", mostrando resultados de la configuración...................129Figura 115. Agregar una "Web Form" en Visual Studio .NET.....................................................130Figura 116. Agregar un objeto "ObjectDataSource" a una "WebForm".....................................131Figura 117. Configurar un "ObjectDataSource", seleccionar el objeto "Business Object"......131Figura 118. Configurar un "ObjectDataSource", seleccionar los métodos que regresan datos.................................................................................................................................................................132Figura 119. Agregar un objeto "GridView" a una "Web Form"....................................................133Figura 120. Configurar un objeto "GridView", seleccionar su fuente de datos.........................133Figura 121. Resultado de ejecutar la "Web Form" de acceso a la base datos.........................134Figura 122. Arquitectura básica de .NET Framework...................................................................137Figura 123. Clases principales de .NET Framework para bases de datos...............................139Figura 124. Arquitectura de ADO.NET............................................................................................139Figura 125. Modelo de objeto de la clase "DataSet".....................................................................142Figura 126. Ubicación del objeto "Error" de ADO..........................................................................143Figura 127. El conector .NET en la página de descarga de conectores de MySQL................145Figura 128. Página de descarga del conector .NET 5.1...............................................................146Figura 129. Seleccionar tipo de archivo de descarga del conector .NET 5.1...........................147Figura 130. Avance de descarga del conector .NET 5.1..............................................................147Figura 131. Instalar el conector .NET, ejecutar archivo de instalación......................................148Figura 132. Instalar el conector .NET, seleccionar tipo de instalación.....................................148Figura 133. Instalar el conector .NET, preparado para instalar.................................................149Figura 134. Instalar el conector .NET, avance de instalación....................................................149Figura 135. Instalar el conector .NET, fin de instalación.............................................................150Figura 136. Ver conector .NET instalado........................................................................................150Figura 137. Ver documentación instalada del conector .NET.....................................................151Figura 138. Seleccionar la base de datos MySQL como fuente de datos.................................152Figura 139. Configurar y probar la conexión a la base de datos de MySQL............................153

vi

Figura 140. Ver la conexión a MySQL en el "Server Explorer" de Visual Studio .NET...........153Figura 141. Controlador JDBC según el DBMS.............................................................................157Figura 142. Jerarquía de clases del paquete "java.sql"................................................................159Figura 143. Jerarquía de interfases del paquete “java.sql”..........................................................160Figura 144. Relación funcional de clases e interfases del paquete “java.sql”..........................162Figura 145. Jerarquía de clases del paquete "javax.sql"..............................................................167Figura 146. Jerarquía de interfases del paquete "javax.sql"........................................................168Figura 147. Página de descarga del conector JDBC en el sitio Web de MySQL.....................170Figura 148. Versiones del conector JDBC y enlace para descarga..........................................170Figura 149. Ficha "Services" en NetBeans.....................................................................................172Figura 150. La base de datos "innovacion" en MySQL................................................................172Figura 151. Propiedades de la conexión JDBC.............................................................................173Figura 152. Opción "Connect" para JDBC......................................................................................174Figura 153. Vista de conexión JDBC exitosa.................................................................................174Figura 154. Ejecutar sentencia SQL en NetBeans........................................................................175Figura 155. Arquitectura del prototipo que usa JDBC..................................................................176Figura 156. Primer página del prototipo que usa JDBC...............................................................177Figura 157. Segunda página que usa JDBC..................................................................................178Figura 158. Avance de la página "proyectos.jsp"..........................................................................179Figura 159. Avance de la página proyectoDetalle.jsp...................................................................181Figura 160. Crear nuevo recurso de servidor en Netbeans.........................................................182Figura 161. Crear un recurso JDBC para GlassFish....................................................................183Figura 162. JDBC y pool de conexiones agregados a GlassFish...............................................184Figura 163. Referencia a un recurso JNDI desde la aplicación..................................................185Figura 164. Contenido del archivo web.xml después de agregar un recurso JNDI.................186Figura 165. Librería JSTL en GlassFish..........................................................................................187Figura 166. Ejecución de las páginas del proyecto Web..............................................................191

vii

ÍNDICE DE TABLAS.

Tabla 1. Esquema de la tabla "Proyectos"..............................................................................48Tabla 2. Esquema de la tabla "Responsables".......................................................................49Tabla 3. Esquema de la tabla "Proyectos_Avances"..............................................................49Tabla 4. Relación de DBMS y sus lenguajes para escribir procedimientos almacenados......62Tabla 5. Tipos de archivos de bitácora de MySQL..................................................................75Tabla 6. Esquema de la tabla "Cuentas".................................................................................93Tabla 7. Esquema de la tabla "Clientes".................................................................................93Tabla 8. Propiedades del objeto "Error"................................................................................144Tabla 9. Propiedades del objeto "Connection" de ADO.NET................................................144Tabla 10. Descripción de clases del paquete “java.sql”........................................................160Tabla 11. Descripción de interfases del paquete “java.sql”...................................................161Tabla 12. Algunos métodos de la interfase "Connection".....................................................163Tabla 13. Algunos métodos de la interfase "Statement".......................................................164Tabla 14. Algunos métodos de la interfase "ResultSet"........................................................166Tabla 15. Descripción de clases del paquete "javax.sql"......................................................167Tabla 16. Descripción de interfases del paquete "javax.sql".................................................168

viii

TEMARIO OFICIAL.

1.- Datos de la asignatura

Nombre de la asignatura: Taller de bases de datosCarrera: Licenciatura en InformáticaClave de la asignatura: IFH - 0439Horas teoría-horas práctica-créditos: 0-4-4

2.- Historia del programa

Lugar y fecha de elaboración o revisión.

Participantes. Observaciones (cambios y justificación).

Instituto Tecnológicode Puebla del8 al 12 septiembre2003.

Instituto Tecnológicode: Cd. Valles, Orizaba,Zacatepec13 septiembre al 28de noviembre 2003.

Academia de sistemas ycomputación

Representantes de laacademia de sistemas ycomputación de losInstitutos Tecnológicos.

Academia de sistemas y computación.

Análisis y enriquecimiento de las propuestas de losprogramas diseñados enla reunión nacional deevaluación.

Reunión nacional deevaluación curricular de lacarrera de Licenciatura enInformática.

Análisis y enriquecimiento delas propuestas de losprogramas diseñados en lareunión nacional deevaluación.

Academia de de sistemas ycomputación

3.- Ubicación de la asignatura.

a). Relación con otras asignaturas del plan de estudios.

AnterioresAsignaturas Temas

Fundamentos debase de datos.

Conceptos debase de datos.

Diseño de basede datos relacionales.

Lenguajes debase de datos.

PosterioresAsignaturas Temas

Desarrollo deaplicacionesdistribuidas.

ix

b). Aportación de la asignatura al perfil del egresadoProporciona conocimientos y habilidades para que utilicen de manera óptima gestores y tecnologías de acceso a bases de datos.

4.- Objetivo(s) general(es) del cursoEl estudiante identificará herramientas de software para diseñar y administrar bases de datos, así como las tecnologías de conectividad.

5.- TEMARIOUnidad Subtemas1 Gestor de bases de datos.

1.1 Características del gestor.1.2 Herramientas.1.2.1 De creación de bases de datos.1.2.2 De administración de bases de datos.1.2.3 De edición para crear esquemas y consultas de bases de datos.1.2.4 De control, monitoreo y estadísticas de acceso a bases de datos.1.2.5 Utilerías diversas.1.3 Instalación y configuración del entorno operativo.

2 Administración de bases de datos.

2.1 Creación de bases de datos2.1.1 Creación de la estructura de la base de datos.2.1.2 Creación de dominios definidos por el DBA.2.1.3 Definir el esquema general de la base de datos (tablas, atributos, llaves primarias y llaves heredadas).2.1.4 Creación de vistas de la base de datos (view).2.2 Definición del esquema de integridad.2.2.1 Validar y verificar integridad de entidad e integridad referencial.2.2.2 Creación de disparadores (Trigger’s).2.2.3 Creación de procedimientos almacenados.2.3 Definición del esquema de seguridad.2.3.1 Creación de usuarios de la base de datos.2.3.2 Asignación de privilegios sobre los objetos de información.2.4 Definición del esquema de recuperación.2.4.1 Diseño y creación de la bitácora2.4.2 Recuperación a partir de la bitácora.2.4.3 Respaldar bases de datos.2.4.4 Recuperar bases de datos.2.5 Diseño y procesamiento de transacciones.2.5.1 Definición de transacciones en un lenguaje huésped.2.5.2 Ejecución de transacciones planas en el gestor de bases de datos.2.5.3 Ejecución de transacciones anidadas.

3 Tecnologías deconectividad a bases de datos.

3.1 ODBC.3.1.1 Terminología y conceptos3.1.2 Administrador de orígenes de datos ODBC.3.1.3 Instalación y configuración del driver acorde al gestor de bases de datos.3.2 ADO.NET.3.2.1 Terminología y conceptos.3.2.2 Componentes disponibles.3.2.2.1 Connection.3.2.2.2 Command.3.2.2.3 Recordsource.3.2.2.4 Error.3.2.3 Prototipo de aplicaciones con conectividad a bases de datos.3.3 JDBC.

x

3.3.1 Terminología y conceptos.3.3.2 SQL y JDBC.3.3.2.1 Jerarquía de clases java.sql.*.3.3.2.2 Interface java.sql.connection.3.3.2.3 Interface java.sql.statement 3.3.2.4 Interface java.sql.resultset.3.3.2.5 Jerarquía de clases javax.sql.*3.3.3 Instalación y configuración del driver acorde al gestor de base de datos.3.3.4 Prototipo de aplicaciones con conectividad a bases de datos.

6.- Aprendizajes requeridos.

Dominio del diseño de bases de datos relacionales. Dominio del lenguaje SQL. Habilidad de programación en un lenguaje orientado a objetos. Habilidades para utilizar software de sistemas. Conocimiento de redes de computadoras y arquitectura cliente/servidor.

7.- Sugerencias didácticas.

Presentar al inicio del curso el objetivo de la asignatura y su relación con otras del plan de estudios, así como el temario y las actividades de aprendizaje.

Propiciar el trabajo en equipo para el desarrollo de las prácticas. Guiar y asesorar el desarrollo de las prácticas. Elaborar instructivos, manuales o material didáctico que auxilie al estudiante. Propiciar la investigación en diversas fuentes de información. Seleccionar en acuerdo de academia, un gestor de base de datos (diferente al

utilizado en la asignatura de fundamentos de base de datos) de acuerdo a las necesidades del entorno, al contenido del programa y a los recursos disponibles.

Conformar equipos de trabajo para el desarrollo de un proyecto de su interés, en el cual aplique las tecnologías de conectividad a bases de datos.

Retomar el proyecto desarrollado en la asignatura de fundamentos de base de datos. Motivar la participación en foros académicos.

8.- Sugerencias de evaluación

Aplicar un examen inicial para conocer en nivel de los aprendizajes requeridos. Establecer de común acuerdo con los estudiantes, la ponderación de las diferentes

actividades del curso. Participar en clase y laboratorio. Realizar trabajos de investigación en diversas fuentes de información. Elaborar reportes de prácticas Exponer temas específicos en aula. Dar seguimiento a los avances y documentación del proyecto propuesto. Participar en foros académicos.

xi

9.- Unidades de aprendizaje

UNIDAD 1.- Gestor de bases de datos.

ObjetivoEducacional

Actividades de Aprendizaje Fuentes deInformación

El estudianteconocerá lascaracterísticas delgestor de bases dedatos , susherramientasdisponibles yconfigurará suentorno operativo.

Realizar prácticas de laboratorio de los temas descritos en la unidad.

Elaborar el reporte de cada práctica realizada. Investigar en distintas fuentes de información las

herramientas del gestor de bases de datos a utilizar, elaborar un informe escrito y discutirlo en el grupo.

Identificar un problema, a partir del cual pueda definir el proyecto del curso de acuerdo con el profesor.

1, 3, 8, 9, 1012, 13, 16, 17

UNIDAD 2.- Administración de bases de datos.

ObjetivoEducacional


Utilizará lasherramientas delgestor para lacreación yadministración debases de datos.


Elaborar el reporte de cada práctica realizada. Identificar las herramientas del gestor para la

administración de bases de datos. Presentar el avance del proyecto.

1, 2, 3, 4, 8, 910, 12, 15,16, 17

UNIDAD 3.- Tecnologías de conectividad a bases de datos.

ObjetivoEducacional


Conocerá y aplicarálas tecnologías deconectividad a basesde datos endiferentesplataformasoperativas.


Elaborar el reporte de cada práctica realizada. Investigar otras tecnologías de conectividad a bases de

datos. Elaborar un informe escrito donde ejemplifique el uso de

alguna de las tecnologías investigadas. Presentación del proyecto.

3, 5, 6, 7, 814, 16, 18, 19

10.- Fuentes de información

1. C. J. Date. Introduction to Data Base Systems, Volumen II. Addison – Wesley Iberoamericana.

xii

2. James R. Groff, Paul N. Weinberg. Aplique SQL. Mc Garw Hill.3. Mukhar, Kevin, et.al. Fundamentos de bases de datos con Java. Wrox/Anaya

Multimedia, 2002.4. Navathe. Fundamentos de Bases de Datos. Addison Wesley 1999.5. Deitel Harvey M., et.al. Visual Basic .NET for Experience Programmers. Microsoft

Press, 2002.6. Balena, Francesco. Programming Microsoft Visual Basic .NET. Microsoft Press, 2002.7. Sceppa, David. Microsoft ADO.NET. Microsoft Press, 2002.8. Worsley John.,et.al. Practical Postgresql. Command prompt Inc. 20029. Korry Douglas.,et.al. PostgreSQL. O'Reilly & Associates, 2003.10.Nielsen Paul. Microsoft SQL Server 2000 Bible.John Wiley & Sons, 2002.11.Houlette Forrest. Fundamentos de SQL.Para programadores. Mc Graw Hill, 2001.12.Nielsen Paul. DeVry College of Technology and Monroe College. Database Systems

Using Oracle: A Simplified Guide to SQL and PL/SQL. Prentice Hall.13.Ray Ranking Paul Jensen Paul Bertucci. Microsoft SQL Server 2000. Unleashed, 2/E

2003. Que/Sams.14.Steve Holzner. Microsoft Visual C#.NET 2003 Kick Start 2003. Que/Sams.15.Buck Woody. Essential SQL Server™ 2000: An Administration Handbook 2002.

Addison Wesley Professional.16.Pérez, C. Domine Microsoft SQL Server 2000 Administración y Análisis. de Bases de

Datos. Alfaomega-RAMA.17.Pérez, C. ORACLE 9i Administración y Análisis de Bases de Datos. Alfaomega-RAMA.18.Melton, Jim y Eisenberg, Andrew. SQL Y JAVA Guía para SQLJ, JDBC. y Tecnologías

Relacionadas. Alfaomega-RAMA.19.Jeffrey P. McManus Chris Kinsman. C# Developer's Guide to ASP.NET. XML, and

ADO.NET 2002. Addison Wesley Professional.

Referencias en Internet[20] www.bivitec.org.mx[21] www.javasun.com

11. Prácticas

Unidad Práctica1 Instalación y configuración del gestor de bases de datos.2 Creación de la estructura de base de datos (Base de datos, dominios, tipos de datos

definidos por el DBA, tablas, relaciones, vistas, restricciones de integridad de entidad, integridad referencial y esquema de seguridad).

3 Creación de disparadores (trigger´s).4 Desarrollar una aplicación que incluya el manejo de transacciones.5 Creación de procedimientos almacenados.6 Diseño y creación de la bitácora como medio de recuperación.

xiii

http://www.javasun.com/

UNIDAD 1. GESTOR DE BASES DE DATOS.

Un Gestor de bases de datos, que en castellano se abrevia como SGBD (“Sistema de gestión de bases de datos”) y en inglés abreviado como DBMS (“Data Base Manager System”) o “Sistema manejador de bases de datos” es un software que permite la creación, uso y administración de una base de datos. Dependiendo de la fuente se usa la palabra “gestor” o “administrador”.

Algunas definiciones de otras fuentes:

Silberschatz y colaboradores indican: “Un sistema de gestión de bases de datos consiste en una colección de datos interrelacionados y un conjunto de programas para acceder a dichos datos. La colección de datos, normalmente denominada base de datos, contiene información de una empresa particular.” Notar que la declaración anterior incluye en su concepto a los datos almacenados (base de datos).

En Wikipedia: “Los sistemas de gestión de base de datos son un tipo de software muy específico, dedicado a servir de interfaz entre la base de datos, el usuario y las aplicaciones que la utilizan. Se compone de un lenguaje de definición de datos, de un lenguaje de manipulación de datos y de un lenguaje de consulta.” Notar que en la definición, la base de datos está “aparte” del DBMS y se mencionan a los usuarios y a las aplicaciones.

En adelante se usarán las iniciales DBMS por considerar que es lo más común para referirse al término.

Los componentes principales de un DBMS son:1. Un lenguaje de modelación que permita definir el esquema de cada base de datos

alojada en el DBMS.2. Las estructuras de datos (campos, registros, archivos y objetos) optimizadas para

tratar con una cantidad muy grande de datos, que se encuentran almacenados en un dispositivo de almacenamiento permanente.

3. Un lenguaje de consulta de bases de datos que permite a los usuarios consultar de manera interactiva la base de datos.

4. Un mecanismo de control de transacciones, que garantice las propiedades ACID (“Atomicidad, Consistencia, Aislamiento -“Isolation” en inglés- y Durabilidad”) de cada transacción. Esto para asegurar la integridad de los datos, controlar el acceso concurrente de usuarios y ser tolerante a fallas.

En el mercado se puede encontrar una gran variedad de software DBMS. Una clasificación importante es según el modelo de datos soportado. Los principales modelos son:

Relacional. Jerárquico. Red. Orientado a ObjetosEl temario de esta materia esta enfocado al modelo relacional de bases de datos. Y será

el modelo a usar en el libro.

1

Según el tipo de licencias, los DBMS se pueden clasificar de manera general en: Libres. Gratuitos. Comerciales.

Es importante observar que algunas veces el software libre –que una de sus características es que el usuario puede ver el código fuente- es también gratuito (por ejemplo ciertas versiones de MySQL). También estas versiones de MySQL tienen un soporte adecuado como DBMS, por lo que se convierte en un buen candidato para usar en este libro. Parece que es publicidad para este software, pero es solo un ejemplo y existen otros casos similares.

También es importante notar que empresas que tienen DBMS comerciales, cuentan con versiones gratuitas, por ejemplo:

La empresa Oracle, tiene disponible para descarga y uso gratuito la versión “Oracle Database 10g Express Edition”. Ver la página de Oracle: http://www.oracle.com/technology/software/products/database/xe/index.html para detalles.

La empresa Microsoft tiene la versión gratuita del DBMS “Microsoft SQL Server 2005 Express Edition”. Para detalles ver la página: http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=220549b5-0b07-4448-8848-dcc397514b41

Para detalles de las limitaciones de cada licencia de uso revisar los sitios oficiales.

En el tema que sigue se mencionan las características generales que debe cumplir un buen DBMS y se incluyen un ejemplo de características técnicas de un DBMS.

1.1 Características del gestor.

Los DBMS deben poseer algunas características generales que garantizan su funcionamiento adecuado y eficiente. Por ejemplo, algunos de los “módulos” o características que debe de proveer cualquier DBMS serían:

El lenguaje de modelación, llamado comúnmente LDD (“Lenguaje de definición de datos”). Como su nombre lo indica, permite a los usuarios crear los esquemas de las bases de datos. Algunas de las operaciones particulares: creación de bases de datos, tablas, índices, vistas, procedimientos almacenados, disparadores, etc.

El lenguaje de consulta de la base de datos, conocido como LMD (“Lenguaje de manipulación de datos”). Que en el caso del modelo relacional el lenguaje SQL (“Structured Query Language”), es de los más usados. El LMD permite hacer consultas en la base de datos y realizar edición de los datos (altas, bajas y cambios).

Módulo para la administración de la base de datos, que debe permitir a los administradores de la base de datos operaciones tales como: crear y editar

2

http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=220549b5-0b07-4448-8848-dcc397514b41

http://www.microsoft.com/downloads/details.aspx?displaylang=es&FamilyID=220549b5-0b07-4448-8848-dcc397514b41

http://www.oracle.com/technology/software/products/database/xe/index.html

usuarios y permisos, respaldos y recuperación de la información, optimizar el funcionamiento de la base de datos, entre otros.

Módulo de control de transacciones, que es transparente al usuario. Garantiza la correcta ejecución de las transacciones, y esta relacionado con el control de la concurrencia y tolerancia a fallas.

Una interfaz gráfica de usuario. Que permite a los administradores y usuarios interactuar con el sistema de manera más sencilla y eficiente.

Opciones de respaldo y recuperación de datos.

Interfaces de programación de aplicaciones para diferentes lenguajes (API).

Conectores de base de datos para diferentes plataformas de desarrollo (ejemplo: ODBC, JDBC, .NET).

Algunos DBMS tienen características adicionales, entre ellas puede mencionarse:

Por ejemplo, el MySQL en su versión comercial incluye el: “MySQL Network Monitoring and Advisory Service”. Este proporciona información concentrada de todos los servidores MySQL en una red, la información proporcionada incluye por ejemplo: estado de los servidores, uso de recursos (CPU, RAM, Entrada/Salida), alertas y advertencias producidas, entre otros. Ver ejemplo en la Figura 1.Información de "MySQL Network Monitoring".

Figura 1. Información de "MySQL Network Monitoring".

Por otro lado se deben tomar en cuenta las características particulares del DBMS seleccionado. Para esto, la pregunta siempre es: ¿Cuál DBMS debo seleccionar para esta aplicación?

No existe una respuesta sencilla a la pregunta anterior, cada DBMS tiene fortalezas y debilidades. No existe una respuesta absoluta: “El DBMS XX es el mejor”. Depende de

3

muchos factores: costos (del software, entrenamiento, mantenimiento, soporte), necesidades particulares de la aplicación, rendimiento, robustez, entre otras. Una buena noticia es que se tienen versiones gratuitas de MySQL, y de empresas que antes solo manejaban software comercial tales como el SQL Server Express Edition (de Microsoft) y Oracle Database Express Edition (de la empresa Oracle).

Como en este libro se utilizará en su mayor parte el DBMS MySQL, se describen aquí las características de dicho software.

Características generales de MySQL.MySQL es un software de marca registrada de la empresa MySQL AB. Es un DBMS

relacional, tiene SQL (Structured Query Language) como lenguaje de definición y manipulación de datos. Es rápido, multi-hilos, multiusuario y robusto. Está diseñado para entornos de producción críticos, con alta carga de trabajo y puede integrarse en software para trabajar en ambientes distribuidos.

El software MySQL tiene doble licencia. Por un lado se puede usar como producto “Open source” mediante la licencia GNU (“General Public License”). Y por otro lado puede adquirirse una licencia comercial estándar de MySQL AB. El software con la licencia comercial tiene facilidades adicionales.

Características particulares de MySQL.De la página http://dev.mysql.com/doc/refman/5.0/es/features.html se toman las

características más particulares del DBMS MySQL 5.0, que se listan a continuación:

Interioridades y portabilidad

Escrito en C y en C++ Probado con un amplio rango de compiladores diferentes Funciona en diferentes plataformas. Usa GNU Automake, Autoconf, y Libtool para portabilidad. APIs disponibles para C, C++, Eiffel, Java, Perl, PHP, Python, Ruby, y Tcl. Uso completo de multi-threaded mediante threads del kernel. Pueden usarse

fácilmente múltiples CPUs si están disponibles. Proporciona sistemas de almacenamiento transaccionales y no transaccionales. Usa tablas en disco B-tree (MyISAM) muy rápidas con compresión de índice. Relativamente sencillo de añadir otro sistema de almacenamiento. Esto es útil

si desea añadir una interfaz SQL para una base de datos propia. Un sistema de reserva de memoria muy rápido basado en threads. Joins muy rápidos usando un multi-join de un paso optimizado. Tablas hash en memoria, que son usadas como tablas temporales. Las funciones SQL están implementadas usando una librería altamente

optimizada y deben ser tan rápidas como sea posible. Normalmente no hay reserva de memoria tras toda la inicialización para consultas.

El código MySQL se prueba con Purify (un detector de memoria perdida comercial) así como con Valgrind, una herramienta GPL (http://developer.kde.org/~sewardj/).

El servidor está disponible como un programa separado para usar en un entorno de red cliente/servidor. También está disponible como biblioteca y

4

http://dev.mysql.com/doc/refman/5.0/es/features.html

puede ser incrustado en aplicaciones autónomas. Dichas aplicaciones pueden usarse por sí mismas o en entornos donde no hay red disponible.

Tipos de columnas Diversos tipos de columnas: enteros con/sin signo de 1, 2, 3, 4, y 8 bytes de

longitud, FLOAT, DOUBLE, CHAR, VARCHAR, TEXT, BLOB, DATE, TIME, DATETIME, TIMESTAMP, YEAR, SET, ENUM, y tipos espaciales OpenGIS..

Registros de longitud fija y longitud variable. Sentencias y funciones

Soporte completo para operadores y funciones en las cláusulas de consultas SELECT y WHERE. Por ejemplo:

mysql> SELECT CONCAT(first_name, ' ', last_name) -> FROM citizen -> WHERE income/dependents > 10000 AND age > 30; Soporte completo para las cláusulas SQL GROUP BY y ORDER BY. Soporte

de funciones de agrupación (COUNT(), COUNT(DISTINCT ...), AVG(), STD(), SUM(), MAX(), MIN(), y GROUP_CONCAT()).

Soporte para LEFT OUTER JOIN y RIGHT OUTER JOIN cumpliendo estándares de sintaxis SQL y ODBC.

Soporte para alias en tablas y columnas como lo requiere el estándar SQL. DELETE, INSERT, REPLACE, y UPDATE devuelven el número de filas que

han cambiado (han sido afectadas). Es posible devolver el número de filas que serían afectadas usando un indicador al conectar con el servidor.

El comando específico de MySQL SHOW puede usarse para obtener información acerca de la base de datos, el motor de base de datos, tablas e índices. El comando EXPLAIN puede usarse para determinar cómo el optimizador resuelve una consulta.

Los nombres de funciones no colisionan con los nombres de tabla o columna. Por ejemplo, ABS es un nombre válido de columna. La única restricción es que para una llamada a una función, no se permiten espacios entre el nombre de función y el '(' a continuación.

Puede mezclar tablas de distintas bases de datos en la misma consulta (como en MySQL 3.22).

Seguridad Un sistema de privilegios y contraseñas que es muy flexible y seguro, y que

permite verificación basada en el host. Las contraseñas son seguras porque todo el tráfico de contraseñas está encriptado cuando se conecta con un servidor.

Escalabilidad y límites Soporte a grandes bases de datos. Usamos MySQL Server con bases de datos

que contienen 50 millones de registros. También conocemos a usuarios que usan MySQL Server con 60.000 tablas y cerca de 5.000.000.000.000 de registros.

Se permiten hasta 64 índices por tabla (32 antes de MySQL 4.1.2). Cada índice puede consistir desde 1 hasta 16 columnas o partes de columnas. El máximo ancho de límite son 1000 bytes (500 antes de MySQL 4.1.2).Un índice puede usar prefijos de una columna para los tipos de columna CHAR, VARCHAR, BLOB, o TEXT.

Conectividad

5

Los clientes pueden conectar con el servidor MySQL usando sockets TCP/IP en cualquier plataforma. En sistemas Windows de la familia NT (NT,2000,XP, o 2003), los clientes pueden usar named pipes para la conexión. En sistemas Unix, los clientes pueden conectar usando ficheros socket Unix.

En MySQL 5.0, los servidores Windows soportan conexiones con memoria compartida si se inicializan con la opción --shared-memory. Los clientes pueden conectar a través de memoria compartida usando la opción --protocol=memory.

La interfaz para el conector ODBC (MyODBC) proporciona a MySQL soporte para programas clientes que usen conexiones ODBC (Open Database Connectivity). Por ejemplo, puede usar MS Access para conectar al servidor MySQL. Los clientes pueden ejecutarse en Windows o Unix. El código fuente de MyODBC está disponible. Todas las funciones para ODBC 2.5 están soportadas, así como muchas otras.

La interfaz para el conector J MySQL proporciona soporte para clientes Java que usen conexiones JDBC. Estos clientes pueden ejecutarse en Windows o Unix. El código fuente para el conector J está disponible.

Localización El servidor puede proporcionar mensajes de error a los clientes en muchos

idomas. Soporte completo para distintos conjuntos de caracteres, incluyendo latin1

(ISO-8859-1), german, big5, ujis, y más. Por ejemplo, los caracteres escandinavos 'â', 'ä' y 'ö' están permitidos en nombres de tablas y columnas. El soporte para Unicode está disponible

Todos los datos se guardan en el conjunto de caracteres elegido. Todas las comparaciones para columnas normales de cadenas de caracteres son case-insensitive.

La ordenación se realiza acorde al conjunto de caracteres elegido (usando colación Sueca por defecto). Es posible cambiarla cuando arranca el servidor MySQL. Para ver un ejemplo de ordenación muy avanzada, consulte el código Checo de ordenación. MySQL Server soporta diferentes conjuntos de caracteres que deben ser especificados en tiempo de compilación y de ejecución.

Clientes y herramientas MySQL server tiene soporte para comandos SQL para chequear, optimizar, y

reparar tablas. Estos comandos están disponibles a través de la línea de comandos y el cliente mysqlcheck. MySQL también incluye myisamchk, una utilidad de línea de comandos muy rápida para efectuar estas operaciones en tablas MyISAM.

Todos los programas MySQL pueden invocarse con las opciones --help o -? para obtener asistencia en línea.

Como resumen, todos los DBMS relacionales proporcionan características funcionales similares. Pero es útil la revisión de las características técnicas detalladas, ya que estas pueden inclinar hacia la elección de cierto DBMS en caso de necesidades muy particulares de la aplicación. Por ejemplo, puede ser que una prioridad de la aplicación sea la rapidez de las operaciones y aquí se puede elegir un DBMS que tenga esa fortaleza.

Además de las características generales de los DBMS, estos proporcionan herramientas adicionales que se tratan en el tema que sigue.

6

1.2 Herramientas.

Además del soporte básico de un DBMS relacional, los DBMS proporcionan un conjunto de herramientas que facilitan su uso. Es interesante ver la evolución de los DBMS en cuanto a características técnicas, eficiencia y opciones “extras” que se ofrecen con el objeto de ser el líder del mercado. Por mencionar algunos ejemplos, la disponibilidad de versiones gratuitas de DBMS por empresas que antes solo manejaban software comercial, interfases de usuario muy elegantes y en Web, opciones para que el administrador defina “motores de almacenamiento”, facilidad de instalación y configuración del DBMS usando asistentes y disponibilidad de información en Web, entre otros.

En este tema se mencionan algunas herramientas generales de los DBMS, pero que deben estar siempre presentes, y que son las siguientes:

Creación y edición de la base de datos. De administración. Facilidades para crear y ejecutar consultas. De control, monitoreo y estadísticas de acceso a la base de datos. Utilerías diversas.

Para ejemplificar la parte práctica de las herramientas, se utilizará el MySQL versión 5.0 en su versión gratuita, instalado en un equipo con sistema operativo Microsoft Windows XP Profesional.

1.2.1 De creación de bases de datos.

Se refiere a las facilidades de los DBMS para crear las bases de datos. Se sabe que para llegar a este punto, se tiene que tener un diseño previo de la base de datos. En este aspecto es útil contar con herramientas de ayuda integradas al DBMS, por ejemplo, la opción para crear diagramas de la base de datos (opción que la he visto en SQL Server Express). Del software que he revisado, pienso que MySQL y SQL Server Express tienen una interfase muy sencilla y amigable para la creación de las bases de datos.

Enseguida se explica como crear una nueva base de datos, mediante el DBMS MySQL:

En MySQL para crear una base de datos realizar los pasos que se indican enseguida. También se puede realizar desde la línea de comandos. Se asume que ya está instalado el software, para ver el proceso de instalación, leer el tema 1.3.

1. Abrir el programa “MySQL Query Browser”, en la ruta: Inicio | Todos los programas | MySQL | MySQL Query Browser. Tal como se indica en la Figura 2. Ruta de accesoal "MySQL Query Browser".

7

Figura 2. Ruta de acceso al "MySQL Query Browser".

2. Indicar los datos necesarios para la conexión al servidor MySQL. Tal como se muestra en la Figura 3. Datos para ingreso al "MySQL Query Browser".

Figura 3. Datos para ingreso al "MySQL Query Browser".

Nota: los datos proporcionados arriba dependen de los datos escritos por el usuario al instalar el software y las bases de datos existentes.

3. Cuando se abre el “QueryBrowser”, se muestra una imagen como la mostrada en la Figura 4. Base de datos y objetos en "MySQL Query Browser".

8

Figura 4. Base de datos y objetos en "MySQL Query Browser".

4. Una vez abierto el “Query Browser”, para crear una nueva base de datos, se presiona el botón derecho del “mouse” sobre cualquier base de datos (al menos están las del sistema) y en el menú contextual que aparece se selecciona la opción “Create New Schema” (ver Figura 5. Crear base de datos ("Schema") en "MySQL QueryBrowser"). Esta opción creará una nueva base de datos vacía con el nombre indicado por el usuario.

Figura 5. Crear base de datos ("Schema") en "MySQL Query Browser".

9

A partir de aquí se pueden agregar objetos a la nueva base de datos. El usuario solo tendrá que seleccionar la base de datos, presionar el botón derecho del “mouse” y seleccionar el nuevo tipo de objeto a agregar. Se abre el mismo diálogo que se mostró en la Figura 5. Crear base de datos ("Schema") en "MySQL Query Browser".

1.2.2 De administración de bases de datos.

Aquí se incluyen las facilidades que proporciona el DBMS para que el administrador de la de la base de datos (BDA) pueda realizar sus tareas. Las tareas de administración son muy amplias e incluyen aspectos como los siguientes (mencionados por Silberschatz y colaboradores):

Definir el esquema o estructura general de la base de datos. Definir la estructura de almacenamiento y los métodos de acceso. Modificar el esquema y la organización física, con objeto de hacer mas eficiente el

acceso a los datos (por ejemplo, agregar índices, modificar el “motor de almacenamiento”).

Crear usuarios, permisos y roles. De esta manera concede autorización para el acceso a los datos. Aspecto que tiene que ver con la seguridad.

Especificar las reglas de integridad para la base de datos (responsabilidad compartida con los desarrolladores de aplicaciones).

Además de las tareas mencionadas, los administradores de la base de datos realizan otras tareas propias de su función:

Realizar respaldos y recuperación de la base de datos. Asegurar la disponibilidad de la base de datos. Ser un experto en “bases de datos”, ya que los desarrolladores de aplicaciones y los

usuarios en general acudirán a el, para cualquier problema con la base de datos. Instalación y configuración de nuevos componentes de software del DBMS. Interacción y coordinación con el administrador del sistema. Prevención de riesgos. Apoyar en la definición de estándares de diseño y nomenclatura de objetos. Documentar y llevar registros periódicos de mantenimientos, actualizaciones, y

cambios en las aplicaciones.

En este punto como en todos los tratados se debe evaluar las facilidades que otorga el DBMS para el administrador de la base de datos.

Por ejemplo el MySQL incluye aparte del núcleo del DBMS un software adicional para su administración, llamado “MySQL Administrator” que se descarga aparte del DBMS y se debe instalar después de este. Este software incluye el “Query Browser” y todo el software adicional de apoyo para la administración. Las opciones que proporciona el MySQL Administrator” se muestran en la Figura 6. Pantalla de información del servidor deMySQL.

10

Figura 6. Pantalla de información del servidor de MySQL.

Las opciones del lado izquierdo de la Figura 6. Pantalla de información del servidor deMySQ, son para la administración. Se menciona enseguida cada una de ellas y para que sirve:

“Server Information”. Proporciona información general del servidor (que se despliega del lado derecho y muestra datos de la instancia del servidor (nombre de usuario, nombre del servidor MySQL y el puerto para la conexión), información del servidor y del cliente que está conectado.

“Service Control”. Permite iniciar y detener el servicio de MySQL y configurar el servicio. “Startup Variables”. Permite ver y configurar los valores de las variables del servidor

MySQL, por ejemplo: el puerto TCP, directorios de datos, uso de la memoria, la forma de almacenamiento, uso de archivos para bitácoras, replicación y seguridad, entre otras. Estas variables pueden influir grandemente en la eficiencia del servidor de la base de datos.

“User Administration”. Permite crear los usuarios y otorgarles permisos sobre los objetos de las bases de datos.

“Server Connections”. Proporciona información sobre los usuarios conectados al servidor. “Health”. Proporciona información gráfica sobre los recursos usados en el servidor, tales

como uso de conexiones, tráfico, número de consultas, uso de memoria, entre otras. También muestra los valores actuales de las variables generales del sistema.

“Server Logs”. Muestra las bitácoras del servidor. Estas tienen que ser definidas en la opción “Startup Variables”.

11

“Replication Status”. Se muestra información sobre el estado de los datos que se han declarado para replicación (repetición). La replicación debe configurarse antes en la opción de “Startup Variables”.

“Backup”. Permite realizar respaldos de las bases de datos. Da facilidad para programar de manera periódica los respaldos y que se ejecuten de manera automática.

“Restore”. Permite recuperar los datos que se han respaldado previamente. “Catalogs”. Permite administrar cada base de datos, permitiendo tareas como: crear,

editar y dar mantenimiento a tablas, actualizar índices, y administrar vistas y procedimientos almacenados.

Otras opciones del “MySQL Administrador” se pueden acceder mediante el menú principal, opción “Tools”. Como se muestra en la Figura 7. Menú "Tools" de "MySQLAdministrator".

Figura 7. Menú "Tools" de "MySQL Administrator".

En el caso del DBMS “Microsoft SQL Server Management Studio Express”, las opciones generales de administración se muestran en la Figura 8. Opciones deadministración en “Microsoft SQL Server Management Studio Express”.

12

Figura 8. Opciones de administración en “Microsoft SQL Server Management Studio Express”.

En la Figura 8. Opciones de administración en “Microsoft SQL ServerManagement Studio Express” se abrió una tabla, que se puede editar también directamente desde el ambiente visual. Observar las opciones generales de administración que incluyen:

Administración de las bases de datos. Seguridad. Que incluye la creación de usuarios y permisos, roles de servidor y

credenciales. Objetos de servidor (“Server objects”). Que incluye facilidades para realizar y

programar respaldos, relacionar con otros servidores y definir disparadores de servidor.

Facilidades de replicación. La opción de administración general (“Management”). Que permite administrar las

bitácoras e incluye el monitor de actividades en el servidor.

Por otro lado la versión gratuita de Oracle (Oracle Database 10g Express Edition) esta contenida en un solo archivo de 206 MB en su versión para Windows. Presenta una interfase elegante en Web y presenta opciones interesantes para la administración. Ver Figura 9. Opciones de administración de "Oracle Database Express Edition" donde se muestra la pantalla principal.

13

Figura 9. Opciones de administración de "Oracle Database Express Edition".

Se muestran las opciones generales de la Administración. Cada opción tiene a su vez otras opciones. Incluye la sección de enlaces y muestra a la vista el “Monitor de Uso”. En mi opinión personal es la interfase más elegante de las tres que se han mostrado, permite también personalizar el ambiente de trabajo.

La pantalla principal muestra 4 opciones generales, cada una representada por un icono. A continuación se describe de manera general cada opción:

Administración. Administrar cuentas de usuarios, administrar memoria, almacenamiento y conexiones de red, monitorear la actividad de la base de datos y ver la información de configuración.

Visor de Objetos. Ver, crear, modificar, explorar, y borrar objetos de base de datos. Usar el editor PL/SQL para editar y compilar paquetes, procedimientos, funciones, y disparadores usando como ayuda el reporte de errores.

SQL. Accede a las siguientes herramientas SQL:o Comandos SQL. Ejecuta comandos SQL y bloques anónimos de PL/SQL. Ejecuta

scripts y consultas almacenadas.o Archivos de comandos SQL. Crear, editar, ver, ejecutar, y borrar archivos de

scripts. Subir y descargar scripts del sistema de archivos local.

14

o Generador de consultas. Con poco o ningún conocimiento de SQL, construir consultas SQL usando una interfase gráfica de usuario. Ver el resultado de consultas creadas y guardar las consultas.

Utilidades. Cargar y descargar datos, generar archivos DDL, ver reportes de objetos, y restaurar objetos de base de datos borrados.

1.2.3 De edición para crear esquemas y consultas de bases de datos.

Esta parte se refiere a las facilidades otorgadas por el DBMS para crear los objetos de la base de datos (tales como tablas, vistas, procedimientos, etc.) y las facilidades para consultar y manipular dichos objetos.

En este punto, tienen una gran ventaja los DBMS que mediante una interfase gráfica de usuario, permiten dichas actividades.

Enseguida se ejemplifica la manera de crear las tablas y consultarlas, mediante MySQL.

Como se mencionó antes, para crear esquemas (bases de datos) y escribir y ejecutar consultas se puede usar el “MySQL Query Browser” o la línea de comandos (para MySQL), pero la primer opción es más amigable y sencilla.

Por ejemplo, enseguida se muestra un ejemplo para crear una tabla. Para crear una tabla en MySQL, primero se abre el “MySQL Query Browser”, después se selecciona la base de datos donde residirá la tabla. Se hace clic con el botón derecho del “mouse” en la base de datos y en el menú contextual que aparece se hace un clic en la opción “Create New Table” (Crear nueva tabla), en ese momento aparece el editor de tablas de MySQL que se muestra en la Figura 10. Crear una tabla con "MySQL Table Editor".

Figura 10. Crear una tabla con "MySQL Table Editor".

15

El “MySQL Table Editor” permite agregar y modificar las tablas de la base de datos. Es decir, se puede modificar la estructura de una tabla ya creada, solo tomar en cuenta las relaciones que se hayan establecido entre ellas. En la Figura 10. Crear una tabla con"MySQL Table Editor" se indican las opciones principales: nombre de la tabla, la base de datos dónde se almacenará dicha tabla, la información de los campos, las llaves primarias y foráneas, y los índices. Observar que existen opciones más particulares que se pueden usar.

Una vez creadas las tablas de la base de datos y establecidas las relaciones entre ellas, se pueden editar los datos. El mismo “Query Browser” permite editar (altas, bajas y cambios) el contenido de las tablas. Para esto se selecciona la tabla a editar, y se hace doble clic sobre ella, de esta manera se abre la tabla para poder editar sus datos. Ver Figura 11.Editar datos de una tabla con "MySQL Query Browser".

Figura 11. Editar datos de una tabla con "MySQL Query Browser".

Por otra parte para realizar las consultas, se realiza un procedimiento similar al anterior, se selecciona y abre la tabla con doble clic. Si la consulta involucra a varias tablas, vistas, etc., no hay problema, se puede abrir cualquier tabla y la consulta SQL puede involucrar a otras tablas o vistas.

Observar en la Figura 11. Editar datos de una tabla con "MySQL Query Browser", que en la parte superior se abre una ventana que contiene una consulta SQL, esta consulta se puede modificar directamente en esta ventana y ejecutarse. El resultado de la ejecución se mostrará en la parte donde se despliegan los datos de la tabla. Ver Figura 12. Consultacon "MySQL Query Browser".

16

Figura 12. Consulta con "MySQL Query Browser".

Observar de la Figura 12. Consulta con "MySQL Query Browser", que en primer lugar (número 1.) se debe escribir la consulta. Si se requiere una tabla de otra base de datos se debe anteponer el nombre de la base de datos, un punto y después el nombre de la tabla. En este caso no se incluye la base de datos, pues se trabaja con la base de datos actual. En las aplicaciones o programas será muy conveniente siempre incluir el nombre de la base de datos para evitar un error. Como segundo paso (número 2.) se ejecuta la consulta haciendo clic en el botón “Execute”. Como resultado de la ejecución, el sistema mostrará el resultado de la consulta (número 3.).

1.2.4 De control, monitoreo y estadísticas de acceso a bases de datos.

Estas son opciones relacionadas y la información la debe proporcionar el DBMS. Las facilidades mencionadas en este punto, son una base fundamental para las tareas y responsabilidades que debe realizar el DBA.

Por ejemplo, hablando del tema del control, el tema de roles que se desarrolla más adelante, proporciona un mecanismo eficiente de control de los usuarios y la seguridad, sin embargo no todos los DBMS gratuitos mencionados en el libro los soportan.

También dentro del tema del control, es posible limitar el acceso y operaciones en la base de datos a ciertos horarios, por ejemplo, solo dentro del horario de trabajo de la gente. Limitar los accesos remotos. Identificar las computadoras desde las cuales se puede acceder al sistema y que solo desde ellas se pueda acceder. Limitar el número de accesos concurrentes de un mismo usuario, etc. Los DBMS proporcionan características de control de acceso que es conveniente revisar.

Mencionando el monitoreo, son deseables las siguientes facilidades: Poder ver en el mismo sistema a los usuarios que están conectados a la base de datos y

las tareas que se encuentran realizando y los recursos que están usando. Tener una información resumida de los recursos del sistema que se están usando

actualmente y los que se han usado históricamente.

17

Detectar operaciones que son comunes y que se pueden optimizar para un mejor rendimiento del sistema en general.

Detectar operaciones “costosas” en cuanto a recursos. Si es una base de datos distribuida, poder revisar los accesos remotos y locales y sus

implicaciones en la eficiencia y diseño de la base de datos.

Un ejemplo de herramienta de monitoreo es el “MySQL Network Monitoring”, que concentra la información de servidores de MySQL en una red.

Oracle cuenta con el “Monitor de uso”, que proporciona información sobre el uso del almacenamiento permanente, de memoria, las sesiones, los usuarios, y sobre los archivos de bitácora. Se puede mostrar información de detalle de cada uno de ellos.

Por otra parte, en cuanto a las estadísticas de acceso a la base de datos, es información que debe ser recopilada por el DBMS durante la operación del sistema. Esta información es importante para que el BDA pueda tomar acciones encaminadas a un mejor rendimiento del sistema. Por ejemplo, mediante las estadísticas se puede detectar una consulta muy frecuente y que no puede usar índices, de esta manera el BDA puede crear los índices necesarios que hagan más eficiente la consulta. Mediante las estadísticas se puede detectar también horas de uso menos concurridas, donde tal vez sea conveniente realizar tareas de mantenimiento y respaldos de información.

En las estadísticas se pueden tener diferencias importantes sobre la información proporcionada por cada DBMS.

Las diferentes bitácoras del DBMS sirven de base para obtener esta información. Por ejemplo por medio de las bitácoras se puede obtener información como la siguiente:

Que usuario accedió a que datos, operaciones realizadas, fecha y hora. De dónde se conecto el usuario.

Sentencias que cambian datos o pudieron haberlo hecho. Errores y advertencias del sistema. Consultas que se ejecutaron sobrepasando un tiempo límite establecido. O consultas que

no utilizaron índices.

De lo anterior, el DBMS genera información para que el DBA pueda llevar un mejor control de la base de datos, al conocer exactamente los usuarios que se están conectando y las operaciones realizadas.

De la información de las bitácoras el DBMS puede generar información resumida o estadísticas que den una visión panorámica del uso de la base de datos y los recursos del sistema utilizados.

Por ejemplo Oracle en la opción de estadísticas (se accede por la ruta: “Administración | Controlar | Estadísticas del sistema”), se muestra la información de la Figura 13.Estadísticas del sistema en Oracle.

18

Figura 13. Estadísticas del sistema en Oracle.

Después de revisar el tema de control, monitoreo y estadísticas, se tratará enseguida el tema de las utilerías diversas.

1.2.5 Utilerías diversas.

Dentro de utilerías diversas se deberían considerar opciones adicionales que no se han mencionado en los temas anteriores (del 1.2.1. al 1.2.4.). Es una clasificación algo arbitraria, pues la mayoría de las utilerías diversas son apoyos adicionales para la administración del DBMS, aunque existen utilerías de apoyo a los desarrolladores y usuarios en general.

Por mencionar algunas “utilerías diversas”, se pueden incluir:

El “MySQL Network Monitoring and Advisory Service” de MySQL, descrito antes. Replicación de la base de datos. Facilidades gráficas para establecer el diseño de la base de datos (relaciones entre

tablas, definición y manejo de llaves foráneas, cardinalidades). Por ejemplo, esta opción esta incluida en SQL Server Express y Access.

Facilidades para automatizar tareas (por ejemplo, que los respaldos se hagan de manera automática). Facilidad que he visto en MySQL y SQL Server.

El “MySQL Migration Toolkit”, herramienta gráfica para migrar esquemas y datos de otros sistemas relacionales a MySQL. Presente en la versión comercial, y solo en ambiente Microsoft Windows (al momento de escribir esto).

El “MySQL Workbench”, es una aplicación gráfica para el diseño del esquema de la base de datos. Permite de manera gráfica diseñar y modificar tablas y otros objetos de la base

19

de datos, y de manera automática el diseño es implementado en MySQL. Es un software en versión beta.

En la versión gratuita de Oracle, la opción de “Utilidades” tiene las opciones mostradas en la Figura 14. Opción "Utilidades" en Oracle.

Figura 14. Opción "Utilidades" en Oracle.

Observar las cuatro opciones de “Utilidades”. En este caso se muestran las opciones de “Carga/Descarga de Datos”.

Oracle, en sus versiones comerciales cuenta con otras utilerías de apoyo a los administradores, desarrolladores y usuarios en general. Aunque algunas son verdaderas aplicaciones de uso muy particular y que pueden ser comercializadas como algo extra al núcleo del DBMS. Algunas de ellas (mencionadas por Burbano) son:

“Enterprice Resource Planning (ERP)”. Enfocada a finanzas, proyectos, recursos humanos, nominas, distribución y manufactura.

“Customer Relationship Management (CRM)”. Se usa en ventas, servicio, mercadotecnia, y “Call Centers”.

“Supply Chain Management (SCM)”. Administración de la cadena de suministro, desarrollo y planeación.

“Business Inteligence”. Inteligencia Operativa, Portal ejecutivo. “Oracle Developer”. Diseñador de formularios, gráficos, reportes. Incluye el “JDeveloper”

para usar Java. “Oracle Designer”. Herramienta CASE. “Oracle WareHouseBuilder”. Para aplicaciones de “Warehouse” o almacenes de datos. “Oracle Enterprice Manager (OEM)”. Aplicación gráfica que usan los administradores para

manejar las instancias de Oracle. “Oracle Data Mining (ODM)”. Para aplicaciones de minería de datos.

Las “utilerías diversas” pueden llegar a ser un aspecto que determine la adopción de un DBMS particular. Especialmente cuando se tiene una necesidad muy específica de la aplicación. Por ejemplo, cuando la aplicación requerirá manejar almacenes de datos (data warehouse) o minería de datos. Normalmente este tipo de utilerías se comercializan aparte

20

del núcleo del DBMS. Tome también en cuenta el lector, la disponibilidad actual de herramientas gratuitas para este tipo de requerimientos.

1.3 Instalación y configuración del entorno operativo.

Este tema se refiere a la instalación y configuración del DBMS y los aspectos relacionados con el sistema operativo, el ambiente de red, servidores, ambiente Web, y en general de todo el entorno que tiene que ver con el funcionamiento del DBMS.

Una arquitectura típica puede ser el tener un servidor dedicado de base de datos (si la aplicación lo requiere), un servidor de Web, un servidor Proxy, y los clientes locales y remotos que accederán a la aplicación.

El procedimiento de instalación y la configuración del entorno operativo varia mucho dependiendo del DBMS seleccionado, el sistema operativo, el ambiente de red, y el uso particular que se le dará al DBMS.

Una característica deseable, es que el DBMS permita que el administrador indique opciones transcendentes sobre la instalación y configuración, y permita hacer los ajustes necesarios durante la operación del sistema. Por ejemplo, en MySQL durante la instalación se puede seleccionar el “motor de almacenamiento”, que tendrá impacto en el rendimiento del sistema.

Como experiencia, cuando se instala el MySQL permite al usuario indicar muchas opciones sobre la instalación, por ejemplo: el número de conexiones esperadas, la “máquina o motor de almacenamiento”, la manera de iniciar el servidor, entre otras. Cuando se instala el SQL Server (hablando de versiones gratuitas), solo permite al usuario indicar opciones mínimas de instalación. En el caso de la versión gratuita de Oracle, solo solicita al usuario la contraseña del usuario “SYS” y “SYSTEM” que es el administrador y la ubicación en disco de la instalación, Oracle como novedad incluye una interfase Web para la administración. Es importante notar que aunque en la instalación de Oracle se solicitan pocos datos, el administrador podrá configurar el DBMS mediante la interfase.

Una ventaja de los DBMS como Oracle y MySQL es que se tienen versiones para los principales sistemas operativos (Windows y Linux), mientras que SQL Server solo funciona en el sistema operativo Windows.

Algunos aspectos generales que deben considerarse sobre la instalación y configuración del entorno operativo serían:

Verificar las restricciones de licenciamiento del DBMS. Por ejemplo, La versión gratuita de Oracle esta limitada a usarse en computadoras con un solo CPU.

Tener permisos de administrador en la computadora donde se instalará el DBMS. Considerar los requisitos de hardware y software del DBMS a instalar. Por ejemplo SQL

Server solo se puede instalar en el sistema operativo Windows. Considerar si es una instalación definitiva en una computadora que funcionará como

servidor de la base de datos, o en una instalación de prueba.

21

Tener definidos previamente los aspectos generales de seguridad del DBMS. Por ejemplo nombre y contraseña del usuario administrador, la ubicación física de los programas y datos del DBMS.

Tener definidos previamente aspectos generales de la configuración del DBMS. Por ejemplo, la estimación de los usuarios que se conectarán de manera simultánea, y el tipo de almacenamiento (MySQL da esta opción).

Aspectos de configuración de la computadora que funcionará como servidor de la base de datos, por ejemplo:

o La seguridad del servidor (física, permisos de acceso al servidor, seguridad en la red, proxys y “firewall”, entre otros).

o Software antivirus y antiespía (en general protección contra software malicioso “malware”) en el servidor.

o Recursos del servidor que se destinarán para uso del DBMS. Tener en cuenta los aspectos relacionados a la red. Por ejemplo, el número de puerto que

se usará para la conexión, la capacidad de transmisión de datos en la red local, si habrá accesos remotos a la base de datos, y los aspectos de seguridad en la red.

Para ejemplificar la instalación del DBMS es mas ilustrativo detallarla para MySQL. Se muestra la instalación y configuración del MySQL 5.0 (DBMS y herramientas visuales) en una computadora con sistema operativo Microsoft Windows XP Profesional para arquitectura de 32 bits. Los pasos son:

1. En primer lugar se debe descargar del sitio www.mysql.com, el MySQL Server y las herramientas visuales para la administración. Para MySQL 5.0 se descargaron los archivos que se muestran en la Figura 15. Archivos para instalar servidor y herramienta gráficapara MySQL 5.0.

Figura 15. Archivos para instalar servidor y herramienta gráfica para MySQL 5.0.

El primer archivo corresponde al DBMS y el segundo archivo contiene el ambiente visual para interactuar con el DBMS.

2. Descomprimir y ejecutar el archivo que corresponde al DBMS. Al hacer esto, se muestra la primer pantalla del asistente para la instalación, como se muestra en la Figura 16.Instalando MySQL Server 5.0., pantalla de bienvenida.

22

http://www.mysql.com/

Figura 16. Instalando MySQL Server 5.0., pantalla de bienvenida.

En la siguiente pantalla (Figura 17. Instalando MySQL Server 5.0., tipo deinstalación) el usuario debe indicar el tipo general de instalación (típica, completa o personalizada).

Figura 17. Instalando MySQL Server 5.0., tipo de instalación.

Lo más recomendable sería la opción completa “Complete”, de manera que en un futuro no sea necesario agregar software que no estaba incluido. En la pantalla mostrada en la Figura 18. Instalando MySQL Server 5.0., confirmar información, el asistente indica el tipo general de instalación seleccionado en el paso previo e indica la ubicación en disco de los archivos del DBMS.

23

Figura 18. Instalando MySQL Server 5.0., confirmar información.

Al hacer clic en el botón de instalar “Install” se instalará el DBMS. Y mostrará una pantalla que muestra el avance del proceso. Ver Figura 19. Instalando MySQL Server 5.0.,copiando archivos.

Figura 19. Instalando MySQL Server 5.0., copiando archivos.

Al terminar el proceso anterior muestra una pantalla que permite crear una cuenta de usuario en el sitio de MySQL.com. Esto es opcional y una ventaja es que se puede solicitar el envío de correo electrónico a la cuenta del usuario, con información de MySQL. Ver Figura20. Instalando MySQL Server 5.0., cuenta en MySQL.com.

24

Figura 20. Instalando MySQL Server 5.0., cuenta en MySQL.com.

En el caso de la pantalla de la Figura 20. Instalando MySQL Server 5.0., cuenta enMySQL.com., se decidió no hacer el proceso de crear una cuenta en el sitio Web de MySQL. Al presionar el botón para la siguiente pantalla (“Next”), muestra la pantalla que notifica el fin de la instalación del MySQL Server. Como se ve en la Figura 21. Instalando MySQL Server5.0., pantalla para confirmar configuración.

Figura 21. Instalando MySQL Server 5.0., pantalla para confirmar configuración.

En la pantalla de la Figura 21. Instalando MySQL Server 5.0., pantalla para confirmarconfiguración es conveniente activar la opción para configurar el DBMS MySQL (“Configure

25

the MySQL Server now”), que entre otras opciones permitirá configurar los aspectos mencionados a continuación: Generar un archivo de configuración de MySQL optimizado. Configurarlo como un servicio de Windows ejecutándose en un puerto dedicado. Asignar la contraseña para el usuario administrador.

Al hacer clic en el botón de terminar (“Finish”), aparecerán las pantallas para la configuración del DBMS.

3. Configuración del DBMS MySQL mediante el asistente. Proporcionar la información adecuada según el tipo de instalación deseada.

La primer pantalla del asistente de configuración se muestra en la Figura 22.Configurando MySQL Server 5.0., pantalla de bienvenida.

Figura 22. Configurando MySQL Server 5.0., pantalla de bienvenida.

En la pantalla que sigue (ver Figura 23. Configurando MySQL Server 5.0.,seleccionar tipo de configuración) se debe indicar si la instalación será detallada (dada por el usuario) o si será una instalación estándar (usa una configuración de propósito general), que posteriormente podrá ser modificada por el administrador.

26

Figura 23. Configurando MySQL Server 5.0., seleccionar tipo de configuración.

Se seleccionó la primer opción “Detailed Configuration”, para analizar las opciones de configuración disponibles. Después de seleccionar la opción indicada y presionar el botón de siguiente (“Next”), aparece la pantalla mostrada en la Figura 24. Configurando MySQLServer 5.0., seleccionar tipo de servidor.

Figura 24. Configurando MySQL Server 5.0., seleccionar tipo de servidor.

27

Las opciones de la pantalla de la Figura 24. Configurando MySQL Server 5.0., seleccionartipo de servidor son:

“Developer Machine”. Adecuada para una computadora que ejecutará muchas otras aplicaciones. Se asignará una cantidad baja de memoria para el MySQL. Recomedada para una computadora de “usuario”, que usará MySQL como prueba o desarrollo de aplicaciones.

“Server Machine”. Adecuada para una computadora dedicada como servidor de base de datos y que ejecuta otras aplicaciones de servidor. MySQL usará una cantidad media de memoria para MySQL. Recomendada para servidores de aplicaciones Web.

“Dedicated MySQL Server Machine”. Para una computadora dedicada exclusivamente como servidor de bases de datos. MySQL podrá usar toda la memoria disponible.

En la pantalla de la Figura 25. Configurando MySQL Server 5.0., seleccionar uso de labase de datos se solicita el uso esperado de la base de datos.

Figura 25. Configurando MySQL Server 5.0., seleccionar uso de la base de datos.

Las opciones disponibles y su interpretación son:

“Multifunctional Database”. Para bases de datos de propósito general. El servidor se optimiza para usar la “máquina de almacenamiento” transaccional rápida llamada “InnoDB” (propiedad de MySQL) y la “máquina de almacenamiento” de alta velocidad llamada “MyISAM”.

“Transactional Database Only”. Está optimizada para aplicaciones de servidor y aplicaciones web transaccionales. La principal “máquina de almacenamiento” será “InnoDB”, pero también “MyISAM” podrá ser usada.

28

“Non-Transactional Database Only”. Para bases de datos no transaccionales. (Ver nota sobre “máquina transaccional”) Recomendada para aplicaciones web simples. Solo se podrá usar la “máquina de almacenamiento” no transaccional “MyISAM”.

Notas: Una “máquina transaccional” permite una mayor seguridad para la ejecución de las

transacciones. Por ejemplo: operaciones de recuperación automática, operaciones tipo “commit” y “rollback” y una mejor concurrencia.

Una “máquina no transaccional” permite que las operaciones sean más rápidas, tienen menor requerimiento de espacio y ocupan menos memoria para las actualizaciones.

La primer opción es la más común, pero las otras opciones podrán ser muy eficientes en los casos particulares citados. En este caso se seleccionó la primer opción. La siguiente pantalla que se muestra aparece en la Figura 26. Configurando MySQL Server 5.0.,seleccionar ruta para almacenar tablas. Las pantallas que aparecen pueden variar según las selecciones hechas.

Figura 26. Configurando MySQL Server 5.0., seleccionar ruta para almacenar tablas.

En la pantalla de la Figura 26. Configurando MySQL Server 5.0., seleccionar rutapara almacenar tablas, el usuario puede aceptar la ruta de almacenamiento para la base de datos o bien podrá cambiar su ubicación. Se proporciona además información sobre el sistema de archivos del sistema operativo y la cantidad de espacio en disco ocupado y libre. En este caso se aceptó la ruta predefinida y se pasó a la siguiente pantalla que se muestra en la Figura 27. Configurando MySQL Server 5.0., seleccionar número de conexiones.

29

Figura 27. Configurando MySQL Server 5.0., seleccionar número de conexiones.

En la pantalla de la Figura 27. Configurando MySQL Server 5.0., seleccionarnúmero de conexiones, se debe indicar el número aproximado de conexiones concurrentes al servidor, seleccionando una de las dos primeras opciones, o bien el usuario puede escribir directamente el número de conexiones en la tercer opción.

Enseguida aparece la pantalla que permite habilitar y definir el puerto para las conexiones de red, que se muestra en la Figura 28. Configurando MySQL Server 5.0.,opciones de conexión en red.

Figura 28. Configurando MySQL Server 5.0., opciones de conexión en red.

30

En la pantalla de la Figura 28. Configurando MySQL Server 5.0., opciones deconexión en red, es necesario seleccionar la opción “Enable TCP/IP Networking” ya sea para trabajar en modo local (cliente y servidor de MySQL en la misma computadora) o si se trabajará en red. Pues el acceso al servidor de MySQL se realizar por medio de puertos. Se puede aceptar el número de puerto propuesto, si este puerto no esta ya en uso. Anotar el número de puerto, pues adelante si la computadora tiene habilitado el “Firewall” será necesario agregar ese puerto para el funcionamiento de MySQL.

La segunda opción “Enable Strict Mode” ayuda en la seguridad y es recomendable seleccionar la opción.

Al hacer clic en el botón de siguiente “Next”, aparece la pantalla para seleccionar el conjunto de caracteres. La primer opción es adecuada como se muestra en la pantalla de la Figura 29. Configurando MySQL Server 5.0., seleccionar conjunto de caracteres.

Figura 29. Configurando MySQL Server 5.0., seleccionar conjunto de caracteres.

Al hacer clic en el botón “Next” aparece la pantalla mostrada en la Figura 30.Configurando MySQL Server 5.0., opciones para Windows.

31

Figura 30. Configurando MySQL Server 5.0., opciones para Windows.

La pantalla de la Figura 30. Configurando MySQL Server 5.0., opciones paraWindows, permite instalar el DBMS como un servicio de Windows, de manera que se podrá administrar como un servicio mas del sistema operativo. Se puede escoger el nombre del servicio, es recomendable un nombre descriptivo, y también está la opción para iniciar el servidor MySQL de manera automática cuando inicia el sistema operativo.

La opción “Incluye Bin Directory in Windows PATH”, permite incluir los archivos ejecutables a nivel cliente y servidor en la variable “PATH” de Windows. De tal manera que los ejecutables puedan ser llamados desde la línea de comandos. En Windows la variable “PATH” contiene rutas de directorios para ubicar y poder ejecutar archivos. Es recomendable activar la opción.

Enseguida aparece la pantalla mostrada en la Figura 31. Configurando MySQLServer 5.0., opciones de seguridad.

Figura 31. Configurando MySQL Server 5.0., opciones de seguridad.

32

En la pantalla de la Figura 31. Configurando MySQL Server 5.0., opciones deseguridad, se debe introducir la contraseña (“password”) para el usuario administrador cuyo nombre es “root”. Es posible habilitar un acceso remoto de este usuario administrador al servidor de MySQL con la opción “Enable root access from remote machines”. Esto permitiría al administrador controlar de manera remota al servidor.

La opción “Create An Anonymous Account”, permite crear un usuario que se pueda conectar al servidor sin necesidad de tener una cuenta creada (usuario anónimo). Ahí mismo se indica el riesgo de habilitar esta opción.

Por último aparece la pantalla mostrada en la Figura 32. Configurando MySQLServer 5.0., preparado para ejecutar.

Figura 32. Configurando MySQL Server 5.0., preparado para ejecutar.

La pantalla de la Figura 32. Configurando MySQL Server 5.0., preparado paraejecutar indica que ya se terminó de seleccionar las opciones de configuración. Y presionando el botón de ejecutar (“Execute”) se aplicarán las opciones de configuración seleccionadas. Al presionar ese botón y aplicar todos los pasos de manera exitosa aparece la pantalla de la Figura 33. Configurando MySQL Server 5.0., fin de la configuración.

33

Figura 33. Configurando MySQL Server 5.0., fin de la configuración.

La pantalla mostrada en la Figura 33. Configurando MySQL Server 5.0., fin de laconfiguración indica el éxito del proceso.

Algunos problemas que pueden presentarse en algunas instalaciones son: Si la computadora tiene habilitado el servicio de “Firewall” debe de darse de alta el puerto

que usará MySQL. En el caso de Windows XP la ruta para hacerlo es: Inicio | Panel de control | Firewall | Excepciones | Agregar puerto. Aquí se debe indicar un nombre descriptivo del puerto y su número. Cuando existe un error por este motivo lo indicará el asistente, entonces ir al “Firewall” y escoger la opción de reintentar en la última pantalla.

Cuando se desinstala y reinstala el MySQL, también puede producir un error en esta última pantalla. En este caso después de desinstalar se debe borrar manualmente la carpeta de MySQL en la ruta de instalación. Después de hacer esto, ya se puede reinstalar de manera normal.

Para otros posibles errores revisar el sitio de MySQL.com.

Como conclusión se puede indicar que un buen DBMS debe permitir al administrador de la base de datos, modificar las opciones de configuración del DBMS en cualquier momento. De manera que el sistema trabaje de la mejor manera posible.

Ejercicios de la unidad 1. Investigar características generales y particulares de tres DBMS que se usen

actualmente. Instalar y configurar en una computadora tres DBMS de uso actual. Documentar la instalación de los tres DBMS mencionados antes. Analizar y discutir las opciones de instalación de los DBMS. Exponer en el grupo los puntos desarrollados anteriormente.

34

UNIDAD 2. ADMINISTRACIÓN DE BASES DE DATOS.

Las opciones y facilidades que proporciona un DBMS para su administración, son un punto de mucha importancia para la selección de un DBMS. El DBA será la persona que más tiempo invertirá en la base de datos, por esto es importante que el DBMS le proporcione las herramientas adecuadas para que el DBA pueda realizar sus tareas en menor tiempo y de la mejor manera. Así mismo serán muy importantes las herramientas adicionales para la administración, para que el DBA las aproveche y lleve sus ventajas hasta los usuarios. Un buen DBA debe conocer todas las herramientas de administración que le ofrece un DBMS particular y aprovechar las que le reportarán ventajas a el y a los usuarios de la base de datos.

Otra tarea del DBA será cuando sea posible, el de recomendar el DBMS a usar, haciendo un análisis crítico de las ventajas y desventajas.

Ya en el tema pasado se desarrolló una introducción al tema de la administración de la base de datos. Se mencionaron las principales funciones de un administrador de base de datos y se analizaron las opciones de administración de tres DBMS de uso común.

Los aspectos generales de la administración de la base de datos que se explican en este capítulo son: Creación de la base de datos (estructura general, dominios definidos por el DBA,

esquema general y vistas). Definición del esquema de integridad (integridad de entidad y referencial, disparadores y

procedimientos almacenados). Definición del esquema de seguridad (creación de usuarios, asignación de privilegios,

esquema de recuperación y diseño de transacciones).

Enseguida se desarrolla cada uno de estos temas.

2.1 Creación de bases de datos.

Las facilidades para la creación de la base de datos, son un punto clave de cualquier DBMS. Y tal vez puede inclinar a los usuarios a seleccionar cierto DBMS.

La tarea de la creación de la base de datos corresponde al DBA y los desarrolladores de los sistemas que tienen los permisos adecuados. Los principales aspectos de la creación de la base de datos incluyen:

Creación de la estructura de la base de datos. Creación de dominios definidos por el DBA. Definir el esquema general de la base de datos (tablas, atributos, llaves primarias y llaves

heredadas). Creación de vistas de la base de datos.

De los tres DBMS mencionados con mayor frecuencia en este libro, todos ofrecen las opciones necesarias para la creación de la base de datos de una manera sencilla. En el caso de MySQL, al menos en su versión gratuita y la revisada en este momento, le faltaría la

35

opción de creación de dominios, pues no presenta la opción de crear y administrar roles de usuarios.

A continuación se desarrolla cada uno de los temas.

2.1.1 Creación de la estructura de la base de datos.

Al mencionar “estructura de la base de datos”, además de incluir a los datos propios de los usuarios y que normalmente conocemos como base de datos, se incluye también la estructura de todos los demás objetos que estarán también almacenados y que son necesarios para el uso de la base de datos.

Muchos de los objetos nunca serán conocidos por los usuarios comunes de la base de datos. El DBA si debe estar conciente de todos los objetos que componen la estructura completa de la base de datos. Pues debe configurar las características generales de cada uno de ellos, para hacer un uso adecuado de los recursos disponibles y con el objeto de tener una base datos eficiente.

La “estructura de la base de datos” comprende varios aspectos:

Estructuras de almacenamiento. Este aspecto define la forma de bajo nivel de almacenamiento, manejo y recuperación de la información.

Asignación de espacio en disco para diferentes estructuras de almacenamiento. Por ejemplo el espacio asignado para las bases de datos del sistema, bases de datos de usuarios, archivos de bitácoras, etc.

Espacio asignado en memoria principal para diferentes objetos de la base de datos. Por ejemplo, en Oracle la memoria asignada al SGA (“System Global Area”, área general de memoria asignada al DBMS) y al PGA (“Program Global Area”, área de memoria asignada a un proceso simple de servidor). En MySQL espacios de memoria para buffers de almacenamiento de resultados de consultas.

Creación de índices. Por este conducto el administrador de manera indirecta hace que el DBMS implemente estructuras de archivos y algoritmos para el mantenimiento y recuperación de la información.

Enseguida se ejemplifican los aspectos anteriores para diferentes DBMS.

Estructuras de almacenamiento.

Como se comentó antes, las estructuras de almacenamiento definen la forma de bajo nivel de almacenamiento, manejo y recuperación de la información. Algunas técnicas de administración del almacenamiento de bajo nivel son: ISAM, MyISAM, VSAM, InnoDB y B-tree. Por ejemplo, en MySQL, la “máquina de almacenamiento” define la forma para almacenar, recuperar y administrar datos.

El DBA puede definir de manera indirecta la estructura de almacenamiento, por ejemplo al crear índices, y el DBMS por ejemplo puede crear una estructura de árbol B “B-tree” para administrar los índices. Por ejemplo, en MySQL el administrador puede seleccionar

36

diferentes opciones de “máquina de almacenamiento” (también traducido como “motor de almacenamiento”), entre ellas están:

InnoDB. Proporciona tablas transaccionales. Se incluye también por defecto en todas las distribuciones binarias de MySQL 5.0. En distribuciones fuente, se puede activar o desactivar este motor de almacenamiento configurando MySQL a las necesidades particulares. Para Windows es el motor por defecto.

InnoDB es una tecnología de almacenamiento de datos de fuente abierta para MySQL, incluido como formato de tabla estándar en todas las distribuciones de MySQL AB a partir de las versiones 4.0. Su característica principal es que soporta transacciones de tipo ACID, bloqueo de registros e integridad referencial. InnoDB ofrece una fiabilidad y consistencia muy superior a MyISAM, la anterior tecnología de tablas de MySQL, si bien el mejor rendimiento de uno u otro formato dependerán de la aplicación específica.

En octubre de 2005, Oracle Corp. Adquirió a la compañía Innobase, compañía que desarrolla InnoDB.

MyISAM. Trata con tablas no transaccionales. Proporciona almacenamiento y recuperación de datos rápida, así como posibilidad de búsquedas de texto completo. Se soporta en todas las configuraciones MySQL, y es el motor de almacenamiento por defecto (sistemas que no son Windows).

Se basa en el código ISAM pero tiene extensiones útiles. ISAM son siglas de “Indexed Sequential Access Method” (Método de Acceso Secuencial Indexado), se trata de un método para almacenar información a la que se pueda acceder rápidamente. ISAM fue desarrollado originalmente por IBM y en la actualidad forma parte del almacenamiento básico de muchos sistemas de bases de datos, tanto relacionales como de otros modelos.

Falcon. Es una “máquina de almacenamiento” transaccional reciente de MySQL. Actualmente es una versión alfa. Esta basada en la “máquina de base de datos” Netfrastructure (). Una de sus ventajas es que requiere de un mínimo de mantenimiento y está diseñada para reconfigurarse de manera automática para manejar de manera eficiente diferentes tipos de carga de trabajo.

BDB. Proporciona tablas transaccionales. Se incluye en la distribución binaria MySQL-Max en aquellos sistemas operativos que la soportan. En distribuciones fuente, se puede activar o desactivar este motor de almacenamiento configurando MySQL a las necesidades particulares.

Las tablas BDB pueden tener una gran probabilidad de sobrevivir a fallos del sistema y ser capaces de realizar “commit” y “rollback” en transacciones.

La empresa “Sleepycat Software” proporcionó a MySQL este motor de almacenamiento transaccional, llamado “Berkeley DB” y conocido tradicionalmente como BDB.

Heap o Memory. Es no transaccional. Como indica su nombre, las tablas “MEMORY” se almacenan en memoria y usan índices hash por defecto. Esto las hace muy rápidas, y

37

muy útiles para crear tablas temporales. Sin embargo, cuando se apaga el servidor, todos los datos almacenados en las tablas MEMORY se pierden. Las tablas por sí mismas continúan existiendo ya que sus definiciones se almacenan en archivos con extensión “.frm” en disco, pero están vacías cuando se reinicia el servidor.

En una base de datos MySQL se pueden tener tablas que usen diferentes “máquinas de almacenamiento”. Cuando se crea una tabla, se puede indicar la máquina a usar, cuando no se indica, se usa la que esta seleccionada por defecto. Lo recomendable es que todas las tablas de una base de datos usen la misma máquina de almacenamiento.

En MySQL 5.0 para ver las “máquinas de almacenamiento” disponibles se abre el programa “MySQL Administrador” (1), la opción “Startup variables” (2), la ficha “General Parameters” (3) y en la opción “Default storage” (4) se ven las opciones de “máquinas de almacenamiento”. La secuencia se indica en la Figura 34. Máquinas de almacenamientoen MySQL.

Figura 34. Máquinas de almacenamiento en MySQL.

Observar en la Figura 34. Máquinas de almacenamiento en MySQL las opciones de “Default storage”. Estas se describieron anteriormente. En este caso en la instalación se seleccionó “InnoDB”.

En MySQL se pueden también configurar los detalles de las “máquinas de almacenamiento”. En la Figura 34. Máquinas de almacenamiento en MySQL, observar las fichas “MyISAM Parameters” e “InnoDB Parameters”. Se muestran las opciones para ellas

38

por ser las máquinas seleccionadas en la instalación. En la Figura 35. Opciones para lamáquina de almacenamiento InnoDB en MySQL se muestran algunas de las opciones de configuración para “InnoDB”.

Figura 35. Opciones para la máquina de almacenamiento InnoDB en MySQL.

Con la Figura 35. Opciones para la máquina de almacenamiento InnoDB enMySQL se da una idea de todos los detalles de configuración que el administrador puede manejar con el objeto de optimizar el funcionamiento de la base de datos. Se recomienda ser precavido, entender el significado de cada opción y llevar un buen registro de las opciones que se han modificado. Lo recomendable también es usar la configuración por defecto y modificarla solo en casos críticos.

Un buen administrador de base de datos, debe ser conciente de estas opciones de configuración y el impacto que tendrán en el funcionamiento de la base de datos.

Estas opciones para definir y configurar las “máquinas de almacenamiento” son propias de MySQL y no están disponibles de esa manera en las versiones gratuitas de SQL Server y Oracle.

39

2.1.1.2 Asignación de espacio en disco para diferentes estructuras de almacenamiento.

Todos los DBMS usan bases de datos del sistema donde almacenan información para un adecuado funcionamiento de este. Por ejemplo, deben almacenar y poder administrar información sobre: diccionarios de datos, usuarios y permisos, etc. Después de que se instala y configura el sistema, se crean estas bases de datos, que solo el DBA podrá ver.

Algunos DBMS (como Oracle y SQL Server) permiten asignar y restringir el tamaño que podrán tener las bases de datos de los usuarios.

Por ejemplo las bases de datos de sistema de MySQL se muestran en la Figura 36.Bases de datos del sistema de MySQL.

Figura 36. Bases de datos del sistema de MySQL.

Observar en la Figura 36. Bases de datos del sistema de MySQL las bases de datos del sistema (“information_schema” y “mysql”), y se muestran algunas tablas de la base de datos “mysql”.

También se asigna espacio en disco para las bitácoras (archivos “log”) del sistema. Los archivos de bitácora permiten entre otros aspectos, que el sistema pueda llevar un registro de las actividades realizadas en la base de datos, se pueda conocer los usuarios que se han conectado y las operaciones realizadas, el sistema pueda realizar una recuperación automática después de una caída, poder realizar operaciones de deshacer (“rollback”) y hacer (“commit”), etc.

40

Por ejemplo, MySQL permite al DBA definir los tipos de archivos de bitácora a mantener y sus características generales (nombre de archivo, como tamaño máximo, datos a guardar, etc.). En la Figura 37. Archivos de bitácora en MySQL, se muestra la pantalla para configurar archivos de bitácora.

Figura 37. Archivos de bitácora en MySQL.

La ruta para ingresar a la pantalla de bitácoras es: “MySQL Administrador” | “Startup Variables” y la ficha “Log files”. Observar los tipos de archivos de bitácora que se pueden activar y el DBA puede definir el nombre de cada archivo.

2.1.1.3 Espacio asignado en memoria principal para diferentes objetos de la base de datos.

En este aspecto el DBA debe optimizar el uso de la memoria principal. Para esto se debe conocer la administración general de la memoria principal por parte del DBMS a usar. Aquí será necesario conocer los objetos de base de datos que requieren almacenamiento en memoria y la posibilidad de que el DBA asigne y pueda modificar el espacio de almacenamiento.

Tal vez algunos de los detalles de requerimientos de espacio por parte de los objetos se conozcan hasta la operación del sistema. Por ejemplo, que sean frecuentes los resultados de consultas con alto requerimiento de espacio y que el DBA puede asignar un espacio mayor para hacerlas mas eficientes.

41

En MySQL el DBA puede asignar espacio en memoria para diferentes objetos, tales como: “buffers” (espacio en memoria principal) para índices, para ordenamientos, memoria cache para resultados de consultas, entre otros. Estas cantidades de memoria se pueden configurar en la opción “Startup Variables”. Por otro lado la cantidad de memoria principal total que puede usar el DBMS MySQL se determina al momento de realizar la configuración inicial del servidor. Recordar que la cantidad máxima de memoria (y de recursos como el CPU) se usará para un servidor dedicado de base de datos. Aunque esto se puede modificar posteriormente.

Como se mencionó antes, en Oracle la cantidad de memoria asignada al SGA y al PGA la puede definir el DBA en base de capacidades del equipo y requerimientos de la aplicación. Aquí se debe conocer el manejo de memoria que hace Oracle y los conceptos principales.

En la versión gratuita de Oracle se puede modificar el espacio asignado a esas áreas mediante las opciones que se muestran en la Figura 38. Configuración de memoria enOracle.

Figura 38. Configuración de memoria en Oracle.

Se puede observar en la Figura 38. Configuración de memoria en Oracle, que las opciones “Gestionar SGA” y “Gestionar PGA” permitirán al DBA modificar la cantidad de memoria asignada a esas áreas. Las cantidades asignadas aquí afectarán el rendimiento de la base de datos. Los valores iniciales para estas áreas se asignan automáticamente en la instalación, en base a la cantidad de memoria del sistema. También existe una cantidad máxima de memoria que puede asignarse por la limitación de la licencia, para esta versión es de 1 gigabyte para la suma de ambas áreas.

42

Por otro lado la cantidad de memoria que usa el DBMS MySQL se asigna en la configuración inicial del sistema (ver Figura 24. Configurando MySQL Server 5.0.,seleccionar tipo de servidor). En este caso la cantidad mayor de memoria se asigna para un servidor dedicado de base de datos (“Dedicated MySQL Server Machine”) en la pantalla de selección del tipo de servidor.

Además del uso general de la memoria para el DBMS y sus procesos, en MySQL se pueden configurar de manera particular cantidad de memoria para procesos particulares. Por ejemplo: para buffer de almacenamiento de resultados de consultas, buffer para bloques que contienen índices, y resultados de consultas anteriores, entre otros.

Para SQL Server Express, no se encontraron opciones para administrar el uso de la memoria principal.

2.1.2 Creación de dominios definidos por el DBA.

El concepto general de dominio tiene varios significados en el diccionario, algunos de los cuáles se mencionan: Poder que uno tiene de disponer de lo suyo. Poder que se ejerce sobre otro. Conocimiento grande en una materia. Ámbito de una actividad.

Desde el punto de vista de los sistemas de bases de datos, creo que el enfoque más adecuado para el concepto general de dominio es el último “Ámbito de una actividad”.

En Wikipedia se menciona la siguiente definición de dominio: “Es una parte identificable de un espacio físico o abstracto donde algo existe, está actuando, o es válido”.

El concepto de dominio se utiliza en muchos campos de la actividad humana. En este caso interesa el concepto aplicado a las tecnologías de la información. Aún dentro de esta área, la palabra “dominio” se puede referir, entre otros a:

Nombre de dominio. Es un nombre común de una red de computadoras, bajo el cuál una colección de dispositivos de red están organizados.

“Domian Name System” (DNS). Se usa en Internet. Es un sistema de nomenclatura jerárquica para computadoras, servicios y otros recursos que se encuentran en Internet.

Dominio de una aplicación. Es la clase de propósitos para los cuáles los usuarios usan un sistema de software.

Dominio en la Ingeniería de software. Es un campo de estudio que define un conjunto común de requerimientos, terminología, y funcionalidad que debe tener cualquier programa de software que es construido para solucionar cierto problema.

Dominio de datos. En la teoría de bases de datos, se refiere al conjunto de los valores permitidos.

Creo que el enfoque más adecuado del concepto para el tema “Creación de dominios definidos por el DBA” es el de “Dominio de una aplicación”. Pues en este contexto, el DBA debe:

43

Identificar a todos los usuarios de la aplicación. Conocer los objetos existentes en la bases de datos (tablas, vistas, procedimientos

almacenados, funciones, índices, clusters, bitácoras, diccionario de datos, etc.). Definir los propósitos o tareas que cada usuario podrá realizar en los objetos de la base

de datos. Establecer los niveles y tipos de permisos de cada usuario sobre cada objeto de la base

de datos. Aquí se incluye la disponibilidad de cada objeto para cada usuario, partes visibles de cada objeto, los operaciones que cada usuario podrá realizar en cada objeto (como lectura o escritura), etc.

Definir grupos de usuarios con propósitos comunes.

Por lo mencionado anteriormente, la creación de dominios tiene que ver con la administración de usuarios del sistema y la seguridad.

Algunos DBMS permiten el uso de “roles” o funciones predefinidas para los usuarios (Oracle y SQL Server, entre otros), la posibilidad de crear nuevos roles y la modificación de los roles. Los roles son una forma más segura y rápida de asignar permisos a los grupos de usuarios. Es posible asignar un rol a otro rol, para heredar los permisos.

Un rol también puede definirse como un grupo con nombre que contiene privilegios asignados, que se pueden otorgar como un grupo a los usuarios o a otros roles.

Por ejemplo, algunos de los roles de base de datos predefinidos en SQL Server Express son: administrador, operador de respaldos, lector de datos, escritor de datos, propietario de datos y administrador de seguridad, entre otros. En este software, el administrador puede asignar los roles a los usuarios y configurar las propiedades de cada rol. De manera que si es necesario modificar algunos aspectos de un rol, esto se haga una sola vez, y los cambios se apliquen de manera automática a todos los usuarios que tienen asignado dicho rol.

Por otra parte en Oracle, se tienen predefinidos 3 roles: “Connect”, “Resource” y “DBA”. En general el rol de “Connect” es el más restringido y debe asignarse a usuarios y aplicaciones que requieren acceder a la base de datos. El rol “Resource” permite a los usuarios crear ciertos objetos de esquema en el mismo esquema del usuario, este rol se asigna normalmente a los desarrolladores. El rol de “DBA” es para los administradores de la base de datos y se incluyen privilegios para crear usuarios y otorgar derechos, crear y asignar roles, crear y eliminar objetos en esquemas de los usuarios, entre otros. En la documentación de Oracle se menciona que estos roles no se proporcionarán por omisión en las siguientes versiones del software y recomiendan que el administrador defina y cree los roles particulares de cada aplicación.

Oracle tiene dos tipos generales de roles: Roles de aplicación. Se utilizan para administrar los privilegios de una aplicación de base

de datos. De esta forma se asignan todos los privilegios necesarios para ejecutar una aplicación de base de datos.

Roles de usuario. Para administrar los privilegios para un grupo de usuarios con requerimientos comunes de privilegios.

44

Algunos DBMS como Oracle incluyen el concepto de “Profile” (perfil), estos se crean para limitar las posibilidades de los usuarios del sistema de base de datos. Oracle tiene predefinidos los perfiles: Administradores (acceso a recursos ilimitados del sistema), y Desarrolladores (pueden disponer de un número ilimitado de sesiones pero uso restringido de CPU). Un perfil permite por ejemplo indicar los ciclos de CPU que puede usar un usuario y el número de sesiones concurrentes que podrá tener. El propósito principal de los perfiles es facilitar la administración de la seguridad, manteniendo siempre bajo control los accesos a los recursos. En Oracle se pueden crear nuevos perfiles y modificarlos.

Por lo desarrollado antes en este tema, pienso que los conceptos de “dominio de base de datos” y “rol de base de datos” son equivalentes. Entonces para que el BDA identifique los dominios necesarios en la aplicación, requiere identificar a todos los usuarios del sistema y las actividades detalladas de cada uno. Se nota que esto dependerá de la aplicación particular.

Por ejemplo, para una aplicación se podrían definir los siguientes roles o dominios: Administrador. Responsable de respaldos y recuperación. Responsable de seguridad y auditoria. Para los diferentes tipos de usuarios.

Dentro de los usuarios se pueden tener varios roles, por ejemplo: Usuario gerente general. Gerente de departamento. Cajero. Vendedor. Generador de reportes.

Enseguida se muestra un ejemplo para crear un rol en Oracle, también se asignarán privilegios al rol, y por último se asignará el rol a un usuario. No se desarrolla la sintaxis completa de las sentencias (para esto consultar la documentación oficial de Oracle). Se usa el lenguaje “Oracle PL/ SQL”.

Creación de un rol.

CREATE ROLE rol_usuario1IDENTIFIED BY clave123;

La sentencia anterior crea un nuevo rol llamado “rol_usuario1” y estará protegido por contraseña, mediante la clave “clave123”.

Conceder privilegios sobre una tabla a un rol.

GRANT SELECT, INSERT, UPDATE, DELETE ON tabla_empleados TO rol_usuario1;

La sentencia concede los privilegios de consulta (select), altas (insert), actualización (update) y bajas (delete) en la tabla llamada “tabla_empleados” al rol con nombre de “rol_usuario1”.

45

Conceder privilegios sobre una función o procedimiento a un rol.

GRANT EXECUTE ON procedimiento1 TO rol_usuario1;

La sentencia permitirá al rol con nombre “rol_usuario1”, poder ejecutar el procedimiento “procedimiento1”.

Asignar el rol a un usuario.

GRANT rol_usuario1 TO usuario1, usuario2, usuario3;

La sentencia asigna el rol “rol_usuario1” a los usuarios “usuario1”, “usuario2” y “usuario3”.

Oracle PL/SQL cuenta con otras sentencias para la administración de roles. Por ejemplo, entre otros: Retirar privilegios en las tablas, funciones o procedimientos a los roles. Habilitar o deshabilitar un rol para la sesión actual. Eliminar un rol. Modificar un rol.

Notar que no es indispensable tener creados los usuarios al momento de crear los roles. Mas bien la definición y creación de roles debe ser previo a la creación de los usuarios. Los roles serán importantes para la seguridad del sistema y facilitar las tareas de administración de la base de datos.

2.1.3 Definir el esquema general de la base de datos (tablas, atributos, llaves primarias y llaves heredadas).

Una vez que se aplicó el análisis y diseño para un sistema de base de datos. El DBA o los desarrolladores pueden implementar el resultado del diseño de la base de datos en el DBMS seleccionado. La responsabilidad del diseño de la base de datos puede ser del DBA o de los desarrolladores. Sin embargo, el DBA debe asegurar que se cumplan los estándares de diseño y nomenclatura de objetos.

El diseño previo de la base de datos normalmente incluye:

Diagramas entidad relación. Es un diagrama conceptual de alto nivel de la base de datos. Que incluye los nombres de las entidades del sistema, sus atributos y sus relaciones con otras entidades. Con nomenclatura especial se identifican atributos particulares como: multivalorados, calculados, llaves primarias, llaves foráneas etc. El diagrama también debe indicar la cardinalidad de cada relación. Toda esta información es necesaria para un buen diseño de la base de datos.

Diccionario de datos. Se describen los datos: tablas (que pueden describir entidades o relaciones) y atributos. Se identifican los atributos que son llaves primarias y llaves foráneas. Se debe indicar el nombre del atributo, el tipo de datos y explicar el significado de cada uno de ellos.

46

Diagramas de dependencias funcionales. Mediante diagramas se identifican relaciones entre los atributos. Información de base para el proceso de normalización.

Normalización de la base de datos. Se deben aplicar las reglas formales de normalización del modelo relacional. Este proceso asegura que se eliminarán inconsistencias en la base de datos derivados de las operaciones de actualización y que toda la información se podrá recuperar de la base de datos. La normalización esta fundamentada en las diferentes formas normales:

o Primera forma normal (1FN).o Segunda forma normal (2FN).o Tercera forma normal (3FN).o Forma normal de Boyce-Codd (BCFN).o Cuarta formal normal (4FN).o Quinta forma normal (5FN).

Diagrama de base de datos. Describe el detalle de las tablas de la base de datos, sus atributos, se identifican llaves primarias y foráneas. Se indican las tablas relacionadas.

Una vez que se tiene el diseño completo se puede implementar en el DBMS. Para el diseño se pueden usar herramientas CASE (por ejemplo ERWIN). ERWIN permite crear los diagramas ER con toda la información necesaria, como resultado esta herramienta puede generar un script (programa) que se puede ejecutar en el DBMS deseado y como resultado se crear el esquema completo de la base de datos.

Para ejemplificar la implementación en el DBMS se usará un ejemplo sencillo, aplicando los criterios de diseño y se usará MySQL para su implementación.

Planteamiento del sistema.El Departamento de Informática de la empresa Innovación SA, desea un sistema de base de datos que le permita administrar los proyectos del departamento. En particular se desea tener registrados todos los proyectos, sus avances e información del responsable de cada proyecto.

De cada proyecto se desea registrar: clave_proyecto, nombre_proyecto, descripción_proyecto, departamento_que_solicita, estado, porcentaje_avance, fecha_inicio, fecha_terminación, responsable.Como información de detalle de cada proyecto se desea tener: fecha_reporte, descripción_avance.De los responsables se desea registrar: clave_responsable, nombre_responsable, puesto.

Alguna información adicional obtenida es: Cada proyecto es asignado a un solo responsable. Una sola persona como responsable

puede tener varios proyectos. De un proyecto particular se pueden tener varios reportes de avance. Los responsables de proyectos deben reportar semanalmente los avances de los

proyectos que se estén en proceso.

47

Como resultado del diseño se definen tres tablas, que se describen a continuación (información que forma parte del diccionario de datos):

Proyectos.Tendrá la información general del los proyectos. Estará relacionada con la tabla de “Responsables”. Por la cardinalidad aplicada se agregará la clave de la persona responsable y de esta manera se asociará con el responsable. En la Tabla 1. Esquema de la tabla"Proyectos".

Descripción de atributos de la tabla Proyectos.Nombre atributo Nombre corto Tipo de

datoDescripción

clave_proyecto cve_proy Número Es la clave del proyecto. Llave primaria.nombre_proyecto nom_proy Texto Nombre del proyecto.descripción_proyecto desc_proy Texto Descripción del proyecto, más completa

que su nombre.departamento_que_solicita depto_proy Número Número del departamento que solicita

este proyecto.Estado estado Texto Indica el estado del proyecto. Posibles

valores: proceso, terminado, suspendido, cancelado.

porcentaje_avance avance_proy Número Indica en porcentaje el grado de avance del proyecto.

fecha_inicio fecha_ini Fecha Fecha (dd/mm/aaaa) de inicio del proyecto.

fecha_terminación fecha_fin Fecha Fecha (dd/mm/aaaa) de terminación del proyecto.

clave_responsable cve_res Número Clave del responsable del proyecto. Llave foránea que está definida en la tabla: Responsables.

Tabla 1. Esquema de la tabla "Proyectos".

Responsables.Tendrá la información general de las personas que pueden ser responsables de proyectos. Estará relacionada con la tabla “Proyectos” (la relación se establece dentro de dicha tabla). En la Tabla 2. Esquema de la tabla "Responsables".

Descripción de atributos de la tabla Responsables.Nombre atributo Nombre corto Tipo de

datoDescripción

clave_responsable cve_res Número Clave del responsable del proyecto. Llave primaria.

nombre_responsable nom_res Texto Nombre del responsable.Puesto Puesto Texto Nombre del puesto del responsable.

Posibles valores: Analista1, Analista2, Analista3.

Tabla 2. Esquema de la tabla "Responsables".

48

Proyectos_AvancesTendrá la información de detalle e histórica de los avances reportados para cada proyecto. Incluirá la descripción del avance y la fecha del reporte. Ver la descripción de los atributos en la Tabla 3. Esquema de la tabla "Proyectos_Avances".

Descripción de atributos de la tabla Proyectos_Avances.Nombre atributo Nombre corto Tipo de

datoDescripción

clave_proyecto cve_proy Número Es la clave del proyecto. Llave primaria. Es llave foránea que está definida en la tabla: Proyectos.

fecha_avance Fecha_avance Fecha Fecha (dd/mm/aaaa) del reporte de avance. Llave primaria.

Descripción_avance desc_avance Texto Descripción del avance del proyecto.Tabla 3. Esquema de la tabla "Proyectos_Avances".

Notar de la Tabla 3. Esquema de la tabla "Proyectos_Avances", la llave primaria compuesta (“cve_proy”, “fecha_avance”). Además “cve_proy” es una llave foránea.

Después de aplicar el proceso de diseño se obtiene el diagrama de base de datos que se muestra en la Figura 39. Diagrama de base de datos del ejemplo práctico.

Figura 39. Diagrama de base de datos del ejemplo práctico.

Para crear esta base de datos en MySQL (ver sección 1.2.1), entrar al “MySQL QueryBrowser”, crear la nueva base de datos (“Schema” en MySQL) “innovación”. Hacer clic en el nombre de la base de datos para agregar las tablas anteriores. El editor de tablas permite definir todos los datos necesarios, indicar el tipo de dato, definir llaves primarias

49

(simples o compuestas) y definir las llaves foráneas. En la Figura 40. Creación de tablacon llave primaria y foránea en MySQL, observar el editor de tablas al crear la tabla “Proyectos_Avances”. Previamente se creó la tabla “Proyectos”.

Figura 40. Creación de tabla con llave primaria y foránea en MySQL.

En la Figura 40. Creación de tabla con llave primaria y foránea en MySQL, observar lo siguiente:o Se puede crear una llave primaria compuesta (varios atributos). Simplemente se hace un

clic en el icono que esta antes del nombre de la columna para activar/desactivar la opción de llave primaria.

o En la ficha “Foreing Keys” (llaves foráneas) se establecen las llaves foráneas de la tabla. Para esto se hizo clic en el icono de “+”, esto crea una nueva definición de llave foránea. MySQL asigna un nombre especial a la restricción de llave foránea. Se tiene que definir el comportamiento (de borrado y actualización) de la llave, las opciones son:

o “No Action”.o “Cascade”.o “Set Null”.o “Restrict”.

o Se selecciona la tabla de relación para la llave foránea (en este caso la tabla “Proyectos”, que se tuvo que crear primero) y MySQL lo relaciona automáticamente con el campo que se llama igual y es del mismo tipo.

2.1.4 Creación de vistas de la base de datos (view).

Como el lector lo sabe, una vista de base de datos permite proporcionar a los usuarios diferentes datos que pueden ver, de tal manera que cada usuario solo pueda ver los

50

datos a los que tiene derecho. Una vista se define en base a una sentencia SQL, que indica el nombre de la vista y la consulta que define los datos. Posteriormente se pueden otorgar permisos a los usuarios para las diferentes vistas creadas. Para el usuario final no existe una diferencia entre una tabla y una vista. Una vez definida una vista esta se puede consultar igual que una tabla.

Una vista es una tabla lógica o virtual que esta formada del resultado de una consulta. A diferencia de las tablas ordinarias en una base de datos relacional, una vista no es parte del esquema físico. La vista es dinámica o cambiante, es una tabla virtual computada o cotejada con los datos almacenados en la base de datos. Cuando se modifican los datos en una tabla, se alteran también los datos mostrados en la vista.

La vista es un aspecto muy importante en la base de datos pues permite: Ocultar la complejidad de la base de datos a los usuarios finales, permitiéndoles ver

datos mas comprensibles para ellos. Mejor manejo de la seguridad. Pues a los usuarios solo se les puede otorgar permisos a

las vistas adecuadas. Las vistas puede limitar los riesgos a los cuales se expone una tabla que esta accesible a

todos los usuarios. Definir un subconjunto de los datos almacenados en una tabla. Una vista puede reunir y simplificar múltiples tablas en una tabla virtual sencilla. Una vista puede actuar como tablas agregadas, donde los datos agregados (suma,

promedio, desviación estándar, etc.) son calculados y presentados como parte de los datos.

Una vista requiere menos espacio de almacenamiento que una tabla, puesto que solo se almacena su definición y no la copia de todos los datos.

Una vista se puede también definir en base a otras vistas, permitiendo de esta manera definiciones anidadas.

Una vista puede ser actualizable o de solo lectura. Para que una vista sea actualizable, el DBMS debe ser capaz de mapear la estructura de la tabla subyacente a partir de la declaración de la vista.

Como algunas facilidades avanzadas de las vistas se pueden mencionar: La base de datos Oracle introduce el concepto de “vista materializada”, la cuál es “pre-

ejecutada”, y son vistas no virtuales (se almacenan los datos) y se usan comúnmente para aplicaciones de “Data warehouse”. Esta son “instantáneas estáticas” de los datos y pueden incluir datos de fuentes remotas.

Microsoft SQL Server, introduce en la versión 2000, “vistas indexadas”, las cuales almacenan un índice separado de la tabla, pero no almacenan los datos completos.

Para el ejemplo que se esta desarrollado, suponer que el área de informática desea que los diferentes departamentos de la empresa puedan consultar los avances de los proyectos que ellos han solicitado. Es decir, el departamento de Recursos Humanos (RH) solo podrá consultar el avance de los proyectos solicitados por RH. De esta manera se creará una vista para cada departamento.

En MySQL para crear una vista, entrar al “MySQL Query Browser”, en la base de datos donde se quiere crear la vista se hace clic con el botón derecho del ratón, y del menú

51

contextual que aparece se selecciona la opción “Create New View”. Como se muestra en la Figura 41. Menú para crear una vista en MySQL.

Figura 41. Menú para crear una vista en MySQL.

Una vez hecho lo anterior se debe escribir la consulta que define a la vista, como se muestra en la Figura 42. Crear una vista en MySQL.

Figura 42. Crear una vista en MySQL.

Una vez escrito el código, hacer clic en el botón “Continue” que compilará y permite crear la vista. Después la vista debe aparecer como un objeto en la base de datos y se puede ejecutar haciendo doble clic sobre ella y mostrará los datos obtenidos. La vista se puede modificar.

Al ejecutar la vista anterior se muestra su resultado, como se ejemplifica en la Figura43. Ejecutar una vista en MySQL.

52

Figura 43. Ejecutar una vista en MySQL.

De manera similar se puede crear una vista para cada departamento, y el administrador podrá otorgar los permisos adecuados para cada vista a cada departamento.

2.2 Definición del esquema de integridad.

El esquema de integridad asegura que la base de datos siempre tendrá un estado consistente sin importar las operaciones que se realicen en la base de datos. El esquema de integridad se implementa mediante las reglas de integridad que estarán almacenadas en la base de datos. Las operaciones en la base de datos se realizan tomando en cuenta las reglas de integridad almacenadas.

Una parte importante del diseño de la base de datos es definir las reglas de integridad que el sistema debe verificar y validar que se cumplan. Las reglas de integridad deben estar almacenadas en la misma base de datos y no depender de la aplicación que accede a la base de datos. Las reglas de integridad aseguran que la base de datos siempre conservará un estado consistente. Ejemplos de reglas de integridad:

Restricciones de dominios. Al definir cada atributo sobre un dominio se impone una restricción sobre el conjunto de valores permitidos para cada atributo.

Integridad de entidad. Asegura que no existen registros duplicados en una tabla, y que el campo (o campos) que identifica cada registro es único y sin valor nulo. La existencia de una clave primaria es el fundamento de la integridad de entidad.

Integridad referencial. Es la consistencia entre tablas relacionadas. Se aplica a las claves foráneas: si en una relación hay alguna clave foránea, sus valores deben coincidir con valores de la clave primaria a la que hace referencia, o bien, deben ser completamente nulos.

Reglas de negocio. Son restricciones específicas sobre los datos, que puede definirlas el usuario o el DBA. Se pueden usar disparadores (“triggers” en inglés) o procedimientos almacenados para definir este tipo de reglas.

En las secciones que siguen se desarrollan estos aspectos.

53

2.2.1 Validar y verificar integridad de entidad e integridad referencial.

La declaración de las reglas de integridad de entidad y referencial se deben establecer desde el diseño de la base de datos.

Integridad de entidad. Se indica la llave primaria de la tabla y se debe establecer como valor no nulo. Recordar que esta integridad asegura que no existirán tuplas duplicadas en una tabla. Normalmente el DBMS construye un índice basado en la clave primaria, de esta manera se pueden agilizar las consultas y la verificación de no repetición del valor de la clave.

Por ejemplo en MySQL, se puede establecer la clave primaria con el diseñador de tablas, como se indica en la Figura 44. Integridad de entidad en MySQL.

Figura 44. Integridad de entidad en MySQL.

Observar en la Figura 44. Integridad de entidad en MySQL, la llave primaria compuesta por dos atributos (cve_proy, fecha_avance) y la indicación de valores obligatorios para estos atributos (“NOT NULL”). Para aplicar la regla de entidad a toda la base de datos, se debe aplicar este criterio al crear cada tabla (llaves primarias y valores obligatorios para ellas).

El lenguaje SQL soporta la definición de la integridad de entidad, que esta incluida en la sentencia para crear la tabla.

Integridad referencial. Como se mencionó, esta integridad mantiene la consistencia entre tablas relacionadas. La relación se establece mediante las llaves foráneas. Se pueden establecer diferentes comportamientos para el manejo de las relaciones.

54

Recordar que una llave foránea en una tabla permite relacionar su información con otra tabla, en la segunda tabla esa misma llave es primaria. Para el ejemplo que se esta desarrollando (ver la Figura 39. Diagrama de base de datos del ejemplo práctico), observar que en la tabla “Proyectos_Avances” el atributo “cve_proy” es una llave foránea (también es parte de la llave primaria junto con el atributo “fecha_avance”). Este atributo “cve_proy” en la tabla “Proyectos_Avances” hace referencia al atributo con el mismo nombre en la tabla de “Proyectos”. En la tabla “Proyectos” el mismo atributo es la llave primaria.

Esto implica que cada vez que se agregue o modifique un registro en la tabla de “Proyectos_Avances”, el campo de “cve_proy” debe tener un valor de una clave de proyecto que exista en la tabla de “Proyectos”. Este es el comportamiento general, las variantes que pueden manejarse se mencionan más adelante.

Existen otras implicaciones como: ¿cuándo se elimine un proyecto en la tabla “Proyectos”, que hacer con los registros de avance de ese proyecto en la tabla “Proyectos_Avances”?, ¿si se actualiza una clave de proyecto en la tabla de “Proyectos”, se permite o como se actualizan los avances de ese proyecto en la tabla “Proyectos_Avances”?.

Para ver la forma de definir la integridad referencial en MySQL consultar el tema 2.1.3.

Las variantes del comportamiento de borrado de una llave foránea en MySQL son:o “No Action”. No se realiza acción alguna en los registros que hacen referencia al registro

referenciado. Es decir, si se elimina un registro de un proyecto en la tabla “Proyectos”, se permitirá la operación, y no se aplicará ninguna operación en los registros de avance de ese proyecto en la tabla “Proyectos_Avances”. Notar que en la tabla “Proyectos_Avances” se podrán tener claves de proyectos que ya no existen en la tabla de “Proyectos” y sus implicaciones en la consistencia de la base de datos.

o “Cascade”. Es el valor por omisión. Si se elimina el registro referenciado, se propaga el borrado a los registros que lo referencian mediante la clave foránea. Es decir, si se elimina un registro de un proyecto en la tabla “Proyectos”, todos los avances de ese proyecto también serán eliminados de la tabla “Proyectos_Avances”.

o “Set Null”. Si se elimina el registro referenciado, los registros que lo referencian se ponen a nulo en la clave foránea (sólo si acepta nulos). Es decir, si se elimina un registro de un proyecto en la tabla “Proyectos”, a todos los avances se ese proyecto se les asignará un valor nulo en su clave foránea (“cve_proy”).

o “Restrict”. No se permite el borrado del registro referenciado. Es decir, si se trata de eliminar un registro de proyecto en la tabla “Proyectos”, pero ese proyecto tiene registros de avance en la tabla “Proyectos_Avances”, no se permitirá la operación de eliminar ese proyecto en la tabla “Proyectos”, ni sus registros relacionados en la tabla “Proyectos_Avances”.

De manera similar, las variantes del comportamiento de actualización (o modificación) de una llave foránea en MySQL son:

o “No Action”. No se realiza acción alguna en los registros que hacen referencia al registro referenciado. Es decir, si se modifica una clave de proyecto (campo “cve_proy”) de un registro de un proyecto en la tabla “Proyectos”, se permitirá la operación, y no se aplicará ninguna operación en los registros de avance de ese proyecto en la tabla

55

“Proyectos_Avances”. Notar que en la tabla “Proyectos_Avances” se podrán tener claves de proyectos que ya no existen o no corresponden en la tabla de “Proyectos” y sus implicaciones en la consistencia de la base de datos.

o “Cascade”. Es el valor por omisión. Si se modifica en valor de la clave primaria del registro referenciado, se propaga la modificación a los registros que lo referencian mediante la clave foránea. Es decir, si se modifica la clave de un proyecto en un registro de un proyecto en la tabla “Proyectos”, todos los avances de ese proyecto también serán actualizados en su llave foránea en la tabla “Proyectos_Avances”.

o “Set Null”. Si se modifica el valor de la clave primaria el registro referenciado, los registros que lo referencian se ponen a nulo en la clave foránea (sólo si acepta nulos). Es decir, si se modifica la clave primaria de un proyecto en la tabla “Proyectos”, a todos los avances se ese proyecto se les asignará un valor nulo en su clave foránea (“cve_proy”).

o “Restrict”. No se permite la actualización del registro referenciado. Es decir, si se trata de modificar la clave primaria de un registro de proyecto en la tabla “Proyectos”, pero ese proyecto tiene registros de avance en la tabla “Proyectos_Avances”, no se permitirá la operación de modificación de ese proyecto en la tabla “Proyectos”, ni sus registros relacionados en la tabla “Proyectos_Avances”.

Las opciones de borrado y actualización de MySQL para el manejo de las llaves foráneas se muestran en la Figura 45. Comportamientos de borrado y actualización dellave foránea.

Figura 45. Comportamientos de borrado y actualización de llave foránea.

56

2.2.2 Creación de disparadores (trigger’s).

Un disparador es una acción que se realiza de manera automática en la base de datos como consecuencia de algún evento. El disparador contiene sentencias de programación y puede también incluir sentencias SQL.

En particular, el disparador responde a ciertos eventos que ocurren en una tabla de la base de datos. Los disparadores pueden restringir el acceso a datos específicos, realizar registro de eventos y auditar modificaciones de datos.

Se tienen dos clases generales de disparadores: Disparador de renglón. Permite definir una acción para cada hilera o renglón de una tabla. Disparador de enunciado. Realiza una sola acción para las sentencias SQL “Insert”,

“Update” y “Delete”.

Los disparadores no se pueden usar para auditar la consulta de datos en el enunciado “Select” de SQL.

De manera general, existen tres tipos de eventos que pueden iniciar la ejecución de un disparador: Evento de agregar. Cuando se está agregando un nuevo registro en la base de datos. Evento de actualizar. Cando se está modificando un registro. Evento de borrar. Cuando se está eliminando un registro.

Las restricciones generales de los disparadores son: No aceptan parámetros o argumentos. No pueden realizar operaciones de “commit” o “rollback”, puesto que son parte del

enunciado SQL que lo produce. Pueden ocasionar errores en las tablas, si no se diseñan y escriben correctamente.

Existen diferentes tipos de disparadores según el DBMS, por ejemplo:

Oracle en su versión 9i, además de los disparadores de modificación de datos, soporta disparadores que se pueden iniciar cuando se modifican objetos del esquema (como tablas) y cuando los usuarios ingresan o salen del sistema. A estos disparadores de les llama disparadores a nivel de esquema (en inglés “Schema-level triggers”).

Microsoft SQL Server soporta disparadores en tablas y vistas. En la versión 2005 introdujo soporte de disparadores para el “Lenguaje de Definición de Datos (DDL)”.

Los disparadores son muy útiles para definir reglas especiales o particulares (de negocio) en la base de datos. Por ejemplo, suponer una base de datos de un inventario, se puede crear un disparador que realice de manera automática un pedido si un artículo baja de cierto nivel de existencias.

Ejemplo práctico en MySQL.

Para el ejemplo de “Proyectos” que se ha estado usando, suponer la necesidad de la siguiente validación que se realizará por medio de un disparador.

57

En la tabla de “Proyectos” se tiene un campo para registrar la fecha de inicio del proyecto (campo “fecha_ini”) y un campo para registrar la fecha de terminación del proyecto (campo “fecha_fin”). Por definición de tipos de datos, el sistema solo aceptará fechas válidas para esos campos, pero de manera independiente en cada campo. Si el usuario por error introduce una fecha de terminación anterior a la fecha de inicio de un proyecto, el sistema no tiene la información sobre lo que debe hacer.

Una solución viable sería que al ingresar un nuevo registro o modificar el existente, si la fecha de terminación es una fecha anterior a la fecha de inicio. El sistema no acepte la fecha de terminación que da el usuario y el valor definitivo para ese campo (“fecha_fin”) sea igual al de la fecha de inicio (“fecha_ini”) para ese proyecto.

Observar que se tienen que crear dos disparadores (para cuando se agrega nuevo registro y para cuando se modifica un registro existente).

MySQL permite crear, eliminar y modificar disparadores. La sintaxis general para crear un disparador es:

CREATE TRIGGER nombre_disp momento_disp evento_dispON nombre_tabla FOR EACH ROW sentencia_disp

Donde: Las palabras en mayúsculas son palabras reservadas. nombre_disp. Es el nombre asignado por el usuario al disparador. momento_disp. Es el momento en que se ejecuta el disparador. Las opciones son:

“BEFORE” (antes) y “AFTER” (después). evento_disp. Es el evento o sentencia que activa al disparador. Las opciones son:

“INSERT”, “UPDATE” y “DELETE”. nombre_tabla. Es el nombre de la tabla donde se ejecutará el disparador. sentencia_disp. Es la sentencia o sentencias que se ejecutan. Si son varias sentencias se

deben encerrar entre “BEGIN” y “END”.

Para crear el disparador de “Update” se entró en la línea de comandos de MySQL (accesible desde la opción de Programas | MySQL o desde el “Query Browser”, en el menú Tools | MySQL Command Line Client), como se muestra en la Figura 46. Acceso a la líneade comandos de MySQL.

58

Figura 46. Acceso a la línea de comandos de MySQL.

Ya en la línea de comandos se muestra el “prompt” o indicador del sistema que es:

mysql>

Cambiarse a la base de datos donde están las tablas del proyecto y donde quedará almacenado el disparador, para esto escribir: “use innovación”, a lo que el sistema responde:

Database changed

Como el delimitador de sentencias es el signo “;” y el disparador incluirá como parte de su sintaxis este signo, es necesario cambiar el delimitador, hacerlo escribiendo:

Delimiter |

Después se puede crear el disparador con las siguientes sentencias como se muestra:

create trigger innovacion.validar_fechas before update on innovacion.proyectos for each row begin if new.fecha_fin < old.fecha_ini then set new.fecha_fin = old.fecha_ini; end if; end; |

Notar que en la última línea se incluyó el nuevo delimitador que indica a MySQL el final de la sentencia. La palabra reservada “new” hace referencia al nuevo valor que se desea para el campo, la palabra “old” hace referencia al valor actual almacenado en la base de datos para el campo indicado. Si todo esta correcto el sistema responde con un mensaje similar a este:

Query OK, 0 rows affected (0.01 sec)

59

La vista completa de la línea de comandos se muestra en la Figura 47. Creardisparador de actualización desde la línea de comandos.

Figura 47. Crear disparador de actualización desde la línea de comandos.

Una vez escrito el disparador de actualización, probarlo en el “Query Browser”. Recordar que por ser disparador de actualización, probar con un registro que ya exista modificando su fecha de fin de proyecto (campo “fecha_fin”), escribiendo una fecha que sea anterior a la fecha de inicio de proyecto (“fecha_ini”). Para ver el resultado del disparador actualizar la vista de los datos de la tabla una vez hecho el cambio.

Para crear el disparador que se ejecute al insertar nuevos registros quedaría de la forma que se muestra en la Figura 48. Crear disparador de inserción desde la línea decomandos.

Figura 48. Crear disparador de inserción desde la línea de comandos.

Observar que en el segundo disparador se hace referencia a la fecha de inicio como “new.fecha_ini”, por ser un nuevo registro.

60

2.2.3 Creación de procedimientos almacenados.

Un procedimiento almacenado es un programa que se encuentra almacenado en la misma base de datos. El procedimiento almacenado puede recibir y regresar parámetros (a diferencia del disparador).

Los procedimientos almacenados pueden mejorar el rendimiento del sistema, pues es posible tener un plan de ejecución previo de parte del DBMS. También se pueden usar para propósitos de seguridad del sistema, al permitir que solo los procedimientos almacenados tengan los permisos de ejecución en el sistema. Esto evita la ejecución de código “extraño” en la base de datos.

Un disparador puede invocar procedimientos almacenados.

El procedimiento almacenado puede regresar conjuntos como resultado. Por ejemplo, el resultado de un enunciado SQL. Tales conjuntos de resultados se pueden procesar usando cursores por otros procedimientos almacenados o por aplicaciones. Los procedimientos almacenados pueden incluir declaración de variables y cursores, que les permiten iterar a través de múltiples renglones de una tabla. El SQL estándar proporciona enunciados “IF”, “WHILE”, “LOOP”, “REPEAT” y “CASE” entre otros. Los procedimientos almacenados pueden recibir variables, regresar resultados o modificar variables y regresarlas.

La implementación de los procedimientos almacenados varía de un DBMS a otro. También dependiendo del sistema, se implementan en diferentes lenguajes de programación, por ejemplo SQL, Java, C y C++.

Por el uso cada vez mayor de los procedimientos almacenados se han introducido elementos procedurales en SQL, en la parte del SQL/PSM (“Structured Query Language/Persistent Stored Modules”). Muchos sistemas de bases de datos ofrecen extensiones propietarias y específicas del fabricante, para extender el SQL/PSM, por ejemplo, en la Tabla 4. Relación de DBMS y sus lenguajes para escribir procedimientosalmacenados, se listan algunos DBMS relacionales y el lenguaje que usan para los procedimientos almacenados.

DBMS Lenguaje para los procedimientos almacenados.Microsoft SQL Server Transact-SQLOracle PL/SQLDB2 SQL/PLPostgreSQL PL/pgSQLMySQL Estándar SQL:2003

Tabla 4. Relación de DBMS y sus lenguajes para escribir procedimientos almacenados.

Algunos usos comunes de los procedimientos almacenados son: Validación de los datos de la base de datos. Como mecanismo de control de acceso. De manera que los usuarios solo puedan

interactuar con la base de datos por medio de los procedimientos almacenados.

61

Consolidar y centralizar la lógica del sistema, que originalmente estaba implementada en las aplicaciones. De esta manera, un procesamiento largo y complejo que puede requerir de la ejecución de algunos enunciados SQL, se pueden poner en un procedimiento almacenado y todas las aplicaciones invocan a los procedimientos.

Mejorar la seguridad. Puesto que este código está almacenado en la misma base de datos, se pueden controlar adecuadamente las operaciones de este en la base de datos.

Mejor eficiencia de las operaciones. Se puede tener un código ejecutable para cada procedimiento almacenado, sin necesidad de compilarlo y optimizarlo cada vez que se ejecute.

Algunas consideraciones sobre los procedimientos almacenados: Los enunciados SQL implementados como procedimientos almacenados, en algunos

casos se pueden ejecutar más rápido. Los planes de ejecución de los enunciados compilados pueden almacenarse en la base de datos, junto con el procedimiento. Esto puede reducir la sobrecarga de compilación que se requiere en situaciones donde aplicaciones de software envían consultas SQL a la base de datos. Sin embargo, algunos sistemas de bases de datos usan “caches” (almacenamiento en memoria) para las sentencias para evitar compilación repetitiva de enunciados SQL dinámicos.

Aunque un enunciado SQL precompilado, puede evitar alguna sobrecarga, es más compleja la creación de un plan de ejecución óptimo, puesto que no se conocen todos los argumentos al momento de la compilación.

El procedimiento almacenado puede ejecutarse directamente dentro de la máquina de base de datos. Lo que significa que el procedimiento almacenado se ejecuta completamente en el servidor de la base de datos. Con el beneficio de que se eliminan costos de comunicación en la red. Esto será muy importante para enunciados SQL complejos.

La ejecución innecesaria o excesiva de procedimientos almacenados en el servidor puede afectar negativamente el rendimiento de todo el sistema.

Ejemplo práctico de un procedimiento almacenado en MySQL.

Para el mismo ejemplo de proyectos que se ha trabajado, suponer que se requiere un procedimiento almacenado que obtenga y regrese la cantidad de proyectos que se encuentran en el estado de “proceso” para un departamento determinado. El procedimiento almacenado recibirá como entrada el nombre del departamento y regresará como salida la cantidad de proyectos que se encuentran en el estado de “proceso” para ese departamento.

Para crear un procedimiento almacenado, seleccionar la base de datos correspondiente y hacer clic con el botón derecho del Mouse, en el menú contextual seleccionar la opción “Create new procedure/function”, como se muestra en la Figura 49.Crear procedimiento almacenado, paso 1.

62

Figura 49. Crear procedimiento almacenado, paso 1.

Se abre el dialogo donde se tiene que indicar el nombre del procedimiento y para indicar si será procedimiento o función, como se muestra en la Figura 50. Crearprocedimiento almacenado, paso 2.

Figura 50. Crear procedimiento almacenado, paso 2.

En la siguiente pantalla (ver Figura 51. Escribir procedimiento almacenado) debe escribirse el procedimiento almacenado, que debe quedar como se muestra ahí mismo.

63

Figura 51. Escribir procedimiento almacenado

Una vez escrito el procedimiento, verificado su sintaxis y almacenado en la base de datos, probarlo desde la línea de comandos de MySQL, como se muestra en la Figura 52.Ejecutar procedimiento almacenado.

Figura 52. Ejecutar procedimiento almacenado.

Observar la llamada o invocación al procedimiento mediante la sentencia:

Call proyectos_cantidad(“RH”, @cantidad);

64

Donde “RH” es el nombre del departamento del cual se quieren obtener el número de proyectos en “proceso”, la variable “cantidad” es la variable de salida donde el procedimiento regresa su resultado.

Observar la sentencia “select @cantidad;”, para obtener y desplegar el resultado de la variable.

Probar el procedimiento para otros departamentos. Escribir nuevos procedimientos almacenados diseñados por usted.

2.3 Definición del esquema de seguridad.

Del diccionario, seguridad significa: “calidad de seguro”. A su vez, seguro se define como: “Libre de todo daño, peligro o riesgo.”, “Cierto, que no admite duda o error.”, “Firme, estable.”, “Que merece confianza, fiel, leal.”, “Confianza, certeza.”.

El término “seguridad informática”, se define como:“La seguridad informática consiste en asegurar que los recursos del sistema de información (material informático o programas) de una organización sean utilizados de la manera que se decidió y que el acceso a la información allí contenida así como su modificación sólo sea posible a las personas que se encuentren acreditadas y dentro de los límites de su autorización.”

Otra definición de seguridad informática: “Garantizar que los recursos informáticos de una compañía estén disponibles para cumplir sus propósitos, es decir, que no estén dañados o alterados por circunstancias o factores externos.”

El tema de la seguridad informática ha ido creciendo y han surgido varias áreas de especialización, entre ellas se pueden mencionar: Auditoria de sistemas de información. Ciencia forense digital. Planeación continua de negocios.

Existen muchos factores que pueden afectar la seguridad informática, se pueden mencionar: El usuario: causa del mayor problema ligado a la seguridad de un sistema informático. Programas maliciosos: programas destinados a perjudicar o a hacer un uso ilícito de los

recursos del sistema. Es instalado (por inatención o maldad) en el ordenador abriendo una puerta a intrusos o bien modificando los datos. Estos programas pueden ser un virus informático, un gusano informático, un troyano, una bomba lógica o un programa espía, entre otros.

Un intruso: persona que consigue acceder a los datos o programas de los cuales no tiene acceso permitido (hacker, cracker, etc.).

Un siniestro (robo, incendio, por agua): una mala manipulación o una mal intención derivan a la pérdida del material o de los archivos.

El personal interno de Sistemas. Las pugnas de poder que llevan a disociaciones entre los sectores y soluciones incompatibles para la seguridad informática.

Por medio de Internet: ataques de negación de servicio y amenazas combinadas, como integración de herramientas automáticas de “hackeo”, accesos no autorizados a los

65

sistemas y capacidad de identificar y explotar las vulnerabilidades de los sistemas operativos o aplicaciones para dañar los recursos informáticos.

Un esquema de seguridad, consiste de políticas, planes y procedimientos que permiten garantizar una seguridad adecuada para la base de datos. Un esquema completo de seguridad debe considerar todos los factores de riesgo para la seguridad. Las políticas de seguridad deben considerar el monitoreo de la infraestructura de la red, los enlaces de telecomunicaciones, la realización del respaldo de datos, y el reconocimiento de las propias necesidades de seguridad. El establecimiento de las políticas permitirá establecer una arquitectura de seguridad basada en soluciones tecnológicas, así como el desarrollo de un plan de acción para el manejo de incidentes y recuperación. Cada plan de acción se detalla mediante uno o más procedimientos, que indican las acciones concretas a realizar.

Cada dispositivo que conforma la red necesita de un nivel de seguridad apropiado y la administración del riesgo implica una protección en varias dimensiones (firewall, autenticación, antivirus, controles, políticas, procedimientos, análisis de vulnerabilidad, entre otros), y no únicamente tecnología.

El esquema de seguridad debe considerar la seguridad física (protección contra robo o daño), y la seguridad lógica (protección de la información).

Hablando en particular de las bases de datos, se puede definir la “seguridad de la base de datos” como: “el sistema, procesos y procedimientos que protegen una base de datos de actividad no prevista. La actividad no prevista puede ser de varios tipos: mal uso de usuarios autorizados, ataques mal intencionados o equivocaciones de individuos o procesos autorizados.”

Las bases de datos proporcionan varias capas y formas para la seguridad de la información, típicamente especificada en el diccionario de datos, que incluye: Control de acceso. Es la habilidad de permitir o denegar el uso de un recurso a una

entidad. Auditoria. Se realiza para asegurar la validez y fiabilidad de la información. Autenticación. Es el acto para establecer o confirmar que alguien o algo es auténtico. Encriptación. Proceso para transformar la información (como “texto plano” o legible

directamente) usando un algoritmo para lograr que la información no pueda leerse, excepto por quien posee una clave.

Controles de integridad. Son los mecanismos establecidos por los creadores de la base de datos para asegurar la consistencia de la información, tales como: llaves primarias, llaves foráneas, reglas de validación, reglas de dominio, disparadores, etc.

Una parte del esquema de seguridad de la base de datos, es la definición de los usuarios que tendrán acceso a la base de datos, definir a que objetos se tiene acceso y los tipos de permisos sobre los objetos. Tarea que normalmente realiza el administrador de la base de datos.

Una facilidad que proporcionan algunos sistemas de bases de datos es crear un “grupo o tipo de usuarios”, a cada grupo se le asigna los permisos y características deseadas y posteriormente cada usuario se asocia a un grupo. De esta manera el usuario “hereda” los permisos de ese grupo.

66

La anterior facilidad no esta disponible en MySQL Server en la versión gratuita, por lo que es necesario asignar a cada usuario individual sus objetos y permisos.

El esquema de seguridad planteado en este libro contendrá los siguientes puntos y que se desarrollan más adelante:

Creación de usuarios de la base de datos. Asignación de privilegios sobre los objetos de información.

2.3.1 Creación de usuarios de la base de datos.

Una vez establecido el esquema de seguridad, se crean los usuarios que tendrán acceso a la base de datos. Para llegar a este punto se deben tener definidos de manera previa los dominios creados por el DBA. Recordar que los dominios sirven para hacer una clasificación general de los tipos de usuarios de la base de datos y de las operaciones permitidas para cada dominio.

Para crear los usuarios se debe tener previamente una lista precisa de todos ellos y su clasificación de dominio. Aunque siempre será necesario administrar a los usuarios, al agregar y eliminar usuarios, y modificar permisos de ellos.

En este caso se ejemplificará la creación de usuarios para MySQL Server. En el “MySQL Administrador” entrar a la opción de “User Administration”, que permite crear los usuarios y asignar permisos. Como se ve en la Figura 53. Opción para administrarusuarios en MySQL.

Figura 53. Opción para administrar usuarios en MySQL.

67

Observar las opciones de “User Administration”: “User information”. Permite agregar, modificar o eliminar usuarios. Es la pantalla mostrada

en la figura anterior. Para crear un nuevo usuario, hacer clic en el botón de “Add new user”.

“Schema Privileges”. Permite asignar privilegios a cada usuario. Se selecciona la base de datos particular y se asignan los permisos deseados.

“Resources”. Permite asignar recursos al usuario, tales como el número de consultas, actualizaciones, conexiones, etc., que podrá realizar. Nota: esta ficha aparece hasta que se selecciona un usuario de la lista o se acaba de crear uno nuevo.

Del lado izquierdo y la parte inferior de la pantalla de la Figura 53. Opción paraadministrar usuarios en MySQL, notar la lista de usuarios que ya están creados, de aquí se puede seleccionar un usuario para modificar sus datos o darlo de baja.

Al hacer clic en el botón de “Add new user”, se escriben los datos del usuario, como un ejemplo se muestra la Figura 54. Crear usuario en MySQL.

Figura 54. Crear usuario en MySQL.

Es recomendable llenar todos los campos de datos, una vez hecho esto, se hace clic en el botón de “Apply changes”, para crear el nuevo usuario.

Una vez creado el usuario se le pueden asignar sus privilegios, como se ejemplifica en el tema que sigue. Recordar que una alternativa a asignar privilegios de manera individual a cada usuario, es asignar cada usuario a un dominio (rol). Y solo modificar una vez los privilegios dentro del rol.

68

2.3.2 Asignación de privilegios sobre los objetos de información.

Los privilegios establecen las operaciones que el usuario podrá realizar en la base de datos. Este es un aspecto de mucha importancia para la seguridad de la base de datos. Pues elimina la posibilidad de que de manera intencional o accidental un usuario pueda hacer operaciones indebidas en la base de datos.

Los usuarios pueden tener varios tipos de privilegios para el acceso a los datos de la base de datos: De lectura. Se pueden leer datos, pero no modificarlos. De inserción. Se pueden agregar nuevos datos. De actualización. Se pueden modificar datos. De borrado. Se pueden eliminar o borrar datos.

Además de los privilegios para el acceso a los datos, se tienen privilegios para modificar el esquema de la base de datos, estos son:

De índices. Permite crear y borrar índices. De recursos. Para la creación de nuevas relaciones y objetos. De alteración. Para añadir o borrar atributos de las relaciones. De eliminación. Para borrar relaciones.

El DBA debe asegurarse de tener siempre a la mano la relación de usuarios, el dominio al que pertenece cada uno y los privilegios asignados sobre cada objeto, una herramienta administrativa del DBMS que proporcione esta información será de gran utilidad.

El mayor nivel de privilegios lo tiene el DBA. Ya que es su responsabilidad la administración de los usuarios, reestructurar la base de datos, etc. Los privilegios se pueden asignar escribiendo de manera directa las sentencias SQL o bien usando la interfase gráfica que proporcione el DBMS.

Enseguida se ejemplifica la asignación de privilegios en MySQL. Para asignar los privilegios, en la misma opción “User Administration” se selecciona el usuario al cuál se desea asignar privilegios. Seleccionar la ficha “Schema Privileges” y aquí seleccionar los privilegios que previamente se definieron para este usuario en el esquema de seguridad. Ver Figura 55. Asignar privilegios en modo gráfico a usuarios en MySQL.

69

Figura 55. Asignar privilegios en modo gráfico a usuarios en MySQL.

Observar los pasos para la asignación de privilegios:1. Seleccionar la base de datos. Aparece la lista de las bases de datos en el servidor. En este caso se seleccionó la base de datos “innovación”.2. Seleccionar el privilegio deseado. Observar la lista de privilegios disponibles y su significado. Para este caso particular, se asignaron privilegios para que el usuario pueda consultar (SELECT), actualizar (UPDATE), borrar (DELETE) y agregar (INSERT) registros en la base de datos “innovación”.3. Agregar el privilegio. Con los botones se puede agregar o quitar cualquier privilegio. Observar los botones para agregar todos (“<<”) y quitar todos (“>>”) los privilegios.4. Aplicar los cambios. Los privilegios asignados al usuario son almacenados de manera permanente en la base de datos.

En cualquier momento se pueden modificar los privilegios de los usuarios.

Una limitación en MySQL Server en su versión gratuita, es que los privilegios se definen sobre la base de datos completa (al menos desde la interfase gráfica). Lo más deseable es poder asignar privilegios sobre objetos particulares de la base de datos, por ejemplo, sobre ciertas vistas, que como se ha mencionado antes, se usan para mejorar la seguridad del sistema.

Para asignar privilegios de manera individual sobre ciertos objetos de la base de datos, se hace desde la ventana de “MySQL Command Line Client”, usando la sentencia “GRANT” de SQL. Revisar la sintaxis y opciones de dicha sentencia. En el ejemplo que sigue (ver Figura 56. Asignar privilegios con la línea de comandos en MySQL) se crea un

70

nuevo usuario llamado “luis” con la contraseña “luis123” y se le asigna permiso de consultar la tabla “Proyectos” de la base de datos “innovación”. Tener en cuenta que los usuarios los puede crear el usuario “root” u otro usuario con permisos de administración.

Figura 56. Asignar privilegios con la línea de comandos en MySQL.

Si el privilegio se asignó correctamente, se muestra el mensaje “Query OK, …”. Para probar que se realizó correctamente, hacer una conexión al servidor de MySQL con este usuario y contraseña para verificar que este podrá consultar la tabla “Proyectos” de la base de datos correspondiente. Se puede usar el “MySQL Query Browser”. Verificar si el usuario podrá modificar los datos de la tabla

La sentencia “GRANT” tiene muchas opciones que es conveniente revisar y analizar las posibles consecuencias de ciertos tipos de privilegios. Una recomendación de seguridad es asignar los privilegios mínimos a los usuarios. Para retirar privilegios a un usuario se usa la sentencia SQL “REVOKE”.

En “MySQL” se tienen que definir los recursos asignados al usuario, de otra manera el usuario no podrá “usar” la base de datos. Para ello entrar a ficha de “Resources” y asignar los recursos necesarios. Como ejemplo, ver la Figura 57. Asignar recursos a usuarios enMySQL.

71

Figura 57. Asignar recursos a usuarios en MySQL.

De la pantalla de la Figura 57. Asignar recursos a usuarios en MySQL, observar que el número máximo de consultas, actualizaciones y conexiones están por hora. En la última opción se puede limitar el número de conexiones simultáneas al servidor para ese usuario. Tomar en cuenta que si el usuario accede a la base de datos desde el “MySQL Query Browser”, cada vez que se abre una tabla, se cuenta como una consulta.

2.4 Definición del esquema de recuperación.

El esquema de recuperación en una base de datos, debe contener políticas, planes y procedimientos que aseguren la consistencia, disponibilidad y funcionalidad adecuada de la base de datos.

Por ejemplo, la falla en un dispositivo de almacenamiento permanente donde este almacenada la base de datos, no debe ser motivo para que esta quede fuera de servicio. Y en el esquema de recuperación debe estar contemplada esta posibilidad, tener las alternativas viables de respuesta y los procedimientos detallados para solucionar y responder de manera adecuada a dicha situación.

Silberschatz y colaboradores mencionan tres tipos generales de fallas, que requerirán del uso del esquema de recuperación: Falla en la transacción. La transacción no puede terminar correctamente su operación.

Esto se puede deber a un error lógico de la misma (alguna condición interna como entrada incorrecta, datos no encontrados, desbordamiento, etc.), o se puede deber a un error del sistema (como un interbloqueo).

Caída del sistema. Se origina por un mal funcionamiento del hardware, un error en el software de la base de datos, o un error del sistema operativo. Este tipo de falla ocasiona

72

la pérdida del contenido de la memoria principal y se abortan las transacciones que se estaban procesando.

Falla del disco. Se pierde una parte (o todo) del contenido de la base de datos. Se deben usar los respaldos de la base de datos y las bitácoras para la recuperación. La recuperación de este tipo de falla requiere de la intervención del DBA.

El sistema de recuperación de fallas incorporado en el DBMS, debe realizar una recuperación automática del sistema en caso de falla en la transacción y de caída del sistema. De manera que después de presentadas estas fallas, el sistema verifica el estado de las transacciones que se estaban ejecutando y realiza una recuperación automática sin una solicitud explícita del DBA o de cualquier otro usuario.

Los DBMS incorporan el sistema de recuperación para asegurar que se cumplan las propiedades de atomicidad y durabilidad de las transacciones. La atomicidad de una transacción indica que se debe tratar a todas las operaciones de una transacción como una unidad, de manera que el sistema asegura que se realicen todas las operaciones de la transacción adecuadamente o ninguna de ellas. La durabilidad significa que una vez que una transacción finaliza con éxito, los cambios realizados por ella en la base de datos son permanentes.

Los DBMS incorporan algunas facilidades para asegurar que la base de datos siga siendo consistente, disponible y funcional a pesar de diversas situaciones de falla. Por ejemplo:

Bitácoras. Son archivos que se almacenan en la base de datos y registran las operaciones realizadas, versiones de los datos antes y después de actualizaciones, usuario que accede a cierto dato, fechas, identificación de las transacciones, eventos, errores, etc. Permiten la administración de las transacciones en la base de datos y sirven de apoyo para la recuperación de la base de datos. En caso de una falla, el DBMS puede usar la información de la bitácora para dejar la base de datos en un estado consistente. Normalmente se usan varios archivos de bitácora.

Respaldo. Se proporcionan facilidades de respaldo de las bases de datos. De tal manera que se pueden tener copias de seguridad, con la frecuencia que requiera el sistema.

Recuperación. Facilidades para restaurar la información de la base de datos en base a los respaldos e información de la bitácora.

Un esquema de recuperación es indispensable en cualquier base de datos. De esta manera el administrador de la base de datos y los responsables de los sistemas pueden responder de manera adecuada a cualquier falla del sistema.

Enseguida se describen algunas facilidades de los DBMS que sirve de apoyo para el esquema de recuperación. Algunos DBMS proporcionan facilidades adicionales como la posibilidad de tener dispositivos de almacenamiento redundantes, como los sistemas RAID (Disposición redundante de discos independientes), crear servidores de replicación, etc.

73

2.4.1 Diseño y creación de la bitácora.

Recordar que una bitácora es un archivo del DBMS, y donde se registran eventos y cambios realizados en la base de datos. Normalmente los DBMS tienen sus archivos de bitácora base que son necesarios para la recuperación automática en caso de fallas, estos son administrados por el DBMS y los usuarios no requieren estar concientes de ellos. También algunos DBMS permiten al DBA definir y crear nuevos archivos de bitácora.

La manera de crear los archivos de bitácora depende del DBMS. Algunos DBMS proporcionan facilidades para que el administrador pueda definir los archivos de bitácora a crear y el contenido que tendrá cada uno de ellos.

En este caso se ejemplificará el tema usando MySQL Server 5.0 en su versión gratuita.

Cuando se instala y configura el servidor no se crean de manera automática todos los archivos de bitácora. Con el “MySQL Administrator” se pueden crear los archivos de bitácora adicionales. Tener en cuenta que los archivos de bitácora que se crean dependerán del motor o máquina de almacenamiento usada, para este ejemplo se está usando “InnoDB” como máquina de almacenamiento, que tiene soporte para transacciones e incluye recuperación automática de fallas.

MySQL permite crear cinco archivos de bitácora (pero uno de ellos ya está en desuso) que se describen de manera breve en la Tabla 5. Tipos de archivos de bitácora deMySQL.. Para mas detalles consultar el manual del software correspondiente.

Debe quedar claro que estos archivos de bitácora no eliminan la necesidad de que el administrador o responsables tengan que realizar las copias de seguridad necesarias para la base de datos. Es recomendable que las copias de seguridad estén en un lugar físico diferente a la base de datos, lo que se aplica también para los archivos de bitácora. Pues por ejemplo en caso de falla del disco duro se perderían todos ellos.

Una vez creados los archivos de bitácora es necesario darles mantenimiento. Un motivo es para asegurarse que no ocupen demasiado espacio, y las actualizaciones que ya están incluidas en las copias de seguridad ya no será necesario mantenerlas en las bitácoras. Es conveniente también indicarle a MySQL el usar archivos de bitácora nuevos, para esto consultar la sentencia “mysqladmin flush-logs” o con la sentencia “FLUSH LOGS”.

En MySQL para crear los archivos de bitácora (nombrados “log files” en MySQL), entrar al programa “MySQL Administrator”, en la lista de opciones del lado izquierdo seleccionar la opción “Startup Variables” y la ficha “Log files”, ver Figura 58. Pantalla paraver archivos de bitácora en MySQL..

Archivo de bitácora Tipo de información almacenada en el archivoRegistro de error (Error log) Registra problemas encontrados iniciando, ejecutando o parando

mysqld (mysqld se refiere a “mysql daemon” o el servidor de MySQL).Registro de consultas (Query log) Registra las conexiones de clientes establecidas, y las sentencias

ejecutadas. Contiene todas la sentencias, incluidas las que no actualizan datos.

Registro de actualizaciones (Update log)

Registra las sentencias que cambian datos. En desuso actualmente.

74

Registro binario (Binary log) Registra todas las sentencias que cambian datos. También se usa para replicación. Usa un formato eficiente y de una manera que es segura para las transacciones. Sustituye al registro “Update log”.

Registro de lentitud (Show query log) Registra todas las sentencias que tardaron mas de cierto tiempo en ejecutarse (establecido en la variable “long_query_time”), o que no usaron índices.

Tabla 5. Tipos de archivos de bitácora de MySQL.

Figura 58. Pantalla para ver archivos de bitácora en MySQL.

En la pantalla de la Figura 58. Pantalla para ver archivos de bitácora en MySQL., se puede activar cada casilla de verificación para crear cada tipo de archivo de bitácora deseado. Observar las opciones adicionales disponibles que por ejemplo permiten:

Configuración cuando se tienen servidores de replicación de la base de datos. Nombres de archivos. Tamaño máximo de archivos. Establecer el valor para la variable “long_query_time”. Formato de archivos de bitácora. Registrar consultas que no usan índices. Registro de advertencias (“warnings”) del sistema. Especificar rotación de archivos de bitácora después de ciertos días, etc.

Como se puede observar se pueden indicar los nombres de los archivos de bitácora,

para el ejemplo, se usaron los nombres que se muestran en la Figura 59. Crear archivos debitácora en MySQL..

75

Figura 59. Crear archivos de bitácora en MySQL.

Después de escribir los nombres de los archivos de bitácora y seleccionar las opciones deseadas hacer clic en el botón de aplicar cambios (“Apply changes”). Para que se creen los archivos y se aplique la configuración seleccionada es necesario reiniciar el servidor. Para hacer esto último, desde el mismo programa de “MySQL Administrador” seleccionar la opción “Service Control” para detener y reiniciar el servidor MySQL.

Después de reiniciar el servidor, verificar la carpeta “data” de MySQL, que en la instalación común tendrá una ruta semejante a: “C:\Archivos de programa\MySQL\MySQL Server 5.0\data”, aquí se podrán observar los archivos de bitácora creados. Ver Figura 60.Ver archivos de bitácora creados en MySQL..

Figura 60. Ver archivos de bitácora creados en MySQL.

76

Una vez hecho esto los archivos de bitácora registrarán lo correspondiente a cada uno de ellos. Algunos son archivos de texto y el usuario podrá revisar su contenido. Para crear nuevos archivos de bitácora (se aplica a “Binary log” y “Error log”), entrar a la línea de comandos de MySQL y escribir la sentencia “Flush logs”, como se muestra en la Figura 61.Crear nuevos archivos de bitácora en MySQL..

Figura 61. Crear nuevos archivos de bitácora en MySQL.

Observar nuevamente la carpeta “data”. El sistema crea un nuevo archivo con una numeración secuencial (para la bitácora “Binary log”). Como se muestra en la Figura 62. Vernuevos archivos de bitácora creados en MySQL..

Figura 62. Ver nuevos archivos de bitácora creados en MySQL.

77

Una vista parcial de la bitácora “Query log”, en este caso nombrada como “bitacora_query_log1”, se muestra en la Figura 63. Vista parcial del contenido del archivo debitácora “Query log" en MySQL..

Figura 63. Vista parcial del contenido del archivo de bitácora “Query log" en MySQL.

Enseguida se mostrará la manera de recuperar información usando los archivos de bitácora.

2.4.2 Recuperación a partir de la bitácora.

Cuando existe una falla, dependiendo del tipo de ella se puede usar la bitácora para la recuperación.

Los tipos de fallas que se pueden presentar, se pueden clasificar en:• Del sistema operativo. • De energía.• Del sistema de archivos.• Problema de hardware (disco duro, tarjeta madre, etc.)

A continuación se describen las acciones a realizar de acuerdo al tipo de falla.

• Del sistema operativo. Se asume que el servidor MySQL está bajo carga de trabajo en el momento del fallo. Si no fuera así, no se necesitaría ninguna recuperación. Para casos de fallos de energía o de sistema operativo, se puede asumir que el disco de datos (base de datos) de MySQL está disponible tras el reinicio. Puede que entonces los archivos de datos de InnoDB no contengan datos consistentes debido al fallo, pero InnoDB lee sus registros y encuentra en ellos la lista de transacciones confirmadas y no confirmadas que todavía no

78

han sido volcadas a sus archivos de datos, y los vuelca. La información sobre este proceso de recuperación de errores se le muestra al usuario a través del registro de errores de MySQL. Es decir, el sistema se recupera de manera automática usando sus archivos de bitácora.

Aún cuando el sistema se recupera de manera automática usando los archivos de bitácora, el administrador o responsable del sistema puede “ejecutar” de manera explícita los archivos de bitácora para asegurarse que las actualizaciones registradas en ellos se escriban de manera permanente hacia la base de datos. Para esto solo se requiere “rotar” los archivos de bitácora, este procedimiento escribe todos los cambios registrados en los archivos de bitácora hacia la base de datos, cierra esos archivos y genera nuevos archivos de bitácora con números secuenciales. Para esto se usa la sentencia “FLUSH LOGS” explicada en el tema 2.4.1 Diseño y creación de la bitácora.

• De energía. Se maneja igual que una falla del sistema operativo.

• Del sistema de archivos. En casos de fallas del sistema de archivos o de hardware, se puede asumir que el disco de datos de MySQL no está disponible tras el reinicio. Esto significa que MySQL no puede arrancar normalmente porque algunos bloques de datos del disco no son legibles. En este caso, es necesario reformatear el disco, instalar uno nuevo, o en cualquier caso, corregir el problema subyacente. Después es necesario recuperar los datos de MySQL desde copias de seguridad, lo que significa que se tiene que tener copias ya realizadas.

• Problema de hardware. Se maneja igual que una falla del sistema de archivos.

2.4.3 Respaldar bases de datos.

Como se ha mencionado antes, es indispensable en cualquier sistema que use una base de datos, hacer los respaldos (copias de seguridad) necesarios, para poder realizar la recuperación de la base de datos en caso de fallas. Para esto es necesario tener establecida una política de respaldos de la base de datos y llevarla a cabo. Dicha política deberá contener como mínimo: las fechas y horas de los respaldos, los responsables, la verificación de la realización de los respaldos, y la verificación de que la base de datos se puede recuperar a partir del respaldo.

Un respaldo completo de la base de datos puede ser un proceso que consume tiempo y puede ser necesario “cerrar” la base de datos para los usuarios. Es común programar y automatizar los respaldos en horarios en que hay pocos (o ningún usuario) trabajando con la base de datos.

Por ejemplo, en SQL Server Express, la opción para realizar los respaldos se encuentra en la opción “Server Objetcs” | “Backup Device” | “Back Up to Database…”. Como se muestra en la Figura 64. Pantalla para respaldar base de datos en SQL Server Express..

79

Figura 64. Pantalla para respaldar base de datos en SQL Server Express.

Una vista de algunas opciones de respaldo se muestran en la Figura 65. Opcionesde respaldo de base de datos en SQL Server.. Observar que se puede seleccionar una base de datos completa o parcial, y que el respaldo es almacenado en un archivo con extensión “.bak”.

Figura 65. Opciones de respaldo de base de datos en SQL Server.

80

En el caso del DBMS Oracle en su versión gratuita, la opción para respaldos se encuentra en “Inicio” | “Utilidades” | “Carga/descarga de Datos”, como se muestra en la Figura 66. Pantalla para respaldar base de datos en Oracle Database Express..

En el caso de MySQL, la opción para respaldos está en el menú principal, opción “Backups”, como se muestra en la Figura 67. Pantalla para respaldar base de datos en MySQL..

Observar en la Figura 67. Pantalla para respaldar base de datos en MySQL., las tres fichas disponibles para respaldos. En este caso para llevar a cabo un respaldo es necesario primero crear un nuevo proyecto de respaldo, haciendo clic en el botón “New Project” de la ficha “Backup Project”. Una vez hecho esto se proporciona la información para el respaldo. Considerar el ejemplo que se indica en la Figura 68. Opciones de respaldo en MySQL.

Figura 66. Pantalla para respaldar base de datos en Oracle Database Express.

81

Figura 67. Pantalla para respaldar base de datos en MySQL.

Nota: En MySQL se recomienda antes de realizar el respaldo, rotar los archivos de bitácora para asegurar que los cambios registrados en los últimos archivos de bitácora se escriban a la base de datos, y el nuevo archivo de bitácora (o archivos) solo contengan los nuevos cambios a partir de la copia de seguridad. El procedimiento para hacer esto para MySQL se explica en el tema 2.4.1 Diseño y creación de la bitácora.

82

Figura 68. Opciones de respaldo en MySQL.

En la pantalla mostrada en la Figura 68. Opciones de respaldo en MySQL, se indicó un nombre descriptivo para el respaldo, haciendo mención a la base de datos correspondiente. Enseguida se seleccionó la base de datos a respaldar. Observar que es posible seleccionar solo ciertos objetos de la base de datos o completa (opción por omisión). Es recomendable salvar la información descriptiva del respaldo con el botón “Save Project”. Esta opción, almacena la definición del respaldo. Para realizar el respaldo hacer clic en el botón “Execute Backup Now”, por omisión MySQL agrega al nombre del archivo que contiene el respaldo, la fecha y hora de este. El respaldo genera un archivo de texto en la ubicación seleccionada por el usuario, y el archivo contiene sentencias SQL para crear los objetos necesarios (tablas, vistas, procedimientos, etc.) y su contenido actual.

Al hacer clic en el botón “Execute Backup Now”, y la acción se realiza con éxito, se muestran mensajes como se ve en la Figura 69. Pantalla de avance de respaldo en MySQL..

83

Figura 69. Pantalla de avance de respaldo en MySQL.

Por otra parte, en la ficha “Advanced Options”, se tienen las opciones mostradas en la Figura 70. Opciones de respaldo avanzadas en MySQL..

Figura 70. Opciones de respaldo avanzadas en MySQL.

84

Notar que hay opciones que dependen del motor de almacenamiento usado. En el caso de InnoDB, la opción por omisión es la más recomendada. También esta la opción “Complete backup” que es útil cuando es frecuente que se agreguen nuevos objetos (tablas, vistas, etc.) a la base de datos que se respalda.

El contenido y un ejemplo con datos de la ficha “Schedule” se muestra en la pantalla de la Figura 71. Calendarización de un respaldo en MySQL.

Figura 71. Calendarización de un respaldo en MySQL.

La ficha “Schedule”, como su nombre lo indica permite calendarizar y automatizar la realización de los respaldos. Es una opción muy útil, sin embargo el administrador debe estar revisando que estos respaldos se estén generando de manera adecuada.

Para este ejemplo, se habilitó la opción para generar respaldos automáticos en la opción “Schedule this backup Project” y se seleccionó la ubicación para el almacenamiento de los respaldos. Se usa el mismo nombre de archivo, no se sobrescribirán los respaldos, pues recordar que MySQL agregará al nombre del archivo la fecha y hora de realización.

Por otro lado se definió que será un respaldo semanal, que se realizará dos días de la semana (miércoles y viernes) a las 23:00 horas.

85

Después de cada cambio en la especificación del proyecto de respaldo es necesario salvar los cambios, haciendo clic en el botón “Save Project”.

Ya contado con los respaldos adecuados, se puede recuperar la base de datos de cualquier falla presentada. La recuperación se trata en el tema que sigue.

2.4.4 Recuperar bases de datos.

Ya en el tema 2.4.2. se mencionaron los tipos de fallas y las acciones del sistema y de los administradores para la recuperación de la base de datos.

Cuando es una falla del sistema operativo o de energía eléctrica, normalmente se tiene disponible la base de datos, y basado en los archivos de bitácora el DBMS realiza una recuperación automática de la base de datos. El DBMS completa las transacciones pendientes de actualizar la base de datos.

En fallas del sistema de archivos y de hardware, se requerirá la intervención del administrador de la base de datos o los responsables de la recuperación. Para esto será indispensable contar con los respaldos de seguridad. También se requerirán los archivos de bitácora que no han escrito sus modificaciones hacia la base de datos. Un ejemplo típico de este tipo de falla es un daño permanente en el dispositivo de almacenamiento de la base de datos, donde se requerirá reinstalar y configurar todo el software necesario en otro dispositivo de almacenamiento permanente.

Los DBMS proporcionan facilidades para la recuperación de la base de datos. Además de la recuperación automática, se tienen opciones explícitas para aplicar la recuperación.

Enseguida se explicará la recuperación de la base de datos en MySQL, usando los respaldos y los archivos de bitácora. A partir de una falla, el procedimiento general consiste en:

Recuperar la base de datos a partir de la última copia de seguridad. Ejecutar los últimos archivos de bitácora que se han generado a partir de la última

copia de seguridad y terminando con el archivo de bitácora más reciente.

Ya en el tema 2.4.3 se explicó la manera de realizar las copias de seguridad. Una vez teniendo las copias de seguridad se puede realizar la recuperación de la base de datos. En MySQL para hacer la recuperación ir a la opción “Restore”, como se muestra en la Figura 72.Pantalla para recuperar base de datos en MySQL..

86

Figura 72. Pantalla para recuperar base de datos en MySQL.

Observar las dos fichas de la opción “Restore”, que son “General” y “Restore Content”. En la ficha “General” se puede seleccionar un archivo de “backup” para la recuperación y realizarla. En la segunda opción “Restore Content”, también permite seleccionar un archivo de “backup”, pero además es posible analizar el contenido del archivo y seleccionar de manera particular los objetos a recuperar.

Para realizar una recuperación de un archivo de copia de seguridad completo, en la primer ficha, se selecciona el archivo de copia de seguridad, haciendo clic en el botón “Open Backup File”, el cuál abre un diálogo para que el usuario seleccione el archivo a usar, como se muestra en la Figura 73. Seleccionar archivo para recuperación en MySQL.

87

Figura 73. Seleccionar archivo para recuperación en MySQL.

Aquí es necesario ubicar el directorio de los archivos de respaldo y debe seleccionarse el más reciente. Recordar que MySQL agrega al nombre del archivo, la fecha y hora de su realización. Para el ejemplo actual, notar que se tienen dos archivos de respaldo del mismo día (15 de abril del 2008), pero el seleccionado es más reciente (13:11 hrs.), comparado con el primer archivo (12:36 hrs.). El formato que está usando MySQL para la fecha y hora concatenada al archivo es:

aaaammdd hh:mm

Donde: aaaa. Son los cuatro dígitos del año. mm. Es el número de mes. dd. Es el día hh. Es la hora. mm. Son los minutos.

Una vez seleccionado el archivo, se vuelve a mostrar la pantalla de la ficha “General”, semejante a como se muestra en la Figura 74. Pantalla para recuperación con informacióncompleta en MySQL..

88

Figura 74. Pantalla para recuperación con información completa en MySQL.

Notar que se habilitan las opciones que permitirán configurar las opciones para la recuperación. En la opción “Target Schema” el usuario podrá seleccionar una base de datos para colocar los objetos recuperados, y dejando la opción por omisión “Original Schema” los objetos de base de datos se colocarán en la base de datos con el mismo nombre que la base de datos original al momento de hacer el respaldo.

Se encuentran otras opciones, por ejemplo para especificar el tipo de archivo del respaldo (por omisión es “.sql”), para ignorar los errores que ocurran y seguir procesando las siguientes sentencias del archivo de respaldo, para crear la base de datos si esta no existiera y para seleccionar el formato del archivo de respaldo (opción “File Charset”).

En este momento se está preparado para realizar la recuperación de la base de datos, para esto hacer clic en el botón correspondiente “Star Restore”. Si la operación tiene éxito, se muestra un dialogo como en la Figura 75. Pantalla de avance de recuperación en MySQL..

89

Figura 75. Pantalla de avance de recuperación en MySQL.

Quiere decir que en este momento ya se tiene recuperada la base de datos, tal y como se tenía en el momento de realizar este respaldo. Pero normalmente se habrán realizado nuevas actualizaciones en la base de datos después de la fecha del respaldo. Estás actualizaciones se encuentran almacenadas en los archivos de bitácora que se han creado después de la copia de respaldo hasta el archivo de bitácora mas reciente. Lo que hace falta para recuperar la base de datos de manera completa es asegurarse que los cambios almacenados en los archivos de bitácora se almacenen en la base de datos.

Para “ejecutar” los archivos de bitácora escribir la sentencia de MySQL en la línea de comandos:

mysql> mysqlbinlog nombre_archivo.[0-9]* | mysql

donde, “nombre_archivo” es el nombre por omisión del archivo de bitácora o el nombre asignado por el administrador.

2.5 Diseño y procesamiento de transacciones.

Recordando el concepto de transacción en el contexto de las bases de datos:

Una transacción es un conjunto de instrucciones que pueden modificar la base de datos. Aún cuando se pueden tener varias instrucciones, por el hecho de pertenecer a la misma transacción, estas son tratadas como una unidad. Es decir, cuando la transacción se ejecuta el sistema debe asegurar que todas las instrucciones se aplicaron correctamente y en caso de una falla en la ejecución de la transacción, el sistema debe asegurar que el estado de la base de datos es el mismo antes de que iniciara dicha transacción.

Otra forma de decir lo anterior es la proposición “todo o nada”, indicando que una transacción es terminada completamente o esta no tendrá ningún efecto en la base de datos.

90

A las transacciones también se les conoce como “Unidades lógicas de trabajo” (en inglés abreviadas como “LUWs” –“Logical Units of Work”).

Por definición una transacción debe ser: Atómica. Tratada como una unidad. El sistema debe asegurar que se ejecutan todas

las instrucciones o tareas de la transacción, o bien ninguna de estas es ejecutada. Consistente. Se debe asegurar que la base de datos esta en un estado correcto antes

del inicio de la transacción y después de que la transacción termina. Aislada. Aunque varias transacciones se ejecuten de manera concurrente, el resultado

en la base de datos es el mismo, que si estas transacciones se ejecutaran una tras otra de manera secuencial.

Durable. Una transacción terminada debe dejar sus cambios en la base de datos de manera permanente.

En resumen, las transacciones proporcionan una ejecución atómica y confiable en presencia de fallas, una ejecución correcta en presencia de accesos de usuario múltiples y un manejo correcto de réplicas (en el caso de que se soporten).

Clasificación de las transacciones.Las transacciones se pueden clasificar por diferentes criterios, algunos de ellos son:

1. Por su área de aplicación. Se pueden ejecutar en aplicaciones no distribuidas y en aplicaciones distribuidas. También existen las transacciones “compensatorias”, que son transacciones que ya ejecutaron un “commit” y deben deshacerse mediante otra transacción. Otro tipo son las transacciones heterogéneas, que se ejecutan en ambientes heterogéneos (diferentes DBMS).2. Tiempo de duración. Pueden ser de tipo “batch” y “en línea”. Las transacciones en línea tienen tiempos de respuesta muy cortos y acceden a una porción relativamente pequeña de la base de datos. Una transacción “batch” toma un tiempo relativamente largo y accede a grandes porciones de la base de datos.3. Estructura. Se considera si una transacción puede contener subtransacciones (transacción anidada) o sin subtransacciones (transacción plana). Además también se considera el orden de las operaciones de lectura y escritura.

En los sistemas reales es fácil obtener ejemplo del porqué varias operaciones deben ser agrupadas en una sola transacción. Imagine el lector una transacción simple: Se desea transferir $1000 de una cuenta A, a una cuenta B. Se tiene dos operaciones básicas, por un lado descontar $1000 de la cuenta A y agregar $1000 a la cuenta B. Si se tratarán como operaciones independientes, ¿que puede pasar si existe una falla del sistema después de descontar $1000 de A y antes de agregarlos a B?

- Se pierden $1000 de A y no se agregaron a B.- Si simplemente se repiten las operaciones, se puede llegar a descontar de A dos

veces la cantidad de $1000.

Las situaciones anteriores pueden llevar a la base de datos a un estado inconsistente o erróneo.

Por esto es importante que los administradores y responsables de los sistemas identifiquen de manera correcta todas las operaciones de la aplicación que deben ser tratadas como transacciones y hacer un diseño adecuado de cada una de ellas.

91

Las sentencias de SQL básicas para el manejo de transacciones son: Commit. Cuando se ejecuta un “commit”, se asegura que todas las transacciones que

han terminado con éxito, escriben sus cambios de manera permanente en la base de datos.

Rollback. Cuando se ejecuta un “rollback”, se deshacen los cambios que han realizado todas las transacciones hasta antes del último “commit” ejecutado.

De manera resumida es el comportamiento de estas sentencias, pero se tienen detalles que deben conocerse, tales como los puntos de revisión, sentencias con “commit” implícito, etc., que deben ser revisadas en detalle de acuerdo al DBMS utilizado.

2.5.1 Definición de transacciones en un lenguaje huésped.

Una vez definidas y diseñadas las transacciones para una aplicación, el paso siguiente es escribirlas en un lenguaje que soporte el DBMS para las transacciones. El lenguaje soportado también se aplica normalmente para otras facilidades como: procedimientos almacenados, disparadores, etc. (ver tema 2.2.3 Creación de procedimientos almacenados).

Algunos lenguajes que se soportan para escribir transacciones según el DBMS son: Oracle usa el lenguaje PL/SQL. SQL Server usa el lenguaje Transact-SQL. MySQL usa el estándar de SQL 2003.

Ejemplo práctico.En este caso se pondrá un ejemplo de cómo definir una transacción para MySQL, por

lo tanto se usará el lenguaje “Estándar SQL 2003”. Para detalles específicos revisar el manual correspondiente.

Recordar que MySQL soporta diferentes motores de almacenamiento, y algunos soportan manejo de transacciones y otros no. El motor InnoDB soporta transacciones y es el motor seleccionado por omisión. Aún dentro de una misma base de datos, MySQL puede permitir que las tablas usen diferentes motores de almacenamiento, y por lo tanto se tendrán diferencias en la administración de transacciones en cada tabla. Sin embargo no es recomendable usar diferentes motores en la misma base de datos.

Para este ejemplo, suponer una aplicación sencilla para un banco, donde se tenga en una tabla la información de cuentas, asumir la estructura para la tabla Cuentas, mostrada en la Tabla 6. Esquema de la tabla "Cuentas"..

Nombre atributo Nombre corto Tipo de dato

Descripción

clave_cuenta cve_cta Número Clave de la cuenta. Llave primaria.clave_cliente cve_clie Número Clave del cliente. Llave foránea. Con

92

referencia a la tabla “Clientes”.Saldo Saldo Número Saldo de la cuentafecha_apertura fecha_aper Fecha Fecha de apertura de la cuenta.

Tabla 6. Esquema de la tabla "Cuentas".

Notar que para la tabla Cuentas se esta asumiendo que una cuenta solo puede pertenecer a un cliente.

Los atributos de la tabla Clientes se describen en la Tabla 7. Esquema de la tabla "Clientes"..


Descripción

clave_cliente cve_clie Número Clave del cliente. Llave primaria.nombre_cliente nom_clie Texto Nombre completo del cliente.direccion_cliente dir_clie Texto Dirección del cliente.

Tabla 7. Esquema de la tabla "Clientes".

Una vez creadas las tablas, junto con sus restricciones de llaves primarias y foráneas se pueden poner algunos datos de prueba, para revisar el correcto funcionamiento de la transacción diseñada.

Se desea tener en una transacción la operación que permita transferir un saldo de una cuenta a otra y de está manera asegurar el funcionamiento correcto de la operación. En el diseño de la transacción deben tomarse en cuenta las condiciones posibles que pueden presentarse en la transferencia de un saldo de una cuenta (llamarle cuenta1) a otra (llamarle cuenta2), algunas de las situaciones pueden ser:

La cuenta1 no existe. La cuenta1 no tiene la cantidad solicitada de saldo a transferir. La cuenta2 no existe.

Observar que cualquiera de las situaciones anteriores que se presente, debe hacer que el sistema no realice la transacción.

La sintaxis de MySQL para especificar transacciones es:

START TRANSACTION | BEGIN [WORK]COMMIT [WORK] [AND [NO] CHAIN] [[NO] RELEASE]ROLLBACK [WORK] [AND [NO] CHAIN] [[NO] RELEASE]SET AUTOCOMMIT = {0 | 1}

Lo más adecuado es que la transacción quede diseñada de una manera flexible, para que funcione para cualquier par de claves de cuenta y se pueda indicar el saldo a transferir. Una opción, es que la transacción este incluida dentro de un procedimiento almacenado que permita el uso de parámetros.

93

Entonces para el ejercicio anterior, se crea un procedimiento almacenado usando el “MySQL Query Browser”, como se explicó en el tema “2.2.3 Creación de procedimientos almacenados”. El procedimiento quedaría de la forma en que se ve en la Figura 76.Escritura de una transacción plana en MySQL.

Figura 76. Escritura de una transacción plana en MySQL.

Observar en la Figura 76. Escritura de una transacción plana en MySQL, los parámetros de entrada del procedimiento, que son las cuentas involucradas y el saldo a transferir. Los tipos de datos de los parámetros deben ser consistentes con los tipos de datos de los campos de las tablas. Notar la condición “if” que valida una situación para llevar a cabo la transacción. Si la transacción tiene éxito, se escriben de manera permanente los cambios realizados a la base de datos mediante la sentencia “commit”. Las estructuras condicionales permiten ejecutar un “commit” o un “rollback” dependiendo de las situaciones revisadas.

Para probar el procedimiento se editó la tabla “cuentas” con los siguientes datos, mostrados en la Figura 77. Contenido de la tabla "Cuentas".

94

Figura 77. Contenido de la tabla "Cuentas".

Después se ejecutó el procedimiento almacenado desde la ventana del “MySQL Query Browser”, como se muestra en la Figura 78. Ejecutar la transacción en MySQL.

Figura 78. Ejecutar la transacción en MySQL.

Para este ejemplo, observar que se está solicitado una transferencia de $1000, de la cuenta 500 a la cuenta 600. Después de ejecutar el procedimiento, observar el nuevo estado de la tabla, que se muestra en la Figura 79. Contenido de la tabla "Cuentas" después deejecutar la transacción.

95

Figura 79. Contenido de la tabla "Cuentas" después de ejecutar la transacción.

Probar el procedimiento almacenado para las situaciones que deben llevar a que no se ejecute y que pudieran llevar la base de datos a un estado inconsistente.

2.5.2 Ejecución de transacciones planas en el gestor de bases de datos.

Una transacción plana consiste entonces en una secuencia de operaciones primitivas.

En MySQL una vez que las transacciones están escritas, por ejemplo dentro de un procedimiento almacenado, para su ejecución solo tiene que invocarse el procedimiento almacenado mediante la sentencia “call”.

Al finalizar la ejecución de la transacción el DBMS tiene dos opciones generales: Si tiene éxito y termina correctamente, hacer los cambios permanentes en la base de

datos (mediante un “commit”). Si la transacción falla, se deben deshacer los cambios que la transacción haya realizado

en la base de datos (mediante un “rollback”).

Una transacción puede incluir sentencias SQL, parámetros (si esta incluida en un procedimiento almacenado), declaración de variables y estructuras de programación (secuenciales, de decisión y repetición). Para verificar las opciones completas ver el manual del software.

Podría pensarse que una transacción plana tiene una ejecución lineal simple en el DBMS, pero recuerde el lector la amplitud del uso actual de las bases de datos distribuidas y los protocolos necesarios para ejecutar transacciones en tales ambientes.

96

2.5.3 Ejecución de transacciones anidadas.

Una transacción anidada incluye internamente una o varias transacciones. Se puede tener cualquier nivel de anidamiento. Un punto clave en el funcionamiento de las transacciones anidadas es que el éxito de una subtransacción solo llega a ser permanente (con una operación de “commit”) si todos sus ancestros también han tenido éxito. Lo inverso no aplica: si un hijo falla, el padre es libre para intentar una tarea alternativa, para de esta manera rescatar el trabajo global.

Las transacciones anidadas tienen dos ventajas importantes: La falla de una subtransacción, tiene claramente delimitado el ámbito de la falla,

permitiendo una clara definición de políticas alternativas. Las subtransacciones definen límites claros de aislamiento entre las partes de la misma

tarea global. Esto puede ser explotado por el sistema para permitir paralelismo dentro de la misma transacción global.

Un ejemplo de la estructura de una transacción anidada se muestra en la Figura 80.Estructura de una transacción anidada.

Figura 80. Estructura de una transacción anidada.

97

En la Figura 80. Estructura de una transacción anidada, la transacción principal es “Reservación”, que contiene dos transacciones anidadas (en el mismo nivel una respecto a la otra), la transacción “Vuelo” y la transacción “Hotel”. El significado general sería que para realizar una reservación completa para el viaje de una persona, es necesario realizar la reservación de su vuelo y la reservación de su hotel.

Algunos aspectos sobre el funcionamiento de transacciones anidadas: Una transacción anidada (hija) dentro de otra transacción (padre) conserva las mismas

propiedades que las de sus padres. Lo que implica que puede contener transacciones dentro de ella.

La transacción anidada debe empezar después que su padre y debe terminar antes que él.

El “commit” de una transacción hija es condicional al “commit” de su padre, es decir, si el padre de una o varias transacciones aborta, las transacciones hijas también serán abortadas.

Las transacciones anidadas permiten mayor concurrencia, ya que es posible tener concurrencia dentro de ella. Esto hace posible que la recuperación de fallas sea independiente para cada transacción hija. Esto limita el daño o la falla a una parte más pequeña de la transacción, haciendo que el costo de la recuperación sea menor.

La capacidad de anidar transacciones es un prerrequisito para las aplicaciones con arquitectura basada en componentes.

Guy Pardon (2000), menciona tres paradigmas para la administración de transacciones anidadas:

Transacciones anidadas cerradas (Closed nested transactions). Los bloqueos se adquieren como en el protocolo de bloqueo de dos fases, pero políticas adicionales determinan el comportamiento de las subtransacciones con respecto a las otras subtransacciones. De manera más precisa, conforme una transacción termina sus bloqueos estos son pasados a su padre. Un hijo del mismo padre puede heredar estos bloqueos si este necesita acceder a los mismos datos. Sin esta facilidad, los hijos del mismo padre podrían bloquearse unos a otros, obteniendo un sistema ineficiente. El manejo de la herencia de bloqueos plantea algunas dificultades y en el momento de la referencia (2000) el autor menciona que no existen sistemas comerciales que implementen este enfoque.

Transacciones anidadas abiertas (Open nested transactions). Difiere del enfoque anterior, en que los bloqueos de una subtransacción son liberados tan pronto como la subtransacción termina (pueden ser liberados completamente o reemplazados por un bloqueo semántico – dependiendo de la variante). Si los bloqueos son liberados completamente, estonces se hace difícil garantizar las propiedades de aislamiento y atomicidad de la transacción global. Cuando se introdujo este enfoque, los sistemas prácticos (basados en un DBMS relacional comercial) tuvieron que usar tareas compensatorias. Estas son tareas que deshacen los efectos de una tarea determinada, después de que esta tarea ha liberado sus bloqueos y ha realizado un “commit”. Esto es necesario debido a que en las bases de datos relacionales actuales la única manera para que el DBMS libere los bloqueos, es haciendo un “commit” a la transacción. Con el objeto de hacer una compensación correcta (deshacer todas las actualizaciones correctamente),

98

se aplican ciertas restricciones, y es aquí donde se pueden aplicar los bloqueos semánticos.

Transacciones multinivel (Multilevel transactions). Es una variante de las transacciones anidadas abiertas, en donde las estructuras de la transacción son árboles perfectamente balanceados, todos de la misma profundidad. Esto permite que la ejecución sea descompuesta en capaz o niveles.

El soporte de las transacciones anidadas depende del DBMS. Y por la literatura revisada pocos sistemas tienen dicho soporte. En este momento se especifica que SQL Server soporta la declaración y ejecución de estas, mientras que en Oracle y MySQL no soportan directamente transacciones anidadas.

Ejemplo práctico.Para el caso práctico, suponer una aplicación simplificada para una agencia de viajes.

La aplicación registrará datos generales del cliente, y realizará dos operaciones: la reservación de hotel y de vuelo. Si ambas operaciones son exitosas, se realizará la reservación completa y se almacenará la información en la base de datos.

Considerar la siguiente estructura simplificada de las tablas:Reservacion_general (id_res_gral, nombre_clien, tel_clien) Reservacion_vuelo (id_res_gral, id_vuelo, num_asiento)Reservacion_hotel (id_res_gral, id_hotel, ciudad_hotel, fecha_llegada, fecha_salida)

El esquema de cada tabla se explica enseguida.

Tabla: reservacion_generalAlmacena información del cliente y la clave de la reservación general.


Descripción

id_reservacion_general id_res_gral Número Clave de la reservación. Llave primaria.nombre_cliente nombre_clien Texto Nombre del cliente a quién se le hace la

reservación.telefono_cliente tel_clien Texto Teléfono del cliente a quién se le hace la

reservación.

En un diseño más completo se deberían tener los catálogos con información de detalle de los vuelos y los hoteles, información que no se incluye aquí. Para esto se incluye en la tabla “reservación_vuelo” el atributo “id_vuelo” y en la tabla “reservación_hotel” el atributo “id_hotel”. También en una tabla aparte se tendría la información de detalle de cada cliente y se relacionaría con la tabla “reservación_general” mediante la identificación del cliente.

En la Figura 81. Diseño de la base de datos para el ejemplo de transaccionesanidadas., se muestra la base de datos creada, las tablas y las relaciones que incluyen las restricciones de llaves primarias y foráneas.

Tabla: reservacion_vueloAlmacena información sobre la reservación del vuelo.

Nombre atributo Nombre corto Tipo de Descripción

99

datoid_reservacion_general id_res_gral Número Clave de la reservación.

Llave primaria.Llave foránea, declarada en la tabla “reservacion_general”.

id_vuelo id_vuelo Número Identificación del vuelo.numero_asiento num_asiento Número Número de asiento en el avión para el

cliente que hace la reservación.

Tabla: reservacion_hotelAlmacena información sobre la reservación del vuelo.


Descripción

id_reservacion_general id_res_gral Número Clave de la reservación. Llave primaria.Llave foránea, declarada en la tabla “Reservacion_general”.

id_hotel id_hotel Número Identificación del hotel.Ciudad_hotel ciudad_hotel Texto Ciudad donde se encuentra el hotel.fecha_llegada fecha_llegada Fecha Fecha de llegada del cliente al hotel.fecha_salida fecha_salida Fecha Fecha de salida del cliente del hotel.

Figura 81. Diseño de la base de datos para el ejemplo de transacciones anidadas.Notar que en la figura anterior se asume una cardinalidad de 1:1 entre las tablas.

Recordar que esto depende de las necesidades particulares cada aplicación. El diseño general de la transacción anidada es mostrado en la Figura 80. Estructura de unatransacción anidada., donde la transacción padre registrará datos del cliente y las subtransacciones (hijas) realizarán la reservación del vuelo y la otra la reservación del hotel.

Para el ejemplo se usará SQL Server en su versión gratuita. Para crear aquí una transacción anidada se puede escribir dentro de un procedimiento almacenado. Para esto, en la ventana del “Explorador de Objetos” (“Object Explorer”), abrir las carpetas: Databases | “Nombre_de_base_de_datos” | Programability | Stored Procedures. En la carpeta “Stored

100

Procedures”, hacer clic con el botón derecho del ratón y en el menú contextual seleccionar la opción “New Stored Procedure”. Esta opción genera un nuevo procedimiento almacenado con una estructura predefinida como se aprecia en la Figura 82. Crear un procedimientoalmacenado en SQL Server Express.

Figura 82. Crear un procedimiento almacenado en SQL Server Express.

Recordar que el lenguaje soportado por SQL Server es el “Transact SQL”. Para entender correctamente el funcionamiento de las transacciones anidadas en este lenguaje se hará una mención de las sentencias básicas y con las opciones principales (consultar el sitio http://msdn.microsoft.com/es-es/library/bb510741.aspx para una referencia completa de “Transact SQL”):

BEGIN TRANSACTION [nombre_transacción]Indica el punto de inicio de una transacción local explícita. La ejecución de la

instrucción incrementa a @@TRANCOUNT en 1. Donde “nombre_transacción” es opcional pero recomendable para indicar claramente el nivel de anidamiento de la transacción. Si se producen errores, se pueden deshacer todas las modificaciones realizadas en los datos después de “BEGIN TRANSACTION” para devolver los datos al estado conocido de coherencia. La transacción dura hasta que se completa sin errores y se emite un “COMMIT TRANSACTION” para hacer que los cambios sean permanentes en la base de datos, o hasta que se produzcan errores y se deshagan las modificaciones con “ROLLBACK TRANSACTION”.

COMMIT TRANSACTION [nombre_transacción]

101

Indica el término de una transacción correcta. Si @@TRANCOUNT es 1, “COMMIT TRANSACTION” hace que todos los cambios de la transacción sean permanentes en la base de datos, libera los recursos obtenidos y pone a “@@TRANCOUNT” en 0. Si “@@TRANCOUNT” es mayor que 1, “COMMIT TRANSACTION” reduce a “@@TRANCOUNT” en 1 y la transacción sigue activa.

La instrucción se asocia a la sentencia “BEGIN TRANSACTION” más reciente.

Notar que para el caso de las transacciones anidadas, una terminación con éxito de las subtransacciones no liberan recursos ni hacen permanentes sus cambios. Las modificaciones permanentes en la base de datos y la liberación de recursos solo se aplica con la terminación exitosa de la transacción más externa.

ROLLBACK TRANSACTION [nombre_transacción | savepoint_name]Deshace todas las modificaciones de datos realizadas desde el inicio de la transacción o hasta un punto de retorno. Y libera los recursos ocupados por la transacción. En transacciones anidadas, esta sentencia se asocia a la instrucción “BEGIN TRANSACTION” más reciente.

“ROLLBACK TRANSACTION” sin “savepoint_name” o “nombre_transaccion” deshace todos los cambios hasta el principio de la transacción. En transacciones anidadas, se deshacen todas las transacciones internas hasta la instrucción “BEGIN TRANSACTION” más reciente. Pone el valor de “@@TRANCOUNT” en 0, a excepción cuando existe un “savepoint_name” en que no disminuye a “@@TRANCOUNT”.

SAVE TRANSACTION [savepoint_name]Permite establecer un punto de retorno dentro de una transacción. El punto de retorno define una ubicación a la que la transacción puede volver si se cancela parte de la transacción de forma condicional. Si se deshace una transacción hasta su punto de retorno, se debe continuar hasta su finalización con mas instrucciones Transact-SQL si es necesario y una instrucción “COMMIT TRANSACTION” o se debe cancelar completamente al deshacer la transacción hasta su inicio. Para cancelar una transacción completa, usar “ROLLBACK TRANSACTION nombre_transaccion”. Esto deshace todas las operaciones de la transacción.

@@TRANTDevuelve un valor entero con el número de transacciones activas de la conexión actual. Recordar que la instrucción “BEGIN TRANSACTION” incrementa en 1 a @@TRANCOUNT. “ROLLBACK TRANSACTION” pone en cero a “@@TRANCOUNT”, excepto para “ROLLBACK TRANSACTION savepoint_name”, que no cambia el valor de “@@TRANCOUNT”. La instrucción “COMMIT TRANSACTION” disminuye en 1 a “@@TRANCOUNT”.

Para el ejemplo, el código fuente dentro del procedimiento almacenado quedaría de la forma:

102

USE [AgenciaTurismo]GO/****** Object: StoredProcedure [dbo].[reservacion] Date: 10/28/2008 14:20:17 ******/SET ANSI_NULLS ONGOSET QUOTED_IDENTIFIER ONGOALTER PROCEDURE [dbo].[reservacion]

@id_res int, @nombre_cliente text,@tel_cliente text,@id_vuelo int,@num_asiento int,@id_hotel int,@ciudad_hotel text = "Chihuahua",@fecha_llegada datetime = "10-30-2008",@fecha_salida datetime = "11-05-2008"

ASBEGIN

SET NOCOUNT ON;

BEGIN TRANSACTION Reservacion_general; insert into reservacion_general values(@id_res, @nombre_cliente, @tel_cliente);

BEGIN TRANSACTION Reservacion_vuelo;insert into reservacion_vuelo values (@id_res, @id_vuelo, @num_asiento);

COMMIT TRANSACTION Reservacion_vuelo;

BEGIN TRANSACTION Reservacion_hotel;insert into reservacion_hotel values (@id_res, @id_hotel, @ciudad_hotel,

@fecha_llegada,@fecha_salida);COMMIT TRANSACTION Reservacion_hotel;

COMMIT TRANSACTION Reservacion_general;

END

SQL Server incluye la opción para revisar la sintaxis del código (botón “parse”). Guardar el procedimiento almacenado. Existen varias formas para ejecutarlo, una de ellas es seleccionar el procedimiento almacenado en el “Object Explorer” hacer clic con el botón derecho del ratón, y en menú contextual que se abre seleccionar la opción de “Execute Stored Procedure” (“Ejecutar procedimiento almacenado”). Al hacer esto se abre un diálogo para la ejecución, donde el usuario debe proporcionar los parámetros para la ejecución del procedimiento y hacer clic en el botón de “OK”, ver Figura 83. Ejecutar procedimiento contransacciones anidadas en SQL Server..

103

Figura 83. Ejecutar procedimiento con transacciones anidadas en SQL Server.

Lo más común será invocar el procedimiento desde una aplicación, donde la mayoría de los lenguajes e IDE soportan esta capacidad.

Probar el procedimiento en diferentes situaciones para analizar la ejecución de la transacción anidada, por ejemplo: ¿Qué hace el sistema en una falla de una subtransacción? Esto se puede probar,

proporcionando un tipo de dato equivocado para una tabla involucrada en una subtransacción.

¿Si existe una falla en la transacción padre? Se puede probar de manera similar al caso anterior.

Ejercicios de la unidad 2. Investigar las facilidades generales para la administración de la base de datos de tres

DBMS que se usen actualmente. Investigar herramientas adicionales para la administración de algunos DBMS. Desarrollar e implementar una aplicación de base de datos (con unas 3 o 4 tablas

relacionadas) que incluya los temas vistos en la unidad. Investigar el concepto, usos, implementación y ventajas y desventajas de vista

“materializada” que se implementa en Oracle.

104

Investigar las opciones de automatización de los respaldos en algún DBMS. Exponer en el grupo los puntos desarrollados anteriormente.

105

UNIDAD 3. TECNOLOGÍAS DE CONECTIVIDAD A BASES DE DATOS.

Un conector (se usa el término “driver”, y normalmente se traduce como controlador o manejador) de base de datos es un programa o conjunto de programas que permiten que programas a nivel cliente se puedan conectar con el servidor de la base de datos.

Un conector es necesario entonces para que las aplicaciones que usen los usuarios finales, y que pueden estar desarrolladas en diferentes plataformas y lenguajes de programación se puedan conectar y trabajar con bases de datos en diferentes DBMS.

No confundir el concepto de “conector” con el de API (“Application Programming Interface”, en español: Interfaz de Programación de Aplicaciones) que es el conjunto de funciones y procedimientos (o métodos si se refiere a programación orientada a objetos) que ofrece cierta biblioteca para ser utilizada por otro software como una capa de abstracción. Básicamente una API representa una interfaz de comunicación entre componentes de software.

Entonces, por lo mencionado antes, se puede decir que un conector es un tipo de API que esta enfocado a las bases de datos.

Los conectores pueden ser proporcionados por el proveedor del DBMS, el ambiente de desarrollo (por ejemplo, NetBeans que es un IDE para programar en Java, incluye el conector JDBC para MySQL) y el propio sistema operativo. Por ejemplo en el sitio Web de MySQL, se tiene la página de acceso a los diferentes conectores, como se ve en la Figura 84. Página de descarga de conectores para MySQL.

Por ejemplo, en el caso de MySQL, este proporciona cinco conectores:

Conector ODBC. Proporciona el manejador o controlador (“driver” en inglés) de soporte para conectarse al servidor de MySQL usando la API ODBC. ODBC son las siglas en inglés de “Open Database Connectivity” que en español se puede decir como “Conectividad abierta de base de datos”. ODBC soporta conectividad para los sistemas operativos Windows, Unix, Linux y Mac OS X.

Conector .NET. Permite a los desarrolladores crear aplicaciones .NET que usan datos almacenados en una base de datos MySQL. Implementa una funcionalidad completa para la interfase ADO.NET. Las aplicaciones que usen este conector pueden ser escritos en cualquiera de los lenguajes .NET que son soportados. Además existe un programa “plugin” (programa de computadora que interactúa con una aplicación principal con el objeto de proporcionar una funcionalidad específica) llamado “MySQL Visual Studio Plugin”, que trabaja con el conector .NET y Microsoft Visual Studio 2005. Este “plugin” proporciona herramientas para manipular y definir datos de una base de datos MySQL, dentro de Visual Studio .NET.

Conector J. Conector Java, el cuál proporciona un manejador que soporta la conexión a MySQL desde aplicaciones con el lenguaje Java. Se usa la API estándar JDBC (“Java Data Base Connectivity”).

Conector MXJ. Es una herramienta que facilita la implementación y administración del servidor MySQL y la base de datos, mediante la aplicación Java.

106

Conector PHP. Es un conector solo para el sistema operativo Windows que permite usar el lenguaje PHP.

Figura 84. Página de descarga de conectores para MySQL.

Por lo mencionado anteriormente, se observa que el conector a usar dependerá del IDE y lenguaje de programación usado. Por ejemplo, si se esta utilizando Microsoft Visual Studio .NET como IDE y se desea acceder a una base de datos en MySQL, se debe usar el conector .NET. Por otro lado si la aplicación se programará en lenguaje Java, se requerirá el conector JDBC para conectarse a cualquier DBMS.

Hablando de los conectores ODBC y .NET, es más nuevo el conector .NET y el más adecuado a usar, si el IDE y el lenguaje permiten escoger. Este es el caso de cuando se programa en Microsoft Visual Studio .NET.

Enseguida se describirán tres de los principales conectores y se ejemplificará su uso.

3.1 ODBC.

3.1.1 Terminología y conceptos.

¿Qué es ODBC?

107

ODBC (Open Database Connectivity) es un software que proporciona una vía para que los programas cliente puedan acceder a un amplio rango de bases de datos o fuentes de datos. ODBC es una API estandarizada que permite conexiones a servidores de bases de datos que usan el lenguaje SQL. ODBC fue desarrollado de acuerdo a las especificaciones de la organización “SQL Access Group” y define un conjunto de llamadas de funciones, códigos de error y tipos de datos que pueden ser usados para desarrollar aplicaciones independientes de las bases de datos empleadas. Usualmente ODBC es usado cuando se requiere independencia de la base de datos o accesos simultáneos a diferentes fuentes de datos.

ODBC es una API ampliamente aceptada para acceso a bases de datos. ODBC esta basada en las especificaciones de la interfase CLI (“Call Level Interface”) de X/OPen y ISO/IEC para APIs de bases de datos, y usa el lenguaje SQL como su lenguaje de acceso a la base de datos.

CLI es un software estándar definido en la especificación ISO/IEC 9075-3:2003. CLI define como un programa debe enviar sentencias SQL al DBMS y como los conjuntos de registros regresados deben ser manejados por la aplicación de una manera consistente.

X/OPen y ISO/IEC, definen estándares para los sistemas de software abiertos.

Para una especificación completa de ODBC, consultar el sitio MSDN de Microsoft en el artículo “ODBC Programmer's Reference” ubicado en la dirección http://msdn.microsoft.com/en-us/library/ms714177.aspx.

Para usar ODBC se requieren de tres componentes básicos que se muestran en la Figura 85. Componentes básicos de ODBC.

Los componentes interactúan de la siguiente manera: El “Cliente ODBC” usa un lenguaje o vocabulario de comandos para solicitar datos o

enviar datos al servidor DBMS. El servidor DBMS se encuentra en el “back-end” (parte del software que procesa la entrada desde el “front-end”).

El “Driver ODBC” traslada o traduce el comando a un formato que puede entender el “Servidor ODBC”. El “Driver ODBC” es un software que reside en el “front-end” (parte del software que interactúa con el usuario).

El “Servidor ODBC” ejecuta el comando y envía la respuesta de regreso al “Driver ODBC”, el cuál traslada la respuesta a un formato que puede entender el “Cliente ODBC”.

Por otro lado, en el sitio MSDN de Microsoft Corporation se menciona que la arquitectura ODBC esta compuesta de cuatro componentes, que se describen a continuación de manera resumida:

Aplicación. El programa que hace la interfase con los usuarios. Realiza procesamiento y llamadas a funciones ODBC para enviar comandos SQL y recibir resultados.

“Driver Manager”. Carga y descarga “drivers” en nombre de una aplicación. Procesa llamadas a funciones ODBC o pasa estas funciones al componente “Driver”.

“Driver”. Procesa llamadas a funciones ODBC, envía requerimientos SQL hacia una fuente de datos específica, y regresa resultados a la aplicación. Si es necesario, el

108

http://msdn.microsoft.com/en-us/library/ms714177.aspx

“driver” modifica un requerimiento de la aplicación para que sea conforme a la sintaxis soportada por el correspondiente DBMS.

“Data Source”. Es la fuente de los datos. Consiste de los datos que el usuario quiere acceder y su sistema operativo correspondiente, el DBMS, y la plataforma de red (si existe) que es usada para acceder al DBMS.

Figura 85. Componentes básicos de ODBC.

En esta arquitectura es importante observar lo siguiente: Mútiples “drivers” y múltiples fuentes de datos pueden existir, lo cual permite que la

aplicación pueda de manera simultánea acceder a datos de más de una fuente de datos. La API ODBC es usada en dos lugares. Primero entre la “Aplicación” y el “Drive

Manager”, y el segundo lugar entre el “Driver Manager” y cada “Driver”.

3.1.2 Administrador de orígenes de datos ODBC.

El administrador de orígenes de datos ODBC debe permitir crear, eliminar y modificar conexiones ODBC en un equipo de cómputo.

En el sistema operativo Microsoft Windows se proporciona este administrador de ODBC.

En los sistemas operativos de Microsoft Windows como Windows 2000 y Windows XP, esta aplicación se localiza en el “Panel de control de Windows” y en la opción de

109

“Herramientas Administrativas”. Su icono se llama “Orígenes de Datos (ODBC)”. En las versiones previas de sistemas operativos de Windows, el icono del administrador ODBC es llamado “32 bit ODBC” o simplemente “ODBC”. Ver Figura 86. Ubicación delAdministrador ODBC en Windows.

Figura 86. Ubicación del Administrador ODBC en Windows.

Una vez abierto el programa se muestra una pantalla como la mostrada en la Figura87. Pantalla principal del Administrador ODBC.

Figura 87. Pantalla principal del Administrador ODBC.

110

Observar las fichas con las opciones: “DSN de usuario”, “DSN de sistema” y “DSN de archivo”. DSN son las siglas en inglés de “Data Source Name” o “Nombre de fuente de datos”. Y son conexiones predefinidas o creadas por los usuarios para acceder a base de datos o archivos de datos. Estas almacenan la información necesaria para conectarse al proveedor de datos indicado. Dicha información puede ser: ruta de la base de datos, nombre de la base de datos, nombre de usuario y contraseña, etc. La diferencia entre ellas es:

DSN de usuario. Es una conexión solo visible y utilizable solo por el usuario que creo la conexión.

DSN de sistema. Es una conexión visible y utilizable para todos los usuarios en este equipo.

DSN de archivo. Es una conexión que pueden usar los usuarios que tengan el mismo controlador instalado.

La descripción general de las otras fichas:

Controladores. Tiene información acerca de los controladores ODBC instalados en el equipo. Solo es información descriptiva y no se puede realizar ninguna acción desde esta ficha.

Trazas. Permite crear archivos de registro de llamadas a los controladores ODBC, esto se puede usar por personal de soporte o para depurar las aplicaciones. Se proporcionan herramientas adicionales como el “Visual Studio Tracing”, que realiza la traza o registro de las llamadas. Otra herramienta es “Visual Studio Analyzer” que se puede utilizar para depurar y analizar una aplicación distribuida.

Agrupación de conexiones. Se puede modificar el tiempo de espera para volver a intentar la conexión y el intervalo del tiempo de espera de la conexión para un controlador seleccionado cuando se utiliza un conjunto de conexiones. También permite habilitar y deshabilitar el control del rendimiento, que registra un número de estadísticas de conexión. El conjunto de conexiones permite que la aplicación utilice una de las conexiones del conjunto de conexiones sin tener que establecerla cada vez. Cuando se crea una conexión y se incluye en un conjunto, una aplicación puede reutilizar la conexión sin realizar todo el proceso de conexión; así puede mejorar el rendimiento.

Acerca de. Es solo informativa y presenta información acerca de los componentes principales de ODBC: incluye el Administrador de controladores, la biblioteca de cursores, la DLL de instalación y los demás archivos que forman parte de los componentes principales.

Para cada ficha se puede consultar la ayuda detallada con el botón de “Ayuda” en la parte inferior de la ventana.

Una ventaja de tener conexiones ODBC a este nivel, es que cualquier aplicación puede usar la conexión, sin necesidad de tener que crearla para cada aplicación.

Consultar la dirección: http://msdn.microsoft.com/en-us/library/ms714024(VS.85).aspx para más información sobre este tema.

111

http://msdn.microsoft.com/en-us/library/ms714024(VS.85).aspx

3.1.3 Instalación y configuración del driver acorde al gestor de bases de datos.

Cuando se requiere usar una conexión ODBC, es necesario instalar el “driver” según el DBMS a utilizar y también debe configurarse la conexión con los datos específicos (por ejemplo, la ruta de la base de datos, nombre de la base de datos, nombre de usuario, contraseña del usuario, etc.).

El sistema operativo puede incluir algunos “drivers” ya instalados, en los cuales solo sería necesario crear la conexión particular y configurarla. Por ejemplo, en esta computadora que tiene Windows XP como sistema operativo se tienen instalados los controladores mostrados en la Figura 88. Vista de la ficha "Controladores" del Administrador ODBC..

Los controladores mostrados en la Figura 88. Vista de la ficha "Controladores" delAdministrador ODBC., son los que ya están incluidos en el sistema operativo o bien algunos se instalan cuando se instala el software correspondiente.

En la Figura 89. Controladores ODBC adicionales a los preinstalados, observar controladores adicionales.

Figura 88. Vista de la ficha "Controladores" del Administrador ODBC.

112

Figura 89. Controladores ODBC adicionales a los preinstalados.

El controlador “Microsoft ODBC Oracle”, como su nombre lo indica es proporcionado por la compañía Microsoft y permite hacer conexiones ODBC al DBMS Oracle. Este controlador ya esta instalado desde un inicio. Notar el otro controlador para Oracle (“Oracle in XE”), este es proporcionado por la compañía Oracle y se instaló al momento de hacer la instalación de la versión del DBMS de Oracle “Oracle 10g Express Edition“. Es una facilidad útil esta instalación “automática” del controlador ODBC de Oracle. Lo que le restará al usuario es crear un “DSN” para hacer la conexión a una base de datos particular para cierto usuario.

Una pregunta podría ser: ¿Si se tienen dos controladores ODBC para Oracle, cuál usar? La respuesta es que se debe usar el más reciente y el recomendado por el proveedor del DBMS, de acuerdo a la versión de este.

Notar el controlador “MySQL ODBC 3.51 Driver” propiedad de la compañía MySQL y el cuál se tuvo que descargar del sitio “MySQL.com”. Es una instalación sencilla, pero tiene que hacerse después de instalar el DBMS MySQL en el equipo y de manera independiente al DBMS MySQL.

También están los controladores “SQL Native Client” y el “SQL Server” (no se ve en la imagen), que se instalaron de manera automática al instalar la versión gratuita de Microsoft SQL Server (“Microsoft SQLServer 2005 Management Studio Express”).

113

Una vez que si tiene el controlador para el DBMS al cuál se desea conectar la aplicación, se debe crear el “DSN” con los datos particulares necesarios para hacer una conexión exitosa.

Ejemplo de instalación, configuración y uso de un controlador ODBC.En este caso se ejemplificará la instalación y configuración de un controlador ODBC

para hacer la conexión de una aplicación Web hecha en Microsoft Visual Studio 2005 que usará una base de datos que estará en el DBMS “MySQL Server 5.0”.

Tener en cuenta que se usaron estas versiones del software que son de las más recientes. Dependiendo de las versiones se pueden tener algunas diferencias. Y también pueden cambiar las versiones de los controladores ODBC.

Pasos generales.1. Instalar primero el software para la aplicación (Microsoft Visual Studio 2005) y el DBMS a usar (MySQL Server 5.0).

2. Descargar del sitio de MySQL.con el controlador ODBC, en este caso el “MySQL ODBC 5.1 Driver”. En este caso se obtuvo de la página http://dev.mysql.com/downloads/connector/ , mostrada anteriormente. En esta página al seleccionar la opción “Connector/ODBC” como se muestra en la Figura 90. Conector ODBC en la página de MySQL.

Figura 90. Conector ODBC en la página de MySQL.

114

http://dev.mysql.com/downloads/connector/

En la página que se muestra enseguida se muestran las versiones del conector ODBC, según el sistema operativo y su versión. Para la computadora particular donde se tiene instalado el Microsoft Visual Studio 2005 y el DBMS MySQL Server 5.0, es una computadora con el sistema operativo “Microsoft Windows XP Profesional” en una arquitectura de 32 bits. Por lo tanto se seleccionó la opción “Windows” como se muestra en la Figura 91. Seleccionar el conector ODBC adecuado al sistema operativo.

En la imagen de la Figura 91. Seleccionar el conector ODBC adecuado al sistemaoperativo, no se aprecian todos los sistemas operativos disponibles, pero es una variedad muy amplia. Al hacer clic en la opción de “Windows” se muestra el detalle de la opción como se ve en la Figura 92. Seleccionar el tipo de archivo para el conector ODBC.

Figura 91. Seleccionar el conector ODBC adecuado al sistema operativo.

La primer opción es la más sencilla de usar, pues incluye un instalador que asiste en todo el proceso para instalar el controlador del conector en la computadora. Al seleccionar la opción de “Pick a mirror” permite seleccionar un servidor de descarga, el cuál conviene que sea el más cercano geográficamente. También se le sugiere al usuario el registrarse en el sitio de “MySQL.com”, con la ventaja de poder recibir información del sitio, poder participar en foros, etc. Después del registro o no aceptarlo se muestran los servidores de descarga para seleccionar uno de ellos y poder realizar la descarga, como se muestra en la Figura 93.Seleccionar un servidor de descarga para el conector ODBC..

115

Figura 92. Seleccionar el tipo de archivo para el conector ODBC.

Figura 93. Seleccionar un servidor de descarga para el conector ODBC.

3. Instalar el controlador ODBC en el equipo.

Una vez descargado el archivo, este se ejecuta en el equipo siguiendo las indicaciones del instalador.

Al ejecutar el archivo descargado, se pregunta al usuario la confirmación para la instalación. Después de aceptarla, aparece la primer pantalla del asistente de instalación, como se muestra en la Figura 94. Instalación del conector ODBC, pantalla de inicio.

116

Figura 94. Instalación del conector ODBC, pantalla de inicio.

Al hacer clic en el botón “Next” aparece la pantalla donde se selecciona el tipo de instalación (“Setup Type”), en este caso se seleccionó la opción completa (“Complete”), que instala todas las facilidades del programa y requiere de mayor espacio en disco. Ver Figura95. Instalación del conector ODBC, seleccionar tipo de instalación.

Figura 95. Instalación del conector ODBC, seleccionar tipo de instalación.

117

Enseguida aparece la pantalla donde indica al usuario que ya se esta preparado para instalar y le muestra las opciones seleccionadas. Se puede aceptar o regresar a cambiar opciones. Esto se ve en la Figura 96. Instalación del conector ODBC, aceptar opcionesde instalación.

Figura 96. Instalación del conector ODBC, aceptar opciones de instalación.

Al hacer clic en el botón “Install” se realiza la instalación. Al terminar correctamente el proceso se muestra la pantalla que indica la instalación exitosa. Ver ejemplo en la Figura 97.Instalación del conector ODBC, fin de instalación.

Figura 97. Instalación del conector ODBC, fin de instalación.

118

Al terminar la instalación se puede verificar la lista de controladores ODBC instalados en el equipo. Como se muestra en la Figura 98. Verificar controlador ODBC instalado.

Figura 98. Verificar controlador ODBC instalado.

Observar el controlador “MySQL ODBC 5.1 Driver” ya instalado. Recordar que este controlador permitirá crear conexiones ODBC al DBMS MySQL para cualquier aplicación instalada en este equipo.

4. Configurar una conexión ODBC particular a una base de datos.

El “Administrador de orígenes de datos ODBC”, permite crear conexiones particulares mediante la opción de crear “DNS”.

En este caso particular se creara una conexión a la base de datos “innovación” en el DBMS MySQL que esta instalado en el mismo equipo donde se encuentra instalado el software para desarrollo de la aplicación. Claro que el servidor de base de datos puede estar en un equipo diferente al de la aplicación, y la conexión se puede crear sin problemas si dichos equipos están en una red.

Entonces la base de datos se llama “innovación”, el servidor MySQL tiene por nombre “localhost” y el usuario para hacer la conexión y que debe tener los permisos adecuados en la base de datos tiene como usuario y contraseña “root/leonardo”.

El primer paso será abrir el “Administrador de orígenes de datos ODBC” y activar la ficha “DSN sistema”, aquí seleccionar el botón de “Agregar” para crear un nuevo DSN, como se muestra en la Figura 99. Crear una nueva conexión ODBC.

119

Figura 99. Crear una nueva conexión ODBC.

En la pantalla de la Figura 99. Crear una nueva conexión ODBC., al hacer clic en el botón de “Agregar” aparece la pantalla que se muestra en la Figura 100. Seleccionarcontrolador para conexión ODBC.

Figura 100. Seleccionar controlador para conexión ODBC.

120

En la pantalla de la Figura 100. Seleccionar controlador para conexión ODBC., se debe seleccionar el controlador adecuado al DBMS a usar y hacer clic en el botón de “Finalizar”. Aparece la pantalla de la Figura 101. Proporcionar información para conexiónODBC, donde se deben proporcionar los datos para la conexión y crearla.

Figura 101. Proporcionar información para conexión ODBC.

Una vez proporcionados los datos y probada la conexión, el botón de “OK” crea la conexión. Si esto tiene éxito se debe mostrar en la lista de “DSN sistema” la conexión recién creada, como se muestra en la Figura 102. Ver conexión ODBC recién creada.

Figura 102. Ver conexión ODBC recién creada.

121

Notar que si es seleccionada una conexión se activan los botones de “Quitar” y “Configurar”, que permiten eliminar y modificar una conexión respectivamente.

Aquí ya esta lista la conexión para ser usada por las diferentes aplicaciones que se encuentren en el equipo donde esta creada la conexión ODBC.

5. Usar la conexión en una aplicación.En este caso se ejemplificará usando el software para desarrollo de aplicaciones

Microsoft Visual Studio 2005.

En el Microsoft Visual Studio 2005 (de ahora en adelante se abreviará como “VS 2005”), se creó un proyecto Web. Una vez creado el proyecto, se debe agregar una conexión ODBC hacia el servidor de base de datos (DBMS) MySQL.

VS 2005 incluye la ventana “Server Explorer”. Mediante esta se pueden establecer conexiones a diversos DBMS. Esta ventana está a un lado de la caja de herramientas “Toolbox”. En la Figura 103. Ventana "Server Explorer" de Microsoft VisualStudio .NET, se muestra la ventana “Server Explorer” con algunas conexiones ya creadas.

Ahora es necesario dentro del proyecto crear la conexión de la aplicación (VS 2005) al servidor MySQL. Aunque en la Figura 103. Ventana "Server Explorer" de Microsoft Visual Studio .NET., ya se muestra configurado, se describirá paso a paso como hacerlo.

Figura 103. Ventana "Server Explorer" de Microsoft Visual Studio .NET.

En la ventana “Server Explorer”, seleccionar la opción “Data Connections” y hacer clic con el botón derecho del ratón. En el menú de contexto que aparece, seleccionar la opción

122

“Add Connection”, como se muestra en la Figura 104. Agregar una nueva conexión dedatos en Visual Studio .NET..

Figura 104. Agregar una nueva conexión de datos en Visual Studio .NET.

Enseguida aparece el asistente para configurar la conexión de base de datos. En la primer pantalla, si la fuente de datos es diferente a ODBC, presionar el botón “Change” para seleccionar la fuente de datos adecuada, como se ve en la Figura 105. Cambiar la fuentede datos de una conexión en Visual Studio .NET.

Figura 105. Cambiar la fuente de datos de una conexión en Visual Studio .NET.

123

Como resultado aparece la ventana donde debe seleccionarse la fuente de datos necesaria, en este caso una fuente de datos ODBC, como se muestra en la Figura 106.Seleccionar la nueva fuente de datos de una conexión en Visual Studio .NET.

Figura 106. Seleccionar la nueva fuente de datos de una conexión en Visual Studio .NET.

Una vez aceptada la opción anterior aparece la pantalla que es mostrada en la Figura107. Seleccionar la conexión ODBC como fuente de datos en Visual Studio .NET.

En la pantalla de la Figura 107. Seleccionar la conexión ODBC como fuente dedatos en Visual Studio .NET, verificar que esté activada la opción “Use user or system data source name”. En la lista de conexiones DSN disponibles seleccionar el DSN que se requiere usar (en este caso el DSN “DSNSistemaMySQL”). Recordar que este DSN es una conexión ODBC a la base de datos “innovación” que esta en el DBMS MySQL.

Proporcionar el nombre de usuario (“User name”) y contraseña (“password”), que tienen que ser iguales a los proporcionados cuando se creó el DSN, para este ejemplo: root/leonardo.

Antes de presionar el botón de “OK”, probar la conexión con el botón de “Test Connection”, para asegurar que la conexión esta funcionando correctamente.

124

Figura 107. Seleccionar la conexión ODBC como fuente de datos en Visual Studio .NET.

Si la conexión es creada correctamente, esta se debe visualizar en la ventana “Server Explorer”. Desde esta ventana se puede tener acceso a la base de datos para hacer consultas, editar datos, ver estructura de las tablas, etc. Ver Figura 108. Ver conexión dedatos creada en Visual Studio .NET.

Figura 108. Ver conexión de datos creada en Visual Studio .NET.

125

Para poder visualizar la tabla “proyectos” en una página Web, es necesario agregar un objeto “DataSet” al proyecto. Para esto en el explorador de soluciones “Solution Explorer” abrir la carpeta “App_Code” del proyecto, hacer un clic con el botón derecho del “Mouse” y seleccionar en el menú contextual la opción para agregar un nuevo elemento “Add New Item”, donde se abre la pantalla que se muestra en la Figura 109. Agregar un nuevo"DataSet" en Visual Studio .NET.

Figura 109. Agregar un nuevo "DataSet" en Visual Studio .NET.

En VS 2005, un objeto tipo “DataSet” permite almacenar datos para que pueden ser mostrados en objetos que despliegan datos para la aplicación. Después de presionar el botón para agregar el objeto “DataSet”, aparece la ventana para configurarlo, como se muestra en la Figura 110. Configurar un "DataSet", seleccionar conexión de datos.

Observar en la Figura 110. Configurar un "DataSet", seleccionar conexión dedatos., que es posible visualizar una lista de conexiones disponibles (solo si la conexión se creó como una “Cadena de conexión” (en ingles “Connection String”), que básicamente es un texto con la información de la conexión. Las cadenas creadas como “Cadena de conexión” están almacenadas en el archivo “web.config” del proyecto de Web. En caso contrario (que no se tenga almacenada la cadena de conexión), se puede crear aquí la conexión con el botón “New Connection”, que abre el asistente visto anteriormente para crear una nueva conexión de datos.

126

Figura 110. Configurar un "DataSet", seleccionar conexión de datos.

Después con el botón de siguiente “Next” aparece la pantalla que se muestra en la Figura 111. Configurar un "DataSet", seleccionar tipo de comando para el"TableAdapter".

Figura 111. Configurar un "DataSet", seleccionar tipo de comando para el "TableAdapter".

127

En la pantalla de la Figura 111. Configurar un "DataSet", seleccionar tipo decomando para el "TableAdapter", verificar que este seleccionada la opción “Use SQL statements”, pues se escribirá una consulta SQL que obtenga el contenido completo de la tabla. Al presionar el botón de “Next >” (siguiente) aparece la pantalla de la Figura 112.Configurar un "DataSet", escribir la consulta SQL para el "TableAdapter"..

Figura 112. Configurar un "DataSet", escribir la consulta SQL para el "TableAdapter".

En la pantalla de la Figura 112. Configurar un "DataSet", escribir la consulta SQL para el"TableAdapter"., se puede escribir la consulta SQL de manera directa, o bien entrar al constructor de consultas mediante el botón de “Query Builder”, que permite ir construyendo la consulta y probarla (algo muy conveniente, por los detalles de sintaxis). Una vez escrita la consulta y estando seguro de que es correcta, con el botón de siguiente “Next” se pasa a la pantalla de la Figura 113. Configurar un "DataSet", seleccionar métodos a generar parael "TableAdapter".

128

Figura 113. Configurar un "DataSet", seleccionar métodos a generar para el "TableAdapter"

Revisar que las opciones seleccionadas en la Figura 113. Configurar un "DataSet",seleccionar métodos a generar para el "TableAdapter", se apliquen y presionar el botón de siguiente “Next”, donde se mostrará la Figura 114. Configurar un "DataSet", mostrando resultados de la configuración.

Figura 114. Configurar un "DataSet", mostrando resultados de la configuración.

En la pantalla de la Figura 114. Configurar un "DataSet", mostrando resultadosde la configuración., se comprueba la correcta configuración y funcionalidad.

Notar la palabra “Adapter”, en VS 2005, un “adaptador de datos” es un objeto que permite definir la tabla o la consulta para extraer los datos de la base de datos. El adaptador “pasa” esos datos al objeto “DataSet” quien los almacena para la aplicación y los hace disponibles a objetos como los “GridView”.

129

Una vez creado el “DataSet”, el paso siguiente será visualizar la tabla “proyectos” en una página Web. Para esto se agrega al proyecto una nueva página tipo “Web Forms” (que tienen extensión .aspx). Para esto se selecciona en el “Solution Explorer” la raíz del proyecto o una carpeta (o subcarpeta) del proyecto. Como se muestra en la Figura 115. Agregar una"Web Form" en Visual Studio .NET..

Figura 115. Agregar una "Web Form" en Visual Studio .NET.

Una vez creada la página, esta se puede editar como cualquier documento HTML. En la página usando la vista de diseño, agregar desde el “Toolbox” y la ficha “Data” un objeto tipo “ObjectDataSource”. Como se muestra en la Figura 116. Agregar un objeto"ObjectDataSource" a una "WebForm".

130

Figura 116. Agregar un objeto "ObjectDataSource" a una "WebForm".

Hacer clic el la opción para configurar la fuente de datos “Configure Data Source”. Al hacerlo se muestra la pantalla que aparece en la Figura 117. Configurar un"ObjectDataSource", seleccionar el objeto "Business Object".

Figura 117. Configurar un "ObjectDataSource", seleccionar el objeto "Business Object".

131

En la pantalla de la Figura 117. Configurar un "ObjectDataSource", seleccionar el objeto"Business Object"., se debe seleccionar el “DataSet” adecuado (para este ejemplo el DataSet5.TableAdapters…) y hacer clic en el botón de “Next”. Se mostrará la pantalla que se muestra en la Figura 118. Configurar un "ObjectDataSource", seleccionar los métodosque regresan datos. Observar aquí que es importante seleccionar el objeto “DataSet” adecuado pero que incluye su adaptador de tabla (“TableAdapters”).

Figura 118. Configurar un "ObjectDataSource", seleccionar los métodos que regresan datos.

En la pantalla de la Figura 118. Configurar un "ObjectDataSource", seleccionar los métodos que regresan datos., solo se necesita terminar el asistente con el botón adecuado “Finish”. Con lo que el objeto “ObjectDataSource” que configurado completamente. Este objeto estará relacionado con el “DataSet” y el “Adapter” configurados previamente.

Enseguida agregar a la página un objeto tipo “GridView”, como se muestra en la Figura 119. Agregar un objeto "GridView" a una "Web Form".

132

Figura 119. Agregar un objeto "GridView" a una "Web Form".

En el asistente para configurar el objeto “GridView”, observar la propiedad para escoger la fuente de datos “Choose Data Source”, aquí debe seleccionarse el nombre del objeto “ObjectDataSource” recién agregado en la misma página “ObjectDataSource1”.

Al hacer lo anterior se muestra la pantalla de la Figura 120. Configurar un objeto"GridView", seleccionar su fuente de datos.

Figura 120. Configurar un objeto "GridView", seleccionar su fuente de datos.

Observar en la Figura 120. Configurar un objeto "GridView", seleccionar sufuente de datos., que el objeto “GridView” incluye ahora los nombres de los campos de la tabla de “proyectos”, y esta terminada la configuración completa. Al guardar todos los archivos del proyecto Web recién creados y visualizar la página en el navegador Web se verá

133

el resultado. Que se muestra en la Figura 121. Resultado de ejecutar la "Web Form" deacceso a la base datos.

Figura 121. Resultado de ejecutar la "Web Form" de acceso a la base datos.

En este ejemplo solo se muestra el contenido de la tabla. Pero de manera muy similar se pueden agregar páginas que permitan diversas operaciones en la base de datos, tales como la edición de datos (altas, bajas y actualizaciones), búsqueda de información, generación de contenido dinámico en las páginas, etc.

Por ejemplo, el objeto “GridView” se puede configurar para permitir la edición de datos, y el objeto “DetailsView” permite hacer alta de nuevos registros. El objeto “GridView” tiene múltiples opciones para configurar su aspecto y su funcionalidad. Respecto a su aspecto se pueden mencionar opciones para:

Definir colores. Tipos y tamaños de letra. Nombres de columnas. Columnas adicionales. Diseños predefinidos.

Respecto a la funcionalidad del objeto GridView, algunas de ellas son: Definir capacidad para ordenar por columnas.

134

Edición de datos. Paginación.

3.2 ADO.NET.

ADO.NET es un conjunto de componentes de software de la empresa Microsoft. Los programadores lo usan para el desarrollo de aplicaciones que acceden a datos y a servicios de datos. Es una parte de la biblioteca de clases base que están incluidas en el Microsoft .NET Framework.

Enseguida se dan más detalles de este tema.


ADO.NET, significa en inglés “ActiveX Data Objects .NET”, que en español se puede traducir como “Objetos de Datos ActiveX de la tecnología .NET”. Forma parte de la biblioteca de clases de Microsoft .NET Framework.

El sitio Web MSDN de la compañía Microsoft (http://msdn.microsoft.com/es-es/library/e80y5yhx(VS.80).aspx), describe a ADO.NET como:

“ADO.NET es un conjunto de clases que exponen servicios de acceso a datos para el programador de .NET. ADO.NET ofrece abundancia de componentes para la creación de aplicaciones de uso compartido de datos distribuidas. Constituye una parte integral de .NET Framework y proporciona acceso a datos relacionales, XML y de aplicaciones. ADO.NET satisface diversas necesidades de desarrollo, como la creación de clientes de base de datos de aplicaciones para usuario y objetos empresariales de nivel medio que utilizan aplicaciones, herramientas, lenguajes o exploradores de Internet.”

También se puede describir a ADO:NET como un modelo de acceso a datos para las aplicaciones .NET. En cierto sentido ADO.NET representa la más reciente evolución de la tecnología ADO. Sin embargo, ADO.NET introduce cambios mayores e innovaciones orientadas principalmente a la naturaleza de las aplicaciones Web, tales como bajo acoplamiento y ambientes desconectados.

Uno de los principales cambios que introduce ADO.NET es la sustitución del objeto “RecordSet” de ADO, con una combinación de objetos de ADO.NET, tales como “DataSet”, “DataTable”, “DataAdapter” y “DataReader”.

ActiveX, es modelo de objeto de componente (COM) desarrollado por Microsoft para sistemas operativos Windows. Usando COM en tiempo de ejecución, los desarrolladores pueden crear componentes de software que realicen una función particular o un conjunto de funciones. Algún software particular puede entonces estar formado por uno o más componentes con el objeto de proporcionar la funcionalidad que se espera de este. Muchas de las aplicaciones de Microsoft Windows, tales como Internet Explorer, Office, Visual Studio, etc., usan controles ActiveX para construir su conjunto de facilidades y encapsular su

135

funcionalidad. De esta manera, la funcionalidad de los controles ActiveX pueden ser embebidos en otras aplicaciones. Internet Explorer también permite que los controles ActiveX puedan ser embebidos dentro de páginas Web.

En resumen, un control ActiveX es un componente de software reutilizable el cuál implementa una interfase estándar que le permite comunicarse con la aplicación y con otros controles. Un control ActiveX no es una aplicación completa, sino que proporciona un “pequeño bloque de construcción” que puede ser compartido por software diferente.

Microsoft .NET Framework. Es un componente de software que puede ser añadido al sistema operativo Windows.

Consta de una biblioteca de clases muy grande, que contienen soluciones predefinidas para necesidades generales de la programación de aplicaciones, y administra la ejecución de los programas escritos específicamente para el “Framework”.

Las soluciones predefinidas que forman la librería de clases base del Framework cubren un rango muy amplio de necesidades de programación en gran número de áreas, tales como: Interfases de usuario. Acceso a datos. Conectividad a bases de datos. Criptografía. Desarrollo de aplicaciones Web. Algoritmos numéricos. Comunicaciones en red.

La librería de clases es usada por los programadores, quienes combinan esta con su propio código para producir aplicaciones.

Los programas escritos para el .NET Framework se ejecutan en un ambiente de software que administra los requerimientos de tiempo de ejecución de los programas. También siendo parte del .NET Framework, este ambiente de tiempo de ejecución es conocido como el “Common Language Runtime” (CLR) que puede traducirse como “Entorno común de ejecución para lenguajes”. El CLR provee la funcionalidad de una “máquina virtual de la aplicación” para que los programadores no necesiten considerar las capacidades específicas del CPU que ejecutará el programa. El CLR también proporciona otros servicios importantes tales como la seguridad, administración de memoria y manejo de excepciones.

La librería de clases y el CLR juntos, componen el .NET Framework.

Como cualquier software, se han liberado diferentes versiones de .NET Framework, iniciando con la versión 1.0 liberada en el año 2002, y al momento de hacer este escrito la mas reciente es la versión 3.5 liberada a finales del año 2007.

Un diagrama de la arquitectura básica del .NET Framework se muestra en la Figura122. Arquitectura básica de .NET Framework.

136

Figura 122. Arquitectura básica de .NET Framework.

Analizando la arquitectura, de abajo hacia arriba. Como base se encuentra el sistema operativo. Observar los dos componentes básicos del .NET Framework (CLR y la librería de clases). La librería de clases es muy extensa y en esta imagen se muestran algunos componentes de la librería que se describen de manera breve: ASP.NET parte de la librería que proporciona clases, interfases, etc., para el desarrollo

de aplicaciones para Web. ADO.NET, para el acceso a datos. WinForms, para el desarrollo de aplicaciones que se ejecutarán en ambientes de

Windows.

Y por último en la capa superior y sin formar parte del .NET Framework se encuentra la aplicación, que son los programas que interactúan con el usuario y pueden ser escritos en diferentes lenguajes de programación. Se mencionan algunos lenguajes como Visual BASIC (VB), C#, Perl y COBOL.

3.2.2 Componentes disponibles.

ADO.NET tiene una gran cantidad de clases que le permiten acceder y administrar datos.

En la literatura se reporta a ADO.NET con una arquitectura con dos partes principales:

1. El proveedor de datos (Data Provider). Contiene clases que permiten el acceso a la fuente de datos. Dentro de las clases principales se pueden mencionar:

Connection. Proporciona una conexión para comunicarse con la fuente de datos.

137

Command. Se usa para realizar alguna acción en la base de datos, como lectura, actualización o borrado de datos. Normalmente son sentencias SQL o la ejecución de un procedimiento almacenado.

Parameter. Permite especificar un parámetro simple para un objeto de la clase “command”. Por ejemplo, para un procedimiento almacenado.

DataAdapter. Funciona como un puente para transferir datos entre una fuente de datos y un objeto de la clase “DataSet”.

DataReader. Es una clase que se usa para procesar de manera eficiente una lista grande de resultados.

2. DataSets. Es un grupo de clases que permiten describir una simple base de datos relacional en memoria. Las clases de este grupo están organizadas en una jerarquía de contención. Y se describen enseguida. DataSet. Clase que permite representar un esquema (o una base de datos completa o un

subconjunto de esta). Puede contener tablas y sus relaciones.o DataTable. Clase que permite representar una sola tabla de la base de datos.

Tiene un nombre, filas y columnas. DataView. Permite el tener el equivalente a una vista de la base de datos.

Toma como base un objeto de la clase “DataTable”, permite ordenar datos y aplicar filtros sobre los datos.

DataColumn. Representa una columna de una tabla, incluye su nombre y tipo.

DataRow. Representa una sola fila en la tabla. Permite leer y actualizar los valores de esa fila. Permite recuperar también cualquier fila que este relacionada con la fila original por medio de una relación clave primaria / clave foránea.

DataRowView. Representa una sola fila de un “DataView”.o DataRelation. Permite establecer una relación entre las tablas, tales como una

relación clave primaria / clave foránea. Esto permite al “DataRow” la funcionalidad de recuperar filas relacionadas.

o Constraint. Describe una propiedad de la base de datos que se debe cumplir. Por ejemplo, que los valores de una clave primaria sean únicos.

Un diagrama general que muestra las relaciones entre las principales clases se muestra en la Figura 123. Clases principales de .NET Framework para bases de datos.

138

Figura 123. Clases principales de .NET Framework para bases de datos.

Un “DataSet” es llenado desde una base de datos por un “DataAdapter” cuyas propiedades “Connection” y “Command” han sido iniciadas. Observar que “Command” y “DataReader” (usando a “Connection”) pueden proveer directamente con datos a los consumidores. Siempre el acceso a la fuente de datos es por medio de “Connection”. Como ejemplos de consumidores de datos de mencionan “WinForm” (formas para aplicaciones de Windows) y “WebForm” (formas para aplicaciones de Web).

Otra manera de visualizar la arquitectura de ADO.NET, reportada en la biblioteca MSDN de Microsoft se muestra en la Figura 124. Arquitectura de ADO.NET.

Figura 124. Arquitectura de ADO.NET.

139

De la Figura 124. Arquitectura de ADO.NET., observar las dos partes principales de la arquitectura (el “Data Provider” – en la figura como “Proveedor de datos de .NET Framework”- y el “DataSet”). Notar que el “DataAdapter” puede contener comandos de manipulación de datos. En la figura se indica la estructura jerárquica de las clases contenidas en el “DataSet”. Se resalta que el “DataSet” usa de manera interna el formato XML para representar los datos y de esta manera puede fácilmente leer y escribir datos en ese formato.

Desde el “DataSet” (y pasando por el “DataAdapter”) es posible actualizar la base de datos o guardar su contenido a XML (con opción de crear también un esquema XSD). También es posible llenar el “DataSet” desde archivos XML, esto es muy útil cuando se usan servicios Web, computación distribuida, y aplicaciones conectadas ocasionalmente.

Por experiencia propia el uso de los “DataSet”, es fácil y útil, guardar y escribir su contenido como XML. Internamente los “DataSet” representan sus datos en formato XML. Por ejemplo, en una aplicación de Web, el usuario final puede recuperar datos en formato XML (recordar que es un formato estándar para compartir información) y los puede procesar.

Un “DataSet”, es la evolución de la clase “RecordSet” mencionado mas adelante, el “DataSet” es una clase con más propiedades y métodos, lo que deriva en mayor funcionalidad y flexibilidad.

Enseguida se describirán las clases de ADO.NET mencionadas en el temario. Con la observación de que no son todas las disponibles (revisarlas para cada versión particular de .NET Framework). También observar que existen clases más recientes, por ejemplo la clase “RecordSet” ha sido extendida por la clase “DataSet”.

3.2.2.1 Connection.

Proporciona una conexión para comunicarse con la fuente de datos y administrar las transacciones en una base de datos.

Los comandos viajan por las conexiones y devuelven conjuntos de resultados en forma de secuencias que puede leer un objeto “DataReader” o que se pueden insertar en un objeto “DataSet”.

3.2.2.2 Command.

Para emitir comandos SQL a una base de datos, y ejecutar procedimientos almacenados.

Los comandos contienen la información que se envía a una base de datos y se representan mediante clases específicas de un proveedor, como “SQLCommand” (clase que se usa cuando el proveedor de datos es Microsoft SQL Server”). Un comando podría ser una llamada a un procedimiento almacenado, una instrucción UPDATE o una instrucción que devuelve resultados. También es posible utilizar parámetros de entrada o de resultados y devolver valores como parte de la sintaxis del comando.

140

3.2.2.3 Recordsource.

En ADO.NET, “RecordSource” se refiere más bien a una propiedad de las clases de ADO.NET que las vinculan con su fuente de datos (o registros).

En la librería MSDN se describe a “RecordSource” como: “La propiedad ‘RecordSource’ especifica el origen de los registros accesibles a través de los controles enlazados del formulario”

En ADO (“ActiveX Data Objects”) que es el antecedente de ADO.NET, la funcionalidad para contar con datos para las aplicaciones la proporciona la clase “RecordSet”. En ADO.NET esta funcionalidad es provista y ampliada por la clase “DataSet”.

La clase “RecordSet”, representa el conjunto entero de registros de una tabla base o el resultado de un comando ejecutado. En el momento de la ejecución, el objeto “RecordSet” hace referencia a un solo registro dentro del conjunto y se conoce como el “registro actual”.

Se usan objetos “RecordSet” para manipular datos de un proveedor de datos (SQL Server, Oracle, MySQL, etc.). Cuando se usa el modelo ADO, los datos se manipulan casi completamente mediante objetos “RecordSet”. Un objeto “RecordSet” consiste de registros (filas) y campos (columnas). Dependiendo de la funcionalidad soportada por el proveedor, es posible que algunos métodos y propiedades de “RecordSet” no estén disponibles.

La funcionalidad de “RecordSet” comparada con la de “DataSet” es más limitada, por ejemplo en un “RecordSet” solo se pueden representar un solo conjunto de registros (una tabla o resultado de una consulta), mientras que en un “DataSet” es posible almacenar una base de datos completa, relaciones y restricciones de integridad. Aún más, un “DataSet” se puede alimentar con fuentes de datos diversas.

Por lo anterior considero mas adecuado describir aquí la clase “DataSet”. En la librería MSDN de Microsoft se describe a la clase “DataSet” de la siguiente manera:

“El objeto DataSet es esencial para admitir escenarios de datos distribuidos de ADO.NET sin mantener una conexión. El DataSet es una representación residente en memoria de datos que proporciona un modelo de programación relacional coherente independientemente del origen de datos. Se puede utilizar con múltiples y distintos orígenes de datos, con datos XML o para administrar datos locales de la aplicación. El DataSet representa un conjunto completo de datos entre los que se incluyen tablas relacionadas, restricciones y relaciones entre las tablas.”

En la misma librería MSDN de Microsoft, se muestra el modelo de objeto de la clase DataSet mediante la Figura 125. Modelo de objeto de la clase "DataSet".

141

Figura 125. Modelo de objeto de la clase "DataSet".

Los métodos y objetos contenidos en un “DataSet” son coherentes con los del modelo de base de datos relacional.

El “DataSet” también puede persistir y volver a cargar su contenido como XML y su esquema como esquema XSD (Lenguaje de definición de esquemas XML). Enseguida se describen las clases contenidas en la clase “DataSet”:

DataTableCollection

Un “DataSet” de ADO.NET contiene una colección de cero o más tablas representadas por objetos “DataTable”. La “DataTableCollection” contiene todos los objetos “DataTable” de un “DataSet”.

Un “DataTable” se define en el espacio de nombres “System.Data” y representa una única tabla de datos residentes en memoria. Contiene una colección de columnas representadas por una “DataColumnCollection” y restricciones representadas por una “ConstraintCollection” que, juntas, definen el esquema de la tabla. Un “DataTable” también contiene una colección de filas representadas por la “DataRowCollection”, que contiene los datos de la tabla. Junto con su estado actual, un “DataRow” conserva tanto la versión original como la actual para identificar los cambios realizados en los valores almacenados en la fila.

142

DataRelationCollection

Un “DataSet” contiene relaciones en su objeto “DataRelationCollection”. Una relación, representada por el objeto “DataRelation”, asocia las filas de un “DataTable” con las filas de otro “DataTable”. Es análogo a una ruta de unión que podría existir entre las columnas de claves externas y principales en una base de datos relacional. Un “DataRelation” identifica columnas coincidentes en dos tablas de un “DataSet”.

Las relaciones permiten pasar de una tabla a otra dentro de un mismo “DataSet”. Los elementos esenciales de un “DataRelation” son el nombre de la relación, el nombre de las tablas relacionadas y las columnas relacionadas de cada tabla. Se pueden establecer relaciones con más de una columna por tabla, para lo que debe especificar una selección de objetos “DataColumn” como columnas clave. Cuando se agrega una relación al “DataRelationCollection”, se puede agregar también un “UniqueKeyConstraint” y un “ForeignKeyConstraint” para imponer restricciones de integridad cuando se realicen cambios en los valores de las columnas relacionadas.

ExtendedProperties

El “DataSet” (así como el “DataTable” y el “DataColumn”) tiene una propiedad “ExtendedProperties”. “ExtendedProperties” es un “PropertyCollection” en el que se puede colocar información personalizada, como la instrucción SELECT que sirve para generar el conjunto de resultados, o una marca de fecha y hora de cuándo se generaron los datos. La colección “ExtendedProperties” se conserva con la información del esquema del “DataSet” (así como el “DataTable” y el “DataColumn”).

3.2.2.4 Error.

“Error” como objeto está definido en ADO, en este contexto, el objeto “Error” contiene detalles acerca de los errores de acceso a datos que pertenecen a una única operación relacionada con el proveedor de datos.

En ADO, el objeto “Error” es parte de la colección “Errors”, que a su vez pertenece al objeto “Connection”, tal como se muestra en la Figura 126. Ubicación del objeto "Error" deADO.

Figura 126. Ubicación del objeto "Error" de ADO.

Cualquier operación donde participan objetos ADO puede generar uno o más errores del proveedor. Cuando cada error ocurre, uno o más objetos “Error” son colocados en la colección “Errors” que pertenece al objeto “Connection”. Cuando otra operación ADO genera

143

un error, la colección “Errors” es limpiada, y un nuevo conjunto de objetos “Error” son colocados en la colección “Errors”.

Cabe aclarar que cada objeto “Error” representa un error del proveedor particular, no un error de ADO. Los errores de ADO se pasan al mecanismo de control de excepciones de ejecución. Por ejemplo, en Microsoft Visual BASIC, la presencia de un error concreto de ADO, desencadena un evento “On Error” y aparecerá en el objeto “Err”.

Es posible leer las propiedades de un objeto “Error” para obtener detalles específicos sobre cada error, dichas propiedades se muestran en la Tabla 8. Propiedades del objeto"Error".

Nombre de la propiedad. Descripción.Description Contiene el texto descriptivo del error.Number Contiene un valor entero largo que corresponde al valor numérico constante

del error.Source Identifica el objeto que ha provocado el error. Esto es muy útil cuando se

tienen varios objetos “Error” en la colección “Errors” después de una petición a un origen de datos.

SQLState, NativeError Son dos propiedades que proporcionan información desde orígenes de datos SQL.

Tabla 8. Propiedades del objeto "Error".

En ADO.NET el manejo de los errores es algo diferente a ADO. En ambos casos, los errores están asociados al objeto “Connection”. En ADO.NET el objeto “Connection” tiene dos eventos que se pueden utilizar para recuperar mensajes informativos de un origen de datos o para determinar si ha cambiado el estado de un objeto “Connection”. Para esto ver la Tabla 9. Propiedades del objeto "Connection" de ADO.NET.

Nombre del evento. Descripción.InfoMessage Se produce cuando se devuelve un mensaje informativo desde un origen de

datos. Los mensajes informativos son aquellos procedentes de orígenes de datos que no inician una excepción.

StateChange Se produce cuando cambia el estado del objeto “Connection”.Tabla 9. Propiedades del objeto "Connection" de ADO.NET.

El evento “InfoMessage” recibe un objeto “InfoMessageEventArgs” que contiene en su propiedad “Errors” una colección de los mensajes del origen de datos. Se puede consultar los objetos “Error” de esa colección para conocer el número de error y el texto del mensaje, así como el origen del error. El proveedor de datos de .NET Framework para SQL Server incluye asimismo datos acerca de la base de datos, el procedimiento almacenado y el número de línea donde se originó el mensaje.

El evento “StateChange” se produce cuando se cambia el estado de un objeto “Connection”. El evento “StateChange” recibe “StateChangeEventArgs” que permiten determinar el cambio de estado de “Connection” por medio de las propiedades “OriginalState” y “CurrentState”. La propiedad “OriginalState” es una enumeración “ConnectionState” que indica el estado del objeto “Connection” antes del cambio.

144

“CurrentState” es una enumeración “ConnectionState” que indica el estado del objeto “Connection” después del cambio.

En ADO.NET “Error” es también una propiedad de ambas clases, por ejemplo en las clases “Console”, “HttpContext”, “IDataErrorInfo”, “PassportIdentity” y “SystemIcons”.

3.2.3 Prototipo de aplicaciones con conectividad a bases de datos.

En este caso se ejemplificará la instalación y configuración de un controlador ADO.NET para hacer la conexión de una aplicación Web hecha en Microsoft Visual Studio 2005 que usará una base de datos que estará en el DBMS “MySQL Server 5.0”

De manera similar a como se explicaron los pasos para establecer una conexión de una aplicación a una base de datos mediante ODBC, se explicarán aquí los pasos para establecer y usar la conexión de la aplicación a una base de datos mediante el conector ADO.NET.

Pasos generales.1. Instalar primero el software para la aplicación (Microsoft Visual Studio 2005) y el DBMS a usar (MySQL Server 5.0).

2. Descargar del sitio de MySQL.com el controlador ADO.NET, en este caso el “Connector/Net”. Que se obtuvo de la página http://dev.mysql.com/downloads/connector/ , en esta página seleccionar la opción “Connector/Net” como se muestra en la Figura 127. Elconector .NET en la página de descarga de conectores de MySQL.

Figura 127. El conector .NET en la página de descarga de conectores de MySQL.Al seleccionar la opción de “Connector/Net” se muestra la página donde se puede

seleccionar el tipo de descarga, como se muestra en la Figura 128. Página de descarga delconector .NET 5.1.

145

http://dev.mysql.com/downloads/connector/

Figura 128. Página de descarga del conector .NET 5.1.

Notar las tres opciones de descarga “Downloads”, la segunda opción “Windows Binaries (ZIP)” es la más sencilla para instalar. Esta incluye un software que asiste en la instalación. En el momento de escribir este texto, la opción del conector ADO.NET es la 5.1.6. Observar que se puede seleccionar la opción de descargar en este momento (Download) o bien el de seleccionar un servidor de descarga.

Al seleccionar la opción para descarga, aparece la pantalla de descarga que se muestra en la Figura 129. Seleccionar tipo de archivo de descarga del conector .NET5.1.

Figura 129. Seleccionar tipo de archivo de descarga del conector .NET 5.1.

146

En la pantalla de diálogo de “Descarga de archivo” hacer clic en el botón de “Guardar” para almacenar el conector en la computadora del usuario. Al hacer esto, se le solicita al usuario que indique ubicación donde se almacenará el archivo e inicia la descarga del conector, y se muestra la pantalla que indica el avance de la descarga, como se muestra en la Figura 130. Avance de descarga del conector .NET 5.1.

Figura 130. Avance de descarga del conector .NET 5.1.

3. Instalar el controlador ADO.NET en el equipo.Una vez descargado el archivo, se ejecuta el programa de instalación (archivo

MySql.Data), como se muestra en la Figura 131. Instalar el conector .NET, ejecutararchivo de instalación.

Figura 131. Instalar el conector .NET, ejecutar archivo de instalación.

147

Al ejecutar el archivo descargado, se pregunta al usuario la confirmación para la instalación. Después de aceptarla con el botón “Next”, aparece la siguiente pantalla del asistente de instalación, como se muestra en la Figura 132. Instalar el conector .NET, seleccionar tipo de instalación.

Figura 132. Instalar el conector .NET, seleccionar tipo de instalación.

En este caso se seleccionó la opción de instalación completa (botón “Complete”). Y se muestra la pantalla de Figura 133. Instalar el conector .NET, preparado para instalar.

.

148

Figura 133. Instalar el conector .NET, preparado para instalar.

En esta pantalla ya se tiene la información para instalar el programa, y al hacer clic en el botón “Install” se inicia la instalación. Enseguida se muestra una pantalla (ver Figura 134.Instalar el conector .NET, avance de instalación) que indica el avance de la instalación.

Figura 134. Instalar el conector .NET, avance de instalación.Al terminar el proceso de instalación se muestra la pantalla que indica el fin del

proceso, como se muestra en la Figura 135. Instalar el conector .NET, fin de instalación.

149

Figura 135. Instalar el conector .NET, fin de instalación.

Una vez terminada la instalación, verificar en la opción de Inicio | Programas | MySQL que esta instalado el conector, como se muestra en la Figura 136. Ver conector .NETinstalado.

Figura 136. Ver conector .NET instalado.

Observar en este caso el programa con el nombre de “MySQL Connector Net 5.1.6”, aquí se encuentra entre otras cosas, una documentación extensa del producto que es adecuado revisar. En la Figura 137. Ver documentación instalada del conector .NET, se muestra un ejemplo de la documentación existente.

150

Figura 137. Ver documentación instalada del conector .NET.

En la pantalla de la Figura 137. Ver documentación instalada del conector .NET., donde se muestra una parte de la ayuda se despliega la ayuda para establecer una conexión de base de datos de Microsoft Visual Studio.NET hacia el DBMS MySQL, usando el conector recién instalado. Que es el paso que sigue.

Por lo anterior es muy importante revisar y apoyarse en la documentación del producto, lo que ayudará a hacer un uso más eficiente de este. La documentación normalmente incluye ejemplos y código que se podrán aplicar al desarrollo de una aplicación. Una revisión general de la documentación proporciona al desarrollador una visión de las posibilidades del software.

4. Realizar la conexión de base de datos en una aplicación.En este caso se ejemplificará usando el software para desarrollo de aplicaciones

Microsoft Visual Studio 2005.

En el Microsoft Visual Studio 2005 (VS 2005), se creó un proyecto Web.

Una vez creado el proyecto, se debe agregar una conexión ADO.NET hacia el servidor de base de datos (DBMS) MySQL. Para realizar la conexión se siguieron los pasos indicados en el manual de documentación del conector. Para ver más detalles y solucionar posibles problemas ver dicha documentación.

151

Recordar que VS 2005 incluye la ventana “Server Explorer”. Mediante esta se pueden establecer conexiones a diversos DBMS. Esta ventana está a un lado de la caja de herramientas “Toolbox”.

El primer paso será crear una nueva conexión en la ventana “Server Explorer”, como se mostró en la Figura 104. Agregar una nueva conexión de datos en VisualStudio .NET..

Aparece la primer pantalla para crear la nueva conexión, como se mostró en la Figura105. Cambiar la fuente de datos de una conexión en Visual Studio .NET, aquí es necesario presionar hacer clic en el botón “Change” para cambiar la fuente de datos, si en la opción “Data Source” no aparece la base de datos “MySQL Database”. Al hacer esto, se muestra la pantalla de la Figura 138. Seleccionar la base de datos MySQL como fuentede datos.

Figura 138. Seleccionar la base de datos MySQL como fuente de datos.

En la pantalla de la Figura 138. Seleccionar la base de datos MySQL como fuentede datos, seleccionar en la opción “Data source” como fuente de datos la base de datos de MySQL “MySQL Database” y después hacer clic en el botón de “OK”. Esta opción aparece aquí por la instalación previa del conector en el equipo. Con lo que aparece la pantalla para configurar la conexión al servidor de MySQL. Como se muestra en la Figura 139. Configurary probar la conexión a la base de datos de MySQL.

152

Figura 139. Configurar y probar la conexión a la base de datos de MySQL.

En la pantalla de la Figura 139. Configurar y probar la conexión a la base de datosde MySQL., se deben proporcionar los datos necesarios para establecer la conexión de base de datos al servidor de MySQL, Es recomendable probar la conexión mediante el botón de “Test Connection” para asegurar que los datos son correctos y se establece la conexión. Una vez hecho lo anterior, hacer clic en el botón de “OK” para crear la conexión. Al crear la conexión verificar que ya esta incluida en la lista de conexiones del explorador de servidores como se muestra en la Figura 140. Ver la conexión a MySQL en el "Server Explorer" deVisual Studio .NET.

Figura 140. Ver la conexión a MySQL en el "Server Explorer" de Visual Studio .NET.

Una vez establecida la conexión esta se puede usar en la aplicación. Es el mismo procedimiento que ya se trató en el tema de ODBC. En este caso se ejemplificará para mostrar el contenido de la tabla “proyectos” de la base de datos “innovación” de MySQL en una aplicación Web.

153

Como es el mismo procedimiento visto antes, solo se resumirán los pasos, para detalles ver el tema “5. Usar la conexión en una aplicación” dentro del tema de ODBC “3.1.3 Instalación y configuración del driver acorde al gestor de bases de datos.”

Los pasos se resumen de la siguiente manera:1. Agregar un nuevo objeto “DataSet” al proyecto, configurarlo para que use la conexión a MySQL recien creada y definir una consulta SQL que permita obtener todos los datos de la tabla “proyectos” de la base de datos “innovación” de MySQL.2. Agregar al proyecto Web una nueva página tipo “Web Forms”. 3. En la página Web agregar un objeto de la clase “ObjectDataSource” de la ficha “Data” de la caja de herramientas (“ToolBox”) de Visual Studio.4. Configurar el objeto “ObjectDataSource” para asociarlo con el objeto “DataSet” recién creado. Recordar asociarlo al “DataSet” más el “TableAdapter”.5. Agregar a la página Web un objeto “GridView” de la misma ficha “Data” del “ToolBox”.6. Configurar el objeto “GridView” y mediante la propiedad “Data Source” asociarlo al objeto “ObjectDataSource” que se agregó y configuró para esta página.7. Salvar los archivos y ejecutar el proyecto.

3.3 JDBC.

JDBC significa “Java Database Connectivity” o en castellano “Conectividad de base de datos para Java”. JDBC es una API que permite ejecutar operaciones en bases de datos usando el lenguaje Java. JDBC es independiente del sistema operativo donde se ejecuta y de la base de datos que se accede. Esta enfocado a bases de datos relacionales y utiliza el dialecto de SQL del DBMS en uso.

A continuación se explican mas detalles sobre JDBC y conceptos relacionados.


En este tema se describen conceptos de base sobre JDBC y temas relacionados.

Java.Es un lenguaje de programación orientado a objetos desarrollado por la empresa Sun

Microsystems. Su sintaxis es muy parecida a C y C++, sin embargo su modelo de objetos es más simple y no incluye herramientas de bajo nivel. Una característica sobresaliente del lenguaje es ser independiente de la plataforma, esto permite que un programa Java escrito en una plataforma pueda ser ejecutado sin necesidad de cambios en otras plataformas.

Existen actualmente muchos IDE (“Ambiente de desarrollo integrado”) para Java, algunos son comerciales, otros son gratuitos y otros como software libre. Para mencionar algunos de ellos: NetBeans, JBuilder y Eclipse.

154

JSP.JSP significa “Java Server Pages” o en castellano “Páginas de Servidor de Java”.

Permite desarrollar aplicaciones para Web en el lenguaje Java y la lógica de la aplicación se ejecuta en el servidor Web. Permite generar contenido dinámico para Web, en forma de documentos HTML, XML o de otros tipos. JSP permite el uso de código Java mediante scripts. También se puede usar algunas acciones JSP predefinidas mediante etiquetas.

JSTL.JSTL significa “JavaServer Pages Standard Tag Library” y es una tecnología que es

un componente de Java EE. Extiende las JSP proporcionando cuatro librerías de etiquetas (Tag Libraries) con utilidades ampliamente utilizadas en el desarrollo de páginas web dinámicas. Estas librerías de etiquetas extienden de la especificación de JSP (la cúal a su vez extiende de la especificación de Servlet). Su API permite además desarrollar librerías de etiquetas personalizadas.

Las librerías englobadas en JSTL son: core, iteraciones, condicionales, manipulación de URL y otras funciones generales. xml, para la manipulación de XML y para XML-Transformation. sql, para gestionar conexiones a bases de datos. fmt, para la internacioalización y formateo de las cadenas de caracteres como cifras.

JavaBeans.Es un modelo de componentes creado por la empresa Sun Microsystems para la

construcción de las aplicaciones en Java. Por este medio se pueden encapsular varios objetos en un único objeto, para hacer uso de un solo objeto en vez de varios. Son componentes de software reutilizables que se pueden manipular visualmente en una herramienta de construcción.

Applet.Es un programa escrito en el lenguaje Java y que se ejecuta dentro del explorador

Web, es decir se ejecuta del lado del cliente. Para ejecutarse requiere de la máquina virtual de Java (JVM). Proporcionan facilidades interactivas que no las puede proporcionar HTML.

Paquete de Java.Un paquete (“package”) de Java es un mecanismo para organizar las clases de Java

dentro de espacios de nombres. Pueden ser almacenados en archivos comprimidos llamados archivos “JAR”, lo que permite que las clases se descarguen en grupo de una manera más rápida en lugar de una a la vez.

Un paquete esta formado por clases (también interfases y otros elementos) de una cierta categoría o que proporcionan una funcionalidad similar. Por ejemplo, el paquete de Java “java.sql” contiene clases e interfases que se requieren para trabajar con bases de datos.

Un paquete Java puede contener los siguientes elementos: otros paquetes, clases, interfases, tipos enumerados y anotaciones.

Archivo “.jar” de Java.

155

Un archivo “.jar” (por “Java Archive”) de Java se utiliza para agregar muchos archivos en uno solo. Generalmente se usa para distribuir clases de Java y los metadatos asociados. Los archivos “.jar” están basados en el formato de archivos “ZIP” (es un formato para almacenamiento y compresión de datos). Los archivos “.jar” se pueden crear y extraer mediante el comando “jar” que esta incluido en el JDK (“Java Development Kit”).

Interfase de Java.En Java una “interface” (término en inglés) es una clase abstracta pura, es decir donde

todos los métodos son abstractos (no se implementa ninguno). Sirve para establecer la forma de una clase, que incluye: atributos, nombres de métodos, listas de argumentos y tipos de retorno, pero no bloques de código. Una interfase sirve para establecer un “protocolo” (una forma de comunicación) entre clases.

Clase.En el contexto de la programación orientada a objetos, una clase es una construcción

de un lenguaje de programación que se usa como una “fábrica” de objetos. La clase incluye atributos y métodos que comparten todos los objetos creados. La clase describe las reglas para el comportamiento de los objetos. Los objetos son instancias de la clase.

Una clase tiene una interfase y una estructura. La interfase describe como la clase y sus instancias pueden interactuar con otras mediante los métodos. La estructura describe la manera en que los datos están acomodados en atributos dentro de una instancia.

Las clases están organizadas mediante jerarquías de herencia.

Objeto.Es una instancia de una clase. El objeto contiene valores para los atributos y las

instrucciones que operan en los datos. Esto hace al objeto capaz de recibir mensajes, procesar datos, y enviar mensajes a otros objetos.

JDBCComo se mencionó antes, esta es una API que se usa en Java para aplicaciones que

requieren usar bases de datos.

El controlador JDBC debe ser específico de acuerdo al DBMS a usar, como se muestra en la Figura 141. Controlador JDBC según el DBMS.

156

Figura 141. Controlador JDBC según el DBMS.

Por ejemplo, si se requiere un controlador JDBC para acceder a una base de datos en el servidor de MySQL, se requiere el controlador que proporciona la empresa MySQL AB, y en este caso el controlador se llama “MySQL Connector/J”.

JDBC permite realizar las siguientes actividades de programación:1. Conectarse a una fuente de datos.2. Enviar consultas y enunciados de actualización a la base de datos.3. Recuperar y procesar los resultados recibidos de la base de datos en respuesta a una consulta.

JDBC incluye cuatro componentes básicos:1. La API JDBC. Permite acceso mediante programación a bases de datos relacionales

mediante el lenguaje de programación Java. Por medio de él, las aplicaciones pueden ejecutar enunciados SQL, recuperar resultados, y propagar cambios hacia la fuente de datos. Esta API puede también interactuar con múltiples fuentes de datos en un ambiente distribuido y heterogéneo.

La API JDBC es parte de la plataforma Java, la cuál incluye las marcas registradas “Java Standard Edition” (“Java SE”) y “Java Enterprise Edition” (“Java EE”). La API JDBC 4.0 esta dividida en dos paquetes: java.sql y javax.sql. Ambos paquetes están incluidos en las plataformas de “Java SE” y “Java EE”.

157

2. JDBC “DriverManager”. La clase “DriverManager” de JDBC define objetos que pueden conectar aplicaciones Java a un controlador JDBC. Esta clase es la columna vertebral de la arquitectura JDBC.

3. JDBC Test Suite. O “Suite de prueba JDBC” es una ayuda para determinar que controladores JDBC ejecutará un programa

4. JDBC – ODBC Bridge. O “Puente JDBC – ODBC” este proporciona acceso JDBC por medio de controladores ODBC.

JNDI.El significado en inglés de JNDI es “Java Naming and Directory Interface”. Es una API

de Java para servicio de directorios que permite que clientes de software Java puedan descubrir y buscar datos y objetos por medio de un nombre

3.3.2 SQL y JDBC.

JDBC fue creado para acceso a datos en representación tabular, tales como las bases de datos relacionales, archivos planos, y hojas electrónicas. Del modelo relacional de base de datos el lenguaje de manipulación y definición de datos más usado es el SQL. Por este motivo, JDBC está diseñado para usar SQL como su lenguaje para interactuar con la base de datos.

De hecho los paquetes del lenguaje Java dónde esta contenida la funcionalidad del JDBC llevan “sql” en su nombre de paquete.

La funcionalidad de JDBC esta comprendida en dos paquetes: java.sql. javax.sql.

Para la documentación de JDBC explicada de aquí en adelante se utilizó la versión de marca registrada “Java Plataform Standard Edition 6”. Esta es la versión en uso más reciente al momento de escribir este material.

Enseguida se hará una descripción general de las jerarquías de clases de los paquetes de Java para uso de bases de datos, así como una descripción general de las interfaces más importantes de JDBC. Para una descripción completa consultar el sitio Web de la empresa Sun Microsystems.

3.3.2.1 Jerarquía de clases java.sql.*.

Este paquete proporciona la API JDBC para acceder y procesar datos almacenados en una fuente de datos (normalmente una base de datos relacional) mediante el lenguaje de programación Java.

Para una descripción oficial y completa del paquete “java.sql” consultar el sitio Web de la empresa Sun Microsystems, en particular la página: http://java.sun.com/javase/6/docs/api/java/sql/package-summary.html.

158

http://java.sun.com/javase/6/docs/api/java/sql/package-summary.html

El paquete “java.sql” contiene la mayor parte de la funcionalidad de JDBC. Las clases que componen dicho paquete están organizadas en una jerarquía de clases, recuerde el lector las implicaciones de lo anterior y la posibilidad de crear nuevas clases hijas a partir de las existentes. En la Figura 142. Jerarquía de clases del paquete "java.sql", se muestra la jerarquía de clases de dicho paquete (tomado del sitio Web de la empresa Sun Microsystems).

Figura 142. Jerarquía de clases del paquete "java.sql".

Una descripción general de las principales clases del paquete se muestra en la Tabla 10. Descripción de clases del paquete “java.sql”.

159

Nombre de la clase

Descripción de la clase

Date Para representar fechas y permite a JDBC asociar este con un valor “DATE” de SQL.

DriverManager Proporciona el servicio básico para manejar un conjunto de controladores JDBC.DriverPropertyInfo Contiene las propiedades del “driver” que permiten hacer la conexión.SQLPermission Contiene datos sobre los permisos que el “SecurityManager” revisará cuando el

código que se está ejecutando en una applet invoque a los métodos “DriverManager.setLogWriter” o “DriverManager.setLogStream”.

Time Permite representar valores de hora y permite que JDBC lo pueda identificar como un valor “TIME” de SQL.

Timestamp Permite representar valores de hora y permite que JDBC lo pueda identificar como un valor “TIMESTAMP” de SQL.

Types Es una clase que define las constantes que serán usadas para identificar tipos de datos genéricos de SQL, llamados tipos JDBC.

Tabla 10. Descripción de clases del paquete “java.sql”.

En el mismo paquete se encuentran varias “interfaces” de Java para soporte al manejo de datos, la jerarquía de dichas interfases se muestra en la Figura 143. Jerarquíade interfases del paquete “java.sql”.

Figura 143. Jerarquía de interfases del paquete “java.sql”.

Se hace una lista de las interfases más significativas y se describe de manera breve el uso de cada una (ver Tabla 11. Descripción de interfases del paquete “java.sql”.).

Nombre de la “interface”

Descripción

Array Es la representación del tipo “ARRAY” de SQL, en el lenguaje de programación Java.Blob Es la representación del valor “BLOP” de SQL, en el lenguaje de programación Java.CallableStatement Se usa para ejecutar procedimientos almacenados de SQL.

160

Clob Es la representación del tipo “CLOP” de SQL, en el lenguaje de programación Java.Connection Representa una conexión (sesión) con una base de datos específica.DatabaseMetaData Contiene información compresible sobre la base de datos como un todo.Driver Es la “interface” que cada clase “driver” debe implementar.ParameterMetaData Permite tener un objeto que puede ser usado para obtener información de los tipos y

propiedades de los parámetros en un objeto “PreparedStatement”PreparedStatement Permite tener un objeto que representa un enunciado precompilado SQL.Ref Es la representación del valor “REF” de SQL, en el lenguaje de programación Java.

En SQL el valor “REF” es una referencia a un valor de tipo estructurado SQL en la base de datos.

ResultSet Permite tener una tabla de datos que representa un resultado obtenido de la base de datos, que es usualmente generado por la ejecución de un enunciado que consulta la base de datos.

ResultSetMetaData Permite tener un objeto que puede ser usado para obtener información sobre los tipos y propiedades de las columnas en un objeto “ResulSet”.

Savepoint Es la representación de un “Savepoint” de la base de datos, el cuál es un punto dentro de la transacción actual que puede ser referenciado desde el método “Connection.rollback”.

SQLData Es la “interface” usada para la representación de un tipo definido por el usuario (“UDT” en inglés”) de SQL a una clase de Java.

SQLInput Representa un flujo de entrada que contiene valores que representan una instancia de un tipo estructurado de SQL o un tipo “distinct” de SQL.

SQLOutput Representa un flujo de salida para escribir los atributos de un tipo definido por el usuario de regreso a la base de datos.

Statement Representa el objeto usado para ejecutar una sentencia estática SQL y regresar los resultados que este produce.

Struct Permite la representación de un tipo estructurado SQL en Java.Tabla 11. Descripción de interfases del paquete “java.sql”.

Un diagrama que ejemplifica la relación funcional entre las clases e interfases más sobresalientes del paquete “java.sql” se muestra en la Figura 144. Relación funcional declases e interfases del paquete “java.sql”.

Figura 144. Relación funcional de clases e interfases del paquete “java.sql”.

161

Observar que se inicia con la clase “DriverManager”, quién crea un objeto tipo “Connection” y así poder realizar la conexión a una base de datos específica. Mediante el objeto “Connection” se crea un objeto tipo “Statement” que contiene la sentencia SQL a ejecutar en la base de datos. El objeto “Statement” envía la sentencia SQL al “Driver JDBC” quién a su vez la hace llegar a la base de datos. El objeto “Statement” también crea un objeto “ResultSet” quien será el encargado de recibir el resultado de la consulta (datos) de la base de datos vía el “Driver JDBC”

En el sitio de Sun el lector puede consultar una especificación más detallada de cada clase e interfase, así como de sus métodos y atributos. Enseguida se dan más detalles de las interfases más comunes.

3.3.2.2 Interface java.sql.connection.

Representa una conexión (sesión) con una base de datos específica. Los enunciados SQL son ejecutados y los resultados son regresados dentro del contexto de una conexión.

Un objeto que es una conexión de base de datos, es capaz de proporcionar información que describe sus tablas, su gramática de SQL soportada, sus procedimientos almacenados, y las capacidades de esta conexión, entre otros. Esta información es obtenida con el método “getMetaData”.

Cuando se configura una conexión, las aplicaciones JDBC deben usar el método de conexión apropiado para la administración de las transacciones, tal como “SetAutoCommit” o “setTransactionIsolation”. Las aplicaciones no deben invocar de manera directa sentencias SQL para cambiar la configuración de la conexión, cuando exista un método JDBC disponible para ello.

Por omisión un objeto “Connection” está en modo de “auto-commit”, lo cuál significa que este automáticamente realizará un “commit” (escribe de manera permanente sus cambios en la base de datos) después de ejecutar cada enunciado. Si el modo “auto-commit” es deshabilitado, el método “commit” se debe de llamar de manera explícita para escribir los cambios de manera permanente en la base de datos; en caso contrario los cambios no serán guardados.

Algunos de los métodos que me parecen más significativos se mencionan en la Tabla12. Algunos métodos de la interfase "Connection".

Nombre demétodo

Descripción

close() Libera de manera inmediata el objeto de conexión de base de datos y los recursos JDBC, en vez de esperar que se liberen de manera automática.

commit() Hace que sean permanentes los cambios hasta el anterior commit/rollback y libera los bloqueos actuales en la base de datos que actualmente están retenidos por este objeto “Connection”.

createstatement() Es un método sobrecargado. Crea un objeto “Statement” enviando enunciados

162

SQL a la base de datos. En algunas implementaciones del método podrá generar objetos tipo “ResulSet”.

preparecall(string sql) Crea un objeto “CallableStatement” para invocar a procedimientos almacenados de la base de datos. Es método sobrecargado.

preparestatement(string sql) Crea un objeto “PrepareStatement” para enviar enunciados SQL con parámetros a la base de datos. Esta sobrecargado y en algunas implementaciones puede auto generar claves y generar objetos “ResultSet”.

rollback() Deshace todos los cambios realizados en la transacción actual y libera los bloqueos de base de datos retenidos por este objeto “Connection”

Tabla 12. Algunos métodos de la interfase "Connection".

Para obtener una descripción detallada de todos los atributos y métodos de la “interface” consultar la página: http://java.sun.com/javase/6/docs/api/java/sql/Connection.html.

3.3.2.3 Interface java.sql.statement.

Esta interfase representa al objeto usado para ejecutar un enunciado estático SQL y regresar los resultados que este produce.

Por omisión, solo un objeto “ResultSet” por objeto “Statement” puede estar abierto en cierto momento. Por lo tanto, si la lectura de un objeto “ResultSet” esta intercalado con la lectura de otro, cada uno debe ser generado por diferentes objetos “Statement”. La ejecución de métodos en la interfase “Statement” de manera implícita cierra un objeto actual “ResulSet” si existe uno que este abierto.

Algunos de los métodos que me parecen más significativos se muestran en la Tabla13. Algunos métodos de la interfase "Statement"..

Nombre demétodo

Descripción

close() Libera de manera inmediata el objeto “Statement” de base de datos y los recursos JDBC, en vez de esperar que se liberen de manera automática.

execute(String sql) Ejecuta el enunciado SQL especificado, el cuál puede regresar múltiples resultados. Es método sobrecargado, y en algunas implementaciones puede indicarle al driver que cualquier clave auto generada debe estar disponible para recuperación.

executeQuery(String sql) Ejecuta el enunciado SQL indicado y regresa un objeto simple tipo “ResulSet”.ExecuteUpdate(String sql) Ejecuta el enunciado SQL indicado, el cuál puede ser un enunciado “INSERT”,

“UPDATE”, o “DELETE” o un enunciado SQL que no regresa resultados. Es sobrecargado.

getResultSet() Recupera el resultado actual como un objeto “ResultSet”. Tabla 13. Algunos métodos de la interfase "Statement".

Para obtener una descripción detallada de los atributos y métodos de la interfase “Statement” consultar la página: http://java.sun.com/javase/6/docs/api/java/sql/Statement.html.

163

3.3.2.4 Interface java.sql.resultset.

Es una tabla de datos que representa un conjunto de resultados de la base de datos., el cuál es generado normalmente por la ejecución de un enunciado que consulta la base de datos.

Un objeto “ResultSet” mantiene un cursor (o indicador) que apunta a su hilera actual de datos. En un inicio el cursor está posicionado antes de la primer hilera. El método “next” mueve el cursor a la siguiente hilera, este método regresa “false” cuando no hay más hileras en el objeto “ResultSet”, por lo anterior se puede usar un ciclo “while” para iterar a través del conjunto de resultados.

Por omisión el objeto “ResultSet” no es actualizable y tiene un cursor que solo se desplaza hacia delante. De esta manera, se puede iterar en el conjunto solo una vez y solo de la primer a la última hilera. Pero es posible producir objetos “ResultSet” que sean navegables (hacia delante y atrás) y actualizables.

La interfase “ResultSet” contiene métodos tipo “get” (como “getBoolean”, “getLong”, etc., estos son métodos que leen valores) que permiten recuperar valores de columna de la hilera actual. Los valores se pueden recuperar por medio de un índice numérico de la columna o por el nombre de la columna. En general, el uso del índice de columna será más eficiente. Las columnas están numeradas a partir del 1. Para máxima portabilidad, el conjunto de columnas dentro de cada hilera debe ser leído en orden de izquierda a derecha, y cada columna debe ser leída solo una vez.

Para los métodos tipo “get”, el driver JDBC intenta convertir el dato subyacente a un tipo de datos de Java que se ha especificado en el método tipo “get” y regresa un valor adecuado para Java. La especificación JDBC tiene una tabla que muestra las correspondencias permitidas de tipos de datos SQL a tipos de datos de Java que pueden ser usadas.

Los nombres de columnas que se usan como entrada en los métodos tipo “get” no son sensibles a minúsculas y mayúsculas. Cuando un método tipo “get” es llamado con un nombre de columna y algunas columnas tienen el mismo nombre, se regresa el valor de la primer columna que corresponda con el nombre. La opción de nombre de columna esta diseñada para ser usada cuando los nombres de columna son usados en consultas SQL que generan el conjunto de resultados. Para las columnas que no son nombradas de manera explícita en la consulta, es mejor usar números de columna.

En nuevas versiones de JDBC se han agregado métodos tipo “update”, que permiten la actualización de los datos contenidos en el objeto “ResultSet” y la actualización de la base de datos.

En la Tabla 14. Algunos métodos de la interfase "ResultSet", se describen de manera general los métodos más significativos de la interfase.

164

Para obtener una descripción detallada de los atributos y métodos de la interfase “ResultSet” consultar la página: http://java.sun.com/javase/6/docs/api/java/sql/ResultSet.html.

Nombre demétodo

Descripción

absolute(int row) Mueve el cursor al número de hilera indicado.close() Libera el objeto “ResultSet” y los recursos JDBC. deleteRow() Borra la hilera actual del objeto “ResultSet” y de la base de datos.first() Mueve el cursor a la primera hilera en este objeto “ResultSet”.getDate(int columnindex) Recupera el valor de la columna designada en la hilera actual de este objeto

“ResultSet” como un objeto “java.sql.Date” en el lenguaje Java. Es método sobrecargado.

getMetadata() Recupera el número, tipos y propiedades de las columnas de este objeto “ResultSet”.

getObject(int columnindex) Obtiene el valor de la columna designada en la hilera actual de este objeto “ResultSet” como un objeto en el lenguaje Java. Es método sobrecargado.

getRow() Recupera el número de hilera actual.insertRow() Inserta una hilera en este objeto “ResultSet” y en la base de datos.last() Mueve el curso a la última hilera del objeto “ResultSet”.next() Mueve al cursor a la siguiente hilera del objeto “ResultSet”..previous() Mueve el cursor a la hilera previa del objeto “ResultSet”.updateDate(int columnIndex, Date x)

Actualiza la columna designada con un valor java.sql.Date.

updateRow() Actualiza la base de datos con el nuevo contenido de la hilera actual de este objeto “ResultSet”.

Tabla 14. Algunos métodos de la interfase "ResultSet".

3.3.2.5 Jerarquía de clases javax.sql.*

El paquete javax.sql es una API para acceder y procesar fuentes de datos del lado del servidor desde el lenguaje de programación Java.

El paquete javax.sql es un suplemento del paquete java.sql.

165

Algunas características del paquete son:1. Tiene a la interfase “DataSource” como una alternativa al “DriverManager”

de java.sql para establecer una conexión con una fuente de datos.2. “Connection pooling”. Permite administrar un grupo de conexiones. También

incluye el “Statement pool”. En computación el término “connection pool” (agrupamiento de conexiones) se refiere a la administración de una colección de conexiones abiertas a una base de datos, para que las conexiones puedan ser reutilizadas y poder hacer múltiples conexiones o actualizaciones.

3. Soporta transacciones distribuidas.4. Maneja conjuntos de hileras (“Rowsets”).

Las aplicaciones usan de manera directa las API “DataSource” y “RowSet”, pero las API del “pool de conexiones” y transacciones distribuidas se usan internamente por una capa intermedia de la infraestructura.

La jerarquía de clases del paquete “javax.sql” se muestra en la Figura 145. Jerarquía de clases del paquete "javax.sql".

Figura 145. Jerarquía de clases del paquete "javax.sql".

Se muestra un resumen de las clases del paquete en la Tabla 15. Descripción declases del paquete "javax.sql".

Nombre dela clase

Descripción

ConnectionEvent Permite tener un objeto tipo “Event” que proporciona información sobre la fuente de un evento relacionado a la conexión.

RowSetEvent Permite tener un objeto tipo “Event” que se genera cuando ocurre un evento en un objeto “RowSet”.

StatementEvent Permite tener un objeto “StatementEvent” que es enviado a todos los objetos tipo “StatementEventListeners” que se encuentran registrados con un objeto “PooledConnection”.

Tabla 15. Descripción de clases del paquete "javax.sql".

La jerarquía de interfases del paquete “javax.sql” se muestra en la Figura 146.Jerarquía de interfases del paquete "javax.sql".

166

Figura 146. Jerarquía de interfases del paquete "javax.sql".

En la Tabla 16. Descripción de interfases del paquete "javax.sql", se hace una descripción general de las interfases más significativas del paquete.

Nombre dela interfase

Descripción

CommonDataSource Es una interfase que define cuales métodos están en común entre “DataSource”, “XADataSource” y “ConnectionPoolDataSource”.

ConnectionPoolDataSource Es la fábrica para objetos “PooledConnection”. DataSource Es la fábrica para conexiones a la fuente de datos física que este objeto

“DataSource” representa.RowSet Es la interfase que incluye el soporte de la API JDBC para el modelo de

componentes de JavaBeans.XAConnection Permite tener objetos que proporcionan soporte para transacciones

distribuidas.Tabla 16. Descripción de interfases del paquete "javax.sql".

La especificación completa de clases e interfases del paquete “javax.sql”, incluyendo sus atributos y métodos, se puede consultar en el sitio Web de la empresa Sun Microsystems, en particular en la dirección http://java.sun.com/javase/6/docs/api/javax/sql/package-summary.html.

Una vez cubierta la parte teórica de JDBC, en el tema que sigue se explicará la instalación y configuración del driver JDBC en un caso práctico.

167

3.3.3 Instalación y configuración del driver acorde al gestor de base de datos.

Como se ha comentado antes, para conectarse a un DBMS mediante una aplicación con el lenguaje Java se requiere del conector JDBC.

En el mercado existen muchos ambientes de desarrollo integrado (IDE) para desarrollo en Java. Una buena noticia es que existen buenos IDE de fuente abierta y gratuitos.

Algunos de los IDE (entre comerciales, de fuente abierta y gratuitos) para Java son:o NetBeans (www.netbeans.org).o Eclipse (www.eclipse.org).o JCreator (www.jcreator.com).o IntelliJ IDEA (www.jetbrains.com/idea).o JBuilder (http://www.codegear.com/products/jbuilder).

En este caso se utilizará el IDE NetBeans, que se puede descargar de manera gratuita del sitio www.netbeans.org. En el momento de escribir este tema, la versión de NetBeans que se ofrece en la página de inicio del sitio Web, es la versión 6.1. Una de las características importantes de este software, es que ya incluye un conector JDBC para conectarse al DBMS de MySQL. Por lo cual se puede usar el conector JDBC integrado en el NetBeans o bien descargar el conector JDBC que se encuentra en la página de descarga de conectores del sitio Web de MySQL.

Haciendo una prueba con el conector JDBC integrado de NetBeans, no se tuvo ningún problema para hacer la conexión hacia MySQL. NetBeans en su ambiente de trabajo incluye la ficha “Services” que permite entre otras actividades, administrar conexiones de bases de datos. La ficha “Services” esta al mismo nivel que las fichas “Projects” y “Files”.

Para este ejemplo, se utilizará NetBeans como ambiente de desarrollo integrado para Java y como DBMS el MySQL. Se explicará la descarga y configuración del conector JDBC para el software mencionado.

Si una aplicación Java requiere conectarse al DBMS MySQL, se puede descargar del sitio de MySQL el conector JDBC, llamado por MySQL como el conector “Connector/J”. Ver Figura 147. Página de descarga del conector JDBC en el sitio Web de MySQL.

Al ingresar a la página de descarga del conector, se muestran las diferentes versiones de este, lo recomendable es descargar la versión más reciente. En este momento la versión más reciente es la 5.1. Desde esta página se puede realizar la descarga o bien seleccionar un servidor específico para la descarga. Ver Figura 148. Versiones del conector JDBC yenlace para descarga.

168

http://www.netbeans.org/

http://www.codegear.com/products/jbuilder

http://www.jetbrains.com/idea

http://www.jcreator.com/

Figura 147. Página de descarga del conector JDBC en el sitio Web de MySQL.

Figura 148. Versiones del conector JDBC y enlace para descarga.

169

Lo que sigue es guardar el archivo de descarga en la computadora local, descomprimir el archivo según su formato de compresión, ubicar el archivo en la carpeta donde será utilizado e incluir la ruta del archivo en la variable “classpath” de Java.

Es importante mencionar que el archivo “.jar” del controlador no es un archivo ejecutable de Java, sino que funciona más bien como una librería para las clases, interfases, etc., que incluye el JDBC de Java. Por ejemplo, si el controlador se va a usar para una aplicación Web, el archivo “.jar” se debe ubicar en un directorio del servidor Web, de manera que el servidor pueda establecer la conexión a la fuente de datos.

El autor, trató de ejecutar el archivo “.jar” del controlador, pero indica un error al no ser archivo ejecutable y se comprobó en el tema que sigue el uso del conector para una aplicación Web usando Java.

3.3.4 Prototipo de aplicaciones con conectividad a bases de datos.

Para el ejemplo práctico se usará el ambiente integrado de desarrollo Netbeans IDE 6.1 que es una marca registrada de la empresa “Netbeans.org”. Netbeans permite el desarrollo de aplicaciones mediante el lenguaje de programación Java. Este es un software gratuito. Como DBMS se usará el MySQL Server 5.0.

NetBeans 6.1, incluye el JDBC para conectarse con MySQL, por lo que usando este IDE no es necesario instalar aparte el controlador JDBC. Para facilitar la administración de las bases de datos NetBeans tiene la ficha “Services”, ubicada junto a la ficha de proyectos “Projects”, archivos “Files” y favoritos “Favorites”, fichas ubicada en la parte superior izquierda del IDE, como se muestra en la Figura 149. Ficha "Services" en NetBeans.. Observar en dicha figura las dos opciones disponibles para conectarse con MySQL, y al hacer un clic con el botón derecho del ratón se abre el menú contextual que permite la configuración de la conexión JDBC.

Para este ejemplo se mostrará la forma para conectarse a la BD “innovación” que esta en servidor de MySQL. Recordar las tablas que forman la base de datos, y que se muestran en la Figura 150. La base de datos "innovacion" en MySQL..

Para recordar el diseño de la base de datos “innovación” y las relaciones de las tablas ver la Figura 39. Diagrama de base de datos del ejemplo práctico..

Para configurar la conexión se abre el menú contextual de la conexión “jdbc:mysql://localhost…” (ver Figura 149. Ficha "Services" en NetBeans.), y se selecciona la opción de propiedades “Properties”, en esta pantalla proporcionar los datos adecuados para la conexión, tal como la ubicación URL del servidor de base de datos, el nombre del esquema (base de datos) a usar, etc., para este caso solo se cambio el nombre del esquema a usar. No se cambio la dirección URL del servidor de la base de datos, porque el servidor y el IDE están en la misma computadora (ver Figura 151. Propiedades de la conexión JDBC.).

170

Figura 149. Ficha "Services" en NetBeans.

Figura 150. La base de datos "innovacion" en MySQL.

171

Figura 151. Propiedades de la conexión JDBC.

Después de proporcionar los datos para la conexión y aceptar los cambios, en el mismo menú contextual para la conexión se debe establecer la conexión física, para esto hacer clic en la opción “Connect”, como se muestra en la figura Figura 152. Opción "Connect"para JDBC.. Esta opción solicitará el nombre y contraseña del usuario de MySQL que debe tener los permisos adecuados en la base de datos correspondiente.

172

Figura 152. Opción "Connect" para JDBC.

Si la conexión tiene éxito, se abre la base de datos y en la ficha “Services” cambia el icono que indica cuando la conexión esta abierta o cerrada. Ver Figura 153. Vista deconexión JDBC exitosa..

Figura 153. Vista de conexión JDBC exitosa.

173

Una vez realizada la conexión se pueden escribir y ejecutar sentencias SQL para interactuar con la base de datos. Para esto se abre el menú contextual de la conexión, se selecciona la opción “Execute Command”, este abre una ventana que permite escribir sentencias SQL, ejecutarlas y visualizar el resultado de la sentencia (ver Figura 154.Ejecutar sentencia SQL en NetBeans).

Figura 154. Ejecutar sentencia SQL en NetBeans.

Es recomendable, probar mediante la ficha “Services” las sentencias SQL que se usarán en la aplicación. De esta manera se puede asegurar que la sintaxis y la semántica de las sentencias es la correcta y evitará un mayor esfuerzo al depurar errores de la aplicación.

Desarrollo del caso prototipo.Para el prototipo del caso práctico se desarrollará una aplicación Web. Se usará el

siguiente software:o IDE Netbeans 6.1.o JDK (“Java Development Kit).o El DBMS MySQL.o Conector de base de datos para aplicaciones en Java (“MySQL Connector/J”). Es

un controlador JDBC y se incluye en el IDE de Netbeans.o “GlassFish V2”. Este es un software que funciona como servidor de Web y esta

incluido (si el usuario lo decide) en el IDE de NetBeans 6.1.

La base de datos a usar es la de “innovación” (ubicada en el DBMS MySQL), que contiene información de los proyectos que el área de Tecnologías de la Información desarrolla para toda la empresa, dicha base de datos cuenta con tres tablas:

174

o Proyectos. Con la información general de los proyectos.o Responsables. Con la información general de los responsables de los proyectos.o Proyectos_avances. Con la información semanal de cada avance de proyecto.

Ver la Figura 39. Diagrama de base de datos del ejemplo práctico., para recordar el diseño de cada tabla y las relaciones entre ellas. Para el prototipo se usarán las tablas “proyectos” y “responsables”. La tabla de “proyectos” incluye como clave foránea la clave del responsable de ese proyecto, y es como ambas tablas están relacionadas. Cada proyecto tiene un solo responsable, y una persona responsable puede tener a su cargo varios proyectos.

La aplicación Web consistirá en dos páginas JSP que mostrarán información de los proyectos y de las personas responsables de cada uno de ellos. En la primer página (proyectos.jsp) se mostrará al usuario una lista con el nombre de los proyectos, donde el usuario podrá seleccionar uno de ellos. En la segunda página (proyectoDetalle.jsp) se mostrará la información de detalle del proyecto seleccionado por el usuario e información del responsable de ese proyecto. Toda la información de los proyectos se obtiene de la base de datos mediante una conexión JDBC. La primer página envía como parámetro a la segunda página el valor de la clave primaria del proyecto seleccionado. La segunda página lee el valor del parámetro y mediante este construye una consulta SQL que extrae de la base de datos la información del proyecto particular y lo muestra en la misma página. El diagrama de la Figura 155. Arquitectura del prototipo que usa JDBC., muestra lo explicado en este párrafo.

Figura 155. Arquitectura del prototipo que usa JDBC.

Recuerde el lector el funcionamiento de una página JSP que incluye código del lado del servidor. Cuando un usuario en su navegador Web solicita una página con extensión “.jsp”, el servidor Web ejecuta primero dicha página en el servidor y después el resultado de la ejecución es enviada al cliente (en su navegador) en un formato HTML. Posteriores

175

operaciones en una página “.jsp” pueden realizar mas peticiones de procesamiento al servidor.

La primer página tendrá una apariencia similar a la mostrada en la Figura 156. Primerpágina del prototipo que usa JDBC..

Figura 156. Primer página del prototipo que usa JDBC.

Cuando el usuario seleccione un nombre de proyecto y haga un clic en el botón de “submit”, se abre la página que muestra la información de detalle de ese proyecto y del responsable del mismo, como se muestra en la Figura 157. Segunda página que usa JDBC..

Los pasos generales para el desarrollo del prototipo serán los siguientes:1. Creación del proyecto.2. Preparación de la interfase.3. Construir un conjunto de conexiones (“Connection Pool”).

3.1.Construir una fuente de datos (“Datasource”) JNDI.3.2.Hacer referencia a la fuente de datos desde la aplicación.3.3.Agregar el archivo JAR del controlador de la base de datos al servidor de Web.

4. Agregar código para contenido dinámico a las páginas.4.1.Agregar la librería JSTL a la variable “CLASSPATH” del proyecto.4.2.Agregar directivas “taglib” a las páginas JSP.4.3.Agregar código JSP y JSTL.

5. Implantar y ejecutar el proyecto.

176

Figura 157. Segunda página que usa JDBC.

1. Creación del proyecto. Iniciar el IDE Netbeans y seleccionar “File | New Project” del menú principal. En

“Categories” seleccionar “Web”; en “Projects” seleccionar “Web Application”. Hacer clic en el botón de siguiente “Next”.

En el dialogo para asignar nombre y localización del proyecto, en el campo para nombre de proyecto (“Project Name”), escribir “AplicacionWeb_JSP_JDBC” (puede ser cualquier nombre válido para el proyecto). Dejar los valores de los demás campos con los datos por omisión y presionar el botón de siguiente “Next”.

Aparece el dialogo de “Server and Settings” (Servidor y configuraciones). En la lista para seleccionar valor para el campo “Server” (servidor de Web) seleccionar “GlassFish V2”. Los demás campos dejarlos con los valores por omisión y hacer clic en el botón de terminar “Finish”.

Realizado lo anterior se crea un formato de proyecto Web y se abre una página vacía JSP (index.jsp).

2. Preparación de la interfase.Se realizará una interfase simple para las dos páginas del proyecto. Las páginas “proyectos.jsp” y “proyectoDetalle.jsp” tendrán una tabla HTML para mostrar los datos. La página “proyectos.jsp” tendrá una forma HTML que incluye una lista “drop-drown”.

Crear la página “proyectos.jsp”.

En la ficha “Projects” seleccionar el proyecto Web recién creado, hacer clic con el botón derecho del ratón y en el menú contextual seleccionar las opciones: “New | JSP”. En el campo para el nombre del archivo (“JSP File Name”) escribir “proyectos”.

177

En el editor del código fuente, cambiar el texto que está entre las etiquetas <title> a “Página de nombres de proyectos”.

Escribir el texto para la página. Puede ser como el texto mostrado en la Figura 156.Primer página del prototipo que usa JDBC., o un texto más corto como “Listado de proyectos”.

Abrir la paleta de componentes del IDE (Palette), seleccionando del menú principal “Window | Palette”. En la ficha HTML localizar el componente tabla “Table”. Hacer clic en el icono “Table” y arrastrar y soltar la tabla dentro de la página, abajo del texto que se agregó para la tabla (y antes de la etiqueta </body>). Se abre el dialogo de propiedades de la tabla, escoger un 1 para renglones (rows) y un 1 para columnas (columns), y hacer clic en “OK”.

Después del texto recién escrito y dentro de las etiquetas “<td></td>”, agregar una forma “Form” de la paleta “HTML Forms”, en la caja de texto para el valor de la propiedad “Action”, escribir “proyectoDetalle.jsp”, y hacer clic en el botón “OK”.

Dentro de las etiquetas “<form>” escribir el texto “Seleccionar un proyecto:”. Agregar un objeto “Drop-down List” de la paleta de componentes “HTML Forms” dentro de

las etiquetas “<form>”. Escribir “cve_proy” como valor para la propiedad “Name” y hacer clic en el botón de “OK”. Más adelante se agregará código para generar de manera dinámica el contenido para este objeto.

Agregar un botón de “Submit” dentro de la forma y después del objeto tipo “Drop-down List”. Escribir “submit” en los campos de texto para los valores “Label” y “Name”, y hacer clic en el botón de “OK”.

Para ejecutar la página y verla en el navegador de Internet, hacer clic derecho en el editor de código fuente (“Source Editor”) y escoger la opción “Run proyectos.jsp (Shift-F6)”. Con esto la página se compila y es implantada en el servidor Web. El IDE de Netbeans abrirá el navegador Web para desplegar la página desde su localización de implantación, como se ve en la Figura 158. Avance de la página "proyectos.jsp"..

Figura 158. Avance de la página "proyectos.jsp".

178

Crear la página “proyectoDetalle.jsp”. Hacer clic con el botón derecho del ratón en el nodo del proyecto

“AplicaciónWeb_JSP_JDBC” en la ventana de Proyectos “Projects” y seleccionar “New | JSP”. Se abre el diálogo de “New JSP File”.

Para el campo nombre “Name” del archivo escribir “proyectoDetalle”. Aceptar todos los demás valores por omisión para la página y hacer clic en el botón para terminar “Finish”.

En el editor de código fuente “Source Editor”, cambiar su título a: Proyecto: -{placeholder} y datos del responsable

Cambiar el texto entre las etiquetas <h2> con lo siguiente: Información del proyecto y su responsable.

Copiar la siguiente tabla HTML debajo de las etiquetas <h2> y antes de cerrar el cuerpo de la página (etiqueta </body>).

<table border="1"> <thead> <tr> <th colspan="2">Proyecto: {placeholder}</th> </tr> </thead> <tbody> <tr> <td><strong>Descripción </strong></td> <td bgcolor="gray">{placeholder}</td> </tr> <tr> <td><strong>Para el departamento </strong></td> <td bgcolor="gray">{placeholder}</td> </tr> <tr> <td><strong>Estado del proyecto</strong></td> <td bgcolor="gray">{placeholder}</td> </tr> <tr> <td><strong>Porcentaje de avance</strong></td> <td bgcolor="gray">{placeholder}</td> </tr> <tr> <td><strong>Fecha de inicio</strong></td> <td bgcolor="gray">{placeholder}</td> </tr> <tr> <td><strong>Fecha de terminación</strong></td> <td bgcolor="gray">{placeholder}</td> </tr> <tr> <td><strong>Nombre del responsable</strong></td> <td bgcolor="gray">{placeholder}</td> </tr> <tr> <td><strong>Puesto del responsable</strong></td> <td bgcolor="gray">{placeholder}</td> </tr> </tbody></table>

179

Para ver la página en el navegador Web, hacer clic derecho con el ratón en el editor de código fuente (“Source Editor”) y seleccionar “Run proyectoDetalle.jsp Shift + F6”. La página tendrá una apariencia similar a la mostrada en la Figura 159. Avance de la páginaproyectoDetalle.jsp..

Figura 159. Avance de la página proyectoDetalle.jsp.

Dentro de las etiquetas “{placeholder}” se escribirá más adelante código del lado del servidor para mostrar valores extraídos de la base de datos.

3. Construir un conjunto de conexiones (“Connection Pool”).Un “connection pool” o conjunto de conexiones es una manera eficiente para

implementar la comunicación entre el servidor de Web y la base de datos. El crear una nueva conexión para cada requerimiento de un cliente puede consumir mucho tiempo, en especial para aplicaciones que de manera continua reciben un gran número de requerimientos. Para remediar esta situación, se crean numerosas conexiones y se mantienen en un “connection pool”. Así, cualquier requerimiento que llega y que requiere acceso a los datos de la aplicación, usa una conexión ya creada y preparada que se encuentra en el “pool”. Asimismo, cuando un requerimiento se termina, no se elimina esa conexión, sino que es regresada al “pool”.

3.1. Construir una fuente de datos (“Datasource”) JNDI.El servidor Web “GlassFish V2” contiene librerias de “Database Conection Pooling (DBCP)” que proporcionan la funcionalidad de un “connection pool” en una forma que es transparente

180

a los desarrolladores. Para esto se requiere configurar una fuente de datos JNDI para el servidor, esto crea una interfase que la aplicación puede usar para el “connection pool”.

GlassFish.El IDE de NetBeans 6.1 proporciona un soporte mejorado para “GlassFish”, permitiendo que se puedan especificar recursos mediante un asistente (“wizard” en inglés). El procedimiento es el siguiente:

En la ventana de proyectos “Proyects”, hacer clic derecho en el nodo de recursos del servidor (“Server Resources”) y escoger “New | Other”. Como se ve en la Figura 160. Crearnuevo recurso de servidor en Netbeans.. Esto abre el asistente de “New File”. Bajo categorías “Categories”, seleccionar “GlassFish”. Bajo tipos de archivo “File Types”, seleccionar “JDBC Resource”. Hacer clic en el botón “Next”. Como se muestra en la Figura 161. Crear un recurso JDBC para GlassFish.

Figura 160. Crear nuevo recurso de servidor en Netbeans.

181

Figura 161. Crear un recurso JDBC para GlassFish.

En la pantalla que se muestra al hacer clic en el botón “Next”, realizar: Bajo atributos generales “General Attributes”, seleccionar la opción “Create New JDBC

Connection Pool”, entonces en el campo de texto para la propiedad “JNDI Name” escribir “jdbc/tallerBD”. Hacer clic en el botón “Next”.

Hacer clic otra vez en “Next” para saltar la ventana “Additional Properties”, entonces en el paso 4, escribir “tallerBDconnectionPool” para el campo “JDBC Connection Pool Name”. Asegurar que la opción “Extract from Existing Connection” está seleccionada y escoger jdbc:MySQL://localhost:3306/innovación de la lista “drop-down”. Hacer clic en “Next”.

En la pantalla de “Add Connection Pool Properties”, escribir el “password” del usuario que tiene los permisos para acceder a la base de datos de MySQL. Dejar los demás campos con los valores por omisión y hacer clic en “Finish” para terminar el asistente.

Al completar el asistente, se declaró una nueva fuente de datos y pool de conexiones para la aplicación. En la ventana de “Projects”, abrir el archivo recién creado en “Server Resources | sun-resources.xml” y observar que las etiquetas <resources> se han agregado para incluir los datos que se han especificado con el asistente.

Para confirmar que una nueva fuente de datos y pool de conexiones están registrados en GlassFish, se debe implantar el proyecto en el servidor, y entonces localizar los recursos en la ventana “Services” del IDE. Los pasos serán:

En la ventana de “Projects”, hacer clic derecho en el nodo del proyecto “AplicaciónWeb_JSP_JDBC” y seleccionar la opción “Undeploy and Deploy”.

182

Abrir la ventana “Services” y expandir los nodos “Servers | GlassFish | Resources | JDBC | JDBC Resources y Connection Pools”. Se debe desplegar la nueva fuente de datos y el pool de conexiones, como se muestra en la Figura 162. JDBC y pool de conexionesagregados a GlassFish..

Figura 162. JDBC y pool de conexiones agregados a GlassFish.

3.2. Hacer referencia a la fuente de datos desde la aplicación.Es necesario hacer una referencia al recurso JNDI recién configurado desde la

aplicación Web. Para esto se puede crear una entrada en el archivo descriptor de implantación de la aplicación (web.xml).

Los descriptores de implantación son archivos de texto basados en XML y contienen información que describen la manera en que una aplicación fue implantada en un ambiente específico. Por ejemplo, se usan normalmente para especificar parámetros de contexto de la aplicación y patrones de comportamiento, configuraciones de seguridad, así como mapeo para “servlets” y filtros, entre otros.

Los pasos para hacer la referencia al recurso JNDI en el descriptor de implantación de la aplicación son:

En la ventana de “Projects”, expandir la carpeta “Web Pages | WEB-INF” y hacer doble clic en el archivo “web.xml”. Se abre un editor gráfico para el archivo, que se despliega en el espacio del editor de código fuente (“Source editor”).

183

Hacer clic en la ficha “References” localizada en la parte superior del “Source Editor”. Expandir el encabezado “Resource References”, hacer clic en el botón “Add”. Esto abre el diálogo ·”Add Resource Reference”.

Para el campo “Resource Name” escribir el nombre del recurso que se usó antes, cuando se configuró la fuente de datos JNDI para el servidor (jdbc/tallerBD). Para el campo “Description”, escribir la URL del recurso (jdbc:mysql://localhost:3306/innovación). Observar que el valor por omisión para el tipo de recurso (“Resource type”) es javax.sql.DataSource. Dejar los demás campos con los valores proporcionados por omisión y hacer clic en el botón de “OK”. El nuevo recurso es agregado bajo el encabezado de “Resource References”, como se muestra en la Figura 163. Referencia aun recurso JNDI desde la aplicación..

Figura 163. Referencia a un recurso JNDI desde la aplicación.

Para verificar que el recurso se agregó al archivo web.xml, hacer clic en la ficha “XML” localizada en la parte superior y a la derecha del “Source Editor” Observar las nuevas etiquetas “<resource-ref>” y su contenido que corresponden al recurso recién agregado. Ver Figura 164. Contenido del archivo web.xml después de agregar un recurso JNDI..

3.3. Agregar el archivo JAR del controlador de la base de datos al servidor de Web.Agregar el controlador JAR para la base de datos es otro paso fundamental para

permitir que el servidor Web se puede comunicar con el DBMS. De manera ordinaria se requeriría localizar el archivo mysql-connector-java-5.x-bin.jar y copiar este dentro de la carpeta de librerías del servidor Web en uso. Afortunadamente el IDE Netbeans es capaz de detectar en la implantación si el archivo JAR se ha incluido en el servidor, y si no es así, lo realiza de manera automática.

184

Figura 164. Contenido del archivo web.xml después de agregar un recurso JNDI.

Para demostrar lo anterior, implantar la aplicación al servidor Web en uso (en la ventana “Projects”, seleccionar la opción “Undeploy and deploy”, haciendo un clic derecho en el nodo del proyecto) y, para el caso del servidor Web GlassFish hacer lo siguiente:

Localizar el directorio de instalación de GlassFish y navegar a la carpeta “domains | domain1 | lib”. Observar que ahí se encuentra el archivo MySQL-connector-java-5.x-bin.jar. Cuando se hace una conexión a GlassFish en el IDE Netbeans, se realiza una conexión a una instancia del servidor de aplicación. Cada instancia se ejecuta aplicaciones en un dominio único, así el archivo JAR es localizado en “domain1”, el cuál es el dominio por omisión creado en la instalación de GlassFish.

4. Agregar código para contenido dinámico a las páginas.Recordar las dos páginas del proyecto. La primera de ellas (proyectos.jsp) debe

obtener de la base de datos los nombres de los proyectos y mostrarlos en el navegador del cliente. En la segunda página (proyectoDetalle.jsp ) se uso de manera temporal la palabra “placeholder” para colocar más adelante el código que obtendrá de la base de datos, información particular de cierto proyecto. En la segunda página el contenido dinámico depende de la selección hecha por el usuario en la primer página.

Para lograr lo anterior se debe agregar código JSP y JSTL para que las páginas puedan generar ese contenido dinámico. Esto se realiza mediante los tres siguientes pasos.

4.1. Agregar la librería JSTL a la variable “CLASSPATH” del proyecto.Para hacer un mejor uso de los recursos JSP que se tienen, se puede usar JSTL para acceder y desplegar datos extraídos de la capa lógica. Esta librería ya esta incluida en el IDE Netbeans. Lo que es necesario es asegurar que la librería JSTL es agregada al “classpath” de compilación del proyecto Web, y después agregar las directivas “taglib”

185

necesarias a cada página JSP. Esto permite al servidor Web identificar las etiquetas cuando las lee en las páginas JSP.

Para el caso de GlassFish, este ya incluye la librería JSTL en su propia librería. De esta manera no es necesario que el programador realice alguna acción. Para verificar esto, en la ficha “Projects” ver el nodo “Libraries | GlassFish” Ahí el archivo appserv-jstl.jar define todas las etiquetas estándar de la librería JSTL. Ver Figura 165. Librería JSTL en GlassFish..

Figura 165. Librería JSTL en GlassFish.

4.2. Agregar directivas “taglib” a las páginas JSP.En este paso se agregarán las directivas “taglib” necesarias a las páginas JSP:

Abrir ambas páginas JSP en el “Source Editor”. Agregar las siguientes directivas como las primeras líneas de código de ambas páginas:

<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%><%@taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>

4.3. Agregar código JSP y JSTL.Para terminar, es necesario agregar el código a cada página. Ambas páginas implementan una consulta SQL que usa las etiquetas <sql:query> y la fuente de datos (datasource) creada al inicio del desarrollo del prototipo.

186

Página proyectos.jspPara desplegar de manera dinámica el contenido de la forma HTML en la página proyectos.jsp, se requiere acceder a todos los nombres de proyectos de la tabla “proyectos” de la base de datos “innovación”.

Agregar la siguiente consulta SQL debajo de las directivas “taglib” incluidas en el paso anterior:

<sql:query var="proyecto" dataSource="jdbc/tallerBD"> SELECT cve_proy, nom_proy FROM proyectos</sql:query>

Las etiquetas <sql:query> permiten el uso de una consulta en el lenguaje SQL de manera directa en una página JSP. Se genera un conjunto de resultados (“resultset”) de la consulta, y los datos obtenidos se pueden insertar dentro de la página usando una etiqueta de iterador (<c:forEach>) de la librería JSTL.

Reemplazar las etiquetas vacías <option> en la forma HTML, con el iterador. De manera que el código completo para la etiqueta <select> quedaría de la siguiente forma:

<select name="cve_proy"> <c:forEach var="proyectos" items="${proyecto.rows}"> <option value="${proyectos.cve_proy}">${proyectos.nom_proy}</option> </c:forEach></select>

La etiqueta “forEach” itera a través de todos los valores de “cve_proy” (clave de proyecto) y “nom_proy” (nombre de proyecto) del conjunto de resultados generado, e inserta cada par en las etiquetas <option> de HTML. De esta manera, la lista “drop-down” de la forma es llenada con datos.

Guardar los cambios (Ctrl + S), hacer clic derecho en el “Source Editor” y seleccionar “Run File (Shift-F6). El archivo se compila, se implanta en el servidor, y “proyectos.jsp” se muestra en el navegador Web. La lista “drop-down” ahora contiene los nombres de proyectos que fueron recuperados de la base de datos.

Página proyectoDetalle.jspPara la página proyectoDetalle.jsp, es necesario acceder a datos de dos tablas de la base

de datos (proyectos y responsables), que corresponde a la “cve_proy” (clave de proyecto) enviada por el usuario mediante la página “proyectos.jsp”. Esto se logra usando una consulta SQL y la fuente de datos (“datasource”) creada ai inicio del desarrollo del prototipo.

Agregar la siguiente consulta SQL debajo de las directivas “taglib” incluidas en el paso previo con esta página:

<sql:query var="conjuntoPR" maxRows="1" dataSource="jdbc/tallerBD"> SELECT p.nom_proy, p.desc_proy, p.depto_proy, p.estado, p.avance_proy, p.fecha_ini, p.fecha_fin, r.nom_res, r.puesto FROM proyectos as p, responsables as r

187

WHERE p.cve_res = r.cve_res AND p.cve_proy = ? <sql:param value="${param.cve_proy}"/></sql:query>

La consulta anterior genera un conjunto de resultados (“resultset”) nombrado “conjuntoPR”, el cuál contiene todos los datos asociados con la “cve_proy” (clave de proyecto) enviada por el usuario mediante la página “proyectos.jsp”.

Agregar la siguiente declaración debajo de la consulta SQL del paso anterior:<c:set var="conjunto" scope="request" value="${conjuntoPR.rows[0]}"/>

La etiqueta <c:set> permite asignar el conjunto de resultados a una variable de ámbito, de manera que se pueda recuperar su contenido posteriormente.

En el documento HTML reemplazar todas las ocurrencias de la palabra “placeholder” con código JSP que recuperará y desplegará los datos retenidos del conjunto de resultados mediante la variable “conjunto”. De manera que el código HTML quedará de la siguiente manera:

<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Proyecto: ${conjunto.nom_proy} y datos del responsable</title> </head> <body> <h2>Información del proyecto y su responsable</h2> <table border="1"> <thead> <tr> <th colspan="2">Proyecto: ${conjunto.nom_proy}</th> </tr> </thead> <tbody> <tr> <td><strong>Descripción </strong></td> <td bgcolor="gray">${conjunto.desc_proy}</td> </tr> <tr> <td><strong>Para el departamento </strong></td> <td bgcolor="gray">${conjunto.depto_proy} </td> </tr> <tr> <td><strong>Estado del proyecto</strong></td> <td bgcolor="gray"> ${conjunto.estado} </td> </tr> <tr> <td><strong>Porcentaje de avance</strong></td> <td bgcolor="gray"> ${conjunto.avance_proy}

188

</td> </tr> <tr> <td><strong>Fecha de inicio</strong></td> <td bgcolor="gray"> ${conjunto.fecha_ini} </td> </tr> <tr> <td><strong>Fecha de terminación</strong></td> <td bgcolor="gray"> ${conjunto.fecha_fin} </td> </tr> <tr> <td><strong>Nombre del responsable</strong></td> <td bgcolor="gray"> ${conjunto.nom_res} </td> </tr> <tr> <td><strong>Puesto del responsable</strong></td> <td bgcolor="gray"> ${conjunto.puesto} </td> </tr> </tbody></table> </body></html>

5. Implantar y ejecutar el proyecto.Si se instaló el servidor GlassFish por medio de la descarga del IDE Netbeans, el

servidor ya está registrado en el IDE. Si es necesario realizar algún cambio a configuraciones del servidor o se desea registrar un diferente servidor Web en el IDE, entonces escoger del menú principal las opciones “Tools | Servers” para abrir el “Server Manager”.

Para implantar el proyecto en el servidor:Desde la ventana “Projects”, hacer clic derecho en el nodo del proyecto y seleccionar

“Undeploy and Deploy”. El IDE compila de manera automática el proyecto, inicia el servidor, e implanta el proyecto en el servidor. Se puede ver la salida generada en la ventana “Output”. Si todo va bien se debe mostrar el mensaje “BUILD SUCCESSFUL” en esta ventana.

Para verificar que la aplicación a sido adecuadamente implantada en el servidor, abrir la ventana “Services” y expandir el nodo “Servers”. Aquí se muestran todos los servidores registrados en el IDE. Para GlassFish, expander “Applications | Web Applications” para ver la aplicación.

Para ejecutar la aplicación.

189

Seleccionar el archivo “proyectos.jsp”, hacer clic derecho y en el menú contextual seleccionar “Run File”.

Nota: por omisión la página de inicio de un proyecto Web se llama “index.jsp”, como no se usó la página por omisión, no se corre en este caso el proyecto con la opción “Run Project”.

Cuando la página “proyectos.jsp” se muestra en el navegador, seleccionar un nombre de proyecto de la lista “drop-down” y hacer clic en submit. Se envía al usuario a la página “proyectoDetalle.jsp”, mostrando los detalles que corresponden al proyecto seleccionado. Ver Figura 166. Ejecución de las páginas del proyecto Web..

Figura 166. Ejecución de las páginas del proyecto Web.

En este punto se tiene el prototipo completo y de manera similar se pueden agregar páginas para que el usuario realice otras consultas y realice edición de datos.

Como un resumen del tema de conectores. Se puede notar que la documentación sobre estos es muy amplia, yo recomiendo hacer una lectura rápida de las principales facilidades de cada uno de ellos en los sitios Web oficiales. Y posteriormente hacer lectura y análisis mas detallados de las clases, métodos y objetos que se van requiriendo para la aplicación particular.

190

Ser un especialista en todos los conectores es muy difícil, pero si es conveniente conocerlos, saber implementarlos y saber sus ventajas y limitaciones. Si es posible escoger solo uno de ellos, profundizar su estudio y obtener toda la ventaja posible de este.

Ejercicios de la Unidad 3.1. Implementar un prototipo de aplicación sencillo (que muestre contenido de la base de datos) usando cada conector.2. Investigar características generales de otros conectores no explicados en esta unidad.

191

BIBLIOGRAFÍA.

Burbano Proaño Diego Javier. Analisis comparativo de bases de datos de codigo abierto vs codigo cerrado (determinacion de indices de comparacion) Quito-Ecuador, 5 de mayo del 2006.

MySQL AB. Manual de referencia de MySQL 5.0. 2007. USA.

Pardon Guy, Composite Systems: Decentralized Nested Transactions. 2000. Disertación para obtener el grado de: “Doctor of Technical Sciences”. Trabajo enviado al: Swiss Federal Institute of Technology Zurich. 129 páginas.

Oracle Corporation. Oracle® Database Express Edition, 2 Day DBA 10g Release 2 (10.2) , B25107-01, February 2006

Oracle® Database Security Guide 10g Release 2 (10.2). Part Number B14266-03, Oracle Corporation, 2008.

Silberschatz A., Korth H. y Sudarshan S. Fundamentos de bases de datos. Tercera edición. Mc Graw Hill. 1998. España.

InternetSitio oficial de MySQL.http://dev.mysql.com/doc/refman/5.0/es/features.htmlConsultado: 4 de febrero de 2008

Sitio de OraclePágina de descarga del software: Oracle Database 10g Express Edition (Universal)http://www.oracle.com/technology/software/products/database/xe/htdocs/102xewinsoft.htmlConsultado: 6 de febrero del 2008

http://en.wikipedia.org/wiki/Falcon_%28storage_engine%29Falcon (storage engine)Consultado: 11 de febrero del 2008.Actualizada: 9 de febrero del 2008.

Wikipedia en Inglés.Artículo: View (database)http://en.wikipedia.org/wiki/View_%28database%29Consultada: 20 de febrero de 2008Actualizada: 31 de enero del 2008

Wikipedia en Inglés.Artículo: Nested transactionhttp://en.wikipedia.org/wiki/Nested_transactionConsultada: 7 de mayo del 2008Actualizada: 6 de enero del 2008

192

http://en.wikipedia.org/wiki/View_(database)

http://en.wikipedia.org/wiki/Falcon_(storage_engine)

http://www.oracle.com/technology/software/products/database/xe/htdocs/102xewinsoft.html

http://dev.mysql.com/doc/refman/5.0/es/features.html

Wikipedia en Inglés.Artículo: Database transactionhttp://en.wikipedia.org/wiki/Database_transactionConsultada: 15 de abril del 2008Actualizada: 11 de abril del 2008

Wikipedia en inglés.Artículo: ActiveXhttp://en.wikipedia.org/wiki/ActiveXConsultada: 11 de junio del 2008Actualizada: 6 de junio del 2008.

CINVESTAV, México.Capítulo 5. Manejo de transacciones distribuidas.http://www.cs.cinvestav.mx/SC/prof_personal/adiaz/Disdb/Cap_5.htmlArturo Díaz PérezConsultado: 3 de mayo del 2008.

Artículo: General Information About ODBC and Connector/ODBChttp://dev.mysql.com/doc/refman/4.1/en/myodbc-general-information.htmlConsultado: 12 de mayo del 2008.Actualizado:Autor: MySQL.com

Artículo: ODBC--Open Database Connectivity Overviewhttp://support.microsoft.com/kb/110093/en-us/Consultado: 12 de mayo del 2008.Actualizado: 29 de marzo del 2007Autor: Microsoft Corporation

Artículo: ODBC Programmer´s Referencehttp://msdn.microsoft.com/en-us/library/ms714177.aspxConsultado: 12 de mayo del 2008.Actualizado: 2008Autor: Microsoft Corporation

Artículo: ADO.NEThttp://msdn.microsoft.com/es-es/library/e80y5yhx(VS.80).aspxAutor: Microsoft CorporationConsultado: 17 de junio del 2008

Monografías.comArtículo: Información general de ADO.NET.http://www.monografias.com/trabajos14/informe-ado-net/informe-ado-net.shtmlConsultado: 17 de junio del 2008Actualizado:Autor: Miguel Tito

193

http://www.monografias.com/trabajos14/informe-ado-net/informe-ado-net.shtml

http://msdn.microsoft.com/es-es/library/e80y5yhx(VS.80).aspx

http://msdn.microsoft.com/en-us/library/ms714177.aspx

http://support.microsoft.com/kb/110093/en-us/

http://dev.mysql.com/doc/refman/4.1/en/myodbc-general-information.html

http://www.cs.cinvestav.mx/SC/prof_personal/adiaz/Disdb/Cap_5.html

http://en.wikipedia.org/wiki/ActiveX

http://en.wikipedia.org/wiki/Database_transaction

Artículo: SQL Server manual en línea. Tema: Objetos ADO.http://www.sqlmax.com/centro/moduloV_3.asp?MX=Consultado: 26 de junio del 2008Actualizado:Autor:

Articulo: Eventos de conexión (ADO.NET)http://msdn.microsoft.com/es-es/library/a0hee08w.aspxConsultado: 26 de junio del 2008Actualizado: 2008Autor: Microsoft MSDN

Articulo: JDBC Introductionhttp://java.sun.com/docs/books/tutorial/jdbc/overview/index.htmlConsultado: 14 de agosto del 2008Actualizado: 14 de febrero del 2008Autor: Sun Microsystems

Articulo: Package java.sqlhttp://java.sun.com/javase/6/docs/api/java/sql/package-summary.htmlConsultado: 19 de agosto del 2008Actualizado: 2006Autor: Sun Microsystems

Articulo: Interface Connectionhttp://java.sun.com/javase/6/docs/api/java/sql/Connection.htmlConsultado: 19 de agosto del 2008Actualizado: 2006Autor: Sun Microsystems

Articulo: Interface Statementhttp://java.sun.com/javase/6/docs/api/java/sql/Statement.htmlConsultado: 19 de agosto del 2008Actualizado: 2006Autor: Sun Microsystems

Articulo: Interface ResultSethttp://java.sun.com/javase/6/docs/api/java/sql/ResultSet.htmlConsultado: 20 de agosto del 2008Actualizado: 2006Autor: Sun Microsystems

Articulo: Package javax.sqlhttp://java.sun.com/javase/6/docs/api/javax/sql/package-summary.htmlConsultado: 22 de agosto del 2008Actualizado: 2006Autor: Sun Microsystems

Articulo: Creating a Simple Web Application Using a MySQL Database

194

http://java.sun.com/javase/6/docs/api/javax/sql/package-summary.html

http://java.sun.com/javase/6/docs/api/java/sql/ResultSet.html

http://java.sun.com/javase/6/docs/api/java/sql/Statement.html

http://java.sun.com/javase/6/docs/api/java/sql/Connection.html

http://java.sun.com/javase/6/docs/api/java/sql/package-summary.html

http://java.sun.com/docs/books/tutorial/jdbc/overview/index.html

http://msdn.microsoft.com/es-es/library/a0hee08w.aspx

http://www.sqlmax.com/centro/moduloV_3.asp?MX

http://www.netbeans.org/kb/60/web/mysql-webapp.htmlConsultado: 7 de octubre del 2008Actualizado: Autor: Netbeans.org

195

http://www.netbeans.org/kb/60/web/mysql-webapp.html

Taller Bd Alum No

Documents

Transcript of Taller Bd Alum No