Traducido del inglés al español - [Link].

com
 SQL

8va edición

por Allen G. Taylor

Autor deDesarrollo de bases de datos para principiantes,
SQL todo en uno para principiantes,y
Crystal Reports 2008 para tontos
SQL para principiantes®, 8ª edición
Publicado por:John Wiley & hijos, inc.,111 River Street, Hoboken, Nueva Jersey 07030-5774,[Link]
Copyright © 2013 por John Wiley & Sons, Inc., Hoboken, Nueva Jersey Publicado simultáneamente en Canadá

Ninguna parte de esta publicación puede reproducirse, almacenarse en un sistema de recuperación ni transmitirse
de ninguna forma ni por ningún medio, electrónico, mecánico, fotocopia, grabación, escaneo o de otro tipo, excepto
según lo permitido en las Secciones 107 o 108 de la Ley de Derechos de Autor de los Estados Unidos de 1976. Actuar,
sin el permiso previo por escrito del Editor. Las solicitudes de permiso al editor deben dirigirse al Departamento de
Permisos, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) 748-6011, fax (201) 748-6008 o en línea
en[Link]
Marcas registradas:Wiley, For Dummies, el logotipo de Dummies Man, [Link], Making Everything Easier y la imagen
comercial relacionada son marcas comerciales o marcas comerciales registradas de John Wiley & Sons, Inc. y no se puede
utilizar sin permiso por escrito. Todas las demás marcas comerciales son propiedad de sus respectivos dueños. John Wiley &
Sons, Inc. no está asociado con ningún producto o proveedor mencionado en este libro.

LÍMITE DE RESPONSABILIDAD/RENUNCIA DE GARANTÍA: EL EDITOR Y EL AUTOR NO HACEN DECLARACIONES

NI GARANTÍAS CON RESPECTO A LA EXACTITUD O INTEGRIDAD DEL CONTENIDO DE ESTE TRABAJO Y
ESPECÍFICAMENTE RECHAZAN TODAS LAS GARANTÍAS, INCLUYENDO, SIN LIMITACIÓN, LAS GARANTÍAS DE
IDONEIDAD PARA UN PROPÓSITO PARTICULAR. NO SE PUEDE CREAR NI AMPLIAR NINGUNA GARANTÍA
MEDIANTE VENTAS O MATERIALES PROMOCIONALES. LOS CONSEJOS Y LAS ESTRATEGIAS CONTENIDOS AQUÍ
PUEDEN NO SER ADECUADOS PARA CADA SITUACIÓN. ESTA OBRA SE VENDE EN EL ENTENDIMIENTO DE QUE EL
EDITOR NO SE DEDICA A PRESTAR SERVICIOS LEGALES, CONTABLES U OTROS SERVICIOS PROFESIONALES. SI SE
REQUIERE ASISTENCIA PROFESIONAL, SE DEBEN SOLICITAR LOS SERVICIOS DE UN PROFESIONAL COMPETENTE.
NI EL EDITOR NI EL AUTOR SERÁN RESPONSABLES POR LOS DAÑOS QUE SURJAN DEL PRESENTE. EL HECHO DE
QUE EN ESTE TRABAJO SE HAGA REFERENCIA A UNA ORGANIZACIÓN O SITIO WEB COMO UNA CITA Y/O FUENTE
POTENCIAL DE INFORMACIÓN ADICIONAL NO SIGNIFICA QUE EL AUTOR O EL EDITOR APRUEBA LA
INFORMACIÓN QUE LA ORGANIZACIÓN O EL SITIO WEB PUEDA PROPORCIONAR O LAS RECOMENDACIONES
QUE PUEDA HACER . ADEMÁS, LOS LECTORES DEBEN TENER EN CUENTA QUE LOS SITIOS WEB DE INTERNET
ENUMERADOS EN ESTE OBRA PUEDEN HABER CAMBIADO O DESAPARECIDOS ENTRE EL CUANDO SE ESCRIBIÓ
ESTE TRABAJO Y EL CUANDO SE LEÍÓ.

Para obtener información general sobre nuestros otros productos y servicios, comuníquese con nuestro Departamento de
Atención al Cliente dentro de los EE. UU. al 877-762-2974, fuera de los EE. UU. al 317-572-3993 o por fax al 317-572-4002. Para
soporte técnico, [Link]/techsupport.

Wiley publica en una variedad de formatos impresos y electrónicos y mediante impresión bajo demanda. Es posible que parte
del material incluido en las versiones impresas estándar de este libro no esté incluido en libros electrónicos o en impresión
bajo demanda. Si este libro hace referencia a medios como un CD o DVD que no están incluidos en la versión que compró,
puede descargar este material en[Link] obtener más información sobre los productos Wiley,
[Link].

Número de control de la Biblioteca del Congreso: 2013942771

ISBN 978-1-118-60796-1 (pbk); 978-1-118-65711-9 (ebk); ISBN 978-1-118-62783-9 (ebk); ISBN

978-1-118-65718-8 (ebk)
Fabricado en los Estados Unidos de América 10
987654321
 Contenido de un vistazo

Introducción ................................................. ............... 1

Parte I: Primeros pasos con SQL ................................ 3
Capítulo 1: Fundamentos de bases de datos relacionales ................................. ................. 5
Capítulo 2: Fundamentos de SQL ................................................ .......................................... 21
Capítulo 3: Los componentes de SQL ................................................ ................................... 51

Parte II: Uso de SQL para crear bases de datos.................... 79

Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple.................... 81
Capítulo 5: Creación de una base de datos relacional multitabla.................................... ..... 105

Parte III: Almacenamiento y recuperación de datos.................... 137

Capítulo 6: Manipulación de datos de bases de datos ................................. ........................ 139
Capítulo 7: Manejo de datos temporales ................................................ ................................ 157
Capítulo 8: Especificación de valores ......................................... .......................................... 171
Capítulo 9: Uso de expresiones de valores SQL avanzadas ......................... ...... 197
Capítulo 10: Centrándose en los datos que desea.................................... ................... 211
Capítulo 11: Uso de operadores relacionales ................................................ ........................ 243
Capítulo 12: Profundizando con consultas anidadas ........................................ ................. 267
Capítulo 13: Consultas recursivas................................................. ........................................ 285

Parte IV: Control de operaciones ................................ 295

Capítulo 14: Proporcionar seguridad a la base de datos ................................. ........................ 297
Capítulo 15: Protección de datos ................................................ ........................................ 313
Capítulo 16: Uso de SQL dentro de las aplicaciones.................................... ........................ 333

Parte V: Llevando SQL al mundo real................... 347

Capítulo 17: Acceso a datos con ODBC y JDBC ......................................... .......... 349
Capítulo 18: Operando con datos XML con SQL ................................. ................. 359

Parte VI: Temas avanzados ................................ 381

Capítulo 19: Recorrer un conjunto de datos con cursores ................................ .... 383
Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes... 393
Capítulo 21: Manejo de errores................................................. ........................................ 411
Capítulo 22: Desencadenantes ................................................ ................................................. ...... 423
IV SQL para principiantes, octava edición

Parte VII: La parte de decenas ......................................... 429

Capítulo 23: Diez errores comunes................................................. ................................ 431
Capítulo 24: Diez consejos de recuperación ......................................... ........................................ 435

Apéndice: SQL: 2011 Palabras reservadas ........................ 439

Índice ................................................. ................. 443

 Tabla de contenido

Introducción ................................................. ................ 1

Sobre este libro ............................................... ................................................ 1
¿Quién debería leer este libro? ................................................. ........................ 2
Iconos utilizados en este libro ................................................ ................................... 2
A dónde ir desde aquí............................................. ........................................ 2

Parte I: Primeros pasos con SQL................................. 3

Capítulo 1: Fundamentos de bases de datos relacionales 5
Seguimiento de las cosas................................................ ................................... 6
¿Que es una base de datos? ................................................. ........................................ 7
Tamaño y complejidad de la base de datos................................................ ........................ 7
¿Qué es un sistema de gestión de bases de datos? ................................................. .8
Archivos planos ................................................ ................................................. .......... 9
Modelos de bases de datos ................................................ .......................................... 11
Modelo relacional ................................................ ................................ 11
Componentes de una base de datos relacional................................................ ... 12
Cómo tratar sus relaciones ................................................ ................. 12
Disfruta la vista ............................................... ........................................ 14
Esquemas, dominios y restricciones................................................ ...... dieciséis
El modelo de objetos desafió el modelo relacional.................... 18
El modelo objeto-relacional ................................................ ................. 18
Consideraciones de diseño de bases de datos .................................. ................. 19

Capítulo 2: Fundamentos de SQL 21

Qué es y qué no es SQL................................................ ........................................ 21
Una (muy) pequeña historia................................................ ........................................ 23
Sentencias SQL................................................ ................................................ 24
Palabras reservadas................................................ ........................................ 26
Tipos de datos................................................ ................................................. .... 26
Números exactos................................................. ........................................ 27
Números aproximados................................................ ........................ 29
Cadenas de caracteres ................................................. ................................ 30
Cadenas binarias ................................................. ........................................ 32
Booleanos................................................ ................................................ 33
Fechas y horas ................................................. ........................................ 33
Intervalos ................................................. ................................................ 35
Tipo XML................................................. ................................................ 35
Tipos de fila ................................................. ................................................ 38
Tipos de colección ................................................ ................................... 39
Tipos de REF ................................................ ................................................ 41
vi SQL para principiantes, octava edición

Tipos definidos por el usuario .................................. ................................ 41

Resumen de tipos de datos.................................. ................................ 44
Valores nulos................................................ ................................................. .... 46
Restricciones................................................ ................................................. .. 46
Uso de SQL en un sistema cliente/servidor.................................... ................. 47
El servidor................................................ ........................................ 47
El cliente ................................................ ................................................ 48
Usando SQL en Internet o una Intranet................................................. .......... 49

Capítulo 3: Los componentes de SQL 51

Lenguaje de definición de datos................................................ ................................ 52
Cuando “¡Simplemente hazlo!” no es un buen consejo................................................ 52
Creando tablas................................................. ........................................ 53
Un cuarto con vista............................................. ................................ 55
Recopilación de tablas en esquemas ................................................ ............ 61
Realizar pedidos por catálogo................................................. ................................ 61
Familiarizarse con las sentencias DDL ................................................ .. 62
Lenguaje de manipulación de datos............................................... ........................ 64
Expresiones de valor................................................ ................................ 64
Predicados ................................................ ................................................ 68
Conectivos lógicos ................................................ ................................ 69
Configurar funciones................................................ ........................................ 69
Subconsultas ................................................. .......................................... 71
Lenguaje de control de datos................................................ ................................... 71
Actas................................................. ........................................ 71
Usuarios y privilegios ................................................. ................................ 73
Las restricciones de integridad referencial pueden poner en peligro sus datos ........... 75
Delegar la responsabilidad de la seguridad................................................ 77

Parte II: Uso de SQL para crear bases de datos ......... 79

Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple. . . 81

Uso de una herramienta RAD para crear una base de datos simple ......................... .. 82
Decidir qué rastrear................................................ ........................ 82
Creando una tabla de base de datos ................................................ ................. 83
Modificar la estructura de la tabla ................................................ ................. 90
Creando un índice ................................................. ................................ 92
Eliminar una tabla................................................. ........................................ 94
Construyendo POWER con DDL de SQL................................................. ................... 95
Usando SQL con Microsoft Access ................................................. ......... 95
Creando una tabla ................................................. ........................................ 97
Creando un índice ................................................. ................................ 101
Modificar la estructura de la tabla ................................................ ................ 102
Eliminar una tabla................................................. ................................ 102
Eliminar un índice ................................................. ................................ 103
Consideraciones de portabilidad ................................................ ........................ 103
 Tabla de contenido viii

Capítulo 5: Creación de una base de datos relacional multitabla 105

Diseño de una base de datos ................................................. ................................ 105
Paso 1: Definir objetos................................................ ........................ 106
Paso 2: Identificar tablas y columnas ........................................... 106
Paso 3: Definir tablas ................................................ ........................ 107
Dominios, juegos de caracteres, intercalaciones y traducciones.... 111
Entrar rápidamente a su base de datos con claves ................................ 112
Trabajar con índices................................................ ................................... 114
¿Qué es un índice?................................................ ......... 115
Por qué debería querer un índice................................................ ............ 116
Mantener un índice................................................. ........................ 117
Mantener la integridad de los datos ................................................ .......................... 118
Integridad de la entidad ................................................ ................................... 118
Integridad del dominio ................................................ ................................ 119
Integridad referencial................................................ .......................... 120
Justo cuando pensabas que era seguro. . ................................................ 123
Posibles áreas problemáticas.................................. ................. 124
Restricciones................................................ ........................................ 126
Normalizando la base de datos ................................................. .......................... 129
Anomalías de modificación y formas normales................................. 129
Primera forma normal................................................ ................................ 132
Segunda forma normal ................................................. ........................ 132
Tercera forma normal ................................................. ................................ 134
Forma normal de clave de dominio (DK/NF) ......................... .......... 134
Forma anormal ................................................. ................................... 135

Parte III: Almacenamiento y recuperación de datos ........................ 137

Capítulo 6: Manipulación de datos de bases de datos 139

Recuperando datos ................................................ ........................................ 139
Creando vistas ................................................. ........................................ 141
De las tablas................................................ ........................................ 142
Con una condición de selección................................................ ................. 143
Con un atributo modificado................................................ ................... 144
Actualizando vistas ................................................ ........................................ 145
Agregar nuevos datos ................................................. .......................................... 146
Agregar datos una fila a la vez ................................. ................ 146
Agregar datos solo a las columnas seleccionadas................................. 148
Agregar un bloque de filas a una tabla ................................. .......... 148
Actualización de datos existentes................................................ ................................ 151
Transferencia de datos................................................ ........................................ 154
Eliminación de datos obsoletos ................................................ ................................ 156
viii SQL para principiantes, octava edición

Capítulo 7: Manejo de datos temporales 157

Comprensión de tiempos y períodos en SQL:2011................................... 158
Trabajar con tablas de períodos de tiempo de aplicación.................................... 159
Designación de claves primarias en tablas de períodos de tiempo de aplicación....162
Aplicar restricciones referenciales al tiempo de aplicación.
tablas de periodos................................................ ................................... 163
Consultar tablas de periodos de tiempo de solicitud ................................ 164
Trabajar con tablas con versión del sistema.................................... ....... 165
Designación de claves primarias en tablas versionadas por el sistema.... 167
Aplicar restricciones referenciales a tablas versionadas por el sistema... 168
Consulta de tablas versionadas por el sistema.................................... ..... 168
Seguimiento de aún más datos de tiempo con tablas bitemporales.................... 169

Capítulo 8: Especificación de valores 171

Valores................................................. ................................................. ......... 171
Valores de fila................................................ .......................................... 172
Valores literales................................................ ........................................ 172
Variables................................................. ........................................ 174
Variables especiales................................................ ................................ 176
Referencias de columnas................................................ ........................ 176
Expresiones de valor ................................................ ........................................ 177
Expresiones de valores de cadena .................................. ................... 178
Expresiones de valores numéricos ................................................ ................. 179
Expresiones de valor de fecha y hora................................ ................. 179
Expresiones de valores de intervalo.................................... ................. 180
Expresiones de valor condicional ................................................ .......... 180
Funciones ................................................. ................................................. ... 181
Resumir mediante el uso de funciones establecidas................................. ... 181
Funciones de valor................................................ ................................ 184

Capítulo 9: Uso de expresiones de valores SQL avanzadas 197

CASO Expresiones Condicionales................................................ ................... 197
Usando CASE con condiciones de búsqueda................................................ .... 198
Usando CASE con valores................................................ ........................ 200
Un CASO especial — NULLIF ................................................. ................... 202
Otro CASO especial: COALESCE ................................................. .. 204
Conversiones de tipos de datos CAST ................................. ........................ 205
Usando CAST dentro de SQL................................................ ........................ 206
Uso de CAST entre SQL y el lenguaje anfitrión ........................ 206
Expresiones de valor de fila.................................... ................................ 207

Capítulo 10: Centrándose en los datos que desea 211

Cláusulas modificatorias ................................................ ........................................ 211
Cláusulas DE ................................................. ................................................ 213
 Tabla de contenido ix
Cláusulas DÓNDE................................................ ........................................ 213
Predicados de comparación................................................ ........................ 215
ENTRE................................................. .......................................... 215
DENTRO y NO DENTRO................................................ ........................................ 217
ME GUSTA y NO ME GUSTA ................................................ ................................ 218
SIMILAR ................................................. ................................................ 220
NULO ................................................. ................................................. 220
TODOS, ALGUNOS, CUALQUIER................................................ ................................. 221
EXISTE ................................................ ................................................ 224
ÚNICO................................................. ................................................ 225
DISTINTO................................................. ........................................ 225
SUPERPOSICIONES................................................ .......................................... 226
FÓSFORO ................................................. ................................................ 226
Reglas de integridad referencial y el predicado MATCH ................228
Conectivos Lógicos ................................................ ................................. 230
Y................................................. ................................................. ... 230
O ................................................. ................................................. ..... 231
NO................................................. ................................................. ... 232
Cláusulas GROUP BY ................................................ ........................................ 232
Cláusulas TENIENDO................................................ .......................................... 234
Cláusulas ORDER BY ................................................ ........................................ 235
FETCH limitada ................................................ ........................................ 236
Mirar a través de una ventana para crear un conjunto de resultados ........................ 238
Dividir una ventana en cubos con NTILE ................................ 239
Navegar dentro de una ventana ................................................ ................. 239
Funciones de la ventana de anidamiento .................................. ................ 241
Evaluación de grupos de filas ................................................ ................. 242

Capítulo 11: Uso de operadores relacionales 243

UNIÓN ................................................. ................................................. ........ 243
La operación UNION TODO ................................................ ................. 245
La operación CORRESPONDIENTE................................................ ...... 245
INTERSECCIONAR ................................................. ................................................. 246
EXCEPTO ................................................. ................................................. ...... 248
Únase a los operadores ................................................ ........................................ 249
Unión básica................................................ ........................................ 249
Unión equivalente ................................................. ................................................ 251
Unión cruzada ................................................. ........................................ 253
Unión natural................................................. ........................................ 253
Unión de condiciones................................................ ........................................ 254
Unión de nombre de columna .................................. ................................ 254
Unir internamente................................................ ........................................ 255
Unión exterior ................................................. ........................................ 256
Unirse al sindicato................................................ ........................................ 259
ENCENDIDO versus DÓNDE ................................................ ........................................ 266
X SQL para principiantes, octava edición

Capítulo 12: Profundizando con consultas anidadas 267

Qué hacen las subconsultas................................................ ........................................ 268
Consultas anidadas que devuelven conjuntos de filas ........................................ 269
Consultas anidadas que devuelven un valor único................................. 272
Los cuantificadores TODOS, ALGUNOS y CUALQUIER................................... .... 275
Consultas anidadas que son una prueba de existencia ................................ 277
Otras subconsultas correlacionadas................................................. ............ 278
ACTUALIZAR, BORRAR e INSERTAR................................................ ............ 282
Recuperar cambios con DML canalizado ........................................ 284

Capítulo 13: Consultas recursivas 285

¿Qué es la recursividad?................................................ ........................................ 285
Houston, tenemos un problema............................................ ................ 287
El fracaso no es una opción ............................................. ........................ 287
¿Qué es una consulta recursiva? ................................................. ........................ 288
¿Dónde podría utilizar una consulta recursiva?................................... ..... 289
Consultar por las malas................................................ ........................ 290
Ahorrar tiempo con una consulta recursiva ................................................ ..... 291
¿En qué otro lugar podría utilizar una consulta recursiva? ........................................ 293

Parte IV: Control de operaciones................................ 295

Capítulo 14: Proporcionar seguridad a la base de datos 297
El lenguaje de control de datos SQL................................................ ................... 298
Niveles de acceso de usuario .................................. ........................................ 298
El administrador de la base de datos ................................................. ................ 298
Propietarios de objetos de base de datos.................................. ........................ 299
El público................................................ .......................................... 300
Otorgar privilegios a los usuarios................................................ ........................ 300
Funciones................................................ ................................................. 301
Insertar datos................................................ ........................................ 302
Mirando los datos................................................. ................................. 302
Modificar datos de la tabla................................................ ........................ 303
Eliminar filas obsoletas de una tabla.................................... .... 304
Referenciar tablas relacionadas................................................ ................. 304
Usando dominios................................................ ................................. 305
Causar la ejecución de sentencias SQL................................. 306
Otorgar privilegios en todos los niveles ................................................ ................. 307
Otorgamiento de la facultad de otorgar privilegios ................................................ ........ 309
Quitar privilegios ................................................ ................................ 310
Uso de GRANT y REVOKE juntos para ahorrar tiempo y esfuerzo... 311
 Tabla de contenido xi
Capítulo 15: Protección de datos 313
Amenazas a la integridad de los datos ................................................ ................................ 313
Inestabilidad de la plataforma ................................................ ................................ 314
Falla en el equipo ................................................ ................................ 314
Acceso simultáneo ................................................. ........................ 315
Reducir la vulnerabilidad a la corrupción de datos ................................. 317
Usando transacciones SQL ................................................. ........................ 318
La transacción predeterminada.................................... ........................ 319
Niveles de aislamiento ................................................ ................................... 320
La declaración implícita de inicio de transacción................................. 322
ESTABLECER TRANSACCIÓN................................................ ................................ 323
COMPROMETERSE ................................................. ........................................ 324
RETROCEDER ................................................. ........................................ 324
Bloquear objetos de base de datos .................................. ................. 324
Copia de seguridad de sus datos................................................ ........................ 325
Puntos de guardado y subtransacciones................................................ ....... 325
Restricciones dentro de las transacciones................................................ ................ 327

Capítulo 16: Uso de SQL dentro de las aplicaciones 333

SQL en una aplicación................................................ ................................. 333
Estando atento al asterisco................................................. ...... 334
Fortalezas y debilidades de SQL................................................ .......... 334
Fortalezas y debilidades de los lenguajes procedimentales ......... 335
Problemas al combinar SQL con un lenguaje procedimental....... 335
Conectando SQL a lenguajes procedimentales ................................................ .... 336
SQL incorporado................................................ ................................... 336
Idioma del módulo ................................................ ................................ 339
Herramientas RAD orientadas a objetos.................................... ................... 342
Usando SQL con Microsoft Access ................................................. ....... 343

Parte V: Llevando SQL al mundo real ........................ 347

Capítulo 17: Acceso a datos con ODBC y JDBC 349
ODBC ................................................. ................................................. .......... 350
La interfaz ODBC................................................ ................................ 350
Componentes de ODBC................................................ ........................ 351
ODBC en un entorno Cliente/Servidor ................................. .......... 352
ODBC e Internet................................................ ................................ 352
Extensiones de servidor................................................ ................................ 353
Extensiones de cliente................................................ ................................ 354
ODBC y una Intranet ................................................ ................................... 355
JDB ................................................. ................................................. .......... 355
xiii SQL para principiantes, octava edición

Capítulo 18: Operar con datos XML con SQL 359

Cómo se relaciona XML con SQL ................................................ ................................ 359
El tipo de datos XML.................................... ........................................ 360
Cuándo utilizar el tipo XML................................................ ................. 361
Cuándo no utilizar el tipo XML................................................ ................ 362
Asignación de SQL a XML y de XML a SQL................................. ............ 362
Mapeo de juegos de caracteres .................................. ........................ 362
Identificadores de mapeo................................................ ................................ 363
Tipos de datos de mapeo .................................. ................................ 364
Tablas de mapeo................................................ ................................... 364
Manejo de valores nulos ................................................. ........................ 365
Generando el esquema XML ................................................ ................ 366
Funciones SQL que operan sobre datos XML ................................. ... 367
DOCUMENTO XML................................................ ................................ 367
ELEMENTO XML ................................................. ................................... 367
BOSQUE XML................................................. ........................................ 368
XMLCONCAT ................................................. ........................................ 368
XMLAGG................................................. ........................................ 369
COMENTARIO XML ................................................. ................................ 369
XMLPARSE ................................................. ........................................ 370
XMLPI ................................................. ................................................ 370
CONSULTA XML ................................................. ........................................ 370
XMLCAST ................................................. .......................................... 371
Predicados................................................. ................................................. .. 371
DOCUMENTO ................................................. ........................................ 371
CONTENIDO................................................. .......................................... 372
XMLEXISTE................................................. ........................................ 372
VÁLIDO................................................. ................................................. 372
Transformar datos XML en tablas SQL ................................................ ..... 373
Asignación de tipos de datos no predefinidos a XML.................................... 375
Dominio ................................................. ................................................ 375
UDT distinta ................................................ ........................................ 376
Fila ................................................. ................................................. ... 377
Formación................................................. ................................................. .378
Conjunto múltiple ................................................. ................................................ 379
La unión de SQL y XML ................................................ ........................ 379

Parte VI: Temas avanzados ................................ 381

Capítulo 19: Recorrer un conjunto de datos con cursores 383
Declarar un cursor................................................ ........................................ 384
Expresión de consulta................................................ ................................ 385
Cláusula ORDER BY................................................ ................................ 385
 Tabla de contenido xiii
Cláusula de actualizabilidad................................................ ................................ 387
Sensibilidad ................................................. .......................................... 387
Capacidad de desplazamiento................................................. ........................................ 388
Abrir un cursor................................................. .......................................... 388
Obteniendo datos de una sola fila ......................................... ................... 390
Sintaxis ................................................. ................................................ 390
Orientación de un cursor desplazable ................................................ ...... 391
Declaraciones DELETE y UPDATE posicionadas ................................ 391
Cerrar un cursor ................................................. .......................................... 392

Capítulo 20: Agregar capacidades de procedimiento con módulos

almacenados persistentes 393
Declaraciones compuestas................................................ ................................ 393
Atomicidad................................................. ................................................ 394
Variables................................................. ........................................ 395
Cursores................................................ ................................................ 396
Condiciones................................................. .......................................... 396
Condiciones de manejo ................................................ ........................ 397
Condiciones que no se manejan ................................................ ............ 400
Asignación ................................................. ........................................ 400
Flujo de declaraciones de control ................................................ ........................ 400
SI... ENTONCES... DE LO CONTRARIO... TERMINAR SI................................... ........................ 401
CASO…FIN DEL CASO................................................ ................................ 401
BUCLE…BUCLE FINAL ................................................ ................................ 402
DEJAR ................................................. ................................................ 403
MIENTRAS... HACER... TERMINAR MIENTRAS.................................... ........................ 404
REPETIR…HASTA…TERMINAR REPETIR ................................................ .......... 404
PARA…HACER…TERMINAR PARA ................................................ ................................ 405
ITERAR ................................................. ........................................ 405
Procedimientos almacenados................................................ ........................................ 406
Funciones almacenadas................................................. .......................................... 407
Privilegios ................................................. ................................................. ... 408
Módulos almacenados................................................ ........................................ 409

Capítulo 21: Manejo de errores 411

ESTADOSQL................................................. ................................................. .. 411
Cláusula SIEMPRE ................................................ ........................................ 413
Áreas de Diagnóstico ................................................. ........................................ 414
Área de encabezado de diagnóstico.................................. ................. 414
Área de detalle de diagnóstico................................................. ........................ 416
Ejemplo de violación de restricciones ................................................ ............ 418
Agregar restricciones a una tabla existente ................................ 419
Interpretación de la información devuelta por SQLSTATE ................... 419
Manejo de excepciones ................................................ ................................... 420
xiv SQL para principiantes, octava edición

Capítulo 22: Desencadenantes 423

Examinando algunas aplicaciones de los desencadenantes................................................. ... 423
Creando un disparador................................................. ........................................ 424
Desencadenantes de declaraciones y filas .................................. ................ 425
Cuando se dispara un disparador ................................................ ................................ 425
La sentencia SQL activada ................................................ ............ 425
Un ejemplo de definición de activador................................................ ............ 426
Disparando una sucesión de disparadores ................................................. ................. 426
Hacer referencia a valores antiguos y valores nuevos................................. ...... 427
Disparar múltiples disparadores en una sola mesa.................................... ..... 428

Parte VII: La parte de decenas................................................ 429

Capítulo 23: Diez errores comunes 431

Suponiendo que sus clientes saben lo que necesitan ................................ 431
Ignorar el alcance del proyecto................................................ ................................ 432
Considerando sólo factores técnicos................................................ .......... 432
No pedir comentarios al cliente................................................ ................. 432
Utilizando siempre su entorno de desarrollo favorito ......... 433
Uso exclusivo de la arquitectura de su sistema favorita ......... 433
Diseño de tablas de bases de datos de forma aislada ................................. ....... 433
Descuidar las revisiones de diseño................................................ ........................ 434
Saltarse las pruebas beta................................................ ................................... 434
No documentar su proceso ................................................ ................. 434

Capítulo 24: Diez consejos de recuperación 435

Verificar la estructura de la base de datos................................................ ........................ 435
Pruebe consultas en una base de datos de prueba ................................. ................... 436
Verifique nuevamente las consultas que incluyen uniones ................................. .... 436
Consultas de triple verificación con subselecciones ................................. .......... 436
Resumir datos con GROUP BY ................................................. ................. 436
Ver Restricciones de la Cláusula GROUP BY.................................... ......... 437
Utilice paréntesis con Y, O y NO ........................................ ....... 437
Controlar los privilegios de recuperación ................................. ........................ 437
Haga una copia de seguridad de sus bases de datos con regularidad................................. ................ 438
Manejar las condiciones de error con elegancia................................. ............ 438

Apéndice: SQL: 2011 Palabras reservadas........................ 439

Índice ................................................. ........................ 443

 Introducción

W. Bienvenido al desarrollo de bases de datos utilizando SQL, el lenguaje de consulta de

bases de datos estándar de la industria. Muchas herramientas de sistemas de gestión de
bases de datos (DBMS) se ejecutan en una variedad de plataformas de hardware. Las diferencias
entre las herramientas pueden ser grandes, pero todos los productos serios tienen una cosa en
común: admiten el acceso y la manipulación de datos SQL. Si conoce SQL, puede crear bases de
datos relacionales y obtener información útil de ellas.

Sobre este libro

Los sistemas de gestión de bases de datos relacionales son vitales para muchas organizaciones.
La gente suele pensar que crear y mantener estos sistemas deben ser actividades
extremadamente complejas: el dominio de los gurús de las bases de datos que poseen una
iluminación más allá de la de los simples mortales. Este libro elimina la mística de las bases de
datos. En este libro, usted

✓ Llegar a las raíces de las bases de datos.

✓ Descubra cómo está estructurado un DBMS.

✓ Descubra los principales componentes funcionales de SQL.

✓ Construya una base de datos.

✓ Proteger una base de datos de daños.

✓ Operar con datos de bases de datos.

✓ Determine cómo obtener la información que desea de una base de datos.

El propósito de este libro es ayudarlo a crear bases de datos relacionales y obtener

información valiosa de ellas mediante el uso de SQL. SQL es el lenguaje estándar
internacional utilizado para crear y mantener bases de datos relacionales. Esta edición
cubre la última versión del estándar, SQL:2011.

Este libro no le dice cómo diseñar una base de datos (lo hago enDesarrollo de bases
de datos para principiantes,también publicado por Wiley). Aquí asumo que usted u
otra persona ya ha creado un diseño válido. Luego ilustro cómo implementar ese
diseño usando SQL. Si sospecha que no tiene un buen diseño de base de datos,
entonces, por supuesto, corrija su diseño antes de intentar construir la base de
datos. Cuanto antes detectes y corrijas los problemas en un proyecto de desarrollo,
más económicas serán las correcciones.
2 SQL para principiantes, octava edición

¿Quién debería leer este libro?

Si necesita almacenar o recuperar datos de un DBMS, puede hacer un trabajo mucho
mejor con conocimientos prácticos de SQL. No es necesario ser programador para
utilizar SQL y no es necesario conocer lenguajes de programación, como Java, C o BASIC.
La sintaxis de SQL es como la del inglés.

Si ustedsonComo programador, puedes incorporar SQL a tus programas. SQL agrega

poderosas capacidades de manipulación y recuperación de datos a los lenguajes
convencionales. Este libro le explica lo que necesita saber para utilizar la amplia variedad de
herramientas y funciones de SQL dentro de sus programas.

Iconos utilizados en este libro

Los consejos le ahorran mucho tiempo y le mantienen alejado de problemas.

Preste atención a la información marcada por este icono; es posible que la necesite más
adelante.

Hacer caso a los consejos que señala este icono puede salvarle de un gran dolor. Ignóralo bajo
tu responsabilidad.

Este icono le alerta de la presencia de detalles técnicos que son interesantes pero no
absolutamente esenciales para comprender el tema que se está discutiendo.

A dónde ir desde aquí

¡Ahora viene la parte divertida! Las bases de datos son las mejores herramientas jamás inventadas
para realizar un seguimiento de las cosas que le interesan. Una vez que comprenda las bases de
datos y pueda usar SQL para hacer que cumplan sus órdenes, ejercerá un poder tremendo. Los
compañeros de trabajo acuden a usted cuando necesitan información crítica. Los gerentes buscan
su consejo. Los jóvenes piden tu autógrafo. Pero lo más importante es que usted sabe, a un nivel
muy profundo, cómo funciona realmente su organización.
 Parte I

Comenzando con SQL

[Link] obtener excelente contenido para principiantes en línea.

 En esta parte…
✓ Los fundamentos de las bases de datos relacionales

✓ Conceptos básicos de SQL

✓ Herramientas fundamentales de bases de datos

✓ [Link]/extras/sqlpara obtener excelente contenido para

principiantes en línea.
 Capítulo 1

Fundamentos de bases de datos relacionales

En este capítulo
▶ Organizar la información
▶ Definición de “base de datos” en términos digitales

▶ Descifrando DBMS
▶ Observando la evolución de los modelos de bases de datos.
▶ Definiendo “relacionalbase de datos” (¿te identificas?)
▶ Considerando los desafíos del diseño de bases de datos

S QL(pronunciadoess-que-ell,nover'qwl,aunque los expertos en bases de datos todavía

discuten sobre eso) es un lenguaje diseñado específicamente teniendo en cuenta las
bases de datos. SQL permite a las personas crear bases de datos, agregarles nuevos datos,
mantener los datos en ellas y recuperar partes seleccionadas de los datos. Desarrollado en la
década de 1970 en IBM, SQL ha crecido y avanzado a lo largo de los años hasta convertirse en
el estándar de la industria. Se rige por una norma formal mantenida por la Organización
Internacional de Normalización (ISO).

Existen varios tipos de bases de datos, cada una de las cuales se adhiere a un modelo diferente de cómo
se organizan los datos en la base de datos.

SQL fue desarrollado originalmente para operar con datos en bases de datos que siguen el modelo
[Link], el estándar internacional SQL ha incorporado parte de lamodelo de objeto,
dando como resultado estructuras híbridas llamadas bases de datos relacionales de objetos. En este
capítulo, analizo el almacenamiento de datos, dedico una sección a cómo se compara el modelo
relacional con otros modelos importantes y doy un vistazo a las características importantes de las
bases de datos relacionales.

Sin embargo, antes de hablar de SQL, quiero precisar lo que quiero decir con el términobase de [Link]
significado ha cambiado, del mismo modo que las computadoras han cambiado la forma en que las personas
registran y mantienen la información.
6 Parte I: Introducción a SQL

Seguimiento de las cosas

Hoy en día la gente utiliza las computadoras para realizar muchas tareas que antes se realizaban con
otras herramientas. Las computadoras han reemplazado a las máquinas de escribir para crear y
modificar documentos. Han superado a las calculadoras electromecánicas como la mejor forma de
hacer matemáticas. También han reemplazado millones de hojas de papel, carpetas y archivadores
como principal medio de almacenamiento de información importante. En comparación con esas
viejas herramientas, por supuesto, las computadoras hacen mucho más, mucho más rápido y con
mayor precisión. Sin embargo, estos mayores beneficios tienen un costo: los usuarios de
computadoras ya no tienen acceso físico directo a sus datos.

Cuando las computadoras fallan ocasionalmente, los trabajadores de oficina pueden

preguntarse si la informatización realmente mejoró algo. En los viejos tiempos, una carpeta de
papel manila “se estropeaba” sólo si se la dejaba caer; luego simplemente se arrodillaba,
recogía los papeles y los volvía a guardar en la carpeta. Salvo terremotos u otros desastres
importantes, los archivadores nunca “se caían” y nunca daban un mensaje de error. Una falla
del disco duro es un asunto completamente diferente: no se pueden “recuperar” bits y bytes
perdidos. Las fallas mecánicas, eléctricas y humanas pueden hacer que sus datos desaparezcan
en el Gran Más Allá para nunca regresar.

Tomar las precauciones necesarias para protegerse de la pérdida accidental de datos le

permitirá comenzar a sacar provecho de la mayor velocidad y precisión que brindan las
computadoras.

Si almacena datos importantes, tiene cuatro preocupaciones principales:

✓ El almacenamiento de datos tiene que ser rápido y sencillo porque es probable que lo haga con
frecuencia.

✓ El medio de almacenamiento debe ser fiable. No querrás volver más tarde y

encontrar que faltan algunos (o todos) tus datos.

✓ La recuperación de datos debe ser rápida y sencilla, independientemente de cuántos elementos

almacene.

✓ Necesita una manera fácil de separar la información exacta que deseaahora de

las toneladas de datos que ustednoquiero ahora mismo.

Las bases de datos informáticas más modernas cumplen estos cuatro criterios. Si almacena
más de una docena de elementos de datos, probablemente desee almacenarlos en una base
de datos.
 Capítulo 1: Fundamentos de bases de datos relacionales 7
¿Que es una base de datos?
El términobase de datosÚltimamente se ha dejado de utilizar, perdiendo gran parte de su significado
original. Para algunas personas, una base de datos es cualquier colección de elementos de datos (guías
telefónicas, listas de lavandería, rollos de pergamino... lo que sea). Otras personas definen el término de
manera más estricta.

En este libro defino unabase de datoscomo una colección de registros integrados que
se describen a sí mismos. Y sí, eso implica tecnología informática, completa con
lenguajes de programación como SQL.

Aregistroes una representación de algún objeto físico o conceptual. Digamos, por

ejemplo, que desea realizar un seguimiento de los clientes de una empresa. Asignas un
registro para cada cliente. Cada registro tiene múltiplesatributos,como nombre,
dirección y número de teléfono. Los nombres individuales, direcciones, etc., son los
datos.

Una base de datos se compone de datos [Link] metadatos son los datos que
describen la estructura de los datos dentro de una base de datos. Si sabe cómo están
organizados sus datos, podrá recuperarlos. Debido a que la base de datos contiene una
descripción de su propia estructura, [Link] base de datos esintegrado porque
incluye no sólo elementos de datos sino también las relaciones entre elementos de datos.

La base de datos almacena metadatos en un área llamadaDiccionario de datos,que

describe las tablas, columnas, índices, restricciones y otros elementos que
componen la base de datos.

Debido a que un sistema de archivos planos (que se describe más adelante en este capítulo) no tiene
metadatos, las aplicaciones escritas para trabajar con archivos planos deben contener el equivalente de los
metadatos como parte del programa de aplicación.

Tamaño y complejidad de la base de datos

Las bases de datos vienen en todos los tamaños, desde simples colecciones de unos pocos registros
hasta sistemas gigantescos que contienen millones de registros. La mayoría de las bases de datos
se clasifican en una de tres categorías, que se basan en el tamaño de la base de datos en sí, el
tamaño del equipo en el que se ejecuta y el tamaño de la organización que la mantiene:

✓ Abase de datos personalestá diseñado para ser utilizado por una sola persona en una sola
computadora. Una base de datos de este tipo suele tener una estructura bastante simple y un
tamaño relativamente pequeño.
8 Parte I: Introducción a SQL

✓ Abase de datos departamental o de grupo de trabajoEs utilizado por los miembros de un

solo departamento o grupo de trabajo dentro de una organización. Este tipo de base de datos
es generalmente más grande que una base de datos personal y necesariamente más
compleja; dicha base de datos debe manejar múltiples usuarios que intentan acceder a los
mismos datos al mismo tiempo.

✓ Unbase de datos empresarialpuede ser enorme. Las bases de datos empresariales pueden
modelar el flujo de información crítica de grandes organizaciones enteras.

¿Qué es un sistema de gestión de bases

de datos?
Me alegra que hayas preguntado. Asistema de administración de base de datos(DBMS) es un conjunto
de programas utilizados para definir, administrar y procesar bases de datos y sus aplicaciones
asociadas. La base de datos que se gestiona es, en esencia, una estructura que se construye para
contener datos valiosos. Un DBMS es la herramienta que utiliza para construir esa estructura y operar
con los datos contenidos en la base de datos.

Puede encontrar muchos programas DBMS en el mercado actual. Algunos se ejecutan en

máquinas grandes y potentes y otros en computadoras personales, portátiles y tabletas. Sin
embargo, una fuerte tendencia es que dichos productos funcionen en múltiples plataformas
o en redes que contienen diferentes clases de máquinas. Una tendencia aún más fuerte es
almacenar datos en centros de datos o incluso almacenarlos en el [Link],que podría
ser una nube pública administrada por una gran empresa como Amazon, Google o
Microsoft, a través de Internet, o podría ser una nube privada operada por la misma
organización que almacena los datos en su propia intranet.

Estos días,nubees una palabra de moda que se utiliza incesantemente en los círculos
tecnológicos. Al igual que las cosas blancas e hinchadas en el cielo, tiene bordes confusos y
parece flotar en algún lugar ahí fuera. En realidad, es una colección de recursos informáticos a
los que se puede acceder a través de un navegador, ya sea a través de Internet o en una
intranet privada. Lo que distingue los recursos informáticos en la nube de recursos
informáticos similares en un centro de datos físico es el hecho de que se puede acceder a los
recursos a través de un navegador en lugar de un programa de aplicación que accede
directamente a esos recursos.

Un DBMS que se ejecuta en plataformas de múltiples clases, grandes y pequeñas, se llama

escalable.
 Capítulo 1: Fundamentos de bases de datos relacionales 9

El valor no está en los datos, sino en la estructura.

Hace años, una persona inteligente calculó que si se cuesta millones de dólares por onza en el mercado
reduce a los seres humanos a sus componentes de farmacéutico. La estructura precisa de estas
átomos de carbono, hidrógeno, oxígeno y nitrógeno combinaciones de átomos es lo que les confiere
(más trazas de otros), valdrían sólo 97 centavos. Por mayor valor. Por analogía, la estructura de la base de
divertida que sea esta evaluación, es engañosa. Las datos hace posible la interpretación de datos
personas no están compuestas por meras aparentemente sin sentido. La estructura saca a la
colecciones aisladas de átomos. Nuestros átomos se superficie patrones, tendencias y tendencias en los
combinan para formar enzimas, proteínas, hormonas datos. Los datos no estructurados (como los átomos
y muchas otras sustancias que no combinados) tienen poco o ningún valor.

Cualquiera que sea el tamaño de la computadora que aloja la base de datos (e

independientemente de si la máquina está conectada a una red), el flujo de información
entre la base de datos y el usuario es siempre el mismo. La Figura 1-1 muestra que el
usuario se comunica con la base de datos a través del DBMS. El DBMS enmascara los
detalles físicos del almacenamiento de la base de datos para que la aplicación tenga que
preocuparse sólo de las características lógicas de los datos, no de cómo se almacenan.

Figura 1-1:
Un bloque

diagrama de
un DBMS-
basado
información
sistema.

Archivos planos
En lo que respecta a los datos estructurados, el archivo plano es tan simple como parece. No,
un archivo plano no es una carpeta aplastada debajo de una pila de [Link] planos Se
llaman así porque tienen una estructura mínima. Si fueran edificios, apenas sobresaldrían del
suelo. Un archivo plano es simplemente una colección de
10 Parte I: Introducción a SQL

registros de datos, uno tras otro, en un formato específico (los datos, todos los datos y nada
más que los datos); en efecto, una lista. En términos informáticos, un archivo plano es simple.
Debido a que el archivo no almacena información estructural (metadatos), su sobrecarga
(cosas en el archivo que no son datos pero que ocupan espacio de almacenamiento) es
mínima.

Supongamos que desea realizar un seguimiento de los nombres y direcciones de los clientes
de su empresa en un sistema de archivos plano. El sistema puede tener una estructura
similar a esta:

Harold Percival 26262 S. Howards Mill Rd Westminster CA92683

Jerry Appel 32323 S. River Lane Rd 232 Santa Ana CA92705
Adrián Hansen Glenwood Corte anaheim CA92640
Juan panadero 2222 Lafayette St Jardín Grove CA92643
plumas miguel 77730 S. New Era Rd irvine CA92715
Bob Michimoto 25252 S. Kelmsley Dr Stanton CA92610
Linda Smith 444 S.E. 7th St 2424 Costa Mesa CA92635
Robert Funnel Sheri Court anaheim CA92640
Verificación de facturas 9595 Curry Dr. Stanton CA92610
Estilo Jed 3535 Randall St Santa Ana CA92705

Como puede ver, el archivo no contiene más que datos. Cada campo tiene una longitud fija (la
Nombrecampo, por ejemplo, siempre tiene exactamente 15 caracteres) y ninguna estructura
separa un campo de otro. La persona que creó la base de datos asignó las posiciones y
longitudes de los campos. Cualquier programa que utilice este archivo debe “saber” cómo se
asignó cada campo, porque esa información no está contenida en la base de datos misma.

Una sobrecarga tan baja significa que operar con archivos planos puede ser muy rápido. Sin
embargo, el lado negativo es que los programas de aplicación deben incluir una lógica que manipule
los datos del archivo a un nivel muy detallado. La aplicación debe saber exactamente dónde y cómo
el archivo almacena sus datos. Por tanto, para sistemas pequeños, los archivos planos funcionan
bien. Sin embargo, cuanto más grande es un sistema, más engorroso se vuelve un sistema de
archivos planos.

El uso de una base de datos en lugar de un sistema de archivos planos elimina la duplicación de
esfuerzos. Aunque los archivos de bases de datos en sí pueden tener más gastos generales, las
aplicaciones pueden ser más portátiles en varias plataformas de hardware y sistemas
operativos. Una base de datos también facilita la escritura de programas de aplicación porque
el programador no necesita conocer los detalles físicos de dónde y cómo se almacenan los
datos.

La razón por la que las bases de datos eliminan la duplicación de esfuerzos es porque el
DBMS maneja los detalles de manipulación de datos. Las aplicaciones escritas para operar
en archivos planos deben incluir esos detalles en el código de la aplicación. Si varias
aplicaciones acceden a los mismos datos de archivo plano, todas estas aplicaciones deben
incluir (de forma redundante) ese código de manipulación de datos. Sin embargo, si está
utilizando un DBMS, no es necesario que incluya dicho código en las aplicaciones.
 Capítulo 1: Fundamentos de bases de datos relacionales 11

Claramente, si una aplicación basada en archivos planos incluye código de manipulación de datos que
se ejecuta sólo en un sistema operativo (SO) en particular, migrar la aplicación a un sistema operativo
diferente es un dolor de cabeza a punto de suceder. Tienes que cambiar todo el código específico del
sistema operativo, y eso es sólo para empezar. Migrar una aplicación similar basada en DBMS a otro
sistema operativo es mucho más sencillo: menos pasos complicados y menos consumo de aspirina.

Modelos de bases de datos

Las primeras bases de datos, allá por los albores de los tiempos (década de 1950), se
estructuraban según un modelo jerárquico. Sufrían problemas de redundancia y su
inflexibilidad estructural dificultaba la modificación de la base de datos. Pronto les
siguieron bases de datos que se adhirieron al modelo de red, que se esforzaron por
eliminar las principales desventajas del modelo jerárquico. Las bases de datos en red
tienen una redundancia mínima, pero pagan esa ventaja con complejidad estructural.

Algunos años más tarde, el Dr. E. F. Codd de IBM desarrolló elrelacionalmodelo, que
presentaba una redundancia mínima y una estructura fácilmente comprensible. El
lenguaje SQL fue desarrollado para operar en bases de datos relacionales. Las bases de
datos relacionales finalmente enviaron las bases de datos jerárquicas y de red al
basurero de la historia.

Un nuevo fenómeno es la aparición de las llamadas bases de datos NoSQL, que carecen
de la estructura de las bases de datos relacionales y no utilizan el lenguaje SQL. No cubro
las bases de datos NoSQL en este libro.

modelo relacional
El Dr. Codd formuló por primera vez el modelo de base de datos relacional en 1970, y este
modelo comenzó a aparecer en productos aproximadamente una década después.
Irónicamente, IBM no entregó el primer DBMS relacional. Esa distinción fue para una pequeña
empresa nueva, que llamó a su producto Oracle.

Las bases de datos relacionales han reemplazado casi por completo a los tipos de bases de
datos anteriores. Esto se debe en gran medida a que puede cambiar la estructura de una base
de datos relacional sin tener que cambiar o modificar aplicaciones basadas en estructuras
antiguas. Supongamos, por ejemplo, que agrega una o más columnas nuevas a una tabla de
base de datos. No necesita cambiar ninguna aplicación escrita previamente que procese esa
tabla, a menos, por supuesto, que modifique una o más de las columnas que esas aplicaciones
deben usar.
12 Parte I: Introducción a SQL

Por supuesto, si elimina una columna que una aplicación existente debe usar, experimentará
problemas sin importar el modelo de base de datos que siga. Una de las formas más rápidas
de hacer que una aplicación de base de datos falle es pedirle que recupere un tipo de datos
que su base de datos no contiene.

Componentes de una base de datos relacional

Las bases de datos relacionales ganan flexibilidad porque sus datos residen en tablas que
son en gran medida independientes entre sí. Puede agregar, eliminar o cambiar datos en
una tabla sin afectar los datos de las otras tablas, siempre que la tabla afectada no sea
unapadrede cualquiera de las otras tablas. (Las relaciones entre tablas padre-hijo se
explican en el Capítulo 5, y no, no implican discutir las mesadas durante la cena). En esta
sección, muestro en qué consisten estas tablas y cómo se relacionan con las otras partes
de una base de datos relacional.

Lidiar con sus relaciones

En época de vacaciones, muchos de mis familiares vienen a mi casa y se sientan a mi mesa. Las
bases de datos también tienen relaciones, pero cada una de sus relaciones tiene sus propiaspropio
mesa. Una base de datos relacional se compone de una o más relaciones.

Arelaciónes una matriz bidimensional de filas y columnas, que contiene entradas con un
solo valor y sin filas duplicadas. Cada celda de la matriz solo puede tener un valor y no
pueden haber dos filas idénticas. Si esto es un poco difícil de imaginar, aquí hay un
ejemplo que lo ubicará en el estadio correcto. . . .

La mayoría de la gente está familiarizada conbidimensionalmatrices de filas y columnas, en

forma de hojas de cálculo electrónicas como Microsoft Excel. Las estadísticas ofensivas de un
jugador de béisbol de las grandes ligas, tal como se enumeran en el reverso de una tarjeta de
béisbol, son un ejemplo de tal conjunto. En la tarjeta de béisbol hay columnas para el año,
equipo, juegos jugados, turnos al bate, hits, carreras anotadas, carreras impulsadas, dobles,
triples, jonrones, bases por bolas, robos y promedio de bateo. Una fila cubre cada año que el
jugador ha jugado en las Grandes Ligas. También puedes almacenar estos datos en una
relación (una tabla), que tiene la misma estructura básica. La Figura 1-2 muestra una tabla de
base de datos relacional que contiene las estadísticas ofensivas de un único jugador de
Grandes Ligas. En la práctica, una tabla de este tipo contendría las estadísticas de todo un
equipo, o quizás de toda la liga.

Las columnas de la matriz sonautoconsistente:Una columna tiene el mismo significado

en cada fila. Si una columna contiene el apellido de un jugador en una fila, la columna
debe contener el apellido de un jugador en todas las filas. El orden en que aparecen las
filas y columnas en la matriz no tiene importancia. En lo que respecta al DBMS, no
importa qué columna es la primera, cuál es la siguiente y cuál es la última. Lo mismo
ocurre con las filas. El DBMS procesa la tabla de la misma manera independientemente
de la organización.
 Capítulo 1: Fundamentos de bases de datos relacionales 13

Figura 1-2:
Una mesa

demostración

una pelota de béisbol

del jugador

ofensivo
Estadísticas.

Cada columna de una tabla de base de datos incorpora un único atributo de la tabla,
como esa tarjeta de béisbol. El significado de la columna es el mismo para todas las filas
de la tabla. Una tabla puede, por ejemplo, contener los nombres, direcciones y números
de teléfono de todos los clientes de una organización. Cada fila de la tabla (también
llamadaregistro,o untupla) contiene los datos de un solo cliente. Cada columna contiene
un soloatributo—como número de cliente, nombre del cliente, calle del cliente, ciudad
del cliente, estado del cliente, código postal del cliente o número de teléfono del cliente.
La figura 1-3 muestra algunas de las filas y columnas de dicha tabla.

Elrelacionesen este modelo de base de datos corresponden amesasen cualquier base de datos
basada en el modelo. Intenta decir eso diez veces más rápido.

Figura 1-3:
Cada
base de datos

la fila contiene
un expediente;

cada
base de datos

columna
sostiene un

soltero
atributo.
14 Parte I: Introducción a SQL

Disfruta la vista
Una de mis vistas favoritas es la del valle de Yosemite desde la boca del túnel
Wawona, en una tarde de primavera. Una luz dorada baña la pura fachada de
El Capitán, Half Dome brilla en la distancia y Bridal Veil Falls forma una
cascada plateada de agua cristalina, mientras tenues nubes tejen un tapiz en
el cielo. Las bases de datos también tienen vistas, aunque no sean tan
pintorescas. La belleza de las vistas de bases de datos es su gran utilidad
cuando trabaja con sus datos.

Las tablas pueden contener muchas columnas y filas. A veces todos esos datos te
interesan y otras no. Es posible que solo le interesen algunas columnas de una tabla, o
quizás desee ver solo filas que cumplan una determinada condición. Algunas columnas
de una tabla y algunas otras columnas de una tabla relacionada pueden interesarle.
Para eliminar datos que no son relevantes para sus necesidades actuales, puede crear
unvista—un subconjunto de una base de datos que una aplicación puede procesar.
Puede contener partes de una o más tablas.

Las vistas a veces se llamanmesas [Link] la aplicación o el usuario, las vistas se

comportan igual que las tablas. Las opiniones, sin embargo, no tienen existencia
independiente. Las vistas le permiten ver los datos, pero no son parte de los datos.

Digamos, por ejemplo, que está trabajando con una base de datos que tiene
una tabla CLIENTE y una tabla FACTURA. La tabla CLIENTE tiene las columnas
ID de cliente, nombre, apellido, calle, ciudad, estado, código postal,y Teléfono.
La tabla FACTURA tiene las columnasNúmero de factura, ID de cliente, Fecha,
Venta total, Total remitido,yForma de pago.

Un gerente de ventas nacional quiere ver una pantalla que contiene solo el
nombre, apellido y número de teléfono del cliente. Crear desde la tabla
CLIENTE una vista que contenga solo elNombre Apellido,y TeléfonoLas
columnas permiten al administrador ver lo que necesita sin tener que ver
todos los datos no deseados en las otras columnas. La figura 1-4 muestra la
derivación de la opinión del gerente de ventas nacional.

Es posible que el gerente de una sucursal desee consultar los nombres y números de teléfono
de todos los clientes cuyos códigos postales se encuentran entre 90000 y 93999 (sur y centro de
California). Una vista que impone una restricción a las filas que recupera, así como a las
columnas que muestra, hace el trabajo. La Figura 1-5 muestra las fuentes de las columnas en la
vista del gerente de sucursal.
 Capítulo 1: Fundamentos de bases de datos relacionales 15

Figura 1-4:
Las ventas
del gerente
ver deriva
desde el
CLIENTE
mesa.

Figura 1-5:
La rama
hombre-

vista de edad
incluye
solo cer-
tain filas
desde el
CLIENTE
mesa.
dieciséis Parte I: Introducción a SQL

Es posible que el administrador de cuentas por pagar desee ver los nombres de los
clientes en la tabla CLIENTE yFecha, TotalVenta, TotalRemitido,y Forma de pagode
la tabla FACTURA, dondeTotalRemitidoes menos queVenta [Link] último sería el
caso si aún no se ha realizado el pago total. Esta necesidad requiere una visión que
se base en ambas tablas. La Figura 1-6 muestra los datos que fluyen hacia la vista
del administrador de cuentas por pagar desde las tablas CLIENTE y FACTURA.

Las vistas son útiles porque le permiten extraer y formatear datos de bases de
datos sin alterar físicamente los datos almacenados. También protegen los datos
que ustednoquieren mostrar, porque no lo contienen. El Capítulo 6 ilustra cómo
crear una vista utilizando SQL.

Figura 1-6:
El
cuentas-
pagadero
del gerente
ver sorteos
de dos
mesas.

Esquemas, dominios y restricciones

Una base de datos es más que una colección de tablas. Estructuras adicionales, en varios
niveles, ayudan a mantener la integridad de los datos. una base de datosesquemaProporciona
una organización general a las mesas. Eldominiode una columna de la tabla le indica qué
valores puede almacenar en la columna. Puedes aplicarrestriccionesa una tabla de base de
datos para evitar que alguien (incluido usted mismo) almacene datos no válidos en la tabla.
 Capítulo 1: Fundamentos de bases de datos relacionales 17

esquemas
La estructura de una base de datos completa es suesquema,ovisión conceptual.A esta
estructura a veces también se le llamavista lógica completade la base de datos. El esquema
son metadatos y, como tales, son parte de la base de datos. Los metadatos en sí, que
describen la estructura de la base de datos, se almacenan en tablas que son como las tablas
que almacenan los datos normales. Incluso los metadatos son datos; esa es la belleza de esto.

Dominios
Un atributo de una relación (es decir, una columna de una tabla) puede asumir un
número finito de valores. El conjunto de todos estos valores es eldominiodel atributo.

Digamos, por ejemplo, que usted es un concesionario de automóviles que maneja el cupé
deportivo Curarri GT 4000 recientemente presentado. Realiza un seguimiento de los
automóviles que tiene en stock en una tabla de base de datos a la que denomina INVENTARIO.
Usted nombra una de las columnas de la [Link],que mantiene el color exterior de cada
coche. El GT 4000 viene en sólo cuatro colores: carmesí intenso, negro medianoche, blanco
copo de nieve y gris metálico. Esos cuatro colores son el dominio de laColor atributo.

Restricciones
Restriccionesson un componente importante, aunque a menudo pasado por alto, de una base de
datos. Las restricciones son reglas que determinan qué valores pueden asumir los atributos de la
tabla.

Al aplicar restricciones estrictas a una columna, puede evitar que las personas ingresen datos
no válidos en esa columna. Por supuesto, cada valor que esté legítimamente en el dominio de
la columna debe satisfacer todas las restricciones de la columna. Como mencioné en la sección
anterior, el dominio de una columna es el conjunto de todos los valores que la columna puede
contener. Una restricción es una restricción sobre lo que puede contener una columna. Las
características de una columna de la tabla, más las restricciones que se aplican a esa columna,
determinan el dominio de la columna.

En el ejemplo del concesionario de automóviles, puede restringir la base de datos para que
acepte solo esos cuatro valores (mencionados en la sección anterior) en elColor columna. Si
un operador de entrada de datos intenta introducir en elColorcolumna un valor de, por
ejemplo,bosque verde,el sistema se niega a aceptar la entrada. La entrada de datos no
puede continuar hasta que el operador ingrese un valor válido en elColorcampo.

Quizás se pregunte qué sucede cuando Curarri AutoWerks decide ofrecer una versión verde
bosque del GT 4000 como opción a mitad de año. La respuesta es (redoble de tambores, por
favor) seguridad laboral para los programadores de mantenimiento de bases de datos.
18 Parte I: Introducción a SQL

Este tipo de cosas sucede todo el tiempo y requiere actualizaciones de la estructura de la base
de datos. Sólo las personas que saben cómo modificar la estructura de la base de datos (como
usted) podrán evitar un problema importante.

El modelo de objetos desafió el

modelo relacional
El modelo relacional ha tenido un éxito fantástico en una amplia variedad de áreas de
aplicación. Sin embargo, no hace todo lo que cualquiera desearía. Las limitaciones se han
hecho más visibles por el aumento de la popularidad de los lenguajes de programación
orientados a objetos como C++, Java y C#. Estos lenguajes son capaces de manejar
problemas más complejos que los lenguajes tradicionales debido a sus características
avanzadas, como sistemas de tipos extensibles por el usuario, encapsulación, herencia,
enlace dinámico de métodos, objetos complejos y compuestos e identidad de objetos.

No voy a explicar toda esa jerga en este libro (aunque abordaré algunos de estos
términos más adelante). Baste decir que el modelo relacional clásico no encaja bien con
muchas de estas características. Como resultado, se han desarrollado sistemas de
gestión de bases de datos basados en el modelo de objetos. Sin embargo, la idea nunca
despegó. Aunque los lenguajes de programación orientados a objetos se han vuelto muy
populares, las bases de datos orientadas a objetos no.

Puntuación final: Bases de datos relacionales 1, bases de datos orientadas a objetos 0.

El modelo relacional de objetos

Los diseñadores de bases de datos, como todos los demás, buscan constantemente el mejor
de los mundos posibles. Reflexionaron: "¿No sería fantástico si pudiéramos tener las ventajas
de un sistema de base de datos orientado a objetos y aún conservar la compatibilidad con el
sistema relacional que conocemos y amamos?" Este tipo de pensamiento condujo al modelo
híbrido objeto-relacional. Los DBMS relacionales de objetos amplían el modelo relacional para
incluir soporte para el modelado de datos orientado a objetos. Se han agregado características
orientadas a objetos al estándar internacional SQL, lo que permite a los proveedores de DBMS
relacionales transformar sus productos en DBMS relacionales de objetos, manteniendo al
mismo tiempo la compatibilidad con el estándar. Así, mientras que el estándar SQL-92 describe
un modelo de base de datos puramente relacional, SQL:1999 describe un modelo de base de
datos relacional de objetos. SQL:2003 tiene más características orientadas a objetos y las
versiones posteriores del estándar SQL han ido aún más lejos en esa dirección.
 Capítulo 1: Fundamentos de bases de datos relacionales 19

En este libro, describo el estándar internacional ISO/IEC SQL. (Si tiene curiosidad, IEC significa
Comisión Electrotécnica Internacional, pero a nadie realmente le importa. ¿Cuántas personas
saben lo que significan las letras del acrónimo LASER?) El sistema descrito por el estándar ISO/
IEC SQL es principalmente un sistema relacional. modelo de base de datos. También incluyo las
extensiones orientadas a objetos del estándar que se introdujeron en SQL:1999 y las
extensiones adicionales incluidas en versiones posteriores. Las características orientadas a
objetos del nuevo estándar permiten a los desarrolladores aplicar bases de datos SQL a
problemas que son demasiado complejos para abordarlos con el paradigma más antiguo,
puramente relacional. Los proveedores de sistemas DBMS están incorporando en sus
productos las características orientadas a objetos del estándar ISO. Algunas de estas
características han estado presentes durante años, pero otras aún no se han incluido.

Consideraciones de diseño de bases de datos

Una base de datos es una representación de una estructura física o conceptual, como una
organización, un ensamblaje de automóviles o las estadísticas de desempeño de todos los
clubes de béisbol de las grandes ligas. La precisión de la representación depende del nivel de
detalle del diseño de la base de datos. La cantidad de esfuerzo que usted pone en el diseño de
la base de datos debe depender del tipo de información que desea obtener de la base de
datos. Demasiados detalles es una pérdida de esfuerzo, tiempo y espacio en el disco duro. Muy
pocos detalles pueden hacer que la base de datos pierda su valor.

Decida cuántos detalles necesita ahora y cuántos puede necesitar en el futuro, y luego
proporcione exactamente ese nivel de detalle en su diseño (ni más ni menos). Pero no se
sorprenda si eventualmente tiene que ajustar el diseño para satisfacer las necesidades
cambiantes del mundo real.

Los sistemas de gestión de bases de datos actuales, completos con atractivas interfaces
gráficas de usuario y herramientas de diseño intuitivas, pueden dar al aspirante a diseñador de
bases de datos una falsa sensación de seguridad. Estos sistemas hacen que el diseño de una
base de datos parezca comparable a crear una hoja de cálculo o realizar alguna otra tarea
relativamente sencilla. No hubo tanta suerte. El diseño de bases de datos es difícil. Si lo hace
incorrectamente, no sólo es probable que su base de datos sufra un rendimiento deficiente,
sino que también puede volverse gradualmente más corrupta a medida que pasa el tiempo. A
menudo, el problema no aparece hasta que se dedica un gran esfuerzo a la entrada de datos.
Cuando sabes que tienes un problema, ya es grave. En muchos casos, la única solución es
rediseñar completamente la base de datos y volver a ingresar todos los datos. La ventaja es
que cuando termine la segunda versión de la misma base de datos, se dará cuenta de cuánto
mejor comprende el diseño de bases de datos.
20 Parte I: Introducción a SQL
 Capitulo 2

Fundamentos de SQL

En este capítulo
▶ Entendiendo SQL
▶ Aclarando conceptos erróneos sobre SQL
▶ Echando un vistazo a los diferentes estándares SQL
▶ Familiarizarse con los comandos SQL estándar y las palabras reservadas
▶ Representar números, caracteres, fechas, horas y otros tipos de datos.
▶ Explorando valores nulos y restricciones
▶ Poner SQL a trabajar en un sistema cliente/servidor
▶ Considerando SQL en una red

S QL es un lenguaje flexible que puede utilizar de diversas formas. Es la

herramienta más utilizada para comunicarse con una base de datos relacional.
En este capítulo, explico qué es y qué no es SQL; específicamente, qué distingue a
SQL de otros tipos de lenguajes informáticos. Luego presento los comandos y tipos
de datos que admite SQL estándar y explico dos conceptos clave:valores nulosy
[Link], doy una descripción general de cómo SQL encaja en el
entorno cliente/servidor, así como en Internet y las intranets organizacionales.

Qué es y qué no es SQL

Lo primero que hay que entender acerca de SQL es que SQL no es unlenguaje procesal,al
igual que BASIC, C, C++, C# y Java. Para resolver un problema en uno de esos lenguajes
procedimentales, se escribe unprocedimiento—una secuencia de comandos que realiza
una operación específica tras otra hasta que se completa la tarea. El procedimiento
puede ser una secuencia lineal sencilla o puede volver sobre sí mismo, pero en cualquier
caso, el programador especifica el orden de ejecución.

SQL, por otro lado, esno [Link] resolver un problema usando SQL, simplemente
dígale a SQLquéquieres (como si estuvieras hablando con el genio de Aladdin) en lugar de
decirle al sistemacómo llegartu lo que quieras. La base de datos
22 Parte I: Introducción a SQL

El sistema de gestión (DBMS) decide la mejor manera de conseguirle lo que

solicita.

Está bien. Acabo de decirles que SQL no es un lenguaje de procedimientos, y eso es

esencialmente cierto. Sin embargo, millones de programadores (y usted probablemente
sea uno de ellos) están acostumbrados a resolver problemas de forma procesal.
Entonces, en los últimos años, ha habido mucha presión para agregar alguna
funcionalidad procedimental a SQL, y SQL ahora incorpora características de un
lenguaje procedimental:COMENZARbloques,SIdeclaraciones, funciones y (sí)
procedimientos. Con estas funciones agregadas, puede almacenar programas en el
servidor, donde varios clientes pueden usar sus programas repetidamente.

Para ilustrar lo que quiero decir con "dígale al sistema lo que quiere", suponga que
tiene una tabla EMPLEADO de la que desea recuperar las filas que corresponden a
todos sus altos cargos. Desea definir una persona mayor como cualquier persona
mayor de 40 años o cualquier persona que gane más de $100,000 por año. Puede
realizar la recuperación deseada utilizando la siguiente consulta:

SELECCIONE * DEL EMPLEADO DONDE Edad > 40 O Salario> 100000;

Esta declaración recupera todas las filas de la tabla EMPLEADO donde el valor en el
Edadcolumna es mayor que 40 o el valor en elSalariola columna es mayor que
100.000. En SQL, no es necesario especificar cómo se recupera la información. El
motor de la base de datos examina la base de datos y decide por sí mismo cómo
cumplir con su solicitud. Sólo necesita especificar qué datos desea recuperar.

AconsultaEs una pregunta que le haces a la base de datos. Si alguno de los datos de la base de
datos satisface las condiciones de su consulta, SQL recupera esos datos.

Las implementaciones actuales de SQL carecen de muchas de las construcciones de programación

básicas que son fundamentales para la mayoría de los demás lenguajes. Las aplicaciones del mundo
real generalmente requieren al menos algunas de estas construcciones de programación, razón por
la cual SQL es en realidad una base de [Link] con las extensiones que se
agregaron en 1999, 2003, 2005 y 2008, aún es necesario usar SQL en combinación con un lenguaje de
procedimientos (como C++) para crear una aplicación completa.

Puede extraer información de una base de datos de dos maneras:

✓ Hacer unaconsulta ad hocdesde su teclado simplemente escribiendo una

declaración SQL y leyendo los resultados en la [Link] consultas desde el teclado
son apropiadas cuando desea una respuesta rápida a una pregunta específica. Para
satisfacer una necesidad inmediata, es posible que necesite información que nunca
antes necesitó de una base de datos. Es probable que tampoco vuelvas a necesitar esa
información nunca más, pero la necesitas ahora. Ingrese la declaración de consulta SQL
apropiada desde el teclado y, a su debido tiempo, el resultado aparecerá en su pantalla.
 Capítulo 2: Fundamentos de SQL 23
✓ Ejecute un programa que recopile información de la base de datos y luego informe
sobre la información ya sea en pantalla o en un informe impreso. Incorporar una
consulta SQL directamente en un programa es una buena manera de ejecutar una
consulta compleja que probablemente volverá a ejecutar en el futuro. De esa manera,
puede formular una consulta solo una vez para usarla tantas veces como desee. El
Capítulo 16 explica cómo incorporar código SQL en programas escritos en otro lenguaje
de programación.

Una (muy) pequeña historia

SQL se originó en uno de los laboratorios de investigación de IBM, al igual que la teoría de
bases de datos relacionales. A principios de la década de 1970, cuando los investigadores de
IBM desarrollaron los primeros sistemas DBMS relacionales (o RDBMS), crearon un
sublenguaje de datos para operar en estos sistemas. Llamaron a la versión preliminar de este
sublenguajeCONTINUACIÓN(SestructuradomiinglesWHATryllengua). Sin embargo, cuando
llegó el momento de publicar formalmente su lenguaje de consulta como producto,
descubrieron que otra empresa ya había registrado el nombre del producto "Sequel". Por lo
tanto, los genios del marketing de IBM decidieron darle al producto lanzado un nombre
diferente de SEQUEL pero aún reconocible como miembro de la misma familia. Entonces lo
llamaron SQL (pronunciadoess-que-ell).

La sintaxis de SQL es una forma de inglés estructurado, de donde proviene su

nombre original. Sin embargo, SQL no es un sistema [Link] el
sentido en que los informáticos entienden ese término. Por lo tanto, a pesar de las
suposiciones de muchas personas, SQL no es un acrónimo de "lenguaje de consulta
estructurado". Es una secuencia de tres letras que no significan nada, al igual que el
nombre del lenguaje C no significa nada.

El trabajo de IBM con bases de datos relacionales y SQL era bien conocido en la industria
incluso antes de que IBM introdujera su producto de base de datos relacional SQL/DS (RDBMS)
en 1981. En ese momento, Relational Software, Inc. (ahora Oracle Corporation) ya había
lanzado su primer RDBMS. . Estos primeros productos inmediatamente establecieron el
estándar para una nueva clase de sistemas de gestión de bases de datos. Incorporaron SQL,
que se convirtió en el estándar de facto para los sublenguajes de datos. Los proveedores de
otros sistemas de gestión de bases de datos relacionales lanzaron sus propias versiones de
SQL. Normalmente, estas otras implementaciones contenían todas las funciones principales de
los productos IBM, ampliadas de manera que aprovechaban las fortalezas particulares de su
propio producto RDBMS. Como resultado, aunque casi todos los proveedores utilizaban algún
tipo de SQL, la compatibilidad entre plataformas era deficiente.

Unimplementaciónes un RDBMS particular que se ejecuta en una plataforma de hardware específica.

24 Parte I: Introducción a SQL

Pronto comenzó un movimiento para crear un estándar SQL universalmente reconocido al

que todos pudieran adherirse. En 1986, ANSI (el Instituto Nacional Estadounidense de
Estándares) publicó un estándar formal al que llamó[Link] actualizó ese estándar en
1989 paraSQL-89y nuevamente en 1992 paraSQL-92.A medida que los proveedores de
DBMS avanzan con los nuevos lanzamientos de sus productos, intentan acercar sus
implementaciones cada vez más a este estándar. Este esfuerzo ha acercado mucho más a la
realidad el objetivo de una verdadera portabilidad de SQL.

La versión completa más reciente del estándar SQL es SQL:2011 (ISO/IEC 9075-X:2011). En este
libro, describo SQL como SQL:2011 define el lenguaje. Cada implementación SQL específica
difiere del estándar hasta cierto punto. Debido a que el estándar SQL completo es integral, es
poco probable que las implementaciones disponibles actualmente lo admitan por completo. Sin
embargo, los proveedores de DBMS están trabajando para admitir un subconjunto central del
lenguaje SQL estándar. La norma ISO/IEC completa está disponible para su compra enhttp://
[Link],pero probablemente no quiera comprarlo a menos que tenga la intención de
crear su propio sistema de gestión de bases de datos estándar ISO/IEC SQL. El estándar es
altamentetécnico y prácticamente incomprensible para cualquiera que no sea un experto en
lenguajes informáticos.

Declaraciones SQL
El lenguaje de comandos SQL consta de un número limitado de declaraciones que
realizan tres funciones de manejo de datos: algunas definen datos, algunas manipulan
datos y otras controlan los datos. Cubro las declaraciones de definición de datos y
declaraciones de manipulación de datos en los Capítulos 4 al 12; Detallo las
declaraciones de control de datos en los Capítulos 13 y 14.

Para cumplir con SQL:2011, una implementación debe incluir un conjunto básico de
características principales. También puede incluir extensiones al conjunto principal (que
también describe la especificación SQL:2011). La Tabla 2-1 enumera las declaraciones SQL:2011
principales y extendidas. Es una gran lista. Si eres uno de esos programadores a los que les
encanta probar nuevas capacidades, alégrate.

Tabla 2-1 Declaraciones SQL:2011

AGREGAR DESASIGNAR LOCALIZADOR GRATUITO

PREPARAR

ASIGNAR CURSOR DECLARAR OBTENER DESCRIPTOR

ASIGNAR DECLARAR LOCAL OBTENER DIAGNÓSTICO

DESCRIPTOR MESA TEMPORAL
ALTERAR DOMINIO BORRAR OTORGAR PRIVILEGIO
ALTERAR LA RUTINA DESCRIBIR LA ENTRADA CONCEDER PAPEL
 Capítulo 2: Fundamentos de SQL 25

ALTERAR SECUENCIA DESCRIBIR LA SALIDA LOCALIZADOR DE ESPERAS

GENERADOR
ALTERAR TABLA DESCONECTAR INSERTAR

ALTERAR TRANSFORMAR GOTA UNIR

ALTERAR TIPO Afirmación de caída ABIERTO

LLAMAR ATRIBUTO DE GOTA PREPARAR

CERCA LANZAMIENTO DE GOTA LIBERAR

PUNTO DE GUARDADO

COMPROMETERSE SOLTAR CARÁCTER DEVOLVER

COLOCAR

CONECTAR COLABORACIÓN DE GOTA REVOCAR

CREAR COLUMNA DE GOTA RETROCEDER

CREAR ASERCIÓN RESTRICCIÓN DE CAÍDA PUNTO DE GUARDADO

CREAR REPARTO GOTA POR DEFECTO SELECCIONAR

CREAR PERSONAJE SOLTAR DOMINIO CONFIGURAR CATÁLOGO

COLOCAR

CREAR COLABORACIÓN MÉTODO DE GOTA ESTABLECER CONEXIÓN

CREAR DOMINIO PEDIDOS DE GOTA ESTABLECER RESTRICCIONES

CREAR FUNCIÓN SOLTAR PAPEL ESTABLECER DESCRIPTOR

CREAR MÉTODO RUTINA DE CAÍDA ESTABLECER NOMBRES

CREAR PEDIDO ESQUEMA DE CAÍDA ESTABLECER RUTA

CREAR PROCEDIMIENTO ALCANCE DE LA CAÍDA ESTABLECER ROL

CREAR PAPEL SECUENCIA DE CAÍDA ESTABLECER ESQUEMA

CREAR ESQUEMA MESA PLEGABLE FIJAR SESIÓN

AUTORIZACIÓN
CREAR SECUENCIA TRANSFORMACIÓN DE GOTA FIJAR SESIÓN
CARACTERÍSTICAS
CREAR MESA TRADUCCIÓN DE GOTA FIJAR SESIÓN
COLACIÓN
CREAR TRANSFORMAR GATILLO DE GOTA ESTABLECER ZONA HORARIA

CREAR TIPO DE GOTA ESTABLECER TRANSACCIÓN

TRADUCCIÓN
CREAR DISPARADOR VISTA CAÍDA ESTABLECER TRANSFORMAR

GRUPO
CREAR TIPO EJECUTAR INMEDIATAMENTE INICIAR TRANSACCIÓN
CREAR VISTA BUSCAR ACTUALIZAR

DESASIGNAR
DESCRIPTOR
26 Parte I: Introducción a SQL

Palabras reservadas
Además de las declaraciones, hay otras palabras que tienen un significado especial
dentro de SQL. Estas palabras, junto con las declaraciones, están reservadas para usos
específicos, por lo que no puede utilizarlas como nombres de variables ni de ninguna
otra forma que difiera de su uso previsto. Puede ver fácilmente por qué a las tablas,
columnas y variables no se les deben dar nombres que aparecen en la lista de palabras
reservadas. Imagínense la confusión que causaría una afirmación como la siguiente:

SELECCIONAR SELECCIONAR DE SELECCIONAR DONDE SELECCIONAR = DONDE;

'Nuff dijo. En el Apéndice A aparece una lista completa de palabras reservadas de SQL.

Tipos de datos
Dependiendo de sus historiales, diferentes implementaciones de SQL admiten una
variedad de tipos de datos. La especificación SQL reconoce siete tipos generales
predefinidos:

✓ Numéricos

✓ Binario
✓ Instrumentos de cuerda

✓ booleanos

✓ Fechas y horas

✓ Intervalos

✓ XML

Dentro de cada uno de estos tipos generales puede haber varios subtipos (números exactos,
números aproximados, cadenas de caracteres, cadenas de bits, cadenas de objetos grandes).
Además de los tipos integrados predefinidos, SQL admite tipos de colección, tipos
construidos y tipos definidos por el usuario, todo lo cual analizaré más adelante en este
capítulo.

Si utiliza una implementación de SQL que admita tipos de datos que no se describen en
la especificación SQL, puede mantener su base de datos más portátil evitando estos tipos
de datos no descritos. Antes de decidir crear y utilizar un tipo de datos definido por el
usuario, asegúrese de que cualquier DBMS al que desee migrar en el futuro también
admita tipos definidos por el usuario.
 Capítulo 2: Fundamentos de SQL 27

numeros exactos
Como probablemente puedas adivinar por el nombre, elnumérico exactoLos tipos de datos le
permiten expresar exactamente el valor de un número. Cinco tipos de datos entran en esta
categoría:

✓ ENTERO
✓ PEQUEÑO
✓ EMPEZANDO

✓ NUMÉRICO

✓ DECIMAL

tipo de datos entero

datos de laENTEROEl tipo no tiene parte fraccionaria y su precisión depende de la
implementación SQL específica. Como desarrollador de la base de datos, no puede
especificar la precisión.

Elprecisiónde un número es el número máximo de dígitos significativos que puede

tener el número.

tipo de datos SMALLINT

ElPEQUEÑOEl tipo de datos también es para números enteros, pero la precisión de un
PEQUEÑO en una implementación específica no puede ser mayor que la precisión de un
ENTEROsobre la misma implementación. En muchas implementaciones,PEQUEÑO y
ENTEROson lo mismo.

Si está definiendo una columna de tabla de base de datos para contener datos enteros
y sabe que el rango de valores en la columna no excederá la precisión de PEQUEÑO
datos sobre su implementación, asigne a la columna elPEQUEÑO tipo en lugar del
ENTEROtipo. Esta asignación puede permitir que su DBMS conserve espacio de
almacenamiento.

tipo de datos GRANDE

ElEMPEZANDOEl tipo de datos se define como un tipo cuya precisión es al menos tan grande
como la delENTEROtipo (puede ser mayor). La precisión exacta de un EMPEZANDOEl tipo de
datos depende de la implementación de SQL utilizada.

tipo de datos NUMÉRICOS

NUMÉRICOLos datos pueden tener un componente fraccionario además de su
componente entero. Puede especificar tanto la precisión como la escala deNUMÉRICO
datos. (Recuerde que la precisión es el número máximo de dígitos significativos posible).
28 Parte I: Introducción a SQL

Elescalade un número es el número de dígitos en su parte fraccionaria. La escala de un

número no puede ser negativa ni mayor que la precisión de ese número.

Si especifica elNUMÉRICOtipo de datos, su implementación de SQL le brinda exactamente

la precisión y escala que solicita. Puedes especificarNUMÉRICO y obtener una precisión y
escala predeterminadas, oNUMÉRICO (pag)y obtener la precisión especificada y la escala
predeterminada, oNUMÉRICO (pag,s)y obtenga tanto la precisión especificada como la
escala especificada. Los parametrospagysson marcadores de posición que serían
reemplazados por valores reales en una declaración de datos.

Digamos, por ejemplo, que elNUMÉRICOLa precisión predeterminada del tipo de datos para su
implementación de SQL es 12 y la escala predeterminada es 6. Si especifica que una columna
de base de datos tenga unNUMÉRICOtipo de datos, la columna puede contener números hasta
999.999,999999. Si, por el contrario, especifica un tipo de datos deNUMÉRICO (10)para una
columna, esa columna solo puede contener números con un valor máximo de 9.999,999999. El
parámetro (10)especifica el número máximo de dígitos posibles en el número. Si especifica un
tipo de datos deNUMÉRICO (10,2) para una columna, esa columna puede contener números
con un valor máximo de 99.999.999,99. En este caso, es posible que aún tengas diez dígitos en
total, pero solo dos de esos dígitos pueden estar a la derecha del punto decimal.

NUMÉRICOLos datos se utilizan para valores como 595,72. Ese valor tiene una precisión
de 5 (el número total de dígitos) y una escala de 2 (el número de dígitos a la derecha del
punto decimal). Un tipo de datos deNUMÉRICO (5,2)es apropiado para tales números.

tipo de datos decimales

ElDECIMALEl tipo de datos es similar aNUMÉ[Link] tipo de datos puede tener un
componente fraccionario y puede especificar su precisión y escala. La diferencia es que
su implementación puede especificar una precisión mayor que la que usted especifica; de
ser así, la implementación utiliza la mayor precisión. Si no especifica precisión o escala, la
implementación utiliza valores predeterminados, como lo hace con elNUMÉRICOtipo.

Un elemento que usted especifica comoNUMÉRICO (5,2)nunca puede contener un número

con un valor absoluto mayor que 999,99. Un elemento que usted especifica como DECIMALES
(5,2)siempre puede contener valoreshasta999,99, pero si su implementación de SQL permite
valores mayores, entonces el DBMS no rechazará valores mayores que 999,99.

Utilizar elNUMÉRICOoDECIMALescriba si sus datos tienen posiciones fraccionarias y

utilice elENTERO, PEQUEÑO,oEMPEZANDOescriba si sus datos siempre constan de
números enteros. Utilizar elNUMÉRICOtipo en lugar delDECIMALescriba si desea
maximizar la portabilidad, porque un valor que usted define comoNUMÉRICO (5,2),por
ejemplo, tiene el mismo rango de valores en todos los sistemas.
 Capítulo 2: Fundamentos de SQL 29

Números aproximados
Algunas cantidades tienen un rango tan grande de valores posibles (muchos órdenes de
magnitud) que una computadora con un tamaño de registro determinado no puede
representar todos los valores exactamente. (Ejemplos detamaños de registroson 32 bits, 64
bits y 128 bits). Por lo general, en tales casos, la exactitud no es necesaria y una aproximación
cercana es aceptable. SQL define tres aproximadosNUMÉRICOtipos de datos para manejar
este tipo de datos:REAL, DOBLE PRECISIÓN,yFLOTAR (como se detalla en las siguientes tres
subsecciones).

tipo de datos REALES

ElREALEl tipo de datos proporciona un número de punto flotante de precisión
simple, cuya precisión depende de la implementación de SQL. En general, el
hardware que utiliza determina la precisión. Una máquina de 64 bits, por ejemplo,
ofrece más precisión que una máquina de 32 bits.

Anúmero de coma flotantees un número que contiene un punto decimal. El punto

decimal puede "flotar" a diferentes ubicaciones del número, dependiendo del valor del
número. Los ejemplos incluyen 3.1, 3.14 y 3.14159 (y sí, los tres pueden usarse como
valores para π), cada uno con una precisión diferente.

Tipo de datos de DOBLE PRECISIÓN

ElPRECISIÓN DOBLEEl tipo de datos le proporciona un número de punto flotante de doble
precisión, cuya precisión nuevamente depende de la implementación. Sorprendentemente, el
significado de la palabraDOBLETambién depende de la implementación. La aritmética de doble
precisión es empleada principalmente por usuarios científicos. Las diferentes disciplinas
científicas tienen diferentes necesidades en el ámbito de la precisión. Algunas
implementaciones de SQL atienden a una categoría de usuarios y otras implementaciones
atienden a otras categorías de usuarios.

En algunos sistemas, elPRECISIÓN DOBLEtipo tiene exactamente el doble de capacidad que el

REALtipo de datos tanto para mantisa como para exponente. (En caso de que hayas olvidado lo
que aprendiste en la escuela secundaria, puedes representar cualquier número como un
mantisamultiplicado por diez elevado a la potencia dada por un exponente. Puedes escribir
6.626, por ejemplo, como 6.626E3. El número 6.626 es la mantisa, que se multiplica por diez
elevado a la tercera potencia; en ese caso,3es el exponente.)

No obtienes ningún beneficio al representar números que están bastante cerca de 1

(como 6.626 o incluso 6.626.000) con un valor [Link]ÉRICOtipo de datos. Los
tipos numéricos exactos funcionan igual de bien y, después de todo, son exactos. Sin
embargo, para números que están muy cerca de 0 o mucho mayores que 1, como
6.626E-34 (un número muy pequeño), debe utilizar un valor [Link]ÉRICOtipo.
Exacto NUMÉRICOlos tipos de datos no pueden contener tales números. En otros
sistemas, el PRECISIÓN DOBLEEl tipo te da algo más del doble de mantisa.
30 Parte I: Introducción a SQL

capacidad, y algo menos del doble de la capacidad exponencial que el REALtipo.

En otro tipo de sistema más, elPRECISIÓN DOBLEtipo da el doble de capacidad
de mantisa pero la misma capacidad de exponente que el REALtipo. En este
caso, la precisión se duplica, pero el alcance no.

La especificación SQL no intenta dictar, arbitrar o establecer por decreto qué

PRECISIÓN DOBLEmedio. La especificación sólo requiere que la precisióndea
PRECISIÓN DOBLEEl número debe ser mayor que la precisió[Link] número.
Aunque esta restricción es bastante débil, probablemente sea la mejor posible,
dadas las grandes diferencias que encontramos en el hardware.

tipo de datos FLOTANTE

ElFLOTAREl tipo de datos es más útil si cree que algún día podrá migrar su base de
datos a una plataforma de hardware con tamaños de registro diferentes a los
disponibles en su plataforma actual. Al utilizar elFLOTARtipo de datos, puede
especificar una precisión, por ejemplo,FLOTADOR (5).Si su hardware admite la
precisión especificada con su circuito de precisión simple, entonces su sistema
actual utiliza aritmética de precisión simple. Si, después de migrar su base de datos,
la precisión especificada requiere aritmética de doble precisión, entonces el sistema
usosaritmética de doble precisión.

UsandoFLOTARen vez deREALoPRECISIÓN DOBLEfacilita el traslado de sus bases

de datos a otro hardware. Eso es porque elFLOTAREl tipo de datos le permite
especificar la precisión y permite que el hardware se preocupe por utilizar
aritmética de precisión simple o doble. (Recuerde, la precisión deREAL yPRECISIÓN
DOBLELos números dependen del hardware.)

Si no está seguro de utilizar exactamenteNUMÉRICOtipos de datos (es decir, NUMÉRICO

yDECIMAL)o el aproximadoNUMÉRICOtipos de datos (es decir, FLOTARyREAL),usa el
exactoNUMÉRICOtipos. Los tipos de datos exactos exigen menos recursos del sistema y,
por supuesto, dan resultados exactos (en lugar de aproximados). Si el rango de valores
posibles de sus datos es lo suficientemente grande como para requerir el uso de tipos
de datos aproximados, probablemente pueda determinar este hecho de antemano.

Cadenas de caracteres
Las bases de datos almacenan muchos tipos de datos, incluidas imágenes gráficas, sonidos y
animaciones. Espero que los olores vengan después. ¿Te imaginas una imagen tridimensional en
color de 1920 x 1080 y 24 bits de una porción grande de pizza de pepperoni en tu pantalla, mientras
una muestra de olor tomada en DiFilippi's Pizza Grotto se reproduce a través de tu tarjeta súper
multimedia? Una configuración de este tipo puede resultar frustrante, al menos hasta que pueda
permitirse el lujo de agregar también datos de sabor a su sistema. Lamentablemente, puede esperar
mucho tiempo antes de que el olor y el sabor se conviertan en tipos de datos SQL estándar. Hoy en
día, los tipos de datos que se utilizan con más frecuencia (después de laNUMÉRICOLos tipos, por
supuesto, son tipos de cadenas de caracteres.
 Capítulo 2: Fundamentos de SQL 31
Tienes tres tipos principales dePERSONAJEdatos:

✓ Datos de caracteres fijos (PERSONAJEoCARBONIZARSE)

✓ Datos de caracteres variables (CARÁCTER VARIABLEoVARCHAR)

✓ Carácter de datos de objetos grandes (PERSONAJE OBJETO GRANDEoCLOB)

También tienes tres variantes de este tipo de datos de personajes:

✓ CARACTER NACIONAL
✓ CARÁCTER NACIONAL VARIABLE
✓ GRAN OBJETO DE CARÁCTER NACIONAL

Los detalles están por llegar.

tipo de datos CARACTER

Si define el tipo de datos de una columna comoPERSONAJEoCARBONIZARSE,puede especificar
el número de caracteres que contiene la columna utilizando la sintaxisCARACTERÍSTICA (X),
dóndeXes el número de caracteres. Si especifica el tipo de datos de una columna como
CARACTERÍSTICA (16),por ejemplo, la longitud máxima de cualquier dato que pueda ingresar en
la columna es de 16 caracteres. Si no especifica un argumento (es decir, no proporciona un
valor en lugar delX, SQL asume una longitud de campo de un carácter. Si ingresa datos en un
PERSONAJEcampo de una longitud especificada e ingresa menos caracteres que el número
especificado, SQL llena los espacios de caracteres restantes con espacios en blanco.

CARÁCTER VARIADO tipo de datos

ElCARÁCTER VARIABLEEl tipo de datos es útil si las entradas de una columna pueden variar en
longitud pero no desea que SQL rellene el campo con espacios en blanco. Este tipo de datos le
permite almacenar exactamente la cantidad de caracteres que ingresa el usuario. No existe
ningún valor predeterminado para este tipo de datos. Para especificar este tipo de datos,
utilice el formularioCARACTER VARIABLE (X)oVARCHAR (X), dóndeXes el número máximo de
caracteres permitidos.

Tipo de datos CARACTER OBJETO GRANDE

ElPERSONAJE OBJETO GRANDE (CLOB)El tipo de datos se introdujo con SQL:1999. Como su nombre lo
indica, se utiliza con cadenas de caracteres enormes que son demasiado grandes para elPERSONAJE
[Link] s se comportan de forma muy parecida a las cadenas de caracteres normales, pero
existen una serie de restricciones sobre lo que se puede hacer con ellos.

Por un lado, unCLOBno se puede utilizar en unCLAVE PRIMARIA, CLAVE EXTRANJERA,o

ÚNICOpredicado. Además, no se puede utilizar en una comparación distinta a la de
igualdad o desigualdad. Debido a su gran tamaño, las aplicaciones generalmente no se
transfierenCLOBs hacia o desde una base de datos. En cambio, un especial
32 Parte I: Introducción a SQL

tipo de datos del lado del cliente llamadolocalizador de CLOBse utiliza para manipular elCLOB
datos. Es un parámetro cuyo valor identifica un objeto de cadena de caracteres grande.

Apredicadoes una afirmación que puede ser lógicamente Verdadera o lógicamente Falsa.

Tipos de datos CARÁCTER NACIONAL, CARÁCTER NACIONAL

VARIABLE y OBJETO GRANDE DE CARÁCTER NACIONAL
Varios idiomas tienen algunos caracteres que difieren de los caracteres de otro idioma.
Por ejemplo, el alemán tiene algunos caracteres especiales que no están presentes en el
conjunto de caracteres del idioma inglés. Algunos idiomas, como el ruso, tienen un
conjunto de caracteres muy diferente al del inglés. Por ejemplo, si especifica el juego de
caracteres inglés como predeterminado para su sistema, puede utilizar juegos de
caracteres alternativos porque elCARÁCTER NACIONAL, CARÁCTER NACIONAL VARIABLE,y
GRAN OBJETO DE CARÁCTER NACIONALLos tipos de datos funcionan igual que el
CARÁCTER, CARÁCTER VARIABLE,yPERSONAJE OBJETO GRANDEtipos de datos: la única
diferencia es que el juego de caracteres que está especificando es diferente del juego de
caracteres predeterminado.

Puede especificar el juego de caracteres al definir una columna de la tabla. Si lo desea, cada
columna puede utilizar un juego de caracteres diferente. El siguiente ejemplo de una declaración
de creación de tabla utiliza varios conjuntos de caracteres:

CREAR TABLA XLATE (

IDIOMA_1 CARÁCTER (40),
IDIOMA_2 CARACTERES VARIABLES (40) CONJUNTO DE CARACTERES
GRIEGO, IDIOMA_3 CARACTER NACIONAL (40),
IDIOMA_4 CARACTERES (40) CONJUNTO DE CARACTERES KANJI
);

Aquí elIDIOMA_1La columna contiene caracteres en el juego de caracteres predeterminado de

la implementación. ElIDIOMA_3La columna contiene caracteres en el juego de caracteres
nacional de la implementación. ElIDIOMA_2La columna contiene caracteres griegos. Y el
IDIOMA_4La columna contiene caracteres Kanji. Después de una larga ausencia, los conjuntos
de caracteres asiáticos, como Kanji, ahora están disponibles en muchos productos DBMS.

cadenas binarias
ElBINARIOLos tipos de datos de cadena se introdujeron en SQL:2008. Teniendo en cuenta que
los datos binarios han sido fundamentales para las computadoras digitales desde la
computadora Atanasoff-Berry de la década de 1930, este reconocimiento de la importancia de
los datos binarios parece un poco tarde en llegar a SQL. (Supongo que más vale tarde que
nunca). Hay tres tipos binarios diferentes,BINARIO, BINARIO VARIABLE,y OBJETO BINARIO
GRANDE.
 Capítulo 2: Fundamentos de SQL 33

tipo de datos BINARIO

Si define el tipo de datos de una columna comoBINARIO,puede especificar el número de
bytes (octetos) que contiene la columna utilizando la sintaxis BINARIA (X), dóndeXes el
número de bytes. Si especifica el tipo de datos de una columna como BINARIO (16),por
ejemplo, la cadena binaria debe tener 16 bytes de longitud. BINARIOLos datos deben
introducirse como bytes, empezando por el byte uno.

Tipo de datos VARIABLE BINARIO

Utilizar elVARIACIÓN BINARIAoVARBINARIOescriba cuando la longitud de una cadena
binaria es una variable. Para especificar este tipo de datos, utilice el formulario
VARIACIÓN BINARIA (X)oVARBINARIO (X), dóndeXes el número máximo de bytes
permitidos. El tamaño mínimo de la cadena es cero y el tamaño máximo esX.

Tipo de datos BINARIO OBJETO GRANDE

ElOBJETO BINARIO GRANDE (BLOB)El tipo de datos se utiliza con cadenas binarias enormes que son
demasiado grandes para elBINARIOtipo. Las imágenes gráficas y los archivos de música son ejemplos de
cadenas binarias [Link] s se comportan de manera muy similar a las cadenas binarias
ordinarias, pero SQL impone una serie de restricciones sobre lo que se puede hacer con ellos.

Por un lado, no puedes usar unGOTAen unCLAVE PRIMARIA, CLAVE EXTRANJERA,o ÚNICO
predicado. Además, noGOTASe permiten s en comparaciones distintas de las de igualdad o
[Link] archivos son grandes, por lo que las aplicaciones generalmente no
transfieren datos [Link] hacia o desde una base de datos. En su lugar, utilizan un tipo
de datos especial del lado del cliente llamadolocalizador de BLOBpara manipular elGOTA
datos. El localizador es un parámetro cuyo valor identifica un objeto binario grande.

booleanos
ElBOOLEANOEl tipo de datos consta de los distintos valores de [Link], así
[Link] se compara un valor booleano Verdadero o Falso con un NULOo Valor
de verdad desconocido, el resultado tendrá el valor Desconocido.

Fechas y horas
El estándar SQL define cinco tipos de datos que tratan con fechas y horas; ellos se llamantipos de
datos de fecha y hora,o simplementefechas y [Link] una superposición considerable entre
estos tipos de datos, por lo que es posible que algunas implementaciones que encuentre no admitan
los cinco.
34 Parte I: Introducción a SQL

Las implementaciones que no admiten completamente los cinco tipos de datos para
fechas y horas pueden tener problemas con las bases de datos que intenta migrar desde
otra implementación. Si tiene problemas con una migración, verifique las
implementaciones de origen y destino para ver cómo representan las fechas y horas.

tipo de datos FECHA

ElFECHAtipo almacena los valores de año, mes y día de una fecha, en ese orden. El valor
del año tiene cuatro dígitos y los valores del mes y del día tienen dos dígitos. AFECHAEl
valor puede representar cualquier fecha desde el año 0001 hasta el año 9999. La longitud
de unFECHAes diez posiciones, como en 1957-08-14.

TIEMPO SIN ZONA HORARIA tipo de datos

ElTIEMPO SIN ZONA HORARIAEl tipo de datos almacena valores de hora, minutos y segundos.
Las horas y los minutos ocupan dos dígitos. El valor de los segundos puede tener solo dos
dígitos, pero también puede ampliarse para incluir una parte fraccionaria opcional. Por lo
tanto, este tipo de datos puede representar una hora como (por ejemplo) 32 minutos y 58,436
segundos después de las 9:00 a. m. como [Link],436.

La precisión de la parte fraccionaria depende de la implementación, pero tiene al menos

seis dígitos. ATIEMPO SIN ZONA HORARIAel valor ocupa ocho posiciones (incluidos los
dos puntos) cuando el valor no tiene parte fraccionaria, o nueve posiciones (incluido el
punto decimal) más el número de dígitos fraccionarios cuando el valor sí incluye una
parte fraccionaria. Tu específicasTIEMPO SIN ZONA HORARIAescriba datos ya sea como
TIEMPO,lo que le da el valor predeterminado de no tener dígitos fraccionarios, o como
HORA SIN ZONA HORARIA (pag), dóndepages el número de posiciones de dígitos a la
derecha del decimal. El ejemplo del párrafo anterior representa un tipo de datos deHORA
SIN HUSO HORARIO (3).

MARCA DE TIEMPO SIN ZONA HORARIA tipo de datos

MARCA DE TIEMPO SIN ZONA HORARIALos datos incluyen información de fecha y
hora. Las longitudes y las restricciones sobre los valores de los componentes deMARCA
DE TIEMPO SIN ZONA HORARIAlos datos son los mismos que para FECHAyTIEMPO SIN
ZONA HORARIAdatos, excepto por una diferencia: la duración predeterminada de la
parte fraccionaria del componente de tiempo de unMARCA DE TIEMPO SIN ZONA
HORARIAes de seis dígitos en lugar de cero.

Si el valor no tiene dígitos fraccionarios, la longitud de unMARCA DE TIEMPO SIN ZONA

HORARIAtiene 19 posiciones: diez posiciones de fecha, un espacio como separador y ocho
posiciones de hora, en ese orden. Si hay dígitos fraccionarios (seis dígitos es el valor
predeterminado), la longitud es de 20 posiciones más el número de dígitos fraccionarios. La
posición 20 es para el punto decimal. Usted especifica un campo comoMARCA DE TIEMPO
SIN ZONA HORARIAescriba usando cualquiera de los dosMARCA DE TIEMPO SIN ZONA
HORARIAoMARCA DE TIEMPO SIN ZONA HORARIA (pag), dóndepag es el número de
posiciones de dígitos fraccionarios. El valor depagno puede ser negativo y la implementación
determina su valor máximo.
 Capítulo 2: Fundamentos de SQL 35

TIEMPO CON ZONA HORARIA tipo de datos

ElHORA CON ZONA HORARIAEl tipo de datos es el mismo que elTIEMPO SIN ZONA
HORARIAtipo de datos, excepto este tipo, agrega información sobre el desplazamiento
desdetiempo Universal(UTC, sucesor de la hora media de Greenwich o GMT). El valor del
desplazamiento puede oscilar entre –12:59 y +13:00. Esta información adicional ocupa
seis posiciones de dígitos más después de la hora: un guión como separador, un signo
más o menos y luego el desplazamiento en horas (dos dígitos) y minutos (dos dígitos) con
dos puntos entre las horas y los minutos. . AHORA CON ZONA HORARIAEl valor sin parte
fraccionaria (el valor predeterminado) tiene una longitud de 14 posiciones. Si especifica
una parte fraccionaria, la longitud del campo es de 15 posiciones más el número de
dígitos fraccionarios.

MARCA DE TIEMPO CON ZONA HORARIA tipo de datos

ElMARCA DE TIEMPO CON ZONA HORARIAEl tipo de datos funciona igual que el MARCA DE TIEMPO
SIN ZONA HORARIAtipo de datos, excepto que este tipo de datos también agrega información
sobre la diferencia con respecto a la hora universal. La información adicional ocupa seis posiciones
de dígitos más después de la marca de tiempo. (Consulte la sección anterior para conocer el
formato de la información de zona horaria). La inclusión de datos de zona horaria configura 25
posiciones para un campo sin parte fraccionaria y 26 posiciones (más el número de dígitos
fraccionarios) para campos que sí incluyen una parte fraccionaria. parte. (Seis es el número
predeterminado de dígitos fraccionarios).

Intervalos
ElintervaloLos tipos de datos se relacionan estrechamente con los tipos de datos de fecha y
hora. Un intervalo es la diferencia entre dos valores de fecha y hora. En muchas aplicaciones
que tratan con fechas, horas o ambas, a veces es necesario determinar el intervalo entre dos
fechas o dos horas.

SQL reconoce dos tipos distintos de intervalos: elaño mesintervalo y eltiempo de

díaintervalo. Un intervalo de año-mes es el número de años y meses entre dos
fechas. Un intervalo diurno es el número de días, horas, minutos y segundos entre
dos instantes dentro de un mes. No se pueden mezclar cálculos que involucran un
intervalo de año-mes con cálculos que involucran un intervalo de día, porque los
meses tienen diferentes duraciones (28, 29, 30 o 31 días).

tipo XML
XML es un acrónimo de eXtensible Markup Language, que define un conjunto de reglas
para agregar marcado a los datos. El marcado estructura los datos de una manera que
transmite lo que significan. XML permite compartir datos entre plataformas muy
diferentes.
36 Parte I: Introducción a SQL

ElXMLEl tipo de datos tiene una estructura de árbol, por lo que un nodo raíz puede tener
nodos secundarios, los cuales, a su vez, pueden tener sus propios hijos. Introducido por
primera vez en SQL:2003, elXMLEl tipo se desarrolló en SQL/XML:2005 y se amplió aún
más en SQL:2008. La edición de 2005 definió cinco subtipos parametrizados, conservando
el original [Link]. Los valores XML pueden existir como instancias de dos o
incluso más tipos, porque algunos de los subtipos son subtipos de otros subtipos. (Tal vez
debería llamarlos subsubtipos, o incluso subsubtipos. Afortunadamente, SQL:2008
definió una forma estándar de referirse a los subtipos).

Los principales modificadores de laXMLtipo sonSECUENCIA, CONTENIDO,y

[Link] modificadores secundarios sonSIN TIPO, CUALQUIER,yESQUEMA
XML. La Figura 2-1 muestra la estructura en forma de árbol que ilustra las relaciones
jerárquicas entre los subtipos.

Figura 2-1:
La rela-
relaciones
del XML
subtipos.

La siguiente lista es un resumen de los tipos XML con los que debería estar
familiarizado. No te asustes si te parece griego (o peor aún, lineal A). Doy una
explicación más detallada de estos tipos en el Capítulo 18. He organizado la lista
para comenzar con los tipos más básicos y terminar con los más complicados:

✓ XML (SECUENCIA):Cada valor en XML es un SQLNULOvalor o una secuencia

XQuery. De esa manera, cada valor XML es una instancia del XML(SECUENCIA)
[Link] un lenguaje de consulta diseñado específicamente para extraer
información de datos XML. Este es el tipo XML más básico.
XML(SECUENCIA)es el menos restrictivo de los tipos XML. Puede aceptar
valores que no sean valores XML bien formados. Los otros tipos XML,
por otro lado, no son tan indulgentes.
✓ XML(CONTENIDO(CUALQUIER)):Este es un tipo ligeramente más
restrictivo que XML(SECUENCIA).Cada valor XML que sea unNULOvalor o
 Capítulo 2: Fundamentos de SQL 37
un nodo de documento XQuery (o un hijo de ese nodo de documento) es una instancia
de este tipo. Cada instancia deXML(CONTENIDO(CUALQUIER))es también un ejemplo de
XML(SECUENCIA).valores XML de laXML(CONTENIDO(CUALQUIER)) El tipo tampoco está
necesariamente bien formado. Dichos valores pueden ser resultados intermedios en
una consulta que luego se reducen a valores bien formados.

✓ XML(CONTENIDO(SIN TIPO)):Esto es más restrictivo queXML (CUALQUIER

CONTENIDO),y por lo tanto cualquier valor de laXML(CONTENIDO(SIN TIPO)) El
tipo es también una instancia de laXML(CONTENIDO(CUALQUIER))tipo y el
XML(SECUENCIA)tipo. Cada valor XML que sea un valor nulo o un valor de tipo no
nuloXML(CONTENIDO(CUALQUIER))es un nodo de documento XQueryD, de
modo que lo siguiente sea cierto para cada nodo de elemento XQuery contenido
en el árbol XQuerytenraizada enD:

• La propiedad de nombre de tipo esxdt: sin escribir.

• Elnulola propiedad esFALSO.

• Para cada nodo de atributo XQuery contenido ent, la propiedad tipo
esxdt:untypedAtomic.
• Para cada nodo de atributo XQuery contenido ent, la propiedad de tipo es un
valor de nombre-tipoXML(CONTENIDO(SIN TIPO)).

✓ XML(CONTENIDO(XMLSCHEMA)):Este es un segundo subtipo de

XML(CONTENIDO(CUALQUIER))ademásXML(CONTENIDO(SIN TIPO)).Como tal,
también es un subtipo deXML(SECUENCIA).Cada valor XML que sea un valor nulo o
un valor de tipo no nuloXML(CONTENIDO(CUALQUIER))y también es un nodo de
documento XQueryDde modo que cada nodo de elemento XQuery contenido en el
árbol XQuerytenraizada enD

• Es válido según el esquema XML.S,o

• Es válido según un espacio de nombres XMLnorteen un esquema XMLS,o

• Es válido según un componente de esquema de declaración de elemento

[Link] un esquema XMLS,o

• Es un valor de tipoXML(CONTENIDO(XMLSCHEMA)),cuyo descriptor de tipo

incluye el descriptor de esquema XML registrado deS, y sinortese especifica,
el URI del espacio de nombres XML denorte,o simise especifica, el URI del
espacio de nombres XML demiy el NCName XML demi.

✓ XML(DOCUMENTO(CUALQUIER)):Este es otro subtipo de

XML(CONTENIDO(CUALQUIER))tipo con la restricción adicional de que las instancias de
XML(DOCUMENTO(CUALQUIER))son nodos de documento que tienen exactamente un
nodo de elemento XQuery, cero o más nodos de comentarios de XQuery y cero o más
nodos de instrucciones de procesamiento de XQuery.

✓ XML(DOCUMENTO(SIN TIPO)):Cada valor que es elNULO valor o un

valor no nulo de tipoXML(CONTENIDO(SIN TIPO)) que es un nodo de
documento XQuery cuyoniñosLa propiedad tiene exactamente un
nodo de elemento XQuery, cero o más XQuery.
38 Parte I: Introducción a SQL

nodos de comentarios y cero o más nodos de instrucciones de procesamiento de

XQuery son un valor de tipoXML(DOCUMENTO(SIN TIPO)). todas las instancias de
XML(DOCUMENTO(SIN TIPO))también son casos deXML(CONTENIDO(SIN TIPO)).
Además, todos los casos deXML(DOCUMENTO(SIN TIPO))también son casos de
XML(DOCUMENTO(CUALQUIER)). XML(DOCUMENTO(SIN TIPO))es el más restrictivo
de los subtipos y comparte las restricciones de todos los demás subtipos. Cualquier
documento que califique comoXML(DOCUMENTO(SIN TIPO))También es una
instancia de todos los demás subtipos XML.

tipos de fila
ElFILAEl tipo de datos se introdujo con SQL:1999. No es tan fácil de entender y,
como programador SQL principiante o intermedio, es posible que nunca lo utilices.
Después de todo, la gente se las arregló sin problemas entre 1986 y 1999.

Una cosa destacable sobre elFILAtipo de datos es que viola las reglas de normalización que E. F.
Codd declaró en los primeros días de la teoría de bases de datos relacionales. (Hablo más
sobre esas reglas en el Capítulo 5.) Una de las características definitorias de la primera forma
normal es que un campo en una fila de la tabla no puede tener múltiples valores. Un campo
puede contener uno y sólo un valor. sin embargo, elFILAEl tipo de datos le permite declarar
que una fila completa de datos estará contenida dentro de un solo campo en una sola fila de
una tabla; en otras palabras, una fila anidada dentro de una fila.

Elformas normales,articuladas por primera vez por el Dr. Codd, son características definitorias
de las bases de datos relacionales. Inclusión de laFILAtype en el estándar SQL fue el primer
intento de ampliar SQL más allá del modelo relacional puro.

Considere la siguiente declaración SQL, que define unaFILAescriba la información de la

dirección de una persona:

CREAR TIPO DE FILA addr_typ (

Calle CARÁCTER VARIADO (25),
Ciudad CARÁCTER VARIADO (20),
Estado PERSONAJE (2),
Código Postal CARÁCTER VARIABLE (9)
);

Una vez definido, el nuevoFILAEl tipo se puede utilizar en una definición de tabla:

CREAR TABLA CLIENTE (

ID de cliente ENTERO CLAVE PRIMARIA,
Apellido CARÁCTER VARIABLE (25),
Nombre de pila CARÁCTER VARIADO (20),
DIRECCIÓN addr_typ,
Teléfono CARÁCTER VARIADO (15)
);
 Capítulo 2: Fundamentos de SQL 39
La ventaja aquí es que si mantiene información de dirección para varias
entidades (como clientes, proveedores, empleados y accionistas) debe definir
los detalles de la especificación de dirección solo una vez: en el FILAdefinición
de tipo.

Tipos de colección
Después de que SQL rompió la camisa de fuerza relacional con SQL:1999, los tipos de
datos que violan la primera forma normal se hicieron posibles. Se hizo posible que un
campo contuviera una colección completa de objetos en lugar de solo uno. El
FORMACIÓN El tipo se introdujo en SQL:1999, y elMULTICONJUNTOEl tipo se introdujo
en SQL:2003.

Dos colecciones pueden compararse entre sí sólo si ambas son del mismo tipo, ya sea
FORMACIÓNoMULTICONJUNTO,y si sus tipos de elementos son comparables. Debido a que las
matrices tienen un orden de elementos definido, se pueden comparar los elementos
correspondientes de las matrices. Los conjuntos múltiples no tienen un orden de elementos
definido, pero puede compararlos si (a) existe una enumeración para cada conjunto múltiple
que se compara y (b) las enumeraciones se pueden emparejar.

tipo de matriz
ElFORMACIÓNEl tipo de datos viola la primera forma normal (1NF), pero de una manera
diferente a la forma en que elFILAEl tipo viola 1NF. ElFORMACIÓNtipo, un tipo de colección, no
es un tipo distinto en el mismo sentido quePERSONAJEyNUMÉRICOson tipos de datos distintos.
UnFORMACIÓNtype simplemente permite que uno de los otros tipos tenga múltiples valores
dentro de un solo campo de una tabla. Por ejemplo, supongamos que su organización necesita
poder comunicarse con los clientes ya sea que estén en el trabajo, en casa o de viaje. Quiere
mantener varios números de teléfono para ellos. Puedes hacer esto declarando elTeléfono
atributo como una matriz, como se muestra en el siguiente código:

CREAR TABLA CLIENTE (

ID de cliente ENTERO CLAVE PRIMARIA,
Apellido CARÁCTER VARIABLE (25),
Nombre de pila CARÁCTER VARIADO (20),
DIRECCIÓN addr_typ,
Teléfono CARACTERES VARIABLES (15) MATRIZ [3]
);

ElMATRIZ [3]La notación le permite almacenar hasta tres números de teléfono en la tabla
CLIENTE. Los tres números de teléfono representan un ejemplo de grupo repetitivo.
Grupos repetidosson un no-no según la teoría clásica de bases de datos relacionales,
pero este es uno de varios ejemplos de casos en los que SQL:1999 rompió las reglas.
Cuando el Dr. Codd especificó por primera vez las reglas de normalización, intercambió
flexibilidad funcional por integridad de datos. SQL: 1999 tomó
40 Parte I: Introducción a SQL

recuperar parte de esa flexibilidad funcional, a costa de cierta complejidad estructural

adicional.

La mayor complejidad estructural podría traducirse en una integridad de los datos comprometida si
no es plenamente consciente de todos los efectos de las acciones que realiza en su base de datos. Las
matrices están ordenadas, en el sentido de que cada elemento de una matriz está asociado con
exactamente unoposición ordinal en la matriz.

Una matriz es una colección ordenada de valores y lacardinalidadde una matriz es el

número de elementos de la matriz. Una matriz SQL puede tener cualquier cardinalidad
desde cero hasta un número máximo declarado de elementos inclusive. Esto significa
que la cardinalidad de una columna del tipo matriz puede variar de una fila a la
siguiente. Una matriz puede ser atómicamente nula, en cuyo caso su cardinalidad
también sería nula. No es lo mismo un array nulo que uno vacío, cuya cardinalidad sería
cero. Una matriz que tenga sólo elementos nulos tendría una cardinalidad mayor que
cero. Por ejemplo, una matriz con cinco elementos nulos tendría una cardinalidad de
cinco.

Si una matriz tiene una cardinalidad menor que el máximo declarado, las celdas no
utilizadas de la matriz se consideran inexistentes. No se considera que contengan
valores nulos; simplemente no están ahí en absoluto.

Puede acceder a elementos individuales en una matriz encerrando sus subíndices entre
corchetes. Si tiene una matriz llamada Teléfono, entonces Teléfono [3] se referiría al
tercer elemento de la matriz Teléfono.

Desde SQL:1999, es posible averiguar la cardinalidad de una matriz invocando el

CARDINALIDADfunción. Lo nuevo en SQl:2011 es la capacidad de descubrir la
cardinalidad máxima de una matriz utilizando elARRAY_MAX_ CARDINALIDAD
función. Esto es muy útil porque le permite escribir rutinas de propósito general que
se aplican a matrices con diferentes cardinalidades máximas. Las rutinas con
cardinalidades máximas codificadas se aplican solo a matrices que tienen una
cardinalidad máxima determinada y tendrían que reescribirse para matrices de
cualquier otra cardinalidad máxima.

Considerando que SQ:1999 introdujo laFORMACIÓNtipo de datos y la capacidad de

abordar elementos individuales dentro de una matriz, no preveía ninguna
disposición para eliminar elementos de una matriz. Ese descuido se corrigió en
SQL:2011 con la introducción de laTRIM_ARRAYfunción, que le permite eliminar
elementos del final de una matriz.

tipo MULTICONJUNTO

Aconjunto múltipleEs una colección desordenada. No se puede hacer referencia a elementos específicos
del conjunto múltiple; normalmente eso se debe a que a esos elementos no se les asignan posiciones
ordinales específicas en el conjunto múltiple.
 Capítulo 2: Fundamentos de SQL 41

tipos de referencia

ÁRBITROLos tipos no son parte del SQL central. Esto significa que un DBMS puede afirmar
que cumple con el estándar SQL sin implementarÁRBITROtipos en absoluto. ElÁRBITROtype
no es un tipo de datos distinto en el sentido de quePERSONAJEy NUMÉRICOson. En cambio,
es unpunteroa un elemento de datos, un tipo de fila o un tipo de datos abstracto que reside
en una fila de una tabla (un sitio). Eliminar la referencia al puntero puede recuperar el valor
almacenado en el sitio de destino.

Si estás confundido, no te preocupes, porque no estás solo. Utilizando elÁRBITRO tipos requiere un
conocimiento práctico de los principios de la programación orientada a objetos (OOP). Este libro se
abstiene de adentrarse demasiado en las turbias aguas de la programación orientada a objetos. De
hecho, porque elÁRBITROLos tipos no forman parte del núcleo de SQL, es posible que sea mejor que
no los utilice. Si desea la máxima portabilidad entre plataformas DBMS, limítese al SQL central.

Tipos definidos por el usuario

Tipos definidos por el usuario(UDT) representan otro ejemplo de características que llegaron
en SQL:1999 y que provienen del mundo de la programación orientada a objetos. Como
programador de SQL, ya no está restringido a los tipos de datos definidos en la especificación
SQL. Puede definir sus propios tipos de datos, utilizando los principios de los tipos de datos
abstractos (ADT) que se encuentran en lenguajes de programación orientados a objetos como
C++.

Uno de los beneficios más importantes de los UDT es el hecho de que puede usarlos para
eliminar eldesajuste de impedanciaentre SQL y el lenguaje anfitrión que "envuelve" el SQL. Un
problema de larga data con SQL ha sido el hecho de que los tipos de datos predefinidos de SQL
no coinciden con los tipos de datos de los lenguajes anfitriones en los que están integradas las
declaraciones SQL. Ahora, con los UDT, un programador de bases de datos puede crear tipos
de datos dentro de SQL que coincidan con los tipos de datos del lenguaje anfitrión.

Un UDT tiene atributos y métodos que están encapsulados dentro del UDT. El
mundo exterior puede ver las definiciones de atributos y los resultados de los
métodos, pero las implementaciones específicas de los métodos están ocultas a la
vista. El acceso a los atributos y métodos de un UDT se puede restringir aún más
especificando que son públicos, privados o protegidos:

✓ PúblicoLos atributos o métodos están disponibles para todos los usuarios de un UDT.

✓ PrivadoLos atributos o métodos están disponibles sólo para el propio UDT.

✓ ProtegidoLos atributos o métodos están disponibles sólo para el propio UDT o

sus subtipos.
42 Parte I: Introducción a SQL

De esto se desprende que un UDT en SQL se comporta de forma muy parecida a una clase en un
lenguaje de programación orientado a objetos. Existen dos formas de tipos definidos por el
usuario: tipos distintos y tipos estructurados.

Tipos distintos
Tipos distintosson la más simple de las dos formas de tipos definidos por el usuario. La
característica que define a un tipo distinto es que se expresa como un único tipo de
datos. Se construye a partir de uno de los tipos de datos predefinidos, llamadotipo de
fuente. Varios tipos distintos que se basan en un único tipo de fuente son distintos
entre sí; por tanto, no son directamente comparables. Por ejemplo, puede utilizar tipos
distintos para distinguir entre diferentes monedas. Considere la siguiente definición de
tipo:

CREAR TIPO DISTINTO Dólar estadounidense COMO DECIMAL (9,2);

Esta definición crea un nuevo tipo de datos para dólares estadounidenses (Dólar
estadounidense),basado en lo predefinidoDECIMALtipo de datos. Puede crear otro tipo distinto
de manera similar:

CREAR TIPO DISTINTO Euro COMO DECIMAL (9,2);

Ahora puede crear tablas que utilicen estos nuevos tipos:

CREAR TABLA USFactura (

InvID ENTERO CLAVE PRIMARIA,
ID de cliente ENTERO,
EmpID ENTERO,
Venta total Dólar estadounidense,

Impuesto Dólar estadounidense,

Envío Dólar estadounidense,

Gran total Dólar estadounidense

);

CREAR TABLA EuroFactura (

InvID ENTERO CLAVE PRIMARIA,
ID de cliente ENTERO,
EmpID ENTERO,
Venta total Euro,
Impuesto Euro,
Envío Euro,
Gran total Euro
);

ElDólar estadounidensetipo y elEuroEl tipo se basa en elDECIMALtipo, pero las instancias

de uno no pueden compararse directamente con instancias del otro o con instancias del
DECIMALtipo. En SQL, como en el mundo real, es posible convertir dólares
estadounidenses a euros, pero hacerlo requiere una operación especial (ELENCO).Una
vez completada la conversión, es posible realizar comparaciones.
 Capítulo 2: Fundamentos de SQL 43

tipos estructurados
La segunda forma de tipo definido por el usuario (el tipo estructurado) se expresa como
una lista de definiciones de atributos y métodos en lugar de basarse en un único tipo de
fuente predefinido.

Constructores

Cuando crea un UDT estructurado, el DBMS crea automáticamente una función

constructora para él, dándole el mismo nombre que el UDT. El trabajo del
constructor es inicializar los atributos del UDT a sus valores predeterminados.

Mutadores y observadores

Cuando crea un UDT estructurado, el DBMS crea automáticamente una función mutadora
y una función observadora. Amutador,cuando se invoca, cambia el valor de un atributo
de un tipo estructurado. Unobservadorla función es lo opuesto a una función mutadora;
su trabajo es recuperar el valor de un atributo de un tipo estructurado. Puede incluir
funciones de observador enSELECCIONARdeclaraciones para recuperar valores de una
base de datos.

Subtipos y supertipos
Puede existir una relación jerárquica entre dos tipos estructurados. Por
ejemplo, un tipo llamadoMúsicaCDudttiene un subtipo llamadoRockCDudty
otro subtipo llamadoClásicaCDudt. MúsicaCDudtes el supertipo de esos dos
[Link] unsubtipo adecuadodeMúsicaCDudtsi no hay subtipo de
MúsicaCDudtese es un supertipo [Link] tiene un subtipo
llamadoHeavyMetalCDudt, HeavyMetalCDudtTambién es un subtipo de
músicaCDudt,pero no es un subtipo adecuado deMúsicaCDudt.

Un tipo estructurado que no tiene supertipo se llamasupertipo máximo,y un tipo

estructurado que no tiene subtipos se llamasubtipo de hoja.

Ejemplo de un tipo estructurado

Puede crear UDT estructurados de la siguiente manera:

/* Crear un UDT llamado MusicCDudt */ CREAR

TIPO MusicCDudt AS
/* Especificar atributos */ Título
CARACTERÍSTICA(40),

Costo DECIMALES(9,2),
Precio sugerido DECIMALES(9,2)
/* Permitir subtipos */ NOT
FINAL ;

CREAR TIPO RockCDudt BAJO MusicCDudt NO FINAL;

44 Parte I: Introducción a SQL

El subtipoRockCDudthereda los atributos de su supertipo

MúsicaCDudt.

CREAR TIPO HeavyMetalCDudt BAJO RockCDudt FINAL;

Ahora que tiene los tipos, puede crear tablas que los utilicen. He aquí un
ejemplo:

CREAR TABLA METALSKU (

Álbum heavymetalcdudt,
SKU ENTERO);

Ahora puedes agregar filas a la nueva tabla:

COMENZAR

/* Declarar una variable temporal a */ DECLARE

a = HeavyMetalCDudt;
/* Ejecutar la función constructora */ SET a =
HeavyMetalCDudt() ;
/* Ejecutar la primera función mutadora */
SET a = [Link]('Eduardo el Grande'); /* Ejecutar la
segunda función mutadora */ SET a =
[Link](7.50) ;
/* Ejecutar la tercera función mutadora */ SET a =
[Link](15.99) ; INSERTAR EN VALORES
METALSKU (a, 31415926);
FIN

Tipos definidos por el usuario procedentes de tipos de colección

En la sección anterior "Tipos distintos", ilustro cómo se puede crear un tipo definido por
el usuario a partir de un tipo predefinido, utilizando el ejemplo de creación de un tipo
USDollar a partir del tipo DECIMAL. Esta capacidad se introdujo en SQL:1999. SQL:2011
amplía esta capacidad al permitirle crear un nuevo tipo definido por el usuario a partir de
un tipo de colección. Esto permite al desarrollador definir métodos en la matriz como un
todo, no sólo en los elementos individuales de la matriz, como lo permite SQL:1999.

Resumen de tipo de datos

La Tabla 2-2 enumera varios tipos de datos y muestra literales que se ajustan a cada
tipo.
 Capítulo 2: Fundamentos de SQL 45

Tabla 2-2 Tipos de datos

Tipo de datos Valor de ejemplo

PERSONAJE (20) 'Radioaficionado '

VARCHAR (20) 'Radioaficionado'
CLOB (1000000) 'Esta cadena de caracteres tiene un
millón de caracteres. . .'
PEQUEÑO, GRANDE,o 7500
ENTERO
NUMÉRICOoDECIMAL 3425.432
REAL, FLOTADOR,o 6.626E-34
PRECISIÓN DOBLE
BINARIO (1) '01100011'
VARBINARIO (4) '011000111100011011100110'
BLOB (1000000) '1001001110101011010101010101. . .'
BOOLEANO 'VERDADERO'

FECHA FECHA '1957-08-14'

TIEMPO (2) SIN HORA '[Link].43' SIN ZONA HORARIA
ZONA HORARIA1

TIEMPO (3) CON HORA ‘[Link].432-08:00’ CON ZONA

ZONA HORARIA HORARIA
MARCA DE TIEMPO SIN MARCA DE TIEMPO '1957-08-14 [Link]'
ZONA HORARIA (0) SIN ZONA HORARIA
MARCA DE TIEMPO CON MARCA DE TIEMPO '1957-08-14 [Link]-
ZONA HORARIA (0) 08:00' CON ZONA HORARIA
DÍA DE INTERVALO INTERVALO '4' DÍA
XML(SECUENCIA) <Cliente>Vince Tenetria</Cliente>
FILA FILA (Calle VARCHAR (25), Ciudad
VARCHAR (20), Estado CHAR (2), Código
Postal VARCHAR (9))
FORMACIÓN MATRIZ DE ENTEROS [15]
MULTICONJUNTO Ningún literal se aplica a laMULTICONJUNTOtipo.

ÁRBITRO No es un tipo, sino un puntero.

TIPO DEFINIDO POR EL USUARIO Divisatipo basado enDECIMAL

El argumento especifica el número de dígitos fraccionarios.
1
46 Parte I: Introducción a SQL

Es posible que su implementación de SQL no admita todos los tipos de datos que
describo en esta sección. Además, su implementación puede admitir tipos de datos no
estándar que no describo aquí. (Su kilometraje puede variar, etc. Ya conoce el
procedimiento).

Valores nulos
Si un campo de base de datos contiene un elemento de datos, ese campo tiene un valor específico. Se dice
que un campo que no contiene un elemento de datos tiene unvalor [Link] eso en mente

✓ En un campo numérico, un valor nulo no es lo mismo que un valor cero.

✓ En un campo de carácter, un valor nulo no es lo mismo que un espacio en blanco.

Tanto un cero numérico como un carácter en blanco son valores definidos. Un valor nulo
indica que el valor de un campo no está definido: su valor no se conoce.

Existen varias situaciones en las que un campo puede tener un valor nulo. La siguiente
lista describe algunas de estas situaciones y ofrece un ejemplo de cada una:

✓ El valor existe, pero aún no sabes cuál [Link] NÚMEROanular

en elFormas de vidafila de laExoplanetasmesa antes de que los
astrónomos hayan descubierto evidencia inequívoca de vida más allá de
nuestro sistema solar en la Vía Láctea.
✓ El valor aún no existe.ConfiguraTOTAL_VENDIDOanular en elSQL para
principiantes, octava ediciónfila de la tabla LIBROS porque aún no se
informa el primer conjunto de cifras de ventas trimestrales.
✓ El campo no es aplicable para esta fila en [Link]
en elC3POfila de la tabla EMPLEADO porque C3PO es un droide que no tiene
género. (Tu lo sabías.)
✓ El valor esta fuera de [Link] en elOprah Winfreyfila
de la tabla EMPLEADO porque diseñó elSALARIO columna como tipo
NUMÉRICO (8,2)y el contrato de Oprah exige un pago superior a 999.999,99
dólares. (Tú también lo sabías).

Un campo puede tener un valor nulo por muchos motivos diferentes. No saque
conclusiones apresuradas sobre lo que significa un valor nulo en particular.

Restricciones
Restriccionesson restricciones que se aplican a los datos que alguien puede ingresar en una tabla de
base de datos. Es posible que sepa, por ejemplo, que las entradas de una columna numérica concreta
deben estar dentro de un rango determinado. Si alguien hace una entrada
 Capítulo 2: Fundamentos de SQL 47
que queda fuera de ese rango, entonces esa entrada debe ser un error. Aplicar
una restricción de rango a la columna evita que ocurra este tipo de error.

Tradicionalmente, el programa de aplicación que utiliza la base de datos aplica cualquier

restricción a una base de datos. Sin embargo, los productos DBMS más recientes le
permiten aplicar restricciones directamente a la base de datos. Este enfoque tiene varias
ventajas. Si varias aplicaciones utilizan la misma base de datos, aplica las restricciones
sólo una vez (en lugar de varias veces). Además, agregar restricciones a nivel de base de
datos suele ser más sencillo que agregarlas a una aplicación. A menudo todo lo que
haces es agregar la cláusula apropiada a tuCREARdeclaración.

Hablo de restricciones yafirmaciones(que son restricciones que se aplican a más de

una tabla) en detalle en el Capítulo 5.

Usando SQL en un sistema cliente/servidor

SQL es un sublenguaje de datos que funciona en un sistema independiente o en un
sistema multiusuario. SQL funciona particularmente bien en un sistema cliente/servidor.
En un sistema de este tipo, los usuarios de varias máquinas cliente que se conectan a una
máquina servidor pueden acceder, a través de una red de área local (LAN) u otro canal de
comunicaciones, a una base de datos que reside en el servidor al que están conectados.
El programa de aplicación en una máquina cliente contiene comandos de manipulación
de datos SQL. La parte del DBMS que reside en el cliente envía estos comandos al
servidor a través del canal de comunicaciones que conecta el servidor con el cliente. En el
servidor, la parte del servidor del DBMS interpreta y ejecuta el comando SQL y luego
envía los resultados al cliente a través del canal de comunicación. Puede codificar
operaciones muy complejas en SQL en el cliente y luego decodificar y realizar esas
operaciones en el servidor. Este tipo de configuración da como resultado el uso más
efectivo del ancho de banda de ese canal de comunicación.

Si recupera datos utilizando SQL en un sistema cliente/servidor, solo los datos que desea viajan
a través del canal de comunicación desde el servidor al cliente. Por el contrario, un sistema
simple de intercambio de recursos, con una inteligencia mínima en el servidor, debe enviar
enormes bloques de datos a través del canal para brindarle la pequeña porción de datos que
desea. Este tipo de transmisión masiva puede ralentizar considerablemente las operaciones. La
arquitectura cliente/servidor complementa las características de SQL para proporcionar un
buen rendimiento a un costo moderado en redes pequeñas, medianas y grandes.

El servidor
A menos que reciba una solicitud de un cliente, el servidor no hace nada; simplemente se queda ahí
y espera. Sin embargo, si varios clientes requieren servicio al mismo tiempo, los servidores deben
responder rápidamente. Los servidores generalmente difieren del cliente.
48 Parte I: Introducción a SQL

máquinas en términos de la cantidad de datos que manejan. Tienen grandes cantidades de

almacenamiento en disco muy rápido, optimizado para un acceso y recuperación rápidos de datos.
Y debido a que deben manejar el tráfico que ingresa simultáneamente desde múltiples máquinas
cliente, los servidores necesitan procesadores multinúcleo rápidos.

que es el servidor
Elservidor(corto paraservidor de base de datos) es la parte de un sistema cliente/servidor
que contiene la base de datos. El servidor también contiene el software del servidor, la
parte de un sistema de gestión de bases de datos que interpreta los comandos que llegan
de los clientes y los traduce en operaciones en la base de datos. El software del servidor
también formatea los resultados de las solicitudes de recuperación y los envía al cliente
solicitante.

Que hace el servidor

El trabajo del servidor es relativamente simple y directo. Todo lo que un servidor necesita
hacer es leer, interpretar y ejecutar los comandos que le llegan a través de la red desde
los clientes. Esos comandos están en uno de varios sublenguajes de datos.

Un sublenguaje no califica como un lenguaje completo: implementa solo una parte de un

lenguaje. Un sublenguaje de datos puede, por ejemplo, ocuparse únicamente del manejo de
datos. El sublenguaje tiene operaciones para insertar, actualizar, eliminar y seleccionar datos,
pero puede no tener estructuras de control de flujo comoHACER bucles, variables locales,
funciones, procedimientos o entrada/salida a impresoras. SQL es el sublenguaje de datos más
común que se utiliza en la actualidad y se ha convertido en un estándar de la industria. De
hecho, SQL ha suplantado a los sublenguajes de datos propietarios en máquinas de todas las
clases de rendimiento. Con SQL:1999, SQL adquirió muchas de las características que faltaban
en los sublenguajes tradicionales. Sin embargo, SQL todavía no es un lenguaje de
programación completo de propósito general; debe combinarse con un lenguaje anfitrión para
crear una aplicación de base de datos.

El cliente
ElclienteParte de un sistema cliente/servidor consta de un componente de
hardware y un componente de software. El componente de hardware es la
computadora cliente y su interfaz con la red de área local. Este hardware de cliente
puede ser muy similar (o incluso idéntico) al hardware del servidor. El software es
el componente distintivo del cliente.

cual es el cliente
El trabajo principal del cliente es proporcionar una interfaz de usuario. En lo que respecta al
usuario, la máquina clienteesla computadora y la interfaz de usuarioesla aplicación. Es posible
que el usuario ni siquiera se dé cuenta de que el proceso implica un servidor. El servidor suele
estar fuera de la vista, a menudo en otra habitación. Aparte de la
 Capítulo 2: Fundamentos de SQL 49
interfaz de usuario, el cliente también contiene el programa de aplicación y la parte
cliente del DBMS. El programa de aplicación realiza la tarea específica que usted requiere
(por ejemplo, en cuentas por cobrar o registro de pedidos). La parte cliente del DBMS
ejecuta los comandos del programa de aplicación e intercambia datos y comandos de
manipulación de datos SQL con la parte servidor del DBMS.

Que hace el cliente

La parte cliente de un DBMS muestra información en pantalla y responde a la entrada del
usuario transmitida a través del teclado, mouse u otro dispositivo de entrada. El cliente
también podrá tratar datos procedentes de un enlace de telecomunicaciones o de otras
estaciones de la red. La parte cliente del DBMS hace todo el “pensamiento” específico de la
aplicación. Para un desarrollador, la parte cliente de un DBMS es la parte interesante. La
parte del servidor simplemente maneja las solicitudes de la parte del cliente de forma
mecánica y repetitiva.

Usar SQL en Internet o una intranet

El funcionamiento de bases de datos en Internet y en intranets difiere fundamentalmente del
funcionamiento de bases de datos en un sistema cliente/servidor tradicional. La diferencia está
principalmente en el lado del cliente. En un sistema cliente/servidor tradicional, gran parte de la
funcionalidad del DBMS reside en la máquina cliente. En un sistema de base de datos basado
en Internet, la mayoría o la totalidad del DBMS reside en el servidor. El cliente no puede alojar
nada más que un navegador web. Como máximo, el cliente dispone de un navegador y una
extensión de navegador, como un complemento de Firefox o un control ActiveX. Así, el “centro
de masa” conceptual del sistema se desplaza hacia el servidor. Este cambio tiene varias
ventajas:

✓ La parte del cliente del sistema (navegador) es de bajo costo o incluso gratuita.

✓ Tiene una interfaz de usuario estandarizada.

✓ El cliente es fácil de mantener.
✓ Tiene una relación cliente/servidor estandarizada.
✓ Tiene un medio común para mostrar datos multimedia.

Las principales desventajas de realizar manipulaciones de bases de datos a través de Internet tienen
que ver con la seguridad y la integridad de los datos:

✓ Para proteger la información contra accesos no deseados o manipulaciones, tanto el

servidor web como el navegador del cliente deben admitir un cifrado seguro.

✓ Los navegadores no realizan comprobaciones adecuadas de validación de entrada de datos.

✓ Las tablas de bases de datos que residen en diferentes servidores pueden quedar
desincronizadas.
50 Parte I: Introducción a SQL

Las extensiones de cliente y servidor diseñadas para abordar estas preocupaciones hacen de
Internet un lugar viable para aplicaciones de bases de datos de producción. La arquitectura de
una intranet es similar a la de Internet, pero la seguridad es una preocupación menor. Debido
a que la organización que mantiene la intranet tiene control físico sobre todas las máquinas
cliente, así como sobre los servidores y la red que conecta estos componentes, una intranet
está mucho menos expuesta a los esfuerzos de piratas informáticos malintencionados. Sin
embargo, los errores de entrada de datos y la desincronización de la base de datos siguen
siendo motivo de preocupación.
 Capítulo 3

Los componentes de SQL

En este capítulo
▶ Creando bases de datos
▶ Manipulación de datos
▶ Proteger bases de datos

S QL es un lenguaje de propósito especial diseñado para la creación y

mantenimiento de datos en bases de datos relacionales. Aunque los proveedores
de sistemas de gestión de bases de datos relacionales tienen sus propias
implementaciones de SQL, un estándar ISO/IEC (revisado en 2011) define y controla qué
es SQL. Todas las implementaciones difieren del estándar en distintos grados. El estricto
cumplimiento del estándar es la clave para ejecutar una base de datos (y sus
aplicaciones asociadas) en más de una plataforma.

Aunque SQL no es un lenguaje de programación de propósito general, contiene algunas

herramientas impresionantes. Tres idiomas dentro del idioma ofrecen todo lo que necesita
para crear, modificar, mantener y brindar seguridad para una base de datos relacional:

✓ El lenguaje de definición de datos (DDL):La parte de SQL que utiliza para crear
(definir completamente) una base de datos, modificar su estructura y destruirla
cuando ya no la necesite.

✓ El lenguaje de manipulación de datos (DML):La parte de SQL que realiza el

mantenimiento de la base de datos. Con esta poderosa herramienta, puede especificar
qué desea hacer con los datos de su base de datos: ingresarlos, cambiarlos, eliminarlos
o recuperarlos.

✓ El lenguaje de control de datos (DCL):La parte de SQL que protege su base

de datos para que no se dañe. Utilizado correctamente, el DCL proporciona
seguridad para su base de datos; la cantidad de protección depende de la
implementación. Si su implementación no proporciona suficiente protección,
debe agregar esa protección a su programa de aplicación.

Este capítulo presenta DDL, DML y DCL.

52 Parte I: Introducción a SQL

Lenguaje de definición de datos

El lenguaje de definición de datos (DDL) es la parte de SQL que se utiliza para crear,
cambiar o destruir los elementos básicos de una base de datos relacional. Los
elementos básicos incluyen tablas, vistas, esquemas, catálogos, clústeres y
posiblemente también otras cosas. En las siguientes secciones, analizo la jerarquía de
contención que relaciona estos elementos entre sí y analizo los comandos que operan
en estos elementos.

En el Capítulo 1, menciono tablas y esquemas, señalando que unesquemaEs una estructura

general que incluye tablas dentro de ella. Las tablas y los esquemas son dos elementos de una
base de datos [Link]ía de contenció[Link] desglosar la jerarquía de contención de
la siguiente manera:

✓ Las tablas contienen columnas y filas.

✓ Los esquemas contienen tablas y vistas.

✓ Los catálogos contienen esquemas.

La propia base de datos contiene catálogos. A veces se hace referencia a la base de datos como
[Link] a mencionar los grupos más adelante en este capítulo, en la sección sobre pedidos
por catálogo.

Cuando “¡Simplemente hazlo!” no es un buen consejo

Supongamos que se propone crear una base de datos para su organización.
Emocionado por la perspectiva de construir una estructura útil, valiosa y totalmente
justa de gran importancia para el futuro de su empresa, se sienta frente a su
computadora y comienza a ingresar [Link]. ¿Bien?

Bueno no. No exactamente. De hecho, esa es una receta para el desastre. Muchos
proyectos de desarrollo de bases de datos fracasan desde el principio cuando la
emoción y el entusiasmo superan la planificación cuidadosa. Incluso si tienes una idea
clara de cómo estructurar tu base de datos,escribir todo en papelantes de tocar el
teclado.

Aquí es donde el desarrollo de bases de datos tiene cierta semejanza con una partida de
ajedrez. En medio de una partida de ajedrez complicada y competitiva, es posible que veas lo
que parece una buena jugada. La necesidad de dar ese paso puede ser abrumadora. Sin
embargo, es muy probable que te hayas perdido algo. Los grandes maestros aconsejan a los
jugadores más nuevos (sólo en parte en broma) que se queden cruzados de brazos. Si sentarse
sobre las manos le impide hacer un movimiento imprudente, que así sea: siéntese sobre las
manos. Si estudias la posición un poco más,
 Capítulo 3: Los componentes de SQL 53
Podrías encontrar un movimiento aún mejor, o incluso podrías ver un contraataque brillante
que tu oponente pueda realizar. Lanzarse a crear una base de datos sin suficiente previsión
puede llevar a una estructura de base de datos que, en el mejor de los casos, no sea óptima.
En el peor de los casos, podría ser desastroso, una invitación abierta a la corrupción de datos.
Sentarse sobre las manos probablemente no ayude, perovoluntadayúdelo a tomar un lápiz
en una de esas manos y comenzar a mapear su plan de base de datos en papel. Para obtener
ayuda para decidir qué incluir en su plan, consulte mi libro Desarrollo de bases de datos para
principiantes,que cubre la planificación en profundidad.

Tenga en cuenta los siguientes procedimientos al planificar su base de datos:

✓ Identifique todas las tablas.

✓ Defina las columnas que debe contener cada tabla.

✓ Dale a cada mesa unClave primariaque puedes garantizar es único. (Hablo de
las claves primarias en los Capítulos 4 y 5.)

✓ Asegúrese de que cada tabla de la base de datos tenga al menos una columna
en común con (al menos) otra tabla de la base de datos. Estas columnas
compartidas sirven como vínculos lógicos que le permiten relacionar la
información de una tabla con la información correspondiente de otra tabla.

✓ Pon cada mesa entercera forma normal(3NF) o mejor para garantizar la prevención de
anomalías de inserción, eliminación y actualización. (Hablo de la normalización de bases
de datos en el Capítulo 5.)

Después de completar el diseño en papel y verificar que esté bien, estará listo para
transferir el diseño a la computadora. Puedes hacer este poco de magia escribiendo
SQLCREARdeclaraciones. Lo más probable es que utilice la interfaz gráfica de
usuario (GUI) de su DBMS para crear los elementos de su diseño. Si utiliza una GUI,
su DBMS convertirá su entrada "bajo las sábanas" en SQL.

Creando tablas
Una tabla de base de datos se parece mucho a una tabla de hoja de cálculo: una matriz
bidimensional formada por filas y columnas. Puedes crear una tabla usando SQL. CREAR
MESAdominio. Dentro del comando, especifica el nombre y el tipo de datos de cada
columna.

Después de crear una tabla, puede comenzar a cargarla con datos. (La carga
de datos es una función DML, no DDL). Si los requisitos cambian, puede
cambiar la estructura de una tabla utilizando elALTERAR TABLAdominio. Si una
tabla deja de ser útil o se vuelve obsoleta, puedes eliminarla con elGOTA
dominio. Las diversas formas de laCREARyALTERARcomandos, junto con el
GOTA comando, cree el DDL de SQL.
54 Parte I: Introducción a SQL

Suponga que es diseñador de bases de datos y no quiere que las tablas de su base de datos se
conviertan en guacamole a medida que realiza actualizaciones con el tiempo. Decide estructurar las
tablas de su base de datos de acuerdo con la mejor forma normalizada para poder mantener la
integridad de los datos.

Normalización,Un extenso campo de estudio por derecho propio, es una forma de estructurar
tablas de bases de datos para que las actualizaciones no introduzcan anomalías. Cada tabla
que crea contiene columnas que corresponden a atributos que están estrechamente
vinculados entre sí.

Puede, por ejemplo, crear una tabla CLIENTE con los atributos [Link] de
Cliente, [Link], [Link], [Link], [Link],
[Link], CLIENTE. Código postal,[Link]é[Link] estos atributos
están más estrechamente relacionados con la entidad del cliente que con cualquier
otra entidad en una base de datos que pueda contener muchas tablas. Estos
atributos contienen toda la información relativamente permanente del cliente que
su organización mantiene archivada.

La mayoría de los sistemas de gestión de bases de datos proporcionan una herramienta

gráfica para crear tablas de bases de datos. También puede crear dichas tablas mediante
un comando SQL. El siguiente ejemplo demuestra un comando que crea su tabla CLIENTE:

CREAR TABLA CLIENTE (

Identificación del cliente ENTERO NO NULO,
Nombre de pila CARACTERÍSTICA (15),

Apellido CARACTERÍSTICA (20) NO NULO,

Calle CARACTERÍSTICA (25),

Ciudad CARACTERÍSTICA (20),

Estado CARACTER (2),

Código postal CARACTERÍSTICA (10),

Teléfono CARACTER (13) );

Para cada columna, especifica su nombre (por ejemplo,Identificación del cliente),su

tipo de datos (por ejemplo,ENTERO),y posiblemente una o más restricciones (por
ejemplo,NO NULO).

La Figura 3-1 muestra una parte de la tabla CLIENTE con algunos datos de muestra.

Si la implementación de SQL que utiliza no implementa completamente la última versión del

estándar SQL ISO/IEC, la sintaxis que necesita utilizar puede diferir de la sintaxis que
proporciono en este libro. Lea la documentación del usuario que viene con su DBMS para
obtener información específica.
 Capítulo 3: Los componentes de SQL 55

Figura 3-1:
Utilizar el
CREAR
TABLA com-
mando a
crear esto
CLIENTE
mesa.

Un cuarto con vista

En ocasiones, desea recuperar información específica de la tabla CLIENTE.
No querrás mirar todo, solo columnas y filas específicas. Lo que necesitas
es una vista.

Avistaes una mesa virtual. En la mayoría de las implementaciones, una vista no tiene existencia
física independiente. La definición de la vista existe sólo en los metadatos de la base de datos,
pero los datos provienen de la tabla o tablas de las que deriva la vista. Los datos de la vista no
se duplican físicamente en ningún otro lugar del almacenamiento en disco en línea. Algunas
vistas constan de columnas y filas específicas de una sola tabla. Otros, conocidos comovistas
de varias mesas,dibujar de dos o más mesas.

Vista de una sola mesa

A veces, cuando tienes una pregunta, los datos que te dan la respuesta residen en
una única tabla de tu base de datos. Si la información que desea existe en una sola
tabla, puede crear una vista de tabla única de los datos. Por ejemplo, supongamos
que desea consultar los nombres y números de teléfono de todos los clientes que
viven en el estado de New Hampshire. Puede crear una vista desde la tabla CLIENTE
que contenga solo los datos que desee. La siguiente declaración SQL crea esta vista:

CREAR VER NH_CUST AS

SELECCIONAR [Link],
[Link],
[Link]éfono
DEL CLIENTE
DONDE [Link] = 'NH';

La Figura 3-2 muestra cómo se obtiene la vista de la tabla CLIENTE.

56 Parte I: Introducción a SQL

Figura 3-2:
tu derivas
el NH_
vista PERSONALIZADA

desde el
CLIENTE
mesa.

Este código es correcto, pero un poco prolijo. Puede realizar la misma tarea
escribiendo menos si su implementación de SQL supone que todas las referencias
de tablas son las mismas que las del archivoDEcláusula. Si su sistema hace esa
suposición predeterminada razonable, puede reducir la declaración a las
siguientes líneas:

CREAR VER NH_CUST AS

SELECCIONE Nombre, Apellido, Teléfono
DEL CLIENTE
DONDE ESTADO = 'NH';

Aunque la segunda versión es más fácil de escribir y leer, es más vulnerable a las
interrupciones causadas porALTERAR TABLAcomandos. Tal interrupción no es un
problema para este caso simple, que no tieneUNIRSE,pero vistas conUNIRSELos s son
más sólidos cuando utilizan nombres completos. yo cubroUNIRSEs en el Capítulo 11.

Crear una vista de varias tablas

La mayoría de las veces, necesita extraer datos de dos o más tablas para responder
su pregunta. Supongamos, por ejemplo, que trabaja para una tienda de artículos
deportivos y desea enviar un correo promocional a todos los clientes que
compraron equipos de esquí desde que abrió la tienda el año pasado. Necesita
información de la tabla CLIENTE, la tabla PRODUCTO, la tabla FACTURA y la tabla
INVOICE_LINE. Puede crear una vista de varias tablas que muestre los datos que
necesita. Después de crear la vista, puede usar la misma vista una y otra vez. Cada
vez que utiliza la vista, refleja los cambios que se produjeron en las tablas
subyacentes desde la última vez que utilizó la vista.

La base de datos de esta tienda de artículos deportivos contiene cuatro tablas: CLIENTE,
PRODUCTO, FACTURA e INVOICE_LINE. Las tablas están estructuradas como se muestra en la
Tabla 3-1.
 Capítulo 3: Los componentes de SQL 57

Tabla 3-1 Tablas de bases de datos de tiendas de artículos deportivos

Mesa Columna Tipo de datos Restricción

CLIENTE Identificación del cliente ENTERO NO NULO

Nombre de pila CARACTERÍSTICA (15)

Apellido CARACTERÍSTICA (20) NO NULO

Calle CARACTERÍSTICA (25)

Ciudad CARACTERÍSTICA (20)

Estado CARACTER (2)

Código postal CARACTERÍSTICA (10)

Teléfono CARACTERÍSTICA (13)

PRODUCTO ID del Producto ENTERO NO NULO

Nombre CARACTERÍSTICA (25)

Descripción CARACTERÍSTICA (30)

Categoría CARACTERÍSTICA (15)

ID del proveedor ENTERO

Nombre del vendedor CARACTERÍSTICA (30)

FACTURA Número de factura ENTERO NO NULO

Identificación del cliente ENTERO
Fecha de la factura FECHA

Venta total NUMÉRICO (9,2)

TotalRemitido NUMÉRICO (9,2)
Forma de pago CARACTERÍSTICA (10)

FACTURA_LINEA Número de línea ENTERO NO NULO

Número de factura ENTERO NO NULO
ID del Producto ENTERO NO NULO
Cantidad ENTERO
Precio de venta NUMÉRICO (9,2)

Observe que algunas de las columnas de la Tabla 3-1 contienen la restricciónNO NULO.
Estas columnas son las claves principales de sus respectivas tablas o columnas que
usted decidadebecontener un valor. La clave principal de una tabla debe identificar de
forma única cada fila. Para hacer eso, la clave principal debe contener un valor no nulo
en cada fila. (Hablo de las claves en detalle en el Capítulo 5.)
58 Parte I: Introducción a SQL

Las tablas se relacionan entre sí a través de las columnas que tienen en

común. La siguiente lista describe estas relaciones (como se muestra en la
Figura 3-3):

✓ La tabla CLIENTE lleva unrelación uno a muchosa la tabla FACTURA. Un

cliente puede realizar múltiples compras, generando múltiples facturas.
Sin embargo, cada factura trata de un, y sólo uno, cliente.
✓ La tabla INVOICE tiene una relación de uno a muchos con la tabla INVOICE_
LINE. Una factura puede tener varias líneas, pero cada línea aparece en una y
sólo una factura.
✓ La tabla PRODUCTO también tiene una relación de uno a muchos con la tabla
INVOICE_LINE. Un producto puede aparecer en más de una línea en una o
más facturas. Cada línea, sin embargo, trata de un solo producto.

Figura 3-3:
Un deporte-

bienes
historias
base de datos

estructura.

La tabla CLIENTE se vincula a la tabla FACTURA por el común Identificación del cliente
columna. La tabla INVOICE se vincula a la tabla INVOICE_LINE por el comúnNúmero
de facturacolumna. La tabla PRODUCTO se vincula a la tabla INVOICE_LINE por el
comúnID del Productocolumna. Estos enlaces son los que hacen de esta base de
datos unarelacionalbase de datos.

Para acceder a la información de los clientes que compraron material de esquí es

necesarioNombre, Apellido, Calle, Ciudad, Estado,yCódigo postaldesde el
 Capítulo 3: Los componentes de SQL 59
tabla CLIENTE;Categoríade la tabla PRODUCTO;Número de factura de la tabla
FACTURA; yNúmero de líneade la tabla INVOICE_LINE. Puede crear la vista que
desee en etapas utilizando las siguientes declaraciones:

CREAR VER SKI_CUST1 COMO

SELECCIONE Nombre,
Apellido,
Calle,
Ciudad,
Estado,
Código postal,
Número de factura
DEL CLIENTE UNIRSE A LA
FACTURA USANDO (CustomerID);
CREAR VER SKI_CUST2 COMO
SELECCIONE Nombre,
Apellido,
Calle,
Ciudad,
Estado,
Código postal,
ID del Producto
DESDE SKI_CUST1 ÚNETE A INVOICE_LINE
USANDO (NúmeroFactura);
CREAR VER SKI_CUST3 COMO
SELECCIONE Nombre,
Apellido,
Calle,
Ciudad,
Estado,
Código postal,
Categoría
DESDE SKI_CUST2 ÚNETE AL
PRODUCTO USANDO (ProductID);
CREAR VER SKI_CUST AS
SELECCIONE Nombre DISTINTO,
Apellido,
Calle,
Ciudad,
Estado,
Código postal
DESDE ESQUÍ_CUST3
DONDE CATEGORÍA = 'Esquí';

EstosCREAR VISTALas declaraciones combinan datos de múltiples tablas usando el

UNIRSEoperador. La Figura 3-4 diagrama el proceso.
60 Parte I: Introducción a SQL

Figura 3-4:
Creando
un multi-
vista de tabla
mediante el uso

Uniones.

Aquí hay un resumen de los [Link] VISTAdeclaraciones:

✓ La primera declaración combina columnas de la tabla CLIENTE con una

columna de la tabla FACTURA para crear laESQUÍ_CUST1vista.
✓ La segunda afirmación combinaESQUÍ_CUST1con una columna de la tabla
INVOICE_LINE para crear elESQUÍ_CUST2vista.
✓ La tercera afirmación combinaESQUÍ_CUST2con una columna de la tabla
PRODUCTO para crear elESQUÍ_CUST3vista.
✓ La cuarta declaración filtra todas las filas que no tienen una categoría deEsquí.El
resultado es una vista (ESQUÍ_CUST)que contiene los nombres y direcciones de
todos los clientes que compraron al menos un producto en elEsquí categoría.

ElDISTINTOpalabra clave en el cuartoCREAR VISTA'sSELECCIONARLa cláusula

garantiza que solo tenga una entrada para cada cliente, incluso si algunos clientes
realizaron varias compras de artículos de esquí. (Yo cubroUNIRSEs en detalle en el
Capítulo 11.)

Es posible crear una vista de varias tablas con una única declaración SQL. Sin embargo,
si cree que una o todas las declaraciones anteriores son complejas, imagine cuán
compleja sería una sola declaración que cumpliera todas sus funciones. Tiendo a preferir
la simplicidad a la complejidad, por eso, siempre que es posible, elijo la forma más
sencilla de realizar una función, incluso si no es la más "eficiente".
 Capítulo 3: Los componentes de SQL 61

Recopilar tablas en esquemas

Una tabla consta de filas y columnas y normalmente trata de un tipo específico de
entidad, como clientes, productos o facturas. El trabajo útil generalmente requiere
información sobre varias (o muchas) entidades relacionadas. Desde el punto de vista
organizativo, recopila las tablas que asocia con estas entidades según un esquema
lógico. Aesquema lógicoes la estructura organizativa de una colección de tablas
relacionadas.

Una base de datos también tiene unesquema fisico—que representa la disposición física
de los datos y sus elementos asociados (como índices) en los dispositivos de
almacenamiento del sistema. Cuando menciono "el esquema" de una base de datos, me
refiero al esquema lógico, no al esquema físico.

En un sistema donde pueden coexistir varios proyectos no relacionados, puede asignar todas
las tablas relacionadas a un esquema. Puede recopilar otros grupos de tablas en sus propios
esquemas.

Asegúrese de nombrar sus esquemas para asegurarse de que nadie mezcle

accidentalmente tablas de un proyecto con tablas de otro. Cada proyecto tiene su propio
esquema asociado; puede distinguirlo de otros esquemas por su nombre. Sin embargo,
es común ver ciertos nombres de tablas (como CLIENTE, PRODUCTO, etc.) en varios
proyectos. Si existe alguna posibilidad de que haya una ambigüedad en el nombre,
califique el nombre de su tabla usando también su nombre de esquema (como en
SCHEMA_NAME.TABLE_NAME).Si no califica un nombre de tabla, SQL asigna esa tabla al
esquema predeterminado.

Realizar pedidos por catálogo

Para sistemas de bases de datos realmente grandes, es posible que varios esquemas no sean
suficientes. En un entorno de base de datos distribuida de gran tamaño con muchos usuarios, es
posible que incluso encuentre nombres de esquemas duplicados. Para evitar esta situación, SQL
agrega otro nivel a la jerarquía de contención: el catálogo. Acatalogares una colección de esquemas
con nombre.

Puedecalificarun nombre de tabla utilizando un nombre de catálogo y un nombre de

esquema. Esta protección es la mejor manera de garantizar que nadie confunda la tabla de
un esquema con una tabla que tiene el mismo nombre en algún otro esquema que tenga el
mismo nombre de esquema. (¿Qué dices? Bueno, a algunas personas les resulta muy difícil
pensar en nombres diferentes). El nombre calificado en el catálogo aparece en el siguiente
formato:

CATALOG_NAME.SCHEMA_NAME.TABLE_NAME
62 Parte I: Introducción a SQL

En la parte superior de la jerarquía de contención de la base de datos se [Link]

sistemas rara vez requieren el uso de todo el alcance de la jerarquía de contención; ir al nivel de
catálogo es suficiente en la mayoría de los casos. Un catálogo contiene esquemas; un esquema
contiene tablas y vistas; Las tablas y vistas contienen columnas y filas.

El catálogo también contiene elesquema de informació[Link] esquema de información contiene las

tablas del sistema. Las tablas del sistema contienen los metadatos asociados con los otros esquemas.
En el Capítulo 1, defino una base de datos como una colección de registros integrados que se
describen a sí mismos. Los metadatos contenidos en las tablas del sistema son los que hacen que la
base de datos sea autodescriptiva.

Como los catálogos se identifican por su nombre, puede tener varios catálogos en una
base de datos. Cada catálogo puede tener varios esquemas y cada esquema puede
tener varias tablas. Por supuesto, cada tabla puede tener varias columnas y filas. Las
relaciones jerárquicas se muestran en la Figura 3-5.

Figura 3-5:
La hier-
archico
estructura
de un típico
datos SQL-
base.

Familiarizarse con las declaraciones DDL

El lenguaje de definición de datos (DDL) de SQL se ocupa de la estructura de una base de
datos. Es distinto del lenguaje de manipulación de datos (descrito más adelante en este
capítulo), que se ocupa de los datos contenidos dentro de esa estructura. El DDL consta
de estas tres declaraciones:

✓ CREAR:Utilice las diversas formas de esta declaración para construir las estructuras
esenciales de la base de datos.

✓ ALTERAR:Utilice esta declaración para cambiar las estructuras que ha

creado.
✓ GOTA:Esta declaración se aplica a estructuras creadas con elCREAR
declaración, para destruirlos.
 Capítulo 3: Los componentes de SQL 63
En las siguientes secciones, le doy breves descripciones de las declaraciones DDL. En los
capítulos 4 y 5 utilizo estas afirmaciones en ejemplos.

CREAR
Puedes aplicar el SQLCREARdeclaración a una gran cantidad de objetos SQL, incluidos
esquemas, dominios, tablas y vistas. Al utilizar elCREAR ESQUEMA declaración, no sólo
puede crear un esquema, sino también identificar a su propietario y especificar un juego
de caracteres predeterminado. Aquí hay un ejemplo de tal declaración:

CREAR ESQUEMA DE VENTAS

AUTORIZACIÓN VENTAS_MGR
CONJUNTO DE CARACTERES PREDETERMINADO ASCII_FULL;

Utilizar elCREAR DOMINIOdeclaración para aplicar restricciones a los valores de las

columnas. Las restricciones que aplica a un dominio determinan qué objetos puede y
no puede contener el dominio. Puede crear dominios después de establecer un
esquema. El siguiente ejemplo muestra cómo utilizar esta declaración:

CREAR DOMINIO Edad COMO ENTERO

VERIFICAR (EDAD> 20);

Crea tablas usando elCREAR MESAdeclaración, y usted crea vistas usando el

CREAR VISTAdeclaración. Al principio de este capítulo, le muestro ejemplos
de estas dos afirmaciones. Cuando usas elCREAR MESA declaración, puede
especificar restricciones en las columnas de la nueva tabla al mismo tiempo.

A veces es posible que desee especificar restricciones que no se adjuntan

específicamente a una tabla sino que se aplican a un esquema completo. Puedes usar el
CREAR ASERCIÓNdeclaración para especificar tales restricciones.

Tu también tienesCREAR CONJUNTO DE CARACTERES,CREAR COLABORACIÓN,yCREAR

TRADUCCIÓNdeclaraciones, que le brindan la flexibilidad de crear nuevos conjuntos de
caracteres, secuencias de clasificación o tablas de traducción. (Secuencias de
intercalación Defina el orden en el que realiza comparaciones o [Link] de
traduccióncontrolar la conversión de cadenas de caracteres de un conjunto de caracteres
a otro). Puede crear una serie de otras cosas (en las que no entraré aquí), como puede
deducir si pasa al Capítulo 2 para echar un vistazo a la Tabla 2. 1.

ALTERAR

Después de crear una tabla, no necesariamente estarás atrapado en esa tabla exacta
para siempre. A medida que utiliza la mesa, puede descubrir que no es todo lo que
necesita. Puedes usar elALTERAR TABLAdeclaración para cambiar la tabla agregando,
cambiando o eliminando una columna en la tabla. Además de las tablas, también
puedesALTERARcolumnas y dominios.
64 Parte I: Introducción a SQL

GOTA
Eliminar una tabla de un esquema de base de datos es fácil. Sólo usa unTABLA DE CAÍDA <
nombre de la tabla>declaración. Borra todos los datos de la tabla, así como los metadatos
que definen la tabla en el diccionario de datos. Es casi como si la mesa nunca hubiera
existido. También puedes utilizar elGOTAdeclaración para deshacerse de cualquier cosa
que haya sido creada por unCREARdeclaración.

GOTAno funcionará si rompe la integridad referencial. Más adelante en este capítulo analizo la
integridad referencial.

Lenguaje de manipulación de datos

Aunque DDL es la parte de SQL que crea, modifica o destruye las estructuras de la base
de datos, no se ocupa de los datos en sí. El manejo de datos es tarea del lenguaje de
manipulación de datos (DML). Algunas declaraciones DML se leen como oraciones
comunes en inglés y son fáciles de entender. Desafortunadamente, debido a que SQL le
brinda un control muy detallado de sus datos, otras declaraciones DML pueden ser
diabólicamente complejas.

Si una declaración DML incluye múltiples expresiones, cláusulas, predicados (más sobre
ellos más adelante en este capítulo) o subconsultas, comprender lo que esa declaración
intenta hacer puede ser un desafío. Después de lidiar con algunas de estas afirmaciones,
incluso puede considerar cambiar a una línea de trabajo más sencilla, como la cirugía
cerebral o la electrodinámica cuántica. Afortunadamente, una acción tan drástica no es
necesaria. Puede comprender sentencias SQL complejas dividiéndolas en sus
componentes básicos y analizándolas fragmento a fragmento.

Las declaraciones DML que puede utilizar sonINSERTAR, ACTUALIZAR, BORRAR,

FUSIONAR, [Link] declaraciones pueden constar de una variedad de
partes, incluidas varias cláusulas. Cada cláusula puede incorporar expresiones de valor,
conectivos lógicos, predicados, funciones agregadas y subconsultas. Puede hacer
discriminaciones finas entre los registros de la base de datos y extraer más información
de sus datos al incluir estas cláusulas en sus declaraciones. En el Capítulo 6, analizo el
funcionamiento de los comandos DML, y en los Capítulos 7 al 13, profundizo en los
detalles de estos comandos.

Expresiones de valor
Puedes usarexpresiones de valorcombinar dos o más valores. Existen varios tipos de
expresiones de valor, correspondientes a los diferentes tipos de datos:
 Capítulo 3: Los componentes de SQL sesenta y cinco

✓ Numérico

✓ Cadena

✓ Fecha y hora

✓ Intervalo

✓ Booleano

✓ Usuario definido

✓ Fila
✓ Recopilación

Los tipos booleano, definido por el usuario, fila y colección se introdujeron con SQL:1999.
Es posible que algunas implementaciones no las admitan todas todavía. Si desea utilizar
estos tipos de datos, asegúrese de que su implementación incluya los que desea utilizar.

Expresiones de valores numéricos

Para combinar valores numéricos, utilice los operadores de suma (+), resta (-),
multiplicación (*) y división (/). Las siguientes líneas son ejemplos de expresiones
de valores numéricos:

12 – 7
15/3 - 4
6* (8+2)

Los valores en estos ejemplos sonliterales numé[Link] valores también pueden ser nombres de
columnas, parámetros, variables del lenguaje principal o subconsultas, siempre que esos nombres de
columnas, parámetros, variables del lenguaje principal o subconsultas se evalúen como un valor
numérico. Los siguientes son algunos ejemplos:

SUBTOTAL + IMPUESTOS + ENVÍO

6 * MILLAS/HORAS
:meses/12

Los dos puntos en el último ejemplo indican que el siguiente término (meses)es un
parámetro o una variable del lenguaje principal.

Expresiones de valor de cadena

Expresiones de valor de cadenapuede incluir eloperador de concatenación(||).Utilice la concatenación
para unir dos cadenas de texto, como se muestra en la Tabla 3-2.
66 Parte I: Introducción a SQL

Tabla 3-2 Ejemplos de concatenación de cadenas

Expresión Resultado

'militar' || 'inteligencia' 'inteligencia militar'

CIUDAD|| ‘ ‘ ||ESTADO|| ' '||ZIP Una sola cadena con ciudad, estado y
código postal, cada uno separado por un
solo espacio.

Algunas implementaciones de SQL utilizan + como operador de concatenación en

lugar de ||.Consulte su documentación para ver qué operador utiliza su
implementación.

Algunas implementaciones pueden incluir operadores de cadena distintos de la

concatenación, pero el SQL estándar ISO no admite dichos operadores. La concatenación se
aplica tanto a cadenas binarias como a cadenas de texto.

Expresiones de valor de intervalo y fecha hora

Expresiones de valor de fecha y horalidiar con fechas y horas (¡sorpresa!). datos de FECHA,
HORA, MARCA DE TIEMPO,yINTERVALOLos tipos pueden aparecer en expresiones de valor de
fecha y hora. El resultado de una expresión de valor de fecha y hora es siempre otra fecha y
hora. Puede sumar o restar un intervalo de una fecha y hora y especificar información de zona
horaria.

A continuación se muestra un ejemplo de una expresión de valor de fecha y hora:

Fecha de vencimiento + INTERVALO '7' DÍA

Una biblioteca puede utilizar dicha expresión para determinar cuándo enviar un aviso
de retraso. El siguiente ejemplo especifica una hora en lugar de una fecha:

HORA ‘[Link]’ EN LOCAL

ElEN LOCALLas palabras clave indican que la hora se refiere a la zona horaria local.

Expresiones de valores de intervalolidiar con la diferencia (cuánto tiempo

pasa) entre una fecha y otra. Tienes dos tipos de intervalos:año mesytiempo
de dí[Link] puedes mezclar los dos en una expresión.

Como ejemplo de intervalo, supongamos que alguien devuelve un libro de la biblioteca

después de la fecha de entrega. Al utilizar una expresión de valor de intervalo como la del
siguiente ejemplo, puede calcular cuántos días tiene retraso el libro y aplicar una multa en
consecuencia:

(Fecha de devolución - Fecha de vencimiento) DÍA

 Capítulo 3: Los componentes de SQL 67
Debido a que un intervalo puede ser del tipo año-mes o diurno, es necesario
especificar qué tipo utilizar. (En el ejemplo anterior, especifico DÍA.)

Expresiones de valores booleanos

Aexpresión de valor booleanoprueba el valor de verdad de un predicado. El siguiente es
un ejemplo de una expresión de valor booleano:

(Clase = SENIOR) ES CIERTO

Si esta fuera una condición para la recuperación de filas de una tabla de estudiantes, solo se
recuperarían las filas que contienen los registros de los estudiantes del último año. Para
recuperar los registros de todos los no mayores, puede utilizar lo siguiente:

NO (Clase = SENIOR) ES VERDADERO

Alternativamente, podrías usar:

(Clase = SENIOR) ES FALSO

Para recuperar cada fila que tiene un valor nulo en elCLASEcolumna, uso

(Clase = SENIOR) ES DESCONOCIDO

Expresiones de valor de tipo definido por el usuario

Describo los tipos de datos definidos por el usuario en el Capítulo 2. Si es necesario, puede definir sus
propios tipos de datos en lugar de tener que conformarse con los proporcionados por SQL “stock”.
Las expresiones que incorporan elementos de datos de un tipo definido por el usuario deben
evaluarse como un elemento del mismo tipo.

Expresiones de valor de fila

Aexpresión de valor de fila,Como era de esperar, especifica un valor de fila. El valor de la fila
puede consistir en una expresión de valor o dos o más expresiones de valor delimitadas por
comas. Por ejemplo:

('Joseph Tykociner', 'Profesor emérito', 1918)

Esta es una fila en una tabla de profesores que muestra el nombre, el rango y el año de contratación de un miembro
de la facultad.

Expresiones de valor de colección

Aexpresión de valor de colecciónse evalúa como una matriz.
68 Parte I: Introducción a SQL

Expresiones de valores de referencia

Aexpresión de valor de referenciase evalúa como un valor que hace referencia a algún otro
componente de la base de datos, como una columna de tabla.

Predicados
Predicadosson equivalentes SQL de proposiciones lógicas. La siguiente
afirmación es un ejemplo de proposición:

"El estudiante es un estudiante de último año".

En una tabla que contiene información sobre los estudiantes, el dominio de la

CLASE la columna puede serSENIOR, JUNIOR, SEGUNDO, PRIMER AÑO,oNULO.
Puedes usar el predicadoCLASE = MAYORpara filtrar filas cuyo predicado es Falso y
retener sólo aquellas cuyo predicado es Verdadero. A veces el valor de un
predicado en una fila es Desconocido (NULO).En esos casos, puede optar por
descartar la fila o conservarla. (Después de todo, el estudiantepodría ser un
estudiante de último año.) El curso de acción correcto depende de la situación.

Clase = MAYORes un ejemplo de unpredicado de comparació[Link] tiene seis operadores

de comparación. Un predicado de comparación simple utiliza uno de estos operadores.
La tabla 3-3 muestra los predicados de comparación y algunos ejemplos legítimos y
falsos de su uso.

Tabla 3-3 Operadores de comparación y predicados de comparación

Operador Comparación Expresión

= Igual a Clase = MAYOR
<> No igual a Clase <> SÉNIOR
< Menos que Clase < SÉNIOR
> Mas grande que Clase> SÉNIOR
<= Menos que o igual a Clase <= SENIOR
>= Mayor qué o igual a Clase >= SENIOR

En el ejemplo anterior, solo las dos primeras entradas de la Tabla 3-3 (Clase = MAYORyClase
<> SÉNIOR)tener [Link] DE SEGUNDO AÑOse considera mayor queSÉNIOR
porqueENTONCESviene despuésSEen la secuencia de clasificación predeterminada, que
clasifica en orden alfabético ascendente. Sin embargo, esta interpretación probablemente
no sea la que usted desea.
 Capítulo 3: Los componentes de SQL 69

Conectivos lógicos
Conectivos lógicosLe permitirá construir predicados complejos a partir de predicados simples.
Digamos, por ejemplo, que desea identificar niños prodigio en una base de datos de
estudiantes de secundaria. Dos proposiciones que podrían identificar a estos estudiantes
podrían leerse como sigue:

"El estudiante es un estudiante de último año".

"La edad del estudiante es inferior a 14 años".

Puedes usar el conectivo ló[Link] crear un predicado compuesto que aísle los
registros de estudiantes que desee, como en el siguiente ejemplo:

Clase = SENIOR Y Edad < 14

Si usas elYconectivo, ambos predicados componentes deben ser verdaderos para que el
predicado compuesto sea verdadero. Utilizar elOconectivo cuando desea que el
predicado compuesto se evalúe como verdadero si cualquiera de los predicados
componentes es [Link] el tercer conectivo lógico. Estrictamente hablando,NO
no conecta dos predicados, sino que invierte el valor de verdad del predicado único al
que lo aplica. Tomemos, por ejemplo, la siguiente expresión:

NO (Clase = SENIOR)

Esta expresión es verdadera sólo siClaseno es igual aSÉNIOR.

Establecer funciones

A veces, la información que desea extraer de una tabla no se relaciona con filas
individuales sino con conjuntos de filas. SQL proporciona cincocolocar(oagregar)
funcionespara hacer frente a este tipo de situaciones. Estas funciones sonCUENTA,
MÁXIMO, MIN, SUMA,[Link] función realiza una acción que extrae datos de
un conjunto de filas en lugar de una sola fila.

CONTAR
ElCONTARLa función devuelve el número de filas de la tabla especificada. Para contar el
número de personas mayores precoces en mi base de datos de ejemplo de escuela secundaria,
utilice la siguiente declaración:

SELECCIONAR CUENTA (*)

DEL ESTUDIANTE
DONDE Grado = 12 Y Edad <14;
70 Parte I: Introducción a SQL

MÁXIMO

Utilizar elMÁXIMOfunción para devolver el valor máximo que ocurre en la columna

especificada. Supongamos que desea encontrar el estudiante de mayor edad matriculado en
su escuela. La siguiente declaración devuelve la fila apropiada:

SELECCIONE Nombre, Apellido, Edad

DEL ESTUDIANTE
DONDE Edad = (SELECCIONAR MAX(Edad) DEL ESTUDIANTE);

Esta declaración devuelve todos los estudiantes cuyas edades son iguales a la edad
máxima. Es decir, si la edad del estudiante mayor es 23 años, esta declaración devuelve
el nombre, apellido y la edad de todos los estudiantes que tienen 23 años.

Esta consulta utiliza una subconsulta. La subconsultaSELECCIONE MAX(Edad) DEL ESTUDIANTEestá

incrustado dentro de la consulta principal. Hablo de subconsultas (también llamadasconsultas
anidadas) en el Capítulo 12.

MÍNIMO

ElMÍNIMOLa función funciona igual queMÁXIMOexcepto esoMÍNIMObusca el valor

mínimo en la columna especificada en lugar del máximo. Para encontrar el estudiante
más joven matriculado, puede utilizar la siguiente consulta:

SELECCIONE Nombre, Apellido, Edad

DEL ESTUDIANTE
DONDE Edad = (SELECCIONAR MIN(Edad) DEL ESTUDIANTE);

Esta consulta devuelve todos los estudiantes cuya edad es igual a la edad del estudiante más
joven.

SUMA
ElSUMALa función suma los valores de una columna especificada. La columna debe ser uno de
los tipos de datos numéricos y el valor de la suma debe estar dentro del rango de ese tipo. Por
lo tanto, si la columna es del tipoPEQUEÑO,la suma no debe ser mayor que el límite superior de
laPEQUEÑOtipo de datos. En la base de datos minorista de este capítulo, la tabla FACTURA
contiene un registro de todas las ventas. Para encontrar el valor total en dólares de todas las
ventas registradas en la base de datos, utilice elSUMAfuncionar de la siguiente manera:

SELECCIONE SUMA(VentaTotal) DE FACTURA;

AVG
ElAVGLa función devuelve el promedio de todos los valores de la columna
especificada. Al igual que elSUMAfunción,AVGse aplica sólo a columnas con un
 Capítulo 3: Los componentes de SQL 71
tipo de datos numéricos. Para encontrar el valor de la venta promedio, considerando todas las
transacciones en la base de datos, use elAVGfuncionar así:

SELECCIONE PROMEDIO (VentaTotal) DE LA FACTURA

Los nulos no tienen valor, por lo que si alguna de las filas delVenta totalLa columna
contiene valores nulos, esas filas se ignoran en el cálculo del valor de la venta
promedio.

Subconsultas
Subconsultas,Como puede ver en la sección "Establecer funciones" anteriormente en este
capítulo, son consultas dentro de una consulta. En cualquier lugar donde pueda usar una
expresión en una declaración SQL, también puede usar una subconsulta. Las subconsultas
son herramientas poderosas para relacionar información de una tabla con información de
otra tabla; puedes incrustar (onido) una consulta en una tabla, dentro de una consulta en otra
tabla. Al anidar una subconsulta dentro de otra, permite el acceso a información de dos o más
tablas para generar un resultado final. Cuando utiliza las subconsultas correctamente, puede
recuperar casi cualquier información que desee de una base de datos. No se preocupe por
cuántos niveles de subconsultas admite su base de datos. Cuando comience a crear
subconsultas anidadas, se quedará sin comprender lo que está haciendo mucho antes de que
su base de datos se quede sin niveles de subconsultas que admite.

Lenguaje de control de datos

El lenguaje de control de datos (DCL) tiene cuatro comandos:COMPROMETER, RETROCEDER,
CONCEDER,[Link] comandos protegen la base de datos de daños, tanto accidentales
como intencionales.

Actas
Su base de datos es más vulnerable a sufrir daños mientras usted u otra persona la modifica. Incluso
en un sistema de usuario único, realizar un cambio puede resultar peligroso para una base de datos.
Si se produce una falla de software o hardware mientras el cambio está en progreso, una base de
datos puede quedar en un estado indeterminado que se encuentra en algún lugar entre donde
estaba antes de que comenzara la operación de cambio y donde estaría si la operación de cambio se
completara exitosamente.
72 Parte I: Introducción a SQL

SQL protege su base de datos restringiendo las operaciones que pueden cambiar la base de
datos para que puedan ocurrir solo dentro de las transacciones. Durante una transacción, SQL
registra cada operación realizada con los datos en un archivo de registro. Si algo interrumpe la
transacción antes delCOMPROMETERSEdeclaración finaliza la transacción, puede restaurar el
sistema a su estado original emitiendo unRETROCEDER declaración. ElRETROCEDERprocesa el
registro de transacciones a la inversa, deshaciendo todas las acciones que tuvieron lugar en la
transacción. Después de revertir la base de datos a su estado antes de que comenzara la
transacción, puede solucionar lo que haya causado el problema e intentar la transacción
nuevamente.

Siempre que pueda ocurrir un problema de hardware o software, su base de datos es

susceptible de sufrir daños. Para minimizar la posibilidad de daño, los DBMS actuales
cierran la ventana de vulnerabilidad tanto como sea posible al realizar todas las
operaciones que afectan la base de datos dentro de una transacción y luego realizar
todas estas operaciones a la vez, al final de la transacción. Los sistemas modernos de
gestión de bases de datos utilizan el registro junto con las transacciones para garantizar
que el hardware, el software o los problemas operativos no dañen los datos. Una vez
confirmada una transacción, está a salvo de todos los fallos del sistema, salvo los más
catastróficos. Antes del compromiso, las transacciones incompletas se pueden revertir a
sus puntos de inicio y aplicarse nuevamente, una vez que se corrija el problema.

En un sistema multiusuario, es posible que se dañe la base de datos o se obtengan resultados

incorrectos incluso si no se producen fallas de hardware o software. Las interacciones entre
dos o más usuarios que acceden a la misma tabla al mismo tiempo pueden provocar graves
problemas. Restringiendo los cambios para que ocurran sólodentrotransacciones, SQL
también soluciona estos problemas.

Al poner todas las operaciones que afectan a la base de datos en transacciones, puede
aislar las acciones de un usuario de las de otro. Este aislamiento es fundamental si
desea asegurarse de que los resultados que obtenga de la base de datos sean
precisos.

Quizás te preguntes cómo la interacción de dos usuarios puede producir resultados

inexactos. Aquí hay un ejemplo divertido y aterrador: supongamos que Donna lee un
registro en una tabla de base de datos. Un instante después (más o menos), David cambia
el valor de un campo numérico en ese registro. Ahora Donna vuelve a escribir un valor en
ese campo, según el valor que leyó inicialmente. Como Donna no está al tanto del cambio
de David, el valor después de la operación de escritura de Donna es incorrecto.

Puede surgir otro problema si Donna escribe en un registro y luego David lee ese
registro. Si Donna revierte su transacción, David no se da cuenta de la reversión y
basa sus acciones en el valor que leyó, que no refleja el valor que hay en la base de
datos después de la reversión. Esto suena como la trama de un episodio deAmo a
Lucy—es una buena comedia pero una pésima gestión de datos.
 Capítulo 3: Los componentes de SQL 73

Usuarios y privilegios
Otra amenaza importante para la integridad de los datos son los propios usuarios. Algunas
personas no deberían tener acceso a los datos. Otros deberían tener sólo acceso restringido a
algunos de los datos pero ningún acceso al resto. Algunos (pista:nomuchísimos) deberían tener
acceso ilimitado a todo lo que hay en la base de datos. Necesita un sistema para clasificar
usuarios y asignar privilegios de acceso a los usuarios en diferentes categorías.

El creador de un esquema especifica quién se considera su propietario. Como propietario de

un esquema, puede otorgar privilegios de acceso a los usuarios que especifique. Se retienen
todos los privilegios que no otorgue explícitamente. También puedes revocar privilegios que
ya hayas otorgado. Un usuario debe pasar un procedimiento de autenticación para demostrar
su identidad antes de poder acceder a los archivos que usted le autoriza a utilizar. Los detalles
de ese procedimiento dependen de la implementación.

SQL le brinda la capacidad de proteger los siguientes objetos de base de datos:

✓ Mesas
✓ columnas
✓ Puntos de vista

✓ Dominios
✓ Conjuntos de caracteres

✓ colaciones
✓ Traducciones

Hablo de conjuntos de caracteres, intercalaciones y traducciones en el Capítulo 5.

SQL admite varios tipos diferentes de protección:ver, agregar, modificar, eliminar,

hacer referencia,yusandobases de datos. También admite protecciones asociadas
con la ejecución de rutinas externas.

Usted permite el acceso utilizando elCONCEDERdeclaración y eliminar el acceso utilizando el

REVOCARdeclaración. Al controlar el uso de laSELECCIONARdeclaración, el DCL controla quién
puede ver un objeto de base de datos, como una tabla, columna o vista. Controlando el
INSERTARLa declaración determina quién puede agregar nuevas filas en una tabla. Restringir
el uso de laACTUALIZARla declaración a los usuarios autorizados le brinda control sobre quién
puede modificar las filas de la tabla; restringiendo elBORRARLa declaración controla quién
puede eliminar filas de la tabla.

Si una tabla de una base de datos contiene como clave externa una columna que es una
clave principal en otra tabla de la base de datos, puede agregar una restricción a la
primera tabla para que haga referencia a la segunda tabla. (El Capítulo 5 describe
74 Parte I: Introducción a SQL

claves externas.) Cuando una tabla hace referencia a otra, un usuario de la primera
tabla puede deducir información sobre el contenido de la segunda. Como propietario
de la segunda mesa, es posible que desee evitar este tipo de espionaje. El REFERENCIAS
DE SUBVENCIÓNLa declaración te da ese poder. La siguiente sección analiza el
problema de una referencia renegada y cómo laREFERENCIAS DE SUBVENCIÓN
declaración lo impide. Al utilizar elUSO DE CONCESIONESdeclaración, puede controlar
quién puede usar (o incluso ver) el contenido de un dominio, juego de caracteres,
intercalación o traducción. (Cubro las disposiciones de seguridad en el Capítulo 14.)

La Tabla 3-4 resume las sentencias SQL que se utilizan para otorgar y revocar
privilegios.

Tabla 3-4 Tipos de protección

Operación de protección Declaración

Permitir al usuario ver una tabla CONCEDER SELECCIONAR

Evitar que el usuario vea una tabla REVOCAR SELECCIÓN

Permitir al usuario agregar filas a una tabla INSERCIÓN DE SUBVENCIÓN

Evitar que el usuario agregue filas a una tabla REVOCAR INSERTAR

Permitir al usuario cambiar datos en las filas de la tabla ACTUALIZACIÓN DE LA SUBVENCIÓN

Evitar que el usuario cambie datos en las filas de la REVOCAR ACTUALIZACIÓN

tabla

Permitir al usuario eliminar filas de la tabla CONCEDER ELIMINAR

Evitar que el usuario elimine filas de la tabla REVOCAR ELIMINAR

Permitir al usuario hacer referencia a una tabla REFERENCIAS DE SUBVENCIÓN

Evitar que el usuario haga referencia a una tabla REVOCAR REFERENCIAS

Permitir al usuario utilizar un dominio, juego de CONCEDER USO EN DOMINIO,
caracteres, traducción o intercalación CONCEDER USO EN CONJUNTO DE
CARACTERES, CONCEDER USO EN
COLABORACIÓN, USO DE CONCESIÓN EN
TRADUCCIÓN

Evitar que el usuario utilice un dominio, juego REVOCAR USO EN DOMINIO,

de caracteres, intercalación o traducción REVOCAR USO EN
CONJUNTO DE CARACTERES, REVOCAR
USO EN COLABORACIÓN,
REVOCAR EL USO EN
TRADUCCIÓN
 Capítulo 3: Los componentes de SQL 75
Puedes dar diferentes niveles de acceso a diferentes personas, dependiendo de sus
necesidades. Los siguientes comandos ofrecen algunos ejemplos de esta capacidad:

CONCEDER SELECCIONAR
EN EL CLIENTE
AL ADMINISTRADOR_VENTAS;

El ejemplo anterior permite que una persona (el gerente de ventas) vea la
tabla CLIENTE.

El siguiente ejemplo permite a cualquier persona con acceso al sistema ver la lista de precios
minoristas:

CONCEDER SELECCIONAR
EN RETAIL_PRICE_LIST
AL PÚBLICO;

El siguiente ejemplo permite al gerente de ventas modificar la lista de precios minoristas.

Puede cambiar el contenido de las filas existentes, pero no puede agregar ni eliminar filas:

ACTUALIZACIÓN DE LA SUBVENCIÓN

EN RETAIL_PRICE_LIST
AL ADMINISTRADOR_VENTAS;

El siguiente ejemplo permite al gerente de ventas agregar nuevas filas a la lista de precios
minoristas:

INSERCIÓN DE SUBVENCIÓN

EN RETAIL_PRICE_LIST
AL ADMINISTRADOR_VENTAS;

Ahora, gracias a este último ejemplo, el gerente de ventas también puede eliminar filas
no deseadas de la tabla:

CONCEDER ELIMINAR
EN RETAIL_PRICE_LIST
AL GERENTE DE VENTAS;

Las restricciones de integridad referencial

pueden poner en peligro sus datos
Quizás piense que si puede controlar quién ve, crea, modifica y elimina datos en
una tabla, está bien protegido. Contramayoríaamenazas, lo eres. Sin embargo, un
hacker experto aún puede saquear la casa utilizando un método indirecto.
76 Parte I: Introducción a SQL

Una base de datos relacional correctamente diseñada tieneintegridad referencial,lo que significa que
los datos de una tabla de la base de datos son coherentes con los datos de todas las demás tablas.
Para garantizar la integridad referencial, los diseñadores de bases de datos aplican restricciones a las
tablas que restringen los datos que los usuarios pueden ingresar en las tablas. Pero aquí está la
desventaja de esa protección: si tiene una base de datos con restricciones de integridad referencial,
un usuario posiblemente pueda crear una nueva tabla que utilice una columna de una tabla
confidencial como clave externa. Esa columna sirve entonces como enlace a través del cual alguien
posiblemente pueda robar información confidencial. Ups.

Digamos, por ejemplo, que es un famoso analista bursátil de Wall Street. Mucha gente
cree en la precisión de sus selecciones de acciones, por lo que cada vez que recomienda
una acción a sus suscriptores, mucha gente la compra y su valor aumenta. Mantiene su
análisis en una base de datos, que contiene una tabla llamadaCUATRO [Link]
principales recomendaciones para su próximo boletín se encuentran en esa tabla.
Naturalmente, usted restringe el acceso aCUATRO ESTRELLASpara que esa noticia no se
filtre al público inversor antes de que sus suscriptores de pago reciban el boletín.

Sin embargo, sigues siendo vulnerable si alguien más puede crear una nueva tabla que utilice el
campo de nombre de acción deCUATRO ESTRELLAScomo clave externa, como se muestra en el
siguiente ejemplo de comando:

CREAR TABLA HOT_STOCKS (

Stock PERSONAJE (30) REFERENCIAS FOUR_STAR
);

El hacker ahora puede intentar insertar en la tabla el nombre de cada acción de la Bolsa
de Nueva York, la Bolsa de Valores de Estados Unidos y el NASDAQ. Las inserciones que
tienen éxito le dicen al hacker qué acciones coinciden con las acciones que usted nombra
en su tabla confidencial. El hacker no tarda mucho en extraer su lista completa de
acciones.

Puedes protegerte de hacks como el del ejemplo anterior teniendo mucho

cuidado al ingresar declaraciones similares a las siguientes:

REFERENCIAS DE SUBVENCIÓN (Stock)

EN CUATRO_ESTRELLAS
AL HACKER SECRETO;

Claramente estoy exagerando aquí. Nunca otorgarías ningún tipo de acceso a una tabla
crítica a una persona que no sea de confianza, ¿verdad? No si te diste cuenta de lo que
estabas haciendo. Sin embargo, los hackers actuales no sólo son inteligentes
técnicamente. También son maestros deIngeniería social,el arte de engañar a las
personas para que hagan lo que normalmente no harían. Aumente la alerta máxima
cada vez que alguien mencione algo relacionado con su información confidencial.
 Capítulo 3: Los componentes de SQL 77
Evite otorgar privilegios a personas que puedan abusar de ellos. Es cierto que la gente
no viene con garantías impresas en la frente. Pero si no le prestarías tu coche nuevo a
una persona para un viaje largo, probablemente no deberías concederle la REFERENCIAS
privilegio en una mesa importante.

El ejemplo anterior ofrece una buena razón para mantener un control cuidadoso de
laREFERENCIASprivilegio. Aquí hay otras dos razones por las que debería mantener
un control cuidadoso deREFERENCIAS:

✓ Si la otra persona especifica una restricción enACCIONES CALIENTESusando un

RESTRINGIRopción e intenta eliminar una fila de su tabla, el DBMS le dice que
no puede, porque hacerlo violaría una restricción de integridad referencial.

✓ Si quieres usar elGOTAcomando para destruir tu mesa, descubres que debes

hacer que la otra personaGOTAsu restricción (o su tabla) primero.

El resultado final: permitir que otra persona especifique restricciones de integridad en su

tabla no sólo introduce una posible brecha de seguridad, sino que también significa que el
otro usuario a veces se interpone en su camino.

Delegar la responsabilidad de la seguridad

Para mantener su sistema seguro, debe restringir severamente los privilegios de acceso que
otorga, así como a las personas a quienes les otorga estos privilegios. Pero es probable que las
personas que no pueden hacer su trabajo porque no tienen acceso lo molesten
constantemente. Para preservar su cordura, probablemente necesitará delegar parte de la
responsabilidad de mantener la seguridad de la base de datos. SQL prevé dicha delegación a
través de laCON OPCIÓN DE SUBVENCIÓNcláusula. Considere el siguiente ejemplo:

ACTUALIZACIÓN DE LA SUBVENCIÓN

EN RETAIL_PRICE_LIST
A SALES_MANAGER CON OPCIÓN DE CONCESIÓN;

Esta afirmación es similar a la [Link]ÓN DE LA SUBVENCIÓNPor ejemplo, el

extracto permite al gerente de ventas actualizar la lista de precios minoristas. ElCON OPCIÓN
DE SUBVENCIÓNLa cláusula también le otorga el derecho de otorgar el privilegio de
actualización a quien quiera. Si utiliza esta forma deCONCEDERdeclaración, no sólo debe
confiar en que el beneficiario usará el privilegio sabiamente, sino también en que ella elegirá
sabiamente al otorgar el privilegio a otros.
78 Parte I: Introducción a SQL

Lo último en confianza (y por lo tanto lo último en vulnerabilidad) es ejecutar una

declaración como la siguiente:

CONCEDE TODOS LOS PRIVILEGIOS

EN CUATRO_ESTRELLAS
A Benedict_Arnold CON OPCIÓN DE SUBVENCIÓN;

SerextremadamenteTenga cuidado al utilizar declaraciones como ésta. Otorgar todos los

privilegios, junto con la opción de otorgar, lo deja al máximo expuesto. Benedict Arnold
fue uno de los generales de confianza de George Washington durante la Guerra
Revolucionaria Americana. Desertó y se pasó a los británicos, convirtiéndose así en el
traidor más vilipendiado de la historia de Estados Unidos. No quieres que te pase algo
así.
 Parte II

Usar SQL para crear bases de datos

[Link]/extras/sqlpara obtener excelente contenido para principiantes en línea.

 En esta parte…
✓ Creando estructuras simples

✓ Establecer relaciones entre tablas.

✓ [Link]/extras/sqlpara obtener excelente contenido para
principiantes en línea.
 Capítulo 4

Construyendo y manteniendo un simple

Estructura de la base de datos

En este capítulo
▶ Usar RAD para crear, cambiar y eliminar una tabla de base de datos
▶ Usar SQL para crear, cambiar y eliminar una tabla de base de datos
▶ Migrar su base de datos a otro DBMS

C La historia de la informática cambia tan rápidamente que a veces el rápido cambio

de generaciones tecnológicas puede resultar confuso. Alto nivel (llamadotercera
generación) lenguajes como FORTRAN, COBOL, BASIC, Pascal y C fueron los primeros
lenguajes utilizados para construir y cambiar grandes bases de datos. Los lenguajes
posteriores incluyeron algunos diseñados específicamente para su uso con bases de
datos, como dBASE, Paradox y R:BASE. (¿Entonces lo eran estos lenguajes de tercera
generación y media? No importa.) El siguiente paso en esta progresión fue la aparición de
entornos de desarrollo como Access, PowerBuilder y C++ Builder, los llamados lenguajes
de cuarta generación (4GL). . Ahora las cosas han ido más allá de las generaciones
numeradas hacia herramientas de desarrollo rápido de aplicaciones (RAD) y entornos de
desarrollo integrados (IDE) como Eclipse y Visual Studio .NET, que se pueden usar con
cualquiera de varios lenguajes (como
C, C++, C#, Python, Java, Visual Basic o PHP). Los utiliza para ensamblar
componentes de aplicaciones en aplicaciones de producción.

Como SQL no es un lenguaje completo, no encaja claramente en una de las categorías

generacionales que acabo de mencionar. Tampoco es un IDE. Hace uso de comandos a
la manera de un lenguaje de tercera generación, pero es esencialmente no
procedimental, como un lenguaje de cuarta generación. No importa cómo clasifique
SQL, puede usarlo junto con un IDE o con herramientas de desarrollo más antiguas de
tercera y cuarta generación. Puede escribir el código SQL usted mismo o puede mover
objetos en la pantalla y hacer que el entorno de desarrollo genere un código
equivalente para usted. Los comandos que salen a la base de datos remota son SQL
puro en cualquier caso.
82 Parte II: Uso de SQL para crear bases de datos

En este capítulo, lo guiaré a través del proceso de uso de una herramienta RAD para crear,
modificar y eliminar una tabla simple, y luego analizo cómo crear, alterar y eliminar la
misma tabla usando SQL.

Uso de una herramienta RAD para crear

una base de datos simple
La gente usa bases de datos porque quiere realizar un seguimiento de información
importante. A veces la información que quieren rastrear es simple y otras no. Un buen
sistema de gestión de bases de datos proporciona lo que necesita en cualquier caso.
Algunos DBMS le brindan SQL. Otros, como herramientas RAD,brindarle un entorno
gráfico orientado a objetos. Algunos DBMS admiten ambos enfoques. En las siguientes
secciones, le muestro cómo crear una base de datos sencilla de una sola tabla utilizando
una herramienta de diseño gráfico de bases de datos. Utilizo Microsoft Access en mis
ejemplos, pero el procedimiento es similar para otros entornos de desarrollo basados
en Windows.

Decidir qué rastrear

El primer paso al crear una base de datos es decidir qué desea rastrear. Por ejemplo,
imagina que acabas de ganar 248 millones de dólares en la lotería Powerball. (Está bien
imaginaralgo como esto. En la vida real, es tan probable como encontrar su automóvil
aplastado por un meteorito gigante). Amigos y conocidos de los que no ha tenido noticias
en años están surgiendo de repente de la nada. Algunos tienen oportunidades de
negocio seguras e imperdibles en las que quieren que usted invierta. Otros representan
causas valiosas que podrían beneficiarse de su apoyo. Como buen administrador de su
nueva riqueza, se da cuenta de que algunas oportunidades comerciales no son tan
buenas como otras y que algunas causas no son tan valiosas como otras. Decide poner
todas las opciones en una base de datos para poder realizar un seguimiento de ellas y
emitir juicios justos y equitativos.

Decide realizar un seguimiento de la siguiente información sobre sus amigos y

familiares:

✓ Nombre de pila

✓ Apellido
✓ DIRECCIÓN

✓ Ciudad

✓ Estado o Provincia
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 83

✓ Código Postal

✓ Teléfono

✓ Qué tan conocido (su relación con la persona)

✓ Propuesta

✓ Negocios o caridad

Decide colocar todos los elementos enumerados en una única tabla de base de datos;
no necesitas algo elaborado.

Creando una tabla de base de datos

Cuando inicia su entorno de desarrollo de Access 2013, aparece la pantalla que se
muestra en la Figura 4-1. A partir de ahí, puede crear una tabla de base de datos de varias
maneras diferentes. Empiezo con la vista Hoja de datos porque ese enfoque le muestra
cómo crear una base de datos desde cero. Sigue leyendo.

Figura 4-1:
El
microsoft
Acceso
apertura
pantalla.

Crear una tabla de base de datos en la vista Hoja de datos

De forma predeterminada, Access 2013 se abre en la vista Hoja de datos. Para crear una base de datos de Access
en la vista Hoja de datos, haga doble clic en la plantilla de base de datos de escritorio en blanco.
84 Parte II: Uso de SQL para crear bases de datos

Su hoja de datos de Access está lista para que usted comience a ingresar datos en la Tabla 1,
la primera tabla de su base de datos, como se muestra en la Figura 4-2. Puede cambiar el
nombre de la tabla por algo más significativo más adelante. Access le da a su nueva base de
datos el nombre predeterminadoBase de datos1 (oBase de datos31si ya creó 30 bases de
datos y no se molestó en darles nombres significativos). Es mejor darle a la base de datos un
nombre significativo desde el principio para evitar confusiones.

Figura 4-2:
El
Ficha de datos

ver en el
Acceso
desarrollo
ambiente.

Ese es el método de empezar desde cero, pero tiene varias formas diferentes de crear
una tabla de base de datos de Access. El siguiente usa la vista Diseño.

Crear una tabla de base de datos en la vista Diseño

En la vista Hoja de datos (consulte la Figura 4-2), crear una tabla de base de datos es bastante fácil:
simplemente comience a ingresar datos. Sin embargo, ese enfoque es propenso a errores, porque es
fácil pasar por alto los detalles. Una mejor manera de crear una tabla es en la vista Diseño siguiendo
estos pasos:

1. Con Access abierto en la vista Hoja de datos (la opción predeterminada), haga clic en la
pestaña Inicio en la cinta y luego haga clic en Ver debajo del icono en la esquina superior
izquierda de la ventana. Elija Vista de diseño en el menú desplegable.

Cuando elige Vista Diseño, aparece un cuadro de diálogo que le pide que ingrese un
nombre de tabla.
Traducido del inglés al español - [Link]

Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 85

2. IngresarFUERZA(para sus ganancias de Powerball) y haga clic en Aceptar.

Aparece la vista Diseño (que se muestra en la Figura 4-3).

Figura 4-3:
El diseño
inicio de la vista-
pantalla de inicio.

Observe que la ventana está dividida en áreas funcionales. Dos de ellos son
especialmente útiles para crear tablas de bases de datos:

• Opciones de vista de diseño:Un menú en la parte superior de la ventana ofrece

opciones de Inicio, Crear, Datos externos, Herramientas de base de datos y
Diseño. Cuando se muestra la cinta, las herramientas disponibles en la vista
Diseño están representadas por los íconos justo debajo del menú. En la Figura
4-3, lo resaltado muestra que los íconos Diseño y Clave principal están
seleccionados.

• Panel Propiedades de campo:En esta área para definir campos de base de datos, el
cursor parpadea en la columna Nombre de campo de la primera fila. Access sugiere que
especifique una clave principal aquí, asígnele un nombreIDENTIFICACIÓN, y dale el
Número automáticotipo de datos.

Autonumérico, un tipo de datos de Access, no es un tipo de SQL estándar;

incrementa un número entero en el campo en uno automáticamente cada vez que
agrega un nuevo registro a una tabla. Este tipo de datos garantiza que el campo
que utilice como clave principal no se duplicará y, por lo tanto, seguirá siendo
único.

3. En el área Propiedades de campo, cambie el Nombre de campo de la clave principal de

IDENTIFICACIÓNaNúmero de propuesta.
86 Parte II: Uso de SQL para crear bases de datos

El nombre de campo sugerido para la clave principal,IDENTIFICACIÓN,simplemente no

es muy informativo. Si adquiere el hábito de cambiarlo por algo más significativo (y/o
proporcionar información adicional en la columna Descripción), será más fácil realizar
un seguimiento de para qué sirven los campos de su base de datos. Aquí el nombre del
campo es suficientemente descriptivo.

La Figura 4-4 muestra el diseño de la tabla de la base de datos en este punto.

Figura 4-4:
Usando un

descriptivo
nombre del campo

para definir el
Clave primaria.

4. En el panel Propiedades de campo, verifique las suposiciones que Access ha hecho

automáticamente sobre elNúmero de propuestacampo.

La Figura 4-4 muestra los siguientes supuestos:

• El Tamaño del campo se ha establecido en Entero largo.

• Los nuevos valores se obtienen incrementando.

• Se requiere indexación y no se permiten duplicados.

• La alineación del texto es general.

Como suele ser el caso, las suposiciones que hace Access están bien para lo
que desea hacer. Si alguna de las suposiciones es incorrecta, puede anularla
ingresando nuevos valores.
5. Especifique el resto de campos que desea que tenga esta tabla.

La Figura 4-5 muestra la vista Diseño después de haber ingresado alNombre de pilacampo.
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 87

Figura 4-5:
La mesa-
creación
ventana
después

Nombre de pila

ha sido
definido.

El tipo de datos paraNombre de pilaesTexto corto,en vez deNúmero automático, por lo

que las propiedades de campo que se le aplican son diferentes. Aquí Access ha dado
Nombre de pilael tamaño de campo predeterminado para datos de texto breve, que es
de 255 caracteres. No conozco mucha gente cuyos nombres sean tan largos. Access es lo
suficientemente inteligente como para asignar sólo el espacio de memoria que
realmente se necesita para una entrada. No asigna ciegamente 255 bytes
independientemente de lo que se ingrese. Sin embargo, es posible que otros entornos de
desarrollo no tengan esta capacidad. Me gusta asignar valores razonables a la longitud
de los campos. Esto me evita problemas cuando paso de un entorno de desarrollo a otro.

Aquí la suposición de acceso predeterminada es queNombre de pilano es un

campo obligatorio. Puede ingresar un registro en la tabla POWER y dejar el Nombre
de pilacampo en blanco, que tiene en cuenta a las personas que tienen un solo
nombre, como Cher o Bono.

6. Cambie el tamaño del campo paraNombre de pilaa 15.

Para obtener un resumen de por qué es una buena idea, consulte la barra lateral
adjunta, "Pensar en el futuro al diseñar su mesa".
88 Parte II: Uso de SQL para crear bases de datos

Pensando en el futuro al diseñar su mesa

En algunos entornos de desarrollo (distintos de Es posible que observe otra propiedad de campo que
Microsoft Access), reducir el tamaño delNombre aparece con frecuencia: la propiedad Indexada. Si no
de pilacampo a 15 ahorra 240 bytes paracada prevé tener que recuperar un registro por un campo
registro en la base de datossi utiliza caracteres determinado, no desperdicie energía de procesamiento
ASCII (UTF-8), 480 bytes si utiliza caracteres indexándolo. Sin embargo, tenga en cuenta que en una
UTF-16 o 960 bytes si utiliza caracteres UTF-32. Se tabla grande con muchas filas, puede acelerar
suma. Mientras lo hace, eche un vistazo a otras enormemente las recuperaciones indexando el campo
suposiciones predeterminadas para algunas otras que utiliza para identificar el registro que desea
propiedades de campo e intente anticipar cómo recuperar. El problema (o, en este caso, un posible
podría usarlas a medida que la base de datos aumento del rendimiento) está en los detalles al diseñar
crezca. Algunos de estos campos requieren las tablas de su base de datos.
atención inmediata para hacerlos más eficientes (
Nombre de pilaes un ejemplo útil); otros se
aplican sólo a casos relativamente oscuros.

7. Para garantizar que pueda recuperar un registro rápidamente de la tabla

POWERApellido (cualesprobable), cambie elIndexadopropiedad para Apellidoa
Sí (se aceptan duplicados),como se muestra en la Figura 4-6.

Figura 4-6:
La mesa-
creación
ventana
después

Apellido
ha sido
definido.
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 89

La figura muestra algunos cambios que hice en el panel Propiedades de campo:

• He reducido el tamaño máximo de campo de 255 a 20.

• Cambié Requerido a Sí, Permitir longitud cero a No e Indexado a Sí
(se aceptan duplicados). Quiero que cada propuesta incluya el
apellido del responsable de la misma. No se permite un nombre
de longitud cero y elApellidoEl campo será indexado.
• Permito duplicados; dos o más proponentes podrán tener el mismo
apellido. Esto es prácticamente seguro en el caso de la tabla POWER;
Espero propuestas de mis tres hermanos, así como de mis hijos y mi
hija soltera, sin mencionar a mis primos.
• La opción Sí (No duplicados), que hicenoelegir, en realidad sería
apropiado para un campo que es la clave principal de una tabla. La
clave principal de una tabla nunca debe contener duplicados.
8. Ingrese el resto de los campos, cambiando el Tamaño de campo predeterminado a
algo apropiado en todos los casos.

La Figura 4-7 muestra el resultado.

Figura 4-7:
La mesa-
creación
ventana
después de todo

los campos son

definido.

Como puede ver en la Figura 4-7, el campo para empresas o organizaciones benéficas
(Negocios o Caridad)no está indexado. No tiene sentido indexar un campo que sólo
tiene dos entradas posibles; la indexación no reduce la selección lo suficiente como
para que valga la pena.
90 Parte II: Uso de SQL para crear bases de datos

Access utiliza el términocampoen vez [Link] sistemas de procesamiento de

archivos originales del programa no eran relacionales y utilizaban la terminología de archivos,
campos y registros que son comunes para los sistemas de archivos planos.

9. Guarde su tabla haciendo clic en el icono del disquete en la esquina superior

izquierda de la ventana.

Es aconsejable mantener un ojo en el futuro a medida que desarrolla su base de datos.

Es una buena idea (por ejemplo) guardar frecuentemente a medida que desarrollas;
simplemente haga clic en el icono del disquete de vez en cuando. Hacerlo podría
ahorrarle muchos trabajos tediosos en caso de un corte de energía u otro evento
adverso. Además, aunque no destruirá el planeta si le da el mismo nombre a una base
de datos y a una de las tablas que contiene la base de datos, puede resultar un poco
confuso para los administradores y usuarios posteriores. Como regla general, es más
práctico (y amable) pensar simplemente en dos nombres diferentes.

Después de guardar su tabla, es posible que necesite modificar su diseño original,

como lo describo en la siguiente sección, "Alteración de la estructura de la tabla".

Modificar la estructura de la tabla

A menudo, las tablas de bases de datos recién creadas necesitan algunos ajustes. Si
trabaja para otra persona, su cliente puede acudir a usted después de crear la base de
datos y decirle que quiere realizar un seguimiento de otro elemento de datos, tal vez
varios más. Eso significa que tienes que volver a la mesa de dibujo.

Si está creando una base de datos para su propio uso, las deficiencias en su estructura
inevitablemente se hacen [Link]ésusted crea la estructura (probablemente sea una
cláusula de la Ley de Murphy). Por ejemplo, supongamos que comienza a recibir propuestas de
otros países y necesita agregar unPaíscolumna. O tiene una base de datos antigua que no
incluía direcciones de correo electrónico: es hora de actualizarla. En esta sección, le muestro
cómo usar Access para modificar una tabla. Otras herramientas RAD tienen capacidades
comparables y funcionan de manera similar.

Si llega un momento en el que necesita actualizar las tablas de su base de datos, tómese un
momento para evaluar todos los campos que están utilizando. Por ejemplo, también puedes
agregar un segundoDIRECCIÓNcampo para personas con direcciones complejas y unPaís
campo para propuestas de otros países.

Aunque es bastante fácil actualizar las tablas de la base de datos, debes evitar hacerlo
siempre que sea posible. Es probable que cualquier aplicación que dependa de la
antigua estructura de la base de datos se rompa y deberá repararse. Si tiene muchas
aplicaciones, esta tarea podría ser una tarea importante. Trate de anticipar ampliaciones
que podrían ser necesarias en el futuro y tome medidas para ello. Que lleva
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 91

Por lo general, es preferible realizar un poco de sobrecarga adicional en la base de datos que
actualizar una gran cantidad de aplicaciones escritas hace varios años. Probablemente hace mucho
que no se sabe cómo funcionan y es posible que, en esencia, no se puedan solucionar.

Para insertar nuevas filas y acomodar cambios, abra la tabla y siga estos
pasos:

1. En la ventana de creación de tabla, haga clic derecho en el pequeño cuadrado de

color a la izquierda del campo Ciudad para seleccionar esa fila y elija Insertar filas
en el menú que aparece.

Aparece una fila en blanco encima de la posición del cursor y empuja hacia abajo todas las filas
existentes, como se muestra en la Figura 4-8.

Figura 4-8:
La mesa-
creación
ventana
después de abrir-

subiendo

espacio para
un segundo
DIRECCIÓN

línea.

2. Ingrese los campos que desea agregar a su tabla.

Agregué unDirección 2campo encima delCiudadcampo y unPaíscampo encima

delTeléfonocampo.

3. Después de terminar las modificaciones, guarde la tabla antes de cerrarla. El

resultado debería ser similar a la Figura 4-9.

92 Parte II: Uso de SQL para crear bases de datos

Figura 4-9:
Tu revisado
definición de tabla

ción debería
parece similar
a esto.

Creando un índice
En cualquier base de datos, necesita una forma rápida de acceder a los registros
de interés. (Esto nunca es más cierto que cuando gana la lotería: la cantidad de
propuestas de inversión y caridad que recibe fácilmente podría llegar a miles).
Digamos, por ejemplo, que desea ver todas las propuestas de personas que dicen
ser su hermano. . Suponiendo que ninguno de tus hermanos haya cambiado su
apellido por motivos teatrales o profesionales, puedes aislar estas ofertas basando
tu recuperación en el contenido delApellidocampo, como se muestra en la
siguiente consulta SQL ad hoc:

SELECCIONAR * DESDE ENERGÍA

DONDE Apellido = 'Marx';

Es posible que esa estrategia no funcione para las propuestas hechas por medios hermanos y
cuñados, por lo que es necesario mirar en un campo diferente, como se muestra en el siguiente
ejemplo:

SELECCIONAR * DESDE ENERGÍA

DONDE HowKnown = 'cuñado'
O
HowKnown = 'medio hermano';
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 93

SQL escanea la tabla fila por fila, buscando entradas que satisfagan lasDÓNDE condición
de la cláusula. Si la tabla POWER es grande (decenas de miles de registros), es posible
que termine esperando un rato. Puedes acelerar las cosas aplicandoíndices a la tabla
POTENCIA. (Uníndicees una tabla de punteros. Cada fila del índice apunta a una fila
correspondiente en la tabla de datos).

Puede definir un índice para todas las diferentes formas en que desee acceder a sus
datos. Si agrega, cambia o elimina filas en la tabla de datos, no necesita volver a ordenar
la tabla; solo necesita actualizar los índices. Puede actualizar un índice mucho más rápido
de lo que puede ordenar una tabla. Después de establecer un índice con el orden
deseado, puede utilizar ese índice para acceder a las filas de la tabla de datos casi
instantáneamente.

Porque elNúmero de propuestaEl campo es único y breve; utilizar ese campo es la forma más
rápida de acceder a un registro individual. Esas cualidades lo convierten en un candidato ideal
para una clave primaria. Y como las claves primarias suelen ser la forma más rápida de acceder
a los datos,la clave principal de todas y cada una de las tablas siempre debe estar indexada;
Acceda a las claves primarias de los índices automáticamente. Sin embargo, para utilizar este
campo, debe conocer elNúmero de propuestadel registro que deseas. Es posible que desee
crear índices adicionales basados en otros campos, comoApellido, Código Postal,oCómo
[Link] una tabla en la que indexaApellido,después de una búsqueda se encuentra la
primera fila que contiene unApellidodeMarx,la búsqueda los ha encontrado a todos. Las claves
de índice para todos losmarxLas filas se almacenan una tras otra. puedes recuperarChico,
Groucho, Harpo, Zeppo,ycarloscasi tan rápido como se pueden obtener los datoschicosolo.

Los índices añaden una sobrecarga a su sistema, lo que ralentiza las operaciones. Debe
equilibrar esta desaceleración con la velocidad que obtiene al acceder a los registros a través
de un índice.

A continuación se ofrecen algunos consejos para elegir buenos campos de indexación:

✓ Siempre es una buena idea indexar los campos que utiliza con frecuencia para acceder a los
registros. Puede acceder rápidamente a los registros sin demasiada latencia.

✓ No se moleste en crear índices para los campos quenuncautilizar como claves de

recuperación. Crear índices innecesarios es una pérdida de tiempo y espacio de
memoria, y no se gana nada.

✓ No cree índices para campos que no diferencien un registro de muchos

otros. Por ejemplo, elNegociosOCaridadEl campo simplemente divide
los registros de la tabla en dos categorías; no es un buen índice.

La eficacia de un índice varía de una implementación a otra. Si migra una base de datos
de una plataforma a otra, es posible que los índices que ofrecieron el mejor rendimiento
en el primer sistema no funcionen mejor en la nueva plataforma. De hecho, el
rendimiento puede ser peor que si no hubiera indexado la base de datos en absoluto.
Pruebe varios esquemas de indexación para ver cuál le brinda la
94 Parte II: Uso de SQL para crear bases de datos

mejor rendimiento general y optimice sus índices para que ni la velocidad de recuperación ni la
velocidad de actualización se vean afectadas por la migración.

Para crear índices para la tabla POWER, simplemente seleccione Sí para Indexado en el panel
Propiedades de campo de la ventana de creación de tablas.

Access hace dos trucos útiles automáticamente: crea un índice para Código Postal (
porque ese campo se usa a menudo para recuperaciones)yindexa la clave principal.
(Ah, progreso. Me encanta).

Código Postalno es una clave principal y no es necesariamente única; lo contrario es

cierto paraNúmero de [Link] creaste un índice [Link] lo mismo para
Cómo conocidoporque es probable que ambos se utilicen para recuperaciones.

Después de crear todos sus índices, no olvide guardar la nueva estructura de la tabla
antes de cerrarla.

Si utiliza una herramienta RAD que no sea Microsoft Access, la información de esta
sección no se aplica a usted. Sin embargo, el proceso general es bastante similar.

Eliminar una tabla

En el curso de la creación de una tabla (como la tabla POWER que describo en este capítulo)
con la estructura exacta que desea, es posible que tenga que crear algunas versiones
intermedias a lo largo del camino. Tener estas tablas variantes en su sistema puede confundir
a las personas más adelante, así que elimínelas ahora mientras aún estén frescas en su mente.
Para hacerlo, haga clic derecho en la tabla que desea eliminar de la lista Todas las tablas en el
lado izquierdo de la ventana. Aparece un menú y una de las opciones que ofrece es Eliminar.
Cuando hace clic en Eliminar, como se muestra en la Figura 4-10, la tabla se elimina de la base
de datos.

Seren realidadseguro de lo que estás haciendo. Cuando haces clic en Eliminar, esa tabla y todo el
trabajo que pusiste en ella desaparecerán.

Figura 4-10:
Seleccionar

Eliminar a
eliminar un

mesa.
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 95

Si Access elimina una tabla, también elimina todas las tablas subsidiarias, incluidos los
índices que pueda tener la tabla.

Construyendo POTENCIA con DDL de SQL

Todas las funciones de definición de bases de datos que puede realizar con una herramienta RAD
(como Access) también son posibles si usa SQL para crear su tabla. Por supuesto, usar SQL no es tan
glamoroso: en lugar de hacer clic en las opciones del menú con el mouse, ingresa comandos desde el
teclado. Las personas que prefieren manipular objetos visuales encuentran las herramientas RAD
fáciles de entender y utilizar. Las personas que se sienten más felices encadenando palabras en
declaraciones lógicas encuentran que los comandos SQL son más fáciles de usar.

Vale la pena volverse competente en el uso de ambos métodos porque algunas

cosas se representan más fácilmente utilizando la técnica orientada a objetos
(ratón) y otras se manejan más fácilmente escribiendo comandos SQL.

En las siguientes secciones, uso SQL para crear la misma tabla que antes y luego hago las
mismas operaciones de alteración y eliminación que hice con la herramienta RAD en la
primera parte de este capítulo.

Usando SQL con Microsoft Access

Access está diseñado como una herramienta de desarrollo rápido de aplicaciones (RAD)
que no requiere programación. Puede escribir y ejecutar sentencias SQL en Access,
pero debe utilizar un método de puerta trasera para hacerlo. Para abrir un editor
básico donde pueda ingresar código SQL, siga estos pasos:

1. Abra su base de datos y haga clic en la pestaña CREAR para mostrar la cinta en la
parte superior de la ventana.

2. Haga clic en Diseño de consulta en la sección Consultas.

Aparece el cuadro de diálogo Mostrar tabla.

3. Seleccione la tabla POTENCIA. Haga clic en el botón Agregar y luego haga clic en el botón Cerrar
para cerrar el cuadro de diálogo.

Al hacerlo, se produce la pantalla que se muestra en la Figura 4-11.

Aparece una imagen de la tabla POWER y sus atributos en la parte superior del
área de trabajo y debajo aparece una cuadrícula de Consulta por ejemplo
(QBE). Access espera que usted ingrese una consulta ahora usando la
cuadrícula QBE. (Tú podríahágalo, claro, pero no le dirá nada sobre cómo usar
SQL en el entorno de Access).
96 Parte II: Uso de SQL para crear bases de datos

Figura 4-11:
La consulta
pantalla con
FUERZA
mesa
seleccionado.

4. Haga clic en la pestaña Inicio y luego en el icono Ver en la esquina izquierda de

la cinta.

Se despliega un menú que muestra las diferentes vistas disponibles en el modo de

consulta, como se muestra en la Figura 4-12.

Figura 4-12:
Los datos-
vistas base
disponible en
Modo de consulta.

Una de esas vistas es la Vista SQL.

5. Haga clic en Vista SQL para mostrar la pestaña Objeto de vista SQL.

Como muestra la Figura 4-13, la pestaña Objeto de vista SQL ha asumido (muy
racionalmente) que desea recuperar cierta información de la tabla POWER,
por lo que ha escrito la primera parte para usted. No sabe exactamente lo que
desea recuperar, por lo que muestra solo la parte en la que se siente seguro.
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 97

Figura 4-13:
El objeto
pestaña en SQL

vista.

Esto es lo que está escrito hasta ahora:

SELECCIONAR

DEL PODER ;
6. Complete un asterisco (*) en el área en blanco de la primera línea y agregue un
DÓNDEcláusula después de laDElínea.

Si ya había ingresado algunos datos en la tabla POWER, podría

recuperarlos con algo como:
SELECCIONAR *
DEL PODER
DONDE Apellido = 'Marx';
Asegúrese de que el punto y coma (;) sea lo último en la declaración SQL. Necesitas moverlo
hacia abajo desde justo despuésFUERZAhasta el final de la siguiente línea hacia abajo.

7. Cuando haya terminado, haga clic en el icono Guardar del disquete.

Access le pide un nombre para la consulta que acaba de crear.

8. Introduzca un nombre y luego haga clic en Aceptar.

Su declaración se guarda y puede ejecutarse como una consulta más adelante.

Creando una tabla

Ya sea que esté trabajando con Access o con un DBMS de nivel empresarial con todas
las funciones, como Microsoft SQL Server, Oracle 11g o IBM DB2, para crear una tabla
de base de datos con SQL, debe ingresar la misma información que usaría.
98 Parte II: Uso de SQL para crear bases de datos

ingrese si creó la tabla con una herramienta RAD. La diferencia es que la herramienta RAD le
ayuda proporcionándole una interfaz visual, en forma de un cuadro de diálogo de creación de
tablas (o algún esqueleto de entrada de datos similar), y evitando que introduzca nombres,
tipos o tamaños de campos no válidos.

SQL no te brinda tanta ayuda. Debes saber lo que estás haciendo desde el principio;
resolver las cosas a lo largo del camino puede conducir a resultados de base de datos
menos que deseables. Debes ingresar todo elCREAR MESAdeclaración antes de que SQL
siquiera la mire, y mucho menos le dé alguna indicación de si cometió errores en la
declaración.

En el SQL estándar ISO/IEC, la declaración que crea una tabla de seguimiento de propuestas
(idéntica a la creada anteriormente en este capítulo) utiliza la siguiente sintaxis:

CREAR TABLA POWERSQL (

Número de propuesta ENTERO CLAVE PRIMARIA,
Nombre de pila CARACTERÍSTICA (15),

Apellido CARACTERÍSTICA (20),

DIRECCIÓN CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Provincia del estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

País CARACTERÍSTICA (30),

Teléfono CARACTERÍSTICA (14),

Cómo conocido CARACTERÍSTICA (30),

Propuesta CARACTERÍSTICA (50),

NegociosOCaridad CARACTER (1) );

La información en la declaración SQL es esencialmente la misma información que ingresa

usando la interfaz gráfica de usuario de Access. Lo bueno de SQL es que el lenguaje es
universal. La misma sintaxis estándar funciona independientemente del producto DBMS
compatible con el estándar que utilice.

En Access 2013, crear objetos de base de datos, como tablas, es un poco más complicado. No puedes
simplemente escribir unCREARdeclaración (como la que se acaba de proporcionar) en la pestaña
Objeto de vista SQL. Esto se debe a que la pestaña Objeto de vista SQL sólo está disponible como
herramienta de consulta; debe realizar algunas acciones adicionales para informar a Access que está a
punto de ingresar una consulta de definición de datos en lugar de una consulta normal que solicita
información de la base de datos. Una complicación adicional: dado que la creación de tablas es una
acción que posiblemente podría comprometer la seguridad de la base de datos, no está permitida de
forma predeterminada. Debe decirle a Access que se trata de una base de datos confiable antes de
que acepte una consulta de definición de datos.

1. Haga clic en la pestaña Crear en la cinta para mostrar los iconos de la funcionalidad
de creación.

2. Haga clic en Diseño de consulta en la sección Consultas.

Esto muestra el cuadro de diálogo Mostrar tabla, que en este momento

contiene varias tablas del sistema junto con POWER.
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 99

3. Seleccione ENERGÍA y haga clic en el botón Agregar.

Como ha visto en el ejemplo anterior, aparece una imagen de la tabla

POTENCIA y sus atributos en la mitad superior del área de trabajo.
4. Haga clic en el botón Cerrar en el cuadro de diálogo Mostrar tabla.

5. Haga clic en la pestaña Inicio y luego en el ícono Ver en el extremo

izquierdo de la cinta y luego elija Vista SQL en el menú desplegable que
aparece.

Como en el ejemplo anterior, Access le ha “ayudado” al poner

SELECCIONAR DE ENERGÍAen el editor SQL. Esta vez no quieres la ayuda.
6. EliminarSELECCIONAR DE ENERGÍAy (en su lugar) ingrese la consulta de definición de datos
proporcionada anteriormente, de la siguiente manera:

CREAR TABLA POWERSQL (

Número de propuesta ENTERO CLAVE PRIMARIA,
Nombre de pila CARACTERÍSTICA (15),

Apellido CARACTERÍSTICA (20),

DIRECCIÓN CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Provincia del estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

País CARACTERÍSTICA (30),

Teléfono CARACTERÍSTICA (14),

Cómo conocido CARACTERÍSTICA (30),

Propuesta CARACTERÍSTICA (50),

BusinOrCharity CARACTER (1) );

En este punto, su pantalla debería verse similar a la Figura 4-14.

Figura 4-14:
Datos-
definición
consulta a
crear un
mesa.
100 Parte II: Uso de SQL para crear bases de datos

7. Después de hacer clic en la pestaña Diseño de la cinta, haga clic en el icono Ejecutar del signo de
exclamación rojo.

Al hacerlo, se ejecuta la consulta, que crea la tabla POWERSQL (como se muestra en la

Figura 4-15).

Figura 4-15:
He aquí el
POWERSQL
mesa.

Debería ver POWERSQL listado en Todos los objetos de acceso en la columna en el

borde izquierdo de la ventana. En cuyo caso, estás dorado. O es posible que no vea la
tabla en la lista Todos los objetos de acceso. En ese caso, sigue leyendo (y trabajando
duro).

Access 2013 hace todo lo posible para protegerle de piratas informáticos

malintencionados y de sus propios errores involuntarios. Debido a que ejecutar una
consulta de definición de datos es potencialmente peligroso para la base de datos,
Access tiene un valor predeterminado que impide que se ejecute la consulta. Si esto te
ha pasado, POWERSQLnoaparecerá en la columna a la izquierda de la ventana, porque
la consulta no habrá sido ejecutada. En cambio, la barra de mensajes puede aparecer
debajo de la cinta, con este conciso mensaje:

Advertencia de seguridad: Cierto contenido de la base de datos tiene

sido inhabilitado.
Si ve este mensaje, continúe con los siguientes pasos.
8. Haga clic en la pestaña Archivo y, en el menú del borde izquierdo, elija Opciones.

Aparece el cuadro de diálogo Opciones de acceso.

9. Seleccione Centro de confianza en el cuadro de diálogo Opciones de acceso.

 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 101

10. Haga clic en el botón Configuración del Centro de confianza cuando aparezca.

11. Seleccione Barra de mensajes en el menú de la izquierda y luego especifique Mostrar la

barra de mensajes haciendo clic en su botón de opción si aún no está seleccionado.

12. Haga clic para regresar al lugar donde puede ejecutar la consulta de
definición de datos que crea la tabla POWERSQL.
13. Ejecute la consulta.

Ser competente en SQL tiene beneficios a largo plazo porque durará mucho tiempo. Es
probable que el esfuerzo que ponga para convertirse en un experto en una herramienta de
desarrollo en particular genere un menor retorno de la inversión. No importa cuán maravillosa
pueda ser la última herramienta RAD, será reemplazada por tecnología más nueva dentro de
tres a cinco años. Si puedes recuperar tu inversión en la herramienta en ese tiempo, ¡genial!
Úselo. De lo contrario, sería prudente seguir con lo probado y verdadero. Capacite a su gente
en SQL y su inversión en capacitación dará sus frutos durante un período mucho más largo.

Creando un índice
Los índices son una parte importante de cualquier base de datos relacional. Sirven como
indicadores de las tablas que contienen los datos de interés. Al utilizar un índice, puede ir
directamente a un registro en particular sin tener que escanear la tabla secuencialmente, un
registro a la vez, para encontrarlo. Para tablas realmente grandes, los índices son una
necesidad; sin índices, es posible que tengas que esperarañosen lugar de segundos para
obtener un resultado. (Bueno, está bien, tal vez en realidad no esperarías añ[Link] embargo,
algunas recuperaciones pueden tardar ese tiempo si las dejas seguir ejecutándose. A menos
que no tenga nada mejor que hacer con el tiempo de su computadora, probablemente sea
mejor cancelar la recuperación y prescindir del resultado. La vida continua.)

Sorprendentemente, el estándar SQL no proporciona un medio para crear un índice. Los

proveedores de DBMS proporcionan sus propias implementaciones de la función. Como
estas implementaciones no están estandarizadas, pueden diferir entre sí. La mayoría de los
proveedores proporcionan la función de creación de índices agregando un CREAR ÍNDICE
comando a SQL.

Aunque dos proveedores pueden usar las mismas palabras para el comando (CREAR ÍNDICE),la
forma en que opera el comando puede no ser la misma. Es probable que encuentre bastantes
cláusulas que dependen de la implementación. Estudie detenidamente la documentación de su
DBMS para determinar cómo utilizar ese DBMS en particular para crear índices.
102 Parte II: Uso de SQL para crear bases de datos

Modificar la estructura de la tabla

Para cambiar la estructura de una tabla existente, puede utilizar SQLALTERAR TABLA
dominio. El SQL interactivo en la estación de su cliente no es tan conveniente como una
herramienta RAD. La herramienta RAD muestra la estructura de su tabla, que luego
puede modificar. Al utilizar SQL, debes conocer de antemano la estructura de la tabla y
cómo quieres modificarla. En el mensaje de pantalla, debe ingresar el comando
apropiado para realizar la modificación. Sin embargo, si desea incrustar las
instrucciones de modificación de tablas en un programa de aplicación, utilizar SQL suele
ser la forma más sencilla de hacerlo.

Para agregar un segundo campo de dirección a la tabla POWERSQL, use el siguiente comando
DDL:

ALTERAR TABLA POWERSQL

AÑADIR COLUMNA Dirección2 CHAR (30);

No es necesario ser un gurú de SQL para descifrar este código. Incluso los supuestos
analfabetos informáticos probablemente puedan resolver esto. El comando modifica una tabla
denominada POWERSQL agregando una columna a la tabla. La columna se llama Dirección 2,es
delCARBONIZARSEtipo de datos y tiene 30 caracteres de longitud. Este ejemplo demuestra con
qué facilidad puede cambiar la estructura de las tablas de la base de datos utilizando
comandos SQL DDL.

SQL estándar proporciona esta declaración para agregar una columna a una tabla y le
permite eliminar una columna existente de manera similar, como en el siguiente código:

ALTERAR TABLA POWERSQL

DROP COLUMN Dirección2;

Eliminar una tabla

Eliminar tablas de bases de datos que ya no necesita es fácil. Sólo usa elMESA PLEGABLE
comando, de la siguiente manera:

TABLA DE SOLTAR POWERSQL;

¿Qué podría ser más sencillo? Si ustedGOTAuna tabla, borras todos sus datos y
metadatos. No queda ningún vestigio de la mesa. Esto funciona muy bien la mayor parte
del tiempo. La única vez que no es así es si otra tabla en la base de datos hace referencia
a la que está intentando eliminar. Esto se llama unrestricción de integridad referencial.
En tal caso, SQL generará un mensaje de error en lugar de eliminar la tabla.
 Capítulo 4: Creación y mantenimiento de una estructura de base de datos simple 103

Eliminar un índice
Si elimina una tabla emitiendo unMESA PLEGABLEcomando, también elimina cualquier
índice asociado con esa tabla. A veces, sin embargo, es posible que desee conservar una
tabla pero eliminarle un índice. El estándar SQL no define un ÍNDICE DE CAÍDAcomando,
pero la mayoría de las implementaciones incluyen ese comando de todos modos. Este
comando resulta útil si su sistema se ralentiza y descubre que sus tablas no están
indexadas de manera óptima. Corregir un problema de índice puede mejorar
drásticamente el rendimiento, lo que hará las delicias de los usuarios que se han
acostumbrado a tiempos de respuesta que recuerdan a verter melaza en un día frío en
Vermont.

Consideraciones de portabilidad
Cualquier implementación de SQL que probablemente utilice puede tener extensiones que le
brinden capacidades que el estándar SQL no cubre. Algunas de estas características pueden
aparecer en la próxima versión del estándar SQL. Otros son exclusivos de una implementación
particular y probablemente estén destinados a permanecer así.

A menudo, las extensiones facilitan la creación de una aplicación que satisfaga sus
necesidades y se sentirá tentado a utilizarlas. Usar las extensiones puede ser su
mejor opción, pero tenga en cuenta las desventajas: si alguna vez desea migrar su
aplicación a otra implementación de SQL, es posible que deba reescribir aquellas
secciones en las que utilizó extensiones que su nuevo entorno no admite.

Cuanto más sepa sobre las implementaciones existentes y las tendencias de desarrollo,
mejores decisiones tomará. Piense en la probabilidad de dicha migración en el futuro y
también en si la extensión que está considerando es exclusiva de su implementación o
está bastante extendida. Dejar de usar una extensión puede ser mejor a largo plazo,
incluso si su uso podría ahorrarle algo de tiempo ahora. Por otro lado, es posible que no
encuentre ningún motivo para no utilizar la extensión. Tu llamada.
104 Parte II: Uso de SQL para crear bases de datos
 Capítulo 5

Construyendo una mesa múltiple

Base de datos relacional

En este capítulo
▶ Decidir qué incluir en una base de datos
▶ Determinar relaciones entre elementos de datos
▶ Vincular tablas relacionadas con claves
▶ Diseño para la integridad de los datos

▶ Normalizando la base de datos

I En este capítulo, le mostraré un ejemplo de cómo diseñar una base de datos de tablas
múltiples. El primer paso para diseñar cualquier base de datos es identificar qué
incluir y qué no incluir. Los siguientes pasos implican decidir cómo se relacionan entre sí
los elementos incluidos y luego configurar las tablas en consecuencia. También hablo de
cómo utilizarllaves,que le permiten acceder a registros e índices individuales
rápidamente.

Una base de datos debe hacer más que simplemente contener sus datos. También debe
proteger los datos para que no se corrompan. En la última parte de este capítulo, analizo cómo
proteger la integridad de sus [Link]ónes uno de los métodos clave que puede
utilizar para proteger la integridad de una base de datos. Analizo las diversas formas normales
y señalo los tipos de problemas que resuelve la normalización.

Diseñar una base de datos

Para diseñar una base de datos, siga estos pasos básicos (entro en detalle sobre cada paso
en las secciones que siguen a esta lista):

1. Decida qué objetos desea incluir en su base de datos.

2. Determine cuáles de estos objetos deberían ser tablas y cuáles deberían ser
columnas dentro de esas tablas.
106 Parte II: Uso de SQL para crear bases de datos

3. Defina tablas según cómo necesite organizar los objetos.

Opcionalmente, es posible que desee designar una columna de la tabla o una combinación de
columnas como [Link] una forma rápida de localizar una fila de interés en una
tabla.

Las siguientes secciones analizan estos pasos en detalle, así como también algunos otros
problemas técnicos que surgen durante el diseño de la base de datos.

Paso 1: Definir objetos

El primer paso en el diseño de una base de datos es decidir qué aspectos del sistema son lo
suficientemente importantes como para incluirlos en el modelo. Trate cada aspecto como un
objeto y cree una lista de todos los objetos que se le ocurran. En esta etapa, no intentes decidir
cómo se relacionan estos objetos entre sí. Intente enumerarlos todos.

Puede resultarle útil reunir un equipo diverso de personas que, de una forma u otra, estén
familiarizadas con el sistema que está modelando. Estas personas pueden intercambiar ideas
y responder a las ideas de los demás. Trabajando juntos, probablemente desarrollarán un
conjunto de objetos importantes más completo y preciso que si lo hicieran por su cuenta.

Cuando tenga un conjunto razonablemente completo de objetos, pase al siguiente paso:

decidir cómo se relacionan estos objetos entre sí. Algunos de los objetos son entidades
importantes (más sobre ellas en un minuto) que son cruciales para brindarle los resultados que
desea. Otros objetos son subsidiarios de esas entidades importantes. En última instancia,
puede decidir que algunos objetos no pertenecen en absoluto al modelo.

Paso 2: Identificar tablas y columnas

Entidades principalestraducir a tablas de bases de datos. Cada entidad importante tiene un conjunto
de atributos—las columnas de la tabla. Muchas bases de datos comerciales, por ejemplo, tienen una
tabla CLIENTE que realiza un seguimiento de los nombres, direcciones y otra información permanente
de los clientes. Cada atributo de un cliente (como nombre, calle, ciudad, estado, código postal,
número de teléfono y dirección de correo electrónico) se convierte en una columna (y un encabezado
de columna) en la tabla CLIENTE.

Si espera encontrar un conjunto de reglas que le ayuden a identificar qué objetos deberían
ser tablas y cuáles atributos del sistema pertenecen a qué tablas, piénselo de nuevo: es
posible que tenga algunas razones para asignar un objeto en particular.
 Capítulo 5: Creación de una base de datos relacional multitabla 107
atributo a una tabla y otras razones para asignarel mismo atributoa otra
mesa. Debes basar tu juicio en dos objetivos:

✓ La información que desea obtener de la base de datos.

✓ ¿Cómo quieres usar esa información?

Al decidir cómo estructurar las tablas de la base de datos, involucre a los futuros usuarios de la
base de datos, así como a las personas que tomarán decisiones basadas en la información de
la base de datos. Si se le ocurre lo que cree que es una estructura razonable, pero no es
consistente con la forma en que las personas usarán la información, su sistema será, en el
mejor de los casos, frustrante de usar e incluso podría producir información incorrecta, lo cual
es aún peor. . ¡No dejes que esto suceda! Esfuércese mucho en decidir cómo estructurar sus
tablas.

Eche un vistazo a un ejemplo para demostrar el proceso de pensamiento necesario para crear
una base de datos de tablas múltiples. Suponga que acaba de establecer VetLab, un
laboratorio de microbiología clínica que analiza muestras biológicas enviadas por veterinarios.
Desea realizar un seguimiento de varias cosas, incluidas las siguientes:

✓ Clientela

✓ Pruebas que realizas

✓ Empleados
✓ Pedidos

✓ Resultados

Cada una de estas entidades tiene atributos asociados. Cada cliente tiene un nombre,
una dirección y otra información de contacto. Cada prueba tiene un nombre y un cargo
estándar. Cada empleado tiene información de contacto, así como una clasificación
laboral y una tarifa salarial. Para cada pedido, necesita saber quién lo solicitó, cuándo se
solicitó y qué prueba se solicitó. Para cada resultado de prueba, necesita saber el
resultado de la prueba, si los resultados fueron preliminares o finales y el número de
orden de la prueba.

Paso 3: definir tablas

Ahora desea definir una tabla para cada entidad y una columna para cada atributo. La
Tabla 5-1 muestra cómo se pueden definir las tablas VetLab que presento en la
sección anterior.
108 Parte II: Uso de SQL para crear bases de datos

Tabla 5-1 Mesas VetLab

Mesa columnas

CLIENTE nombre del cliente

Dirección 1

Dirección 2

Ciudad

Estado

Código Postal

Teléfono

Fax
Persona de contacto

PRUEBAS Nombre de la prueba

Cargo estándar
EMPLEADO Nombre de empleado

Dirección 1

Dirección 2

Ciudad

Estado

Código Postal

Teléfono de casa

Extensión de oficina

Fecha de contratación

Clasificación de Trabajo

Por hora/Salario/Comisión
PEDIDOS Número de orden

nombre del cliente

Prueba ordenada

Vendedor responsable
Fecha de orden

RESULTADOS Número de resultado

Número de orden

Resultado

Fecha reportada

Preliminar/Final
 Capítulo 5: Creación de una base de datos relacional multitabla109
Puede crear las tablas definidas en la Tabla 5-1 utilizando una herramienta de desarrollo
rápido de aplicaciones (RAD) o utilizando el lenguaje de definición de datos (DDL) de SQL,
como se muestra en el siguiente código:

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) NO NULO,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30) );

CREAR PRUEBAS DE TABLA (

Nombre de la prueba CARACTERÍSTICA (30) NO NULO,
Cargo estándar CARACTERÍSTICA (30) );

CREAR TABLA EMPLEADO (

Nombre de empleado CARACTERÍSTICA (30) NO NULO,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono de casa CARACTERÍSTICA (13),

Extensión de oficina CARACTER (4),

Fecha de contratación FECHA,
Clasificación de trabajo CHAR (10),
HourSalComm CARACTER (1) );

CREAR PEDIDOS DE MESA (

Número de orden ENTERO NO NULO,
Nombre del cliente CARACTERÍSTICA (30),

PruebaOrdenada CARACTERÍSTICA (30),

vendedor CARACTERÍSTICA (30),

Fecha de orden FECHA ) ;

CREAR TABLA DE RESULTADOS (

Número de resultado ENTERO NO NULO,
Número de orden ENTERO,
Resultado CARACTERÍSTICA (50),

Fecha de notificación FECHA,

PreliminarFinal CARACTER (1) );
110 Parte II: Uso de SQL para crear bases de datos

Estas tablas se relacionan entre sí mediante los atributos (columnas) que comparten, como se
describe en la siguiente lista:

✓ La tabla CLIENTE se vincula a la tabla PEDIDOS mediante elNombre del clientecolumna.

✓ La tabla PRUEBAS se vincula a la tabla PEDIDOS mediante elNombre de prueba

(Prueba ordenada)columna.

✓ La tabla EMPLEADO se vincula a la tabla PEDIDOS mediante elNombre del

empleado (vendedor)columna.

✓ La tabla RESULTADOS se vincula a la tabla PEDIDOS mediante elNúmero de orden

columna.

Si desea que una tabla sirva como parte integral de una base de datos relacional,
vincule esa tabla al menos a otra tabla de la base de datos, utilizando una columna
común. La Figura 5-1 ilustra las relaciones entre las tablas.

Figura 5-1:
Laboratorio Veterinario

base de datos

mesas y
Enlaces.

Los enlaces en la Figura 5-1 ilustran cuatro diferentesuno a muchosrelaciones.

El diamante en el medio de cada relación muestra la cardinalidad máxima de
cada extremo de la relación. El número 1 denota el lado "uno" de la relación y
N denota el lado "muchos".
 Capítulo 5: Creación de una base de datos relacional multitabla 111
✓ Un cliente puede realizar muchos pedidos, pero cada pedido lo realiza
un solo cliente.
✓ Cada prueba puede aparecer en muchos pedidos, pero cada pedido requiere una y sólo
una prueba.

✓ Cada pedido lo toma un, y solo uno, empleado (o vendedor), pero cada
vendedor puede (y, espera, así lo haga) tomar múltiples pedidos.
✓ Cada orden puede producir varios resultados de prueba preliminares y un
resultado final, pero cada resultado está asociado con una y sólo una orden.

Como puedes ver en el código, el atributo que vincula una tabla con otra puede tener
un nombre diferente en cada tabla. Sin embargo, ambos atributos deben tener tipos
de datos coincidentes. En este punto, no he incluido ninguna restricción de integridad
referencial, con el fin de evitar darle demasiadas ideas a la vez. Abordo la integridad
referencial más adelante en este capítulo, después de haber sentado las bases para
comprenderla.

Dominios, conjuntos de caracteres,

intercalaciones y traducciones
Aunque las tablas son los componentes principales de una base de datos, también influyen
elementos adicionales. En el Capítulo 1, defino ladominiode una columna en una tabla como el
conjunto de todos los valores que la columna puede asumir. Establecer dominios claros para
las columnas de una tabla, mediante el uso de restricciones, es una parte importante del
diseño de una base de datos.

Las personas que se comunican en inglés americano estándar no son las únicas que utilizan
bases de datos relacionales. Otros idiomas, incluso algunos que utilizan otros conjuntos de
caracteres, funcionan igual de bien. Incluso si sus datos están en inglés, algunas aplicaciones
pueden requerir un juego de caracteres especializado. SQL le permite especificar el juego de
caracteres que desea utilizar. De hecho, puedes utilizar un juego de caracteres diferente para
cada columna de una tabla si es necesario. Esta flexibilidad generalmente no está disponible
en lenguajes distintos de SQL.

Acolación,osecuencia de clasificación,es un conjunto de reglas que determina cómo se

comparan las cadenas de un juego de caracteres entre sí. Cada conjunto de caracteres tiene
una intercalación predeterminada. En la clasificación predeterminada del juego de caracteres
ASCII,Aviene antesB,yBviene antesC. Una comparación, por tanto, consideraAcomo menos que
By consideraCcomo mayor queB. SQL le permite aplicar diferentes intercalaciones a un juego
de caracteres. Este grado de flexibilidad generalmente no está disponible en otros lenguajes,
por lo que ahora tiene otra razón para amar SQL.
112 Parte II: Uso de SQL para crear bases de datos

A veces codifica datos en una base de datos en un conjunto de caracteres pero desea
procesar los datos en otro conjunto de caracteres. Quizás tenga datos en el juego de
caracteres alemán (por ejemplo), pero su impresora no admite caracteres alemanes que
no estén incluidos en el juego de caracteres ASCII. SQL permitetraducciónde cadenas de
caracteres de un juego de caracteres a otro. Una traducción puede convertir un carácter
en dos, como cuando una ü alemana se convierte en [Link], o cambie los caracteres en
minúscula a mayúsculas. Incluso puedes traducir un alfabeto a otro (por ejemplo, hebreo
a ASCII).

Ingresando rápidamente a su base de datos con claves

Una buena regla para el diseño de bases de datos es asegurarse de que cada fila de una
tabla de base de datos se pueda distinguir de todas las demás filas; cada fila debe ser
única. A veces es posible que desees extraer datos de tu base de datos para un
propósito específico (como un análisis estadístico) y, al hacerlo, terminar creando tablas
en las que las filas no son necesariamente únicas. Para un propósito tan limitado, este
tipo de duplicación no importa. Sin embargo, las tablas que puede utilizar de más de
una manera no deben contener filas duplicadas.

Allavees un atributo (o combinación de atributos) que identifica de forma única una fila
en una tabla. Para acceder a una fila en una base de datos, debe tener alguna forma de
distinguir esa fila de todas las demás. Como las claves deben ser únicas, proporcionan
dicho mecanismo de acceso.

Además, una clave nunca debe contener un valor nulo. Si utiliza claves nulas, es posible
que no pueda distinguir entre dos filas que contienen un campo de clave nula.

En el ejemplo del laboratorio veterinario, puede designar las columnas apropiadas como
claves. En la tabla CLIENTE,Nombre del clientees una buena clave. Esta clave puede distinguir
a cada cliente individual de todos los demás clientes. Por lo tanto, ingresar un valor en esta
columna es obligatorio para cada fila de la [Link] de la prueba yNombre de empleado
hacer buenas claves para las tablas PRUEBAS y EMPLEADOS. Número de ordenyNúmero de
resultadohacer buenas claves para las tablas PEDIDOS y RESULTADOS. Asegúrese de ingresar
un valor único para cada fila.

Puedes tener dos tipos de claves:claves primariasyllaves [Link] claves que

analizo en el párrafo anterior son ejemplos de claves primarias; Garantizan la unicidad.
Me concentro en las claves primarias y externas en las dos secciones siguientes.

Claves primarias
AClave primariaes una columna o combinación de columnas en una tabla con valores que
identifican de forma única las filas de la tabla. Para incorporar la idea de claves en la base de
datos VetLab, puede especificar la clave principal de una tabla como
 Capítulo 5: Creación de una base de datos relacional multitabla113
tu creas la tabla. En el siguiente ejemplo, una sola columna es suficiente (suponiendo
que todos los clientes de VetLab tengan nombres únicos):

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) CLAVE PRIMARIA,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30)

);

la restricciónCLAVE PRIMARIAreemplaza la restricciónNO NULO,dado en la

definición anterior de la tabla CLIENTE. ElCLAVE PRIMARIArestricción implica laNO
NULOrestricción, porque una clave principal no puede tener un valor nulo.

Aunque la mayoría de los DBMS le permiten crear una tabla sin una clave principal, todas las
tablas de una base de datos deben tener una. Teniendo esto en cuenta, reemplace elNO
NULOrestricción en todas sus tablas. En mi ejemplo, las tablas PRUEBAS, EMPLEADO,
PEDIDOS y RESULTADOS deben tener elCLAVE PRIMARIArestricción, como en el siguiente
ejemplo:

CREAR PRUEBAS DE TABLA (

Nombre de la prueba CARACTERÍSTICA (30) CLAVE PRIMARIA,
Cargo estándar CARACTERÍSTICA (30) );

A veces, ninguna columna de una tabla puede garantizar la unicidad. En tales casos, puede
utilizar unclave compuesta—una combinación de columnas que garantizan la singularidad
cuando se usan juntas. Imaginemos que algunos de los clientes de VetLab son cadenas que
tienen oficinas en varias [Link] del clienteNo es suficiente distinguir entre dos
sucursales de un mismo cliente. Para manejar esta situación, puede definir una clave
compuesta de la siguiente manera:

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) NO NULO,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25) NO NULO,

Estado CARACTER (2),
Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30),

RESTRICCIÓN RamaPK CLAVE PRIMARIA

(Nombre del cliente, ciudad)
);
114 Parte II: Uso de SQL para crear bases de datos

Como alternativa al uso de una clave compuesta para identificar de forma única un registro,
puede dejar que su DBMS asigne una automáticamente, como lo hace Access al sugerir que el
primer campo en una nueva tabla se llame ID y sea del tipo Autonumeración. Una clave así no
tiene significado en sí misma. Su único propósito es ser un identificador único.

Llaves extranjeras

Aclave externaes una columna o grupo de columnas en una tabla que corresponde o hace
referencia a una clave principal en otra tabla de la base de datos. Una clave externa no tiene
que ser única, pero debe identificar de forma única las columnas de la tabla particular a las
que hace referencia la clave.

Si elNombre del clienteLa columna es la clave principal en la tabla CLIENTE (por ejemplo),
cada fila en la tabla CLIENTE debe tener un valor único en el Nombre del clientecolumna.
Nombre del clientees una clave externa en la tabla PEDIDOS. Esta clave externa
corresponde a la clave principal de la tabla CLIENTE, pero la clave no tiene que ser única
en la tabla PEDIDOS. De hecho, esperas que la clave externano esúnico; Si cada uno de
sus clientes le diera solo un pedido y luego nunca volviera a realizarlo, cerraría el negocio
con bastante rapidez. Espera que muchas filas de la tabla PEDIDOS se correspondan con
cada fila de la tabla CLIENTE, lo que indica que casi todos sus clientes son clientes
habituales.

La siguiente definición de la tabla PEDIDOS muestra cómo se puede agregar el

concepto de claves foráneas a unaCREARdeclaración:

CREAR PEDIDOS DE MESA (

Número de orden ENTERO CLAVE PRIMARIA,
Nombre del cliente CARACTERÍSTICA (30),

PruebaOrdenada CARACTERÍSTICA (30),

vendedor CARACTERÍSTICA (30),

Fecha de orden FECHA,

RESTRICCIÓN NombreFK CLAVE EXTRANJERA (NombreCliente)
REFERENCIAS CLIENTE (ClientName), RESTRICCIÓN
TestFK CLAVE EXTRANJERA (TestOrdered)
PRUEBAS DE REFERENCIAS (Nombre de la prueba),
RESTRICCIÓN CLAVE EXTRANJERA SalesFK (Vendedor)
REFERENCIAS EMPLEADO (Nombre del empleado)
);

En este ejemplo, las claves externas en la tabla PEDIDOS vinculan esa tabla con las
claves primarias de las tablas CLIENTE, PRUEBAS y EMPLEADO.

Trabajar con índices

La especificación SQL no aborda el tema de los índices, pero esa omisión no significa que los
índices sean partes raras o incluso opcionales de un sistema de base de datos. Todas las
implementaciones de SQL admiten índices, pero no encontrará ninguna
 Capítulo 5: Creación de una base de datos relacional multitabla 115
acuerdo universal sobre cómo apoyarlos. En el Capítulo 4, le muestro cómo crear un
índice utilizando Microsoft Access, una herramienta de desarrollo rápido de
aplicaciones (RAD). Consulte la documentación de su sistema de gestión de bases de
datos (DBMS) en particular para ver cómo el sistema implementa los índices.

¿Qué es un índice?
Los datos generalmente aparecen en una tabla en el orden en que ingresó originalmente la
información. Es posible que ese orden no tenga nada que ver con el orden en el que
posteriormente desea procesar los datos. Digamos, por ejemplo, que desea procesar su tabla
CLIENTE enNombre del clienteorden. La computadora primero debe ordenar la tabla en
Nombre del clienteorden. Ordenar los datos de esta manera lleva tiempo. Cuanto más grande
sea la tabla, más tardará la clasificación. ¿Qué pasa si tienes una tabla con 100.000 filas? ¿O una
tabla con un millón de filas? En algunas aplicaciones, estos tamaños de mesa no son raros. Los
mejores algoritmos de clasificación tendrían que realizar unos 20 millones de comparaciones y
millones de intercambios para poner la tabla en el orden deseado. Incluso si estás usando una
computadora muy rápida, es posible que no quieras esperar tanto.

Los índices pueden suponer un gran ahorro de tiempo. Uníndicees una subsidiaria omesa
de apoyo que va junto con una tabla de datos. Para cada fila de la tabla de datos, tiene una
fila correspondiente en la tabla de índice. El orden de las filas en la tabla de índice es
diferente.

La tabla 5-2 es un pequeño ejemplo de una tabla de datos para el laboratorio veterinario.

Tabla 5-2 Tabla CLIENTE

Nombre del cliente Dirección 1 Dirección 2 Ciudad Estado

Animal nogal 5 carril de mantequilla hudson NUEVA HAMPSHIRE

Clínica

Ámbar 470 Círculo Kolvir Ámbar MI

Veterinaria, Inc.
Veterinarios R Us 2300 Geoffrey habitación 230 anaheim California

Camino

Doctor perrito 32 Terraza Terry Nutley Nueva Jersey

El ecuestre Veterinario 7890 Gallup Nuevo Méjico

Centro Paddock
avenida
Instituto de Delfines 1002 Unidad Marina Key West Florida

J.C. Campbell, 2500 calle principal los Angeles California

Veterinario de crédito

El gusano de Wenger 15 bulevar de cebo Sedona Arizona

Granja
116 Parte II: Uso de SQL para crear bases de datos

Aquí las filas no están en orden alfabético porNombre del [Link] hecho, no
están en ningún orden útil. Las filas están simplemente en el orden en que
alguien ingresó los datos.

Un índice para esta tabla CLIENTE puede parecerse a la Tabla 5-3.

Tabla 5-3 Índice de nombres de clientes para la tabla CLIENT

Nombre del cliente Puntero a la tabla de datos

Ámbar Veterinaria, Inc. 2

Clínica de animales Butternut 1
Doctor perrito 4
Instituto de Delfines 6
J. C. Campbell, veterinario de crédito 7
El Centro Ecuestre 5
Veterinarios R Us 3
La granja de lombrices de Wenger 8

El índice contiene el campo que forma la base del índice (en este caso, Nombre del
cliente)y un puntero a la tabla de datos. El puntero en cada fila del índice proporciona
el número de fila de la fila correspondiente en la tabla de datos.

¿Por qué deberías querer un índice?

Si desea procesar una tabla enNombre del clienteorden, y tienes un índice organizado
enNombre del clienteEn orden, puede realizar la operación casi tan rápido como lo
haría si la tabla de datos ya estuviera enNombre del clienteorden. Puede trabajar a
través del índice, moviéndose inmediatamente al registro de datos correspondiente de
cada fila del índice utilizando el puntero en el índice.

Si utiliza un índice, el tiempo de procesamiento de la tabla es proporcional aNORTE,

dóndenortees el número de registros en la tabla. Sin un índice, el tiempo de
procesamiento de la misma operación es proporcional anorte lg norte,dóndelg nortees
el logaritmo de nortea la base 2. Para mesas pequeñas, la diferencia es insignificante,
pero para mesas grandes, la diferencia es grande. En tablas grandes, algunas
operaciones no son prácticas de realizar sin la ayuda de índices.

Supongamos que tiene una tabla que contiene 1.000.000 de registros (norte=1.000.000),
y procesar cada registro lleva un milisegundo (una milésima de segundo).
 Capítulo 5: Creación de una base de datos relacional multitabla 117
Si tiene un índice, procesar la tabla completa toma solo 1000 segundos (menos de
17 minutos). Sin un índice, es necesario recorrer la tabla aproximadamente
1.000.000×20 veces para lograr el mismo resultado. Este proceso tardaría 20.000
segundos, más de cinco horas y media. Creo que estarán de acuerdo en que la
diferencia entre 17 minutos y cinco horas y media es sustancial. Éste es sólo un
ejemplo de la diferencia que hace la indexación en el procesamiento de registros.

Mantener un índice
Después de crear un índice, debe mantenerlo. Afortunadamente, no tiene que
pensar demasiado en el mantenimiento: su DBMS mantiene sus índices
automáticamente, actualizándolos cada vez que actualiza las tablas de datos
correspondientes. Este proceso lleva algo de tiempo extra, pero vale la pena.
Cuando crea un índice y su DBMS lo mantiene, el índice siempre está disponible
para acelerar el procesamiento de datos, sin importar cuántas veces necesite
consultarlo.

El mejor momento para crear un índice es al mismo tiempo que creas su tabla de
datos correspondiente. Si crea el índice temprano y el DBMS comienza a mantenerlo
al mismo tiempo, no necesita sufrir la molestia de crear el índice más adelante; toda
la operación se lleva a cabo en una única y larga sesión. Intente anticipar todas las
formas en que desee acceder a sus datos y luego cree un í[Link] cada
posibilidad.

Algunos productos DBMS le brindan la capacidad de desactivar el mantenimiento de índices.

Es posible que desee hacerlo en algunas aplicaciones en tiempo real donde la actualización de
índices lleva mucho tiempo y tiene muy poco de sobra. Incluso puede optar por actualizar los
índices como una operación separada durante las horas de menor actividad. Como siempre,
“haz lo que funcione para ti” es la regla.

No caiga en la trampa de crear un índice de órdenes de recuperación que probablemente

nunca utilizará. El mantenimiento del índice es una operación adicional que la computadora
debe realizar cada vez que modifica el campo del índice o agrega o elimina una fila de la tabla
de datos, y esta operación afecta el rendimiento. Para obtener un rendimiento óptimo, cree
solo aquellos índices que espera utilizar como claves de recuperación, y solo para tablas que
contengan una gran cantidad de filas. De lo contrario, los índices pueden degradar el
rendimiento.

Es posible que necesites compilar algo como un informe mensual o trimestral que
requiera los datos en un orden extraño que normalmente no necesitas. Cree un índice
justo antes de ejecutar ese informe periódico, ejecute el informe y luego elimine el
índice para que el DBMS no tenga la carga de mantener el índice durante el largo
período entre informes.
118 Parte II: Uso de SQL para crear bases de datos

Mantener la integridad de los datos

Una base de datos sólo es valiosa si está razonablemente seguro de que los datos que contiene son
correctos. En bases de datos médicas, aeronáuticas y espaciales, por ejemplo, datos incorrectos
pueden provocar la muerte. Los datos incorrectos en otras aplicaciones pueden tener consecuencias
menos graves, pero aun así pueden resultar perjudiciales. Los diseñadores de bases de datos deben
hacer todo lo posible para asegurarse de que nunca entren datos incorrectos en las bases de datos
que producen. Esto no siempre es posible, peroesposible al menos asegurarse de que los datos que
se ingresan sean válidos. mantenimientointegridad de los datos significa asegurarse de que cualquier
dato que se ingrese en un sistema de base de datos satisfaga las restricciones que se han establecido
para él. Por ejemplo, si un campo de base de datos es del tipoFechatipo, el DBMS debe rechazar
cualquier entrada en ese campo que no sea una fecha válida.

Algunos problemas no se pueden detener en el nivel de la base de datos. El programador de

aplicaciones debe interceptar estos problemas antes de que puedan dañar la base de datos.
Todos los responsables de manejar la base de datos de cualquier manera deben ser
conscientes de las amenazas a la integridad de los datos y tomar las medidas adecuadas para
anular esas amenazas.

Las bases de datos pueden experimentar varios tipos de integridad claramente diferentes y
una serie de problemas que pueden afectar la integridad. En las siguientes secciones, analizo
tres tipos de integridad:entidad, dominio,[Link]én analizo algunos de los
problemas que pueden amenazar la integridad de la base de datos.

Integridad de la entidad

Cada tabla de una base de datos corresponde a una entidad en el mundo real. Esa entidad
puede ser física o conceptual, pero en cierto sentido, la existencia de la entidad es
independiente de la base de datos. una mesa tieneintegridad de la entidadsi la tabla es
totalmente consistente con la entidad que modela. Para tener integridad de entidad, una tabla
debe tener una clave principal que identifique de forma única cada fila de la tabla. Sin una
clave principal, no puede estar seguro de que la fila recuperada sea la que desea.

Para mantener la integridad de la entidad, asegúrese de especificar que la columna (o grupo

de columnas) que constituye la clave principal esNO [Link]ás, debe restringir la clave
principal para que seaÚ[Link] implementaciones de SQL le permiten agregar dichas
restricciones a la definición de la tabla. Sin embargo, con otras implementaciones, debe aplicar
la restricción más adelante, después de especificar cómo agregar, cambiar o eliminar datos de
la tabla.
 Capítulo 5: Creación de una base de datos relacional multitabla 119
La mejor manera de garantizar que su clave principal sea ambasNO NULOyÚNICO
es darle la llaveCLAVE PRIMARIArestricción al crear la tabla, como se muestra en el
siguiente ejemplo:

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) CLAVE PRIMARIA,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30)

);

Una alternativa es utilizarNO NULOen combinación conÚNICO,como se muestra

en el siguiente ejemplo:

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) NO NULO,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30),

ÚNICO (NombreCliente) );

Integridad del dominio

Por lo general, no se puede garantizar que un elemento de datos en particular en una base de
datos sea correcto, peropoderdeterminar si un elemento de datos es válido. Muchos elementos
de datos tienen un número limitado de valores posibles. Si realiza una entrada que no es uno
de los valores posibles, esa entrada debe ser un error. Estados Unidos, por ejemplo, tiene 50
estados más el Distrito de Columbia, Puerto Rico y algunas posesiones. Cada una de estas
áreas tiene un código de dos caracteres que reconoce el Servicio Postal de EE. UU. Si su base de
datos tiene unEstadocolumna, puede hacer cumplirintegridad del dominioal exigir que
cualquier entrada en esa columna sea uno de los códigos de dos caracteres reconocidos. Si un
operador ingresa un código que no está en la lista de códigos válidos, esa entrada viola la
integridad del dominio. Si prueba la integridad del dominio, puede negarse a aceptar cualquier
operación que provoque dicha violación.
120 Parte II: Uso de SQL para crear bases de datos

Surgen problemas de integridad del dominio si agrega nuevos datos a una tabla utilizando el
INSERTARdeclaración o laACTUALIZARdeclaración. Puede especificar un dominio para una
columna utilizando unCREAR DOMINIOdeclaración antes de usar esa columna en unCREAR
MESAdeclaración, como se muestra en el siguiente ejemplo, que crea una tabla para los
equipos de béisbol de las grandes ligas:

CREAR DOMINIO LeagueDom CHAR (8)

VERIFICAR (VALOR EN ('Americano', 'Nacional'));
CREAR EQUIPO DE MESA (
Nombre del equipo CARACTERÍSTICA (20) NO NULO,
Liga LigaDom NO NULO
);

El dominio de laLigaLa columna incluye solo dos valores válidos:Americano y

[Link] DBMS no le permite confirmar una entrada o actualizar elEQUIPO
mesa a menos que elLigaLa columna de la fila que estás agregando tiene un
valor de "Americano'o 'Nacional'.

Integridad referencial
Incluso si cada tabla en su sistema tiene integridad de entidad e integridad de dominio, aún
puede tener un problema debido a inconsistencias en la forma en que una tabla se relaciona
con otra. En la mayoría de las bases de datos de tablas múltiples bien diseñadas, cada tabla
contiene al menos una columna que hace referencia a una columna de otra tabla de la base de
datos. Estas referencias son importantes para mantener la integridad general de la base de
datos. Sin embargo, las mismas referencias posibilitan anomalías en las actualizaciones.
Actualizar anomalíasson problemas que pueden ocurrir después de actualizar los datos en una
fila de una tabla de base de datos. Las siguientes secciones analizan un ejemplo típico y
sugieren cómo abordarlo.

Problema entre las tablas padre e hijo

Las relaciones entre tablas generalmente no son bidireccionales. Una tabla suele
depender de la otra. Digamos, por ejemplo, que tiene una base de datos con una
tabla CLIENTE y una tabla PEDIDOS. Es posible que pueda ingresar un cliente en la
tabla CLIENTE antes de que realice cualquier pedido. Sin embargo, no puede
ingresar un pedido en la tabla PEDIDOS a menos que ya tenga una entrada en la
tabla CLIENTE para el cliente que realiza ese pedido. La tabla PEDIDOS depende de
la tabla CLIENTE. Este tipo de arreglo a menudo se denomina relación padre-hijo,
donde CLIENTE es la tabla principal y PEDIDOS es la tabla secundaria. El niño
depende de los padres.

Generalmente, la clave principal de la tabla principal es una columna (o grupo de columnas) que
aparece en la tabla secundaria. Dentro de la tabla secundaria, esa misma columna (o grupo) es una
clave externa. Sin embargo, tenga en cuenta que una clave externa no tiene por qué ser única.
 Capítulo 5: Creación de una base de datos relacional multitabla 121
Las anomalías de actualización surgen de varias maneras entre las tablas principal y
secundaria. Un cliente se muda, por ejemplo, y deseas eliminar su información de tu
base de datos. Si ella ya realizó algunos pedidos (que usted registró en la tabla
PEDIDOS), eliminarla de la tabla CLIENTE podría presentar un problema. Tendría
registros en la tabla PEDIDOS (secundaria) para los cuales no tiene registros
correspondientes en la tabla CLIENTE (principal). Pueden surgir problemas similares si
agrega un registro a una tabla secundaria sin realizar la adición correspondiente a la
tabla principal.

Las claves foráneas correspondientes en todas las tablas secundarias deben reflejar cualquier cambio en
la clave principal de una fila en una tabla principal; de lo contrario, se producirá una anomalía de
actualización.

Eliminaciones en cascada: utilícelas con cuidado

Puede eliminar la mayoría de los problemas de integridad referencial controlando
cuidadosamente el proceso de actualización. En algunos casos, hay quecascadaeliminaciones
de una tabla principal a sus hijos. Para realizar una eliminación en cascada cuando elimina
una fila de una tabla principal, también elimina todas las filas en sus tablas secundarias cuyas
claves externas coincidan con la clave principal de la fila eliminada en la tabla principal. Eche
un vistazo al siguiente ejemplo:

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) CLAVE PRIMARIA,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25) NO NULO,

Estado CARACTER (2),
Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30)

);

CREAR PRUEBAS DE TABLA (

Nombre de la prueba CARACTERÍSTICA (30) CLAVE PRIMARIA,
Cargo estándar CARACTERÍSTICA (30)

);

CREAR TABLA EMPLEADO (

Nombre de empleado CARACTERÍSTICA (30) CLAVE PRIMARIA,
DIRECCIÓN 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono de casa CARACTERÍSTICA (13),

Extensión de oficina CARACTER (4),

Fecha de contratación FECHA,
Clasificación de Trabajo CARACTERÍSTICA (10),
122 Parte II: Uso de SQL para crear bases de datos

HoraSalCom CARACTER (1)

);

CREAR PEDIDOS DE MESA (

Número de orden ENTERO CLAVE PRIMARIA,
Nombre del cliente CARACTERÍSTICA (30),

PruebaOrdenada CARACTERÍSTICA (30),

vendedor CARACTERÍSTICA (30),

Fecha de orden FECHA,

RESTRICCIÓN NombreFK CLAVE EXTRANJERA (NombreCliente)
CLIENTE DE REFERENCIAS (NombreCliente)
AL BORRAR CASCADA,
RESTRICCIÓN TestFK CLAVE EXTRANJERA (PruebaOrdered)
PRUEBAS DE REFERENCIAS (NombredePrueba)
AL BORRAR CASCADA,
RESTRICCIÓN SalesFK CLAVE EXTRANJERA (Vendedor)
REFERENCIAS EMPLEADO (Nombre del empleado)
EN BORRAR CASCADA
);

la restricciónNombreFKnombresNombre del clientecomo una clave externa que hace

referencia a laNombre del clientecolumna en la tabla CLIENTE. Si elimina una fila en la tabla
CLIENTE, también elimina automáticamente todas las filas en la tabla PEDIDOS que tienen el
mismo valor en elNombre del clientecolumna como las de laNombre del cliente columna de la
tabla CLIENTE. La eliminación se produce en cascada desde la tabla CLIENTE a la tabla
PEDIDOS. Lo mismo ocurre con las claves externas de la tabla PEDIDOS que hacen referencia a
las claves primarias de las tablas PRUEBAS y EMPLEADOS.

Formas alternativas de controlar las anomalías de actualización

Es posible que no desee realizar una eliminación en cascada. En su lugar, es posible que desee
cambiar la clave externa de la tabla secundaria a unaNULOvalor. Considere la siguiente variante del
ejemplo anterior:

CREAR PEDIDOS DE MESA (

Número de orden ENTERO CLAVE PRIMARIA,
Nombre del cliente CARACTERÍSTICA (30),

PruebaOrdenada CARACTERÍSTICA (30),

vendedor CARACTERÍSTICA (30),

Fecha de orden FECHA,

RESTRICCIÓN NombreFK CLAVE EXTRANJERA (NombreCliente)
REFERENCIAS CLIENTE (ClientName), RESTRICCIÓN
TestFK CLAVE EXTRANJERA (TestOrdered)
PRUEBAS DE REFERENCIAS (Nombre de la prueba),
RESTRICCIÓN CLAVE EXTRANJERA SalesFK (Vendedor)
REFERENCIAS EMPLEADO (Nombre del empleado)
AL ELIMINAR ESTABLECER NULO
);
 Capítulo 5: Creación de una base de datos relacional multitabla 123
la restricciónVentasFKnombra elvendedorcolumna como una clave externa que
hace referencia a laNombre de empleadocolumna de la tabla EMPLEADO. Si un
vendedor deja la empresa, elimina su fila en la tabla EMPLEADO. Eventualmente se
asignan nuevos vendedores a sus cuentas, pero por ahora, eliminar su nombre de la
tabla EMPLEADO hace que todos sus pedidos en la tabla PEDIDO reciban un valor
nulo en elvendedorcolumna.

También puede mantener los datos inconsistentes fuera de una base de datos utilizando uno de estos
métodos:

✓ Negarse a permitir una adición a una tabla secundaria hasta que exista una fila
correspondiente en su tabla [Link] rechaza permitir filas en una tabla
secundaria sin una fila correspondiente en una tabla principal, evita la aparición de filas
"huérfanas" en la tabla secundaria. Este rechazo ayuda a mantener la coherencia entre
las tablas.

✓ Negarse a permitir cambios en la clave principal de una [Link] se niega a permitir

cambios en la clave principal de una tabla, no necesita preocuparse por actualizar las
claves externas en otras tablas que dependen de esa clave principal.

Justo cuando pensabas que era seguro. . .

Lo único con lo que puedes contar en las bases de datos (como en la vida) es el
cambio. ¿No lo sabrías? Crea una base de datos, completa con tablas, restricciones
y filas y filas de datos. Entonces llega la noticia desde la dirección de que es
necesario cambiar la estructura. ¿Cómo se agrega una nueva columna a una tabla
que ya existe? ¿Cómo se elimina uno que ya no necesitas? ¡SQL al rescate!

Agregar una columna a una tabla existente

Supongamos que su empresa instituye la política de organizar una fiesta para cada
empleado en su cumpleaños. Para darle al coordinador de fiestas el aviso previo que
necesita cuando planifica estas fiestas, debes agregar un Cumpleañoscolumna a la
tabla EMPLEADO. Como dicen en las Bahamas: “¡No hay problema!” Sólo usa elALTERAR
TABLAdeclaración. Así es cómo:

ALTERAR EMPLEADO DE MESA

AÑADIR COLUMNA FECHA de cumpleaños;

Ahora todo lo que tienes que hacer es agregar la información del cumpleaños a cada fila
de la tabla y podrás seguir festejando. (Por cierto,dónde¿Dijiste que trabajas?)
124 Parte II: Uso de SQL para crear bases de datos

Eliminar una columna de una tabla existente

Ahora supongamos que una crisis económica golpea a su empresa y ésta ya no puede permitirse
financiar lujosas fiestas de cumpleaños. Incluso en una mala economía, los honorarios de los DJ se
han disparado. No más fiestas significa que ya no es necesario conservar los datos de cumpleaños.
Con elALTERAR TABLAdeclaración, usted también puede manejar esta situación.

ALTERAR EMPLEADO DE MESA

COLUMNA DE GOTA Cumpleaños;

Ah, bueno, fue divertido mientras duró.

Áreas potencialmente problemáticas

La integridad de los datos está sujeta a ataques desde diversos sectores. Algunos de estos
problemas surgen sólo en bases de datos de tablas múltiples; otros pueden ocurrir incluso en
bases de datos que contienen una sola tabla. Quiere reconocer y minimizar todas estas
amenazas potenciales.

Datos de entrada incorrectos

Los documentos fuente o archivos de datos que utiliza para completar su base de datos
pueden contener datos incorrectos. Estos datos pueden ser una versión corrupta de los datos
correctos o pueden no ser los datos que desea. Averificación de rangole indica si los datos
tienen integridad de dominio. Este tipo de verificación detecta algunos problemas, pero no
todos. (Por ejemplo, los valores de campo incorrectos que están dentro del rango aceptable,
pero que aún son incorrectos, no se identifican como problemas).

Error del operador

Sus datos de origen pueden ser correctos, pero el operador de entrada de datos puede transcribirlos
incorrectamente. Este tipo de error puede provocar el mismo tipo de problemas que los datos de
entrada incorrectos. Algunas de las soluciones también son las mismas. Las comprobaciones de
alcance ayudan, pero no son infalibles. Otra solución es que un segundo operador valide de forma
independiente todos los datos. Este enfoque es costoso porque la validación independiente requiere
el doble de personas y el doble de tiempo. Pero en algunos casos en los que la integridad de los datos
es fundamental, el esfuerzo y el gasto adicionales pueden resultar valiosos.

Falla mecánica
Si experimenta una falla mecánica, como una falla del disco, los datos de la tabla pueden
destruirse. Unas buenas copias de seguridad son su principal defensa contra este
problema.
 Capítulo 5: Creación de una base de datos relacional multitabla 125

Malicia
Considere la posibilidad de que alguien puedadesearpara corromper sus datos. Su primera línea de
defensa contra la corrupción intencional es negar el acceso a la base de datos a cualquier persona
que pueda tener intenciones maliciosas y restringir a los usuarios autorizados para que puedan
acceder solo a los datos que necesitan. Su segunda defensa es mantener copias de seguridad de los
datos en un lugar seguro. Vuelva a evaluar periódicamente las características de seguridad de su
instalación. Ser un poco paranoico no hace daño.

Redundancia de datos
Redundancia de datos—los mismos elementos de datos que surgen en múltiples lugares es un gran
problema con el modelo de base de datos jerárquico, pero el problema también puede afectar a las
bases de datos relacionales. Esta redundancia no sólo desperdicia espacio de almacenamiento y
ralentiza el procesamiento, sino que también puede provocar una corrupción grave de los datos. Si
almacena el mismo elemento de datos en dos tablas diferentes de una base de datos, el elemento de
una de esas tablas puede cambiar mientras que el elemento correspondiente de la otra tabla sigue
siendo el mismo. Esta situación genera una discrepancia y es posible que no tenga forma de
determinar qué versión es la correcta. Ésa es una buena razón para mantener la redundancia de
datos al mínimo.

Aunque es necesaria una cierta cantidad de redundancia para que la clave principal de
una tabla sirva como clave externa en otra, debe intentar evitar la repetición de
cualquier elemento de datos más allá de eso.

Después de eliminar la mayor parte de la redundancia del diseño de una base de datos, es
posible que descubra que el rendimiento ahora es inaceptable. Los operadores suelen utilizar
intencionadamente un poco de redundancia para acelerar el procesamiento. En la base de
datos de VetLab, por ejemplo, la tabla PEDIDOS contiene solo el nombre del cliente para
identificar el origen de cada pedido. Si preparas un pedido, debes unir la tabla PEDIDOS con la
tabla CLIENTE para obtener la dirección del cliente. Si esta unión de tablas hace que el
programa que imprime los pedidos se ejecute demasiado lento, puede decidir almacenar la
dirección del cliente de forma redundante en la tabla PEDIDOS así como en la tabla CLIENTE.
Entonces, al menos, podrá imprimir los pedidos más rápido, pero a costa de ralentizar y
complicar cualquier actualización de la dirección del cliente.

Una práctica común es diseñar inicialmente una base de datos con poca redundancia y con
altos grados de normalización y luego, después de descubrir que las aplicaciones importantes
se ejecutan con lentitud, agregar selectivamente redundancia y desnormalizar. La palabra
clave aquí [Link] redundancia que vuelva a agregar debe tener un propósito
específico y, debido a que es muy consciente tanto de la redundancia como del peligro que
representa, debe tomar las medidas adecuadas para garantizar que la redundancia no cause
más problemas de los que resuelve. (Para obtener más información, avance un poco a la
sección "Normalización de la base de datos").
126 Parte II: Uso de SQL para crear bases de datos

Exceder la capacidad de su DBMS

Un sistema de base de datos puede funcionar correctamente durante años y luego empezar a
experimentar errores intermitentes que se vuelven progresivamente más graves. Esto puede
ser una señal de que se está acercando a uno de los límites de capacidad del sistema. Después
de todo, existen límites en cuanto al número de filas que puede tener una tabla. También
existen límites en las columnas, restricciones y otras características de la base de datos.
Verifique el tamaño y el contenido actuales de su base de datos con las especificaciones
enumeradas en la documentación de su DBMS. Si está cerca del límite en cualquier área,
considere actualizar a un sistema con mayor capacidad. O quizás desee archivar datos más
antiguos que ya no están activos y luego eliminarlos de su base de datos.

Restricciones
Anteriormente en este capítulo, hablé de las restricciones como mecanismos para garantizar
que los datos que se ingresan en una columna de la tabla caigan dentro del dominio de esa
columna. Arestricciónes una regla de aplicación que el DBMS aplica. Después de definir una
base de datos, puede incluir restricciones (comoNO NULO)en una definición de tabla. El DBMS
se asegura de que usted nunca pueda realizar ninguna transacción que viole una restricción.

Tienes tres tipos de restricciones:

✓ Arestricción de columnaimpone una condición en una columna de una tabla.

✓ Arestricción de tablaPone una restricción especificada en una tabla completa.

✓ Unafirmaciónes una restricción que puede afectar a más de una tabla.

Restricciones de columna

Se muestra un ejemplo de una restricción de columna en la siguiente declaración del

lenguaje de definición de datos (DDL):

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) NO NULO,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30)

);
 Capítulo 5: Creación de una base de datos relacional multitabla127
La declaración aplica la restricció[Link] NULOhaciaNombre del clientecolumna,
especificando queNombre del clienteno puede asumir un valor nulo.ÚNICOes otra
restricción que puede aplicar a una columna. Esta restricción especifica que cada valor
de la columna debe ser único. ElCONTROLARLa restricción es particularmente útil porque
puede tomar cualquier expresión válida como argumento. Considere el siguiente
ejemplo:

CREAR PRUEBAS DE TABLA (

Nombre de la prueba CARACTERÍSTICA (30) NO NULO,
Cargo estándar NUMÉRICO (6,2)
VERIFICAR (Carga estándar >= 0,0
Y carga estándar <= 200,0)
);

El cargo estándar de VetLab por una prueba siempre debe ser mayor o igual a
cero. Y ninguna de las pruebas estándar cuesta más de 200 dólares. El CONTROLAR
La cláusula se niega a aceptar cualquier entrada que quede fuera del rango. 0 <=
Carga estándar <= [Link] forma de expresar la misma restricción es la siguiente:

VERIFICAR (Carga Estándar ENTRE 0.0 Y 200.0)

restricciones de tabla
ElCLAVE PRIMARIALa restricción especifica que la columna a la que se aplica es una
clave principal. Esta restricción se aplica a toda la tabla y es equivalente a una
combinación de lasNO NULOyÚNICOrestricciones de columna. Puede especificar
esta restricción en unCREARdeclaración, como se muestra en el siguiente ejemplo:

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) CLAVE PRIMARIA,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30)

);

Restricciones con nombre, como laNombreFKLa restricción del ejemplo de la sección

anterior “Eliminaciones en cascada: utilícela con cuidado” puede tener alguna
funcionalidad adicional. Supongamos, por ejemplo, que desea realizar una carga
masiva de varios miles de clientes potenciales en su tabla PROSPECT. Tiene un archivo
que contiene principalmente prospectos en los Estados Unidos, pero con algunos
prospectos canadienses esparcidos por todo el archivo. Normalmente, quieres
128 Parte II: Uso de SQL para crear bases de datos

restrinja su tabla PROSPECT para incluir solo prospectos de EE. UU., pero no desea que esta
carga masiva se interrumpa cada vez que alcance uno de los récords canadienses. (Los códigos
postales canadienses incluyen letras además de números, pero los códigos postales de EE. UU.
solo contienen números). Puede optar por no aplicar una restricción aCódigo Postalhasta que
se complete la carga masiva y luego podrá restaurar la aplicación de restricciones más
adelante.

Inicialmente, su tabla PROSPECT se creó con lo siguienteCREAR MESA

declaración:

CREAR TABLA PROSPECTO (

Nombre del cliente CARACTERÍSTICA (30) CLAVE PRIMARIA,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30),

RESTRICCIÓN Zip CHECK (Código Postal ENTRE 0 Y 99999)

);

Antes de la carga masiva, puede desactivar la aplicación de laCremallerarestricción:

ALTERAR PROSPECTO DE TABLA

RESTRICCIÓN Zip NO APLICADA;

Una vez completada la carga masiva, puede restaurar la aplicación de la

restricción:

ALTERAR PROSPECTO DE TABLA

RESTRICCIÓN Zip APLICADA;

En este punto puedes eliminar cualquier fila que no cumpla la restricción

con:

ELIMINAR DEL PROSPECTO

DONDE Código Postal NO ENTRE 0 Y 99999;

Afirmaciones
Unafirmaciónespecifica una restricción para más de una tabla. El siguiente ejemplo
utiliza una condición de búsqueda extraída de dos tablas para crear una aserción:
 Capítulo 5: Creación de una base de datos relacional multitabla 129

CREAR PEDIDOS DE MESA (

Número de orden ENTERO NO NULO,
Nombre del cliente CARACTERÍSTICA (30),

PruebaOrdenada CARACTERÍSTICA (30),

vendedor CARACTERÍSTICA (30),

Fecha de orden FECHA

);

CREAR TABLA DE RESULTADOS (

Número de resultado ENTERO NO NULO,
Número de orden ENTERO,
Resultado CARACTERÍSTICA (50),

Fecha del pedido FECHA,

PreliminarFinal CARACTER (1)
);

CREAR ASERCIÓN
VERIFICAR (NO EXISTE (SELECCIONAR * DE PEDIDOS, RESULTADOS)
DONDE PEDIDOS.Número de pedido = RESULTADOS.Número de pedido
Y [Link] > [Link])) ;

Esta afirmación garantiza que los resultados de la prueba no se informen antes de solicitar la
prueba.

Normalizando la base de datos

Algunas formas de organizar los datos son mejores que otras. Algunos son más lógicos.
Algunas son más simples. Algunos son mejores para prevenir inconsistencias cuando
comienzas a usar la base de datos. Sí, modificar una base de datos abre toda una serie de
problemas y (afortunadamente) sus soluciones, conocidas respectivamente como . . .

Anomalías de modificación y formas normales.

Una serie de problemas, llamadosanomalías de modificación—puede afectar una base de
datos si no la estructura correctamente. Para evitar estos problemas, puedenormalizarla
estructura de la base de datos. La normalización generalmente implica dividir una tabla
de base de datos en dos tablas más simples.

Anomalías de modificaciónSe denominan así porque se generan mediante la adición,

cambio o eliminación de datos de una tabla de base de datos.

Para ilustrar cómo pueden ocurrir anomalías de modificación, considere la tabla que se
muestra en la Figura 5-2.
130 Parte II: Uso de SQL para crear bases de datos

Figura 5-2:
Estas VENTAS
mesa
lleva a
modificación
anomalías.

Supongamos, por ejemplo, que su empresa vende productos de limpieza para el

hogar y de cuidado personal y cobra a todos los clientes el mismo precio por cada
producto. La tabla VENTAS realiza un seguimiento de todo por usted. Ahora
supongamos que el cliente 1001 se muda fuera del área y ya no es cliente. No te
importa lo que haya comprado en el pasado, porque no volverá a comprar nada de
tu empresa. Quiere eliminar su fila de la tabla. Sin embargo, si lo hace, no sólo
perderá el hecho de que el cliente 1001 ha comprado detergente para la ropa;
También pierdes el hecho de que el detergente para ropa cuesta $12. Esta situación
se llamaanomalía de eliminació[Link] eliminar un hecho (que el cliente 1001 compró
detergente para ropa), sin darse cuenta elimina otro hecho (que el detergente para
ropa cuesta $12).

Puede utilizar la misma tabla para ilustrar una anomalía de inserción. Por ejemplo,
supongamos que desea agregar desodorante en barra a su línea de productos a un precio
de $2. No puede agregar estos datos a la tabla VENTAS hasta que un cliente compre
desodorante en barra.

El problema con la tabla VENTAS en la figura es que esta tabla trata más de una
cosa: cubre no solo qué productos compran los clientes, sino también cuánto
cuestan los productos. Para eliminar las anomalías, debe dividir la tabla VENTAS en
dos tablas, cada una de las cuales trata solo un tema o idea, como se muestra en la
Figura 5-3.

La Figura 5-3 muestra la tabla VENTAS dividida en dos tablas:

✓ CUST_PURCH, que trata la idea única de compras de los clientes.

✓ PROD_PRICE, que trata sobre la idea única del precio del producto.
 Capítulo 5: Creación de una base de datos relacional multitabla 131

Figura 5-3:
Dividiendo el
tabla de VENTAS
En dos
mesas.

Ahora puede eliminar la fila del cliente 1001 de CUST_PURCH sin perder el hecho de que el
detergente para ropa cuesta $12. (El costo del detergente para ropa ahora se almacena en
PROD_PRICE). También puedes agregar desodorante en barra a PROD_PRICE
independientemente de que alguien haya comprado el producto o no. La información de
compra se almacena en otro lugar, en la tabla CUST_PURCH.

El proceso de dividir una tabla en varias tablas, cada una de las cuales tiene un solo
tema, se llamanormalizació[Link] posible que una operación de normalización que
resuelva un problema no afecte a otros problemas. Es posible que tengas que realizar
varias operaciones de normalización sucesivas para reducir cada tabla resultante a un
único tema. Cada tabla de la base de datos debe abordar un tema principal, y sólo uno.
A veces (como probablemente habrás adivinado) determinar que una tabla en realidad
Tratar dos o más temas puede resultar difícil.

Puedes clasificar las tablas según los tipos de anomalías de modificación a las que están
sujetas. En un artículo de 1970, E. F. Codd, el primero en describir el modelo relacional,
identificó tres fuentes de anomalías de modificación y definió la primera, segunda y
[Link] normales(1NF, 2NF, 3NF) como remedios para esos tipos de anomalías. En
los años siguientes, Codd y otros descubrieron tipos adicionales de anomalías y
especificaron nuevas formas normales para abordarlas. La forma normal de Boyce-Codd
(BCNF), la cuarta forma normal (4NF) y la quinta forma normal (5NF) ofrecieron cada una
un mayor grado de protección contra anomalías de modificación. Sin embargo, no fue
hasta 1981 que un artículo escrito por Ronald Fagin describió la forma normal de clave de
dominio o DK/NF (que ocupa una sección completa más adelante en este capítulo). El uso
de esta última forma normal le permitegarantizarque una tabla esté libre de anomalías
de modificación.

Las formas normales sonanidadoen el sentido de que una tabla que está en 2NF es automáticamente
tambiénen 1NF. De manera similar, una tabla en 3NF está automáticamente en 2NF, y así sucesivamente.
Para la mayoría de las aplicaciones prácticas, colocar una base de datos en 3NF es suficiente para garantizar
un alto grado de integridad. Para estar absolutamente seguro de su integridad, usted
132 Parte II: Uso de SQL para crear bases de datos

debe poner la base de datos en DK/NF; Para obtener más información sobre por qué, pase a la
sección "Forma normal de clave de dominio (DK/NF)".

Después de normalizar una base de datos tanto como sea posible, es posible que desee
realizar desnormalizaciones seleccionadas para mejorar el rendimiento. Si lo hace, tenga en
cuenta los tipos de anomalías que ahora pueden ser posibles.

Primera forma normal

Para estar en primera forma normal (1NF), una tabla debe tener las siguientes cualidades:

✓ La tabla es bidimensional con filas y columnas.

✓ Cada fila contiene datos que pertenecen a alguna cosa o parte de una cosa.
✓ Cada columna contiene datos para un único atributo de lo que
describe.
✓ Cada celda (intersección de una fila y una columna) de la tabla debe
tener un solo valor.
✓ Todas las entradas de cualquier columna deben ser del mismo tipo. Si, por ejemplo, la
entrada en una fila de una columna contiene el nombre de un empleado, todas las demás
filas también deben contener nombres de empleados en esa columna.

✓ Cada columna debe tener un nombre único.

✓ No pueden haber dos filas idénticas (es decir, cada fila debe ser única).
✓ El orden de las columnas y el orden de las filas no son significativos.

Una tabla (relación) en primera forma normal es inmune a algunos tipos de anomalías de
modificación, pero aún está sujeta a otras. La tabla SALES que se muestra en la Figura 5-2 está
en su primera forma normal y, como se analizó anteriormente, la tabla está sujeta a anomalías
de eliminación e inserción. La primera forma normal puede resultar útil en algunas aplicaciones
pero poco fiable en otras.

Segunda forma normal

Para apreciar la segunda forma normal, debes comprender la idea de
dependencia funcional. Adependencia funcionales una relación entre o entre
atributos. Un atributo depende funcionalmente de otro si el valor del segundo
atributo determina el valor del primer atributo. Si conoce el valor del segundo
atributo, puede determinar el valor del primer atributo.
 Capítulo 5: Creación de una base de datos relacional multitabla 133
Supongamos, por ejemplo, que una tabla tiene atributos (columnas) Carga estándar,
número de pruebas,yCarga totalque se relacionan a través de la siguiente ecuación:

Carga total = Carga estándar * Número de pruebas

Carga totaldepende funcionalmente de ambosCargo estándar yNúmero

de [Link] conoces los valores deCargo estándary número de
pruebas,puedes determinar el valor deCarga total.

Cada tabla en primera forma normal debe tener una clave primaria única. Esa clave puede
constar de una o más de una columna. Una clave que consta de más de una columna se llama
clave [Link] estar en la segunda forma normal (2NF), todos los atributos (columnas)
que no son clave deben depender de la clave completa. Por lo tanto, toda relación que esté en
1NF con una única clave de atributo está automáticamente en segunda forma normal. Si una
relación tiene una clave compuesta, todos los atributos que no son clave deben depender de
todos los componentes de la clave. Si tiene una tabla donde algunos atributos no clave no
dependen de todos los componentes de la clave, divida la tabla en dos o más tablas para que,
en cada una de las tablas nuevas, todos los atributos no clave dependan de todos los
componentes. de la clave primaria.

¿Suena confuso? Mire un ejemplo para aclarar las cosas. Considere una tabla como la
tabla VENTAS de la Figura 5-2. En lugar de registrar solo una compra para cada cliente,
agrega una fila cada vez que un cliente compra un artículo por primera vez. Una
diferencia adicional es que los clientes de vuelos chárter (aquellos conIdentificación del
clientevalores de 1001 a 1007) obtienen un descuento sobre el precio normal. La Figura
5-4 muestra algunas de las filas de esta tabla.

Figura 5-4:
En el
VENTAS_
PISTA
mesa, la
Cliente_
identificación y

Producto
columnas
constituir un
compuesto
llave.
134 Parte II: Uso de SQL para crear bases de datos

En la Figura 5-4,Identificación del clienteno identifica de forma única una fila. En dos filas,
Identificación del clientees 1001. En otras dos filas,Identificación del clientees 1010. La
combinación de losIdentificación del clientecolumna y elProductoLa columna identifica de
forma única una fila. Estas dos columnas juntas son una clave compuesta.

Si no fuera por el hecho de que algunos clientes califican para un descuento y otros no,
la tabla no estaría en la segunda forma normal, porquePrecio (un atributo que no es
clave) dependería sólo de parte de la clave (Producto). Debido a que algunos clientes
califican para un descuento,Preciodepende de ambos Identificación del clientey
Producto,y la tabla está en segunda forma normal.

Tercera forma normal

Las tablas en segunda forma normal son especialmente vulnerables a algunos tipos de
anomalías de modificación, en particular aquellas que provienen de dependencias
transitivas.

Adependencia transitivaOcurre cuando un atributo depende de un segundo atributo, el cual

depende de un tercer atributo. Las eliminaciones en una tabla con dicha dependencia pueden
provocar una pérdida de información no deseada. Una relación en tercera forma normal es
una relación en segunda forma normal sin dependencias transitivas.

Mire nuevamente la tabla VENTAS en la Figura 5-2, que sabe que está en primera forma
normal. Siempre que restrinja las entradas para permitir solo una fila para cada Identificación
del cliente,tiene una clave primaria de un solo atributo y la tabla está en la segunda forma
normal. Sin embargo, la tabla todavía está sujeta a anomalías. ¿Qué pasa si el cliente 1010 no
está satisfecho con el blanqueador con cloro, por ejemplo, y devuelve el artículo para obtener
un reembolso? Quiere eliminar la tercera fila de la tabla, que registra el hecho de que el cliente
1010 compró blanqueador con cloro. Tienes un problema: si eliminas esa fila, también pierdes
el hecho de que el blanqueador con cloro tiene un precio de $4. Esta situación es un ejemplo
de dependencia transitiva. Preciodepende deProducto,que, a su vez, depende de la clave
primaria Identificación del cliente.

Dividir la tabla VENTAS en dos tablas resuelve el problema de dependencia transitiva. Las
dos tablas que se muestran en la Figura 5-3, CUST_PURCH y PROD_PRICE, forman una
base de datos que está en tercera forma normal.

Forma normal de clave de dominio (DK/NF)

Una vez que una base de datos está en tercera forma normal, se han eliminado la mayoría, pero
no todas, las posibilidades de anomalías de modificación. Las formas normales más allá de la
tercera se definen para eliminar los pocos errores restantes. Forma normal de Boyce-Codd
 Capítulo 5: Creación de una base de datos relacional multitabla 135
(BCNF), cuarta forma normal (4NF) y quinta forma normal (5NF) son ejemplos de tales
formas. Cada formulario elimina una posible anomalía de modificación, pero no
garantiza la prevención de todas las posibles anomalías de modificación. La forma
normal de Domainkey, sin embargo, ofrece dicha garantía.

Una relación está enforma normal de clave de dominio (DK/NF)si cada restricción de la
relación es una consecuencia lógica de la definición de claves y dominios. ArestricciónEn esta
definición se encuentra cualquier regla que sea lo suficientemente precisa como para que
puedas evaluar si es cierta o no. Allavees un identificador único de una fila en una tabla. A
dominioes el conjunto de valores permitidos de un atributo.

Mire nuevamente la base de datos en la Figura 5-2, que está en 1NF, para ver qué debe
hacer para poner esa base de datos en DK/NF.

Mesa: VENTAS (Customer_ID, Producto, Precio)

Llave: Customer_ID
Restricciones: [Link]ón del clientedeterminaProducto
[Link]
[Link]ón del clientedebe ser un número entero > 1000

Para hacer cumplir la Restricción 3 (queIdentificación del clientedebe ser un número entero
mayor que 1000), simplemente puede definir el dominio paraIdentificación del clientepara
incorporar esta restricción. Eso hace que la restricción sea una consecuencia lógica del dominio
de laIdentificación del [Link] deIdentificación del cliente, y
Identificación del clientees una clave, por lo que no tienes ningún problema con la Restricción
1, que es una consecuencia lógica de la definición de la clave. Restricción 2esun problema.
Preciodepende de (es una consecuencia lógica de)Producto,yProducto no es una clave. La
solución es dividir la tabla VENTAS en dos tablas. Una mesa utilizaIdentificación del cliente
como clave, y los demás usosProductocomo clave. Esta configuración es la que tiene en la
Figura 5-3. La base de datos de la Figura 5-3, además de estar en 3NF, también está en DK/NF.

Diseñe sus bases de datos para que estén en DK/NF si es posible. Si puede hacer eso, aplicar
restricciones de clave y dominio hará que se cumplan todas las restricciones y no será posible
que se produzcan anomalías de modificación. Si la estructura de una base de datos está
diseñada de una manera que le impide colocarla en DK/NF, entonces debe crear las
restricciones en el programa de aplicación que utiliza la base de datos. La base de datos en sí
no garantiza que se cumplan las restricciones.

forma anormal
Como en la vida, también ocurre en las bases de datos: a veces, ser anormal vale la pena. Puedes
dejarte llevar por la normalización e ir demasiado lejos. Puedes dividir una base de datos
136 Parte II: Uso de SQL para crear bases de datos

en tantas tablas que todo se vuelve difícil de manejar e ineficiente. El rendimiento puede
caer en picado. A menudo, la estructura óptima de su base de datos está algo
desnormalizada. De hecho, las bases de datos prácticas (las realmente grandes, al
menos) casi nunca están normalizadas hasta DK/NF. Sin embargo, desea normalizar las
bases de datos que diseña tanto como sea posible para eliminar la posibilidad de
corrupción de datos que resulte de anomalías de modificación.

Después de normalizar la base de datos lo más que pueda, realice algunas

recuperaciones como prueba. Si el rendimiento no es satisfactorio, examine su diseño
para ver si la desnormalización selectiva mejoraría el rendimiento sin sacrificar la
integridad. Al agregar cuidadosamente redundancia en ubicaciones estratégicas y
desnormalizarsólo lo suficiente,puede llegar a una base de datos que sea eficiente y
esté a salvo de anomalías.
 Parte III

Almacenamiento y recuperación de datos

[Link]/extras/sqlpara obtener excelente contenido para principiantes en línea.

 En esta parte…
✓ Gestión de datos

✓ Tiempo de seguimiento

✓ Valores de procesamiento

✓ Consultas de construcción

✓ [Link]/extras/sqlpara obtener excelente contenido para

principiantes en línea.
 Capítulo 6

Manipulación de datos de bases de datos

En este capítulo
▶ Tratar con datos
▶ Recuperar los datos que desea de una tabla
▶ Mostrar solo información seleccionada de una o más tablas
▶ Actualización de la información en tablas y vistas.
▶ Agregar una nueva fila a una tabla
▶ Cambiar algunos o todos los datos en una fila de la tabla
▶ Eliminar una fila de la tabla

C Los capítulos 3 y 4 revelan que crear una estructura sólida de base de datos es
fundamental para mantener la integridad de los datos. Sin embargo, lo que realmente
le interesa son los datos en sí, no su estructura. En un momento dado, probablemente desee
hacer una de cuatro cosas con los datos: agregarlos a las tablas, recuperarlos y mostrarlos,
cambiarlos o eliminarlos de las tablas.

En principio, la manipulación de una base de datos es bastante sencilla. Comprender

cómo agregar datos a una tabla no es difícil: puede agregar sus datos una fila a la vez o
en un lote. En la práctica, cambiar, eliminar o recuperar una o más filas de la tabla
también es sencillo. El principal desafío para la manipulación de bases de datos es
seleccionandolas filas que desea cambiar, eliminar o recuperar. Los datos que desea
pueden residir en una base de datos que contenga un gran volumen de datos queno
desear. Afortunadamente, si puedes especificar lo que quieres usando un SQL
SELECCIONAR declaración, la computadora hace toda la búsqueda por usted. Supongo
que eso significa que manipular una base de datos con SQL es pan comido. ¡Agregar,
cambiar, eliminar y recuperar es fácil! (Hmmm. Quizás “fácil” podría ser una ligera
exageración). Al menos puedes comenzar fácil con una simple recuperación de datos.

Recuperando datos
La tarea de manipulación de datos que realizan los usuarios con mayor frecuencia es recuperar
información seleccionada de una base de datos. Es posible que desee recuperar el contenido.
140 Parte III: Almacenamiento y recuperación de datos

de una fila entre miles en una tabla. Es posible que desee recuperar todas las filas que
cumplan una condición o una combinación de condiciones. Es posible que incluso desees
recuperar todas las filas de la tabla. Una declaración SQL particular, laSELECCIONAR
declaración, realiza todas estas tareas por usted.

El uso más simple delSELECCIONARLa declaración es recuperar todos los datos en todas las
filas de una tabla especificada. Para hacerlo, utilice la siguiente sintaxis:

SELECCIONAR * DEL CLIENTE ;

El asterisco (*) es un carácter comodín que [Link] este contexto, el asterisco es

un sustituto abreviado de una lista de todos los nombres de columnas de la tabla
CLIENTE. Como resultado de esta declaración, todos los datos de todas las filas y
columnas de la tabla CLIENTE aparecen en pantalla.

SELECCIONARLas declaraciones pueden ser mucho más complicadas que la declaración de

este ejemplo. De hecho, algunosSELECCIONARLas declaraciones pueden ser tan complicadas
que son prácticamente indescifrables. Esta posible complejidad es el resultado del hecho de
que se pueden agregar múltiples cláusulas modificadoras a la declaración básica. El Capítulo
10 cubre la modificación de cláusulas en detalle; En este capítulo analizo brevemente laDÓNDE
cláusula, que es el método más comúnmente utilizado para restringir las filas que un
SELECCIONARretornos de declaración.

ASELECCIONARdeclaración con unDÓNDEcláusula tiene la siguiente forma general:

SELECCIONE lista_columna DESDE nombre_tabla

DONDE condición;

La lista de columnas especifica qué columnas desea mostrar. La declaración

muestra solo las columnas que usted enumera. ElDELa cláusula especifica de
qué tabla desea mostrar columnas. ElDÓNDELa cláusula excluye filas que no
satisfacen una condición específica. La condición puede ser simple (por
ejemplo,DONDE ESTADO_CLIENTE = 'NH'),o puede ser compuesto (por
ejemplo,WHERE CUSTOMER_STATE='NH' AND STATUS='Activo').

El siguiente ejemplo muestra una condición compuesta dentro de unSELECCIONAR

declaración:

SELECCIONE Nombre, Apellido, Teléfono DEL CLIENTE

DONDE Estado = 'NH'
Y Estado = 'Activo';

Esta declaración devuelve los nombres y números de teléfono de todos los clientes
activos que viven en New Hampshire. ElYpalabra clave significa que para que una fila
califique para su recuperación, esa fila debe cumplir ambas condiciones:Estado = 'NH' y
Estado = 'Activo'.
 Capítulo 6: Manipulación de datos de bases de datos 141

SQL en herramientas propietarias

Usando SQLSELECCIONARLas declaraciones no son la En algunos casos, las herramientas propietarias no pueden
única forma de recuperar datos de una base de datos. Si expresar todo lo que usted puede expresar mediante SQL. Si
está interactuando con su base de datos a través de un necesita realizar una operación que la herramienta propietaria
DBMS, este sistema probablemente ya tenga no puede manejar, es posible que necesite utilizar SQL. Por lo
herramientas patentadas para manipular datos. Puede tanto, familiarizarse con SQL es una buena idea, incluso si
utilizar estas herramientas (muchas de las cuales son utiliza una herramienta propietaria la mayor parte del tiempo.
bastante intuitivas) para agregar, eliminar, cambiar o Para realizar con éxito una operación que es demasiado
consultar su base de datos. compleja para su herramienta patentada, necesita una
comprensión clara de cómo funciona SQL y qué puede hacer.
Muchas interfaces DBMS le ofrecen la opción de
utilizar sus herramientas patentadas o SQL. En

Creando vistas
La estructura de una base de datos diseñada según principios sólidos, incluida la
normalización adecuada (consulte el Capítulo 5), maximiza la integridad de los datos. Sin
embargo, esta estructura a menudo no es la mejor manera de observar los datos. Varias
aplicaciones pueden utilizar los mismos datos, pero cada aplicación puede tener un énfasis
diferente. Una de las características más poderosas de SQL es su capacidad para mostrar
vistas de los datos que están estructuradas de manera diferente a cómo las tablas de la base
de datos almacenan los datos. Las tablas que utiliza como fuentes para columnas y filas en
una vista son lasmesas [Link] Capítulo 3 analiza las vistas como parte del lenguaje de
definición de datos (DDL); Esta sección analiza las vistas en el contexto de la recuperación y
manipulación de datos.

ASELECCIONARLa declaración siempre devuelve un resultado en forma de tabla virtual. A

vistaEs un tipo especial de mesa virtual. Puede distinguir una vista de otras tablas
virtuales porque los metadatos de la base de datos contienen la definición de una vista.
Esta distinción le da a la vista un grado de persistencia que otras mesas virtuales no
poseen.

Puede manipular una vista del mismo modo que puede manipular una tabla real. La
diferencia es que los datos de una vista no tienen una existencia independiente. La vista
deriva sus datos de la tabla o tablas de las que extrae las columnas de la vista. Cada
aplicación puede tener sus propias vistas únicas de los mismos datos.

Considere la base de datos VetLab que describo en el Capítulo 5. Esa base de datos contiene
cinco tablas: CLIENTE, PRUEBAS, EMPLEADO, PEDIDOS y RESULTADOS. Supongamos que el
gerente nacional de marketing quiere ver de qué estados provienen los pedidos de la
empresa. Parte de esta información se encuentra en el CLIENTE.
142 Parte III: Almacenamiento y recuperación de datos

mesa; algunas mentiras en la tabla PEDIDOS. Supongamos que el oficial de control de calidad
quiere comparar la fecha del pedido de una prueba con la fecha en la que llegó el resultado
final de la prueba. Esta comparación requiere algunos datos de la tabla PEDIDOS y algunos
de la tabla RESULTADOS. Para satisfacer necesidades como éstas, puedes crear vistas que te
proporcionen exactamente los datos que deseas en cada caso.

De tablas
Para el director de marketing, puede crear la vista que se muestra en la Figura 6-1.

Figura 6-1:
El
PEDIDOS_
POR_ESTADO
vista para el
marketing
gerente.

La siguiente declaración crea la visión del gerente de marketing:

CREAR VER PEDIDOS_POR_ESTADO

(Nombre del cliente, estado, número de pedido)
COMO SELECCIONAR [Link], Estado, Número de Pedido
DEL CLIENTE, PEDIDOS
DONDE [Link] = [Link];

La nueva vista tiene tres columnas:Nombre del cliente, estado,yNúmero de

orden. Nombre del clienteaparece en las tablas CLIENTE y PEDIDOS y sirve
como enlace entre las dos tablas. La nueva vista atraeEstadoinformación de la
tabla CLIENTE y toma laNúmero de ordende la tabla PEDIDOS. En el
 Capítulo 6: Manipulación de datos de bases de datos 143

En el ejemplo anterior, declara los nombres de las columnas explícitamente en la

nueva vista.

Tenga en cuenta que le puse el prefijoNombre del clientecon la tabla que lo contiene, pero no
hice eso porEstadoyNúmero de [Link] es porqueEstadoaparece sólo en la tabla CLIENTE y
Número de ordenAparece sólo en la tabla PEDIDOS, por lo que no hay ambigüedad. Sin
embargo,Nombre del clienteaparece tanto en CLIENTE como en PEDIDOS, por lo que se
necesita el identificador adicional.

No necesita esta declaración si los nombres son los mismos que los nombres de las columnas
correspondientes en las tablas fuente. El ejemplo de la siguiente sección muestra una situación
[Link] VISTAdeclaración, excepto que los nombres de las columnas de la vista están
implícitos en lugar de indicados explícitamente.

Con una condición de selección.

El oficial de control de calidad requiere una visión diferente de la que utiliza el
gerente de marketing, como lo muestra el ejemplo de la Figura 6-2.

Figura 6-2:
El
INFORMES
_Vista LAG
Para el
calidad-
control
oficial.

Aquí está el código que crea la vista en la Figura 6-2:

CREAR VER INFORMES_LAG

COMO SELECCIONAR PEDIDOS.Número de pedido, Fecha de pedido, Fecha de informe
DE PEDIDOS, RESULTADOS
DONDE PEDIDOS.Número de pedido = RESULTADOS.Número de pedido
Y [Link] = 'F';
144 Parte III: Almacenamiento y recuperación de datos

Esta vista contiene información de la fecha del pedido de la tabla PEDIDOS e

información de la fecha del informe final de la tabla RESULTADOS. Sólo las filas que
tienen un 'F'en elPreliminarFinalLa columna de la tabla RESULTADOS aparece en la
INFORMES_LAGvista. Tenga en cuenta también que la lista de columnas en la vista
ORDERS_BY_ STATE es opcional. ElINFORMES_LAGLa vista funciona bien sin esa lista.

Con un atributo modificado

ElSELECCIONARLas cláusulas de los ejemplos de las dos secciones anteriores contienen sólo
nombres de columnas. Puedes incluir expresiones en elSELECCIONARcláusula también.
Supongamos que el propietario de VetLab cumple años y quiere ofrecer a todos sus clientes un
descuento del 10 por ciento para celebrarlo. Puede crear una vista basada en la tabla
[Link] tabla PRUEBAS. Puede construir esta tabla como se muestra en el siguiente
ejemplo de código:

CREAR VER CUMPLEAÑOS

(Nombre del cliente, prueba, fecha del pedido, cargo de cumpleaños)
AS SELECT Nombre del cliente, Prueba solicitada, Fecha del pedido,
Carga estándar * .9
DE PEDIDOS, PRUEBAS
DONDE PruebaOrdered = NombreDePrueba;

Observe que la segunda columna delCUMPLEAÑOSvista -Prueba -corresponde a la

PruebaOrdenadacolumna en la tabla PEDIDOS, que también corresponde a laNombre de
la pruebacolumna de la tabla PRUEBAS. La Figura 6-3 muestra cómo crear esta vista.

Figura 6-3:
La vista
creado
mostrar
cumpleaños dis-
cuenta.

Puede crear una vista basada en varias tablas, como se muestra en los ejemplos
anteriores, o puede crear una vista basada en una sola tabla. Si no necesita algunas de
las columnas o filas de una tabla, cree una vista para eliminarlas
 Capítulo 6: Manipulación de datos de bases de datos 145

elementos de la vista y luego tratar con la vista en lugar de la tabla original. Este
enfoque garantiza que los usuarios vean sólo las partes de la tabla que son relevantes
para la tarea en cuestión.

Otra razón para crear una vista es brindar seguridad a sus tablas subyacentes. Es posible que
desee que algunas columnas de sus tablas estén disponibles para su inspección y, al mismo
tiempo, ocultar otras. Puede crear una vista que incluya solo aquellas columnas que desea
que estén disponibles y luego otorgar un acceso amplio a esa vista mientras restringe el
acceso a las tablas desde las que dibuja la vista. (El Capítulo 14 explora la seguridad de la base
de datos y describe cómo otorgar y revocar privilegios de acceso a datos).

Actualizando vistas
Después de crear una tabla, esa tabla es automáticamente capaz de acomodar inserciones,
actualizaciones y eliminaciones. Las vistas no necesariamente exhiben la misma capacidad. Si
actualiza una vista, en realidad está actualizando su tabla subyacente. A continuación se
detallan algunos problemas potenciales que puede encontrar al actualizar las vistas:

✓ Algunas vistas pueden extraer componentes de dos o más [Link] actualiza dicha
vista, es posible que las tablas subyacentes no se actualicen correctamente.

✓ Una vista puede incluir una expresión en [Link] a que las

expresiones no se asignan directamente a las filas de las tablas, su DBMS no sabrá
cómo actualizar una expresión.

Supongamos que crea una vista utilizando la siguiente declaración:

CREAR VER COMP (EmpName, Pay)

AS SELECT EmpName, Salario+Comm AS Pay
DEL EMPLEADO ;

Quizás pienses que puedes [Link] la siguiente declaración:

ACTUALIZAR COMP SET Pago = Pago + 100;

Desafortunadamente, este enfoque no tiene ningún sentido. Esto se debe a

que la tabla subyacente no tienePagarcolumna. No puede actualizar algo que
no existe en la tabla base.

Tenga en cuenta la siguiente regla siempre que considere actualizar vistas: no puede actualizar
una columna en una vista a menos que corresponda a una columna en una tabla base
subyacente.
146 Parte III: Almacenamiento y recuperación de datos

Agregar nuevos datos

Cada tabla de base de datos comienza vacía. Después de crear una tabla, ya sea utilizando
DDL de SQL o una herramienta RAD, esa tabla no es más que un caparazón estructurado que
no contiene datos. Para que la tabla sea útil, debes incluir algunos datos en ella. Es posible
que usted tenga o no esos datos ya almacenados en formato digital. Sus datos podrán
aparecer en alguna de las siguientes formas:

✓ Aún no compilado en ningún formato digital:Si sus datos aún no están en formato
digital, probablemente alguien tendrá que ingresarlos manualmente, un registro a la vez.
También puede ingresar datos utilizando escáneres ópticos y sistemas de reconocimiento
de voz, pero el uso de dichos dispositivos para ingresar datos es relativamente raro.

✓ Compilado en algún tipo de formato digital:Si sus datos ya están en formato

digital, pero quizás no en el formato de las tablas de la base de datos que
utiliza, debe traducir los datos al formato apropiado y luego insertarlos en la
base de datos.
✓ Compilado en el formato digital correcto:Si sus datos ya están en formato
digital y en el formato correcto, está listo para transferirlos a una nueva base de
datos.

Las siguientes secciones abordan la adición de datos a una tabla cuando existe en cada una
de estas tres formas. Dependiendo de la forma actual de los datos, es posible que pueda
transferirlos a su base de datos en una sola operación o que necesite ingresar los datos un
registro a la vez. Cada registro de datos que ingresa corresponde a una sola fila en una tabla
de base de datos.

Agregar datos una fila a la vez

La mayoría de los DBMS admiten la entrada de datos basada en formularios. Esta característica le
permite crear un formulario de pantalla que tiene un campo para cada columna en una tabla de base
de datos. Las etiquetas de campo en el formulario le permiten determinar fácilmente qué datos se
incluyen en cada campo. El operador de entrada de datos ingresa todos los datos de una sola fila en
el formulario. Después de que el DBMS acepta la nueva fila, el sistema borra el formulario para
aceptar otra fila. De esta manera, puede agregar fácilmente datos a una tabla, una fila a la vez.

La entrada de datos basada en formularios es fácil y menos susceptible a errores de entrada de

datos que usar una lista devalores delimitados por [Link] principal problema con la entrada de
datos basada en formularios es que no es estándar; Cada DBMS tiene su propio método para crear
formularios. Esta diversidad, sin embargo, no es un problema para el operador de entrada de datos.
Puede hacer que el formulario tenga el mismo aspecto general de un DBMS a otro.
 Capítulo 6: Manipulación de datos de bases de datos 147

otro. (El operador de entrada de datos puede no sufrir demasiado, pero el desarrollador de la
aplicación debe volver al final de la curva de aprendizaje cada vez que cambia de herramienta
de desarrollo.) Otro posible problema con la entrada de datos basada en formularios es que
algunas implementaciones pueden no permitir una gama completa de comprobaciones de
validez de los datos que introduce.

La mejor manera de mantener un alto nivel de integridad de los datos en una base de datos es
mantener los datos incorrectos fuera de la base de datos. Puede evitar la entrada de algunos datos
incorrectos aplicando restricciones a los campos de un formulario de entrada de datos. Este enfoque
le permite asegurarse de que la base de datos acepte solo valores de datos del tipo correcto y dentro
de un rango predefinido. Estas restricciones no pueden evitar todos los errores posibles, pero pueden
detectar algunos errores.

Si la herramienta de diseño de formularios en su DBMS no le permite aplicar todas las

comprobaciones de validez que necesita para garantizar la integridad de los datos, es posible que
desee crear su propia pantalla, aceptar entradas de datos en variables y verificar las entradas
utilizando el programa de aplicación. código. Una vez que esté seguro de que todos los valores
ingresados para una fila de la tabla son válidos, puede agregar esa fila usando SQLINSERTAR
dominio.

Si ingresa los datos de una sola fila en una tabla de base de datos, elINSERTAREl
comando utiliza la siguiente sintaxis:

INSERTAR EN tabla_1 [(columna_1, columna_2, ..., columna_n)]

VALORES (valor_1, valor_2, ..., valor_n);

Como lo indican los corchetes ([ ]), la lista de nombres de columnas es opcional. El orden
predeterminado de la lista de columnas es el orden de las columnas de la tabla. Si pones
elVALORESEn el mismo orden que las columnas de la tabla, estos elementos van en las
columnas correctas, ya sea que especifique esas columnas explícitamente o no. Si desea
especificar elVALORESen algún orden distinto al orden de las columnas de la tabla, debe
enumerar los nombres de las columnas en el mismo orden que la lista de valores de la
[Link]áusula.

Para ingresar un registro en la tabla CLIENTE, por ejemplo, use la siguiente

sintaxis:

INSERTAR EN EL CLIENTE (ID de cliente, nombre, apellido,

Calle, Ciudad, Estado, Código Postal, Teléfono)
VALORES (:vcustid, ‘David’, ‘Taylor’, ‘235 Loco Ave.’,
‘El Pollo’, ‘CA’, ‘92683’, ‘(617) 555-1963’);

La primeraVALORen la tercera línea,vcustid,es una variable que incrementa con el

código de su programa después de ingresar cada nueva fila de la tabla. Este enfoque
garantiza que no habrá duplicación delIdentificación del cliente (que es la clave
principal de esta tabla y debe ser única). El resto de los valores son elementos de datos
en lugar de variables quecontenerelementos de datos. De
148 Parte III: Almacenamiento y recuperación de datos

Por supuesto, si lo desea, también puede mantener los datos de estas columnas en variables. El
INSERTARLa declaración funciona igual de bien ya sea que use variables o una copia explícita de
los datos mismos para formar los argumentos de laVALORESpalabra clave.

Agregar datos solo a las columnas seleccionadas

A veces quieres notar la existencia de un objeto incluso si aún no tienes todos los datos
sobre él. Si tiene una tabla de base de datos para dichos objetos, puede insertar una fila
para el nuevo objeto sin completar los datos en todas las columnas.
Si desea que la tabla esté en su primera forma normal, debe insertar suficientes datos para
distinguir la nueva fila de todas las demás filas de la tabla. (Para conocer las complejidades de
las formas normales, incluida la primera, consulte el Capítulo 5). Insertar la clave principal de la
nueva fila es suficiente para este propósito. Además de la clave principal, inserte cualquier otro
dato que tenga sobre el objeto. Las columnas en las que no ingresa datos contienen valores
nulos.

El siguiente ejemplo muestra una entrada de fila parcial:

INSERTAR EN EL CLIENTE (ID de cliente, nombre, apellido)

VALORES (:vcustid, 'Tyson', 'Taylor');

Inserta solo el número de identificación único y el nombre del cliente en la tabla de la

base de datos. Las otras columnas de esta fila contienen valores nulos.

Agregar un bloque de filas a una tabla

Cargar una tabla de base de datos una fila a la vez usandoINSERTARLas declaraciones pueden ser
tediosas, especialmente si eso es todo lo que haces. Incluso ingresar los datos en una pantalla
ergonómica cuidadosamente diseñada por humanos resulta agotador después de un tiempo.
Claramente, si tiene una forma confiable de ingresar los datos automáticamente, encontrará
ocasiones en las que la entrada automática es mejor que tener a una persona sentada frente a un
teclado y escribiendo.

La entrada automática de datos es factible, por ejemplo, si los datos existen en formato
electrónico porque alguien ya los ha introducido manualmente. Si es así, no hay razón
para repetir la historia. Transferir datos de un archivo de datos a otro es una tarea que
una computadora puede realizar con una mínima participación humana. Si conoce las
características de los datos de origen y la forma deseada de la tabla de destino, una
computadora puede (en principio) realizar la transferencia de datos automáticamente.
 Capítulo 6: Manipulación de datos de bases de datos 149

Copiar desde un archivo de datos externo

Suponga que está creando una base de datos para una nueva aplicación. Algunos datos que
necesita ya existen en un archivo de computadora. El archivo puede ser un archivo plano o una tabla
en una base de datos creada por un DBMS diferente al que utiliza. Los datos pueden estar en código
ASCII o EBCDIC o en algún formato propietario arcano. ¿A qué te dedicas?

Lo primero que debe hacer es esperar y rezar para que los datos que desea estén en un
formato ampliamente utilizado. Si los datos están en un formato popular, es muy probable que
encuentre una utilidad de conversión de formato que pueda traducir los datos a uno o másotro
formatos populares. Su entorno de desarrollo probablemente pueda importar al menos uno de
estos formatos; si eresen realidadAfortunadamente, su entorno de desarrollo puede manejar el
formato de datos actual directamente. En ordenadores personales, los formatos Access, xBASE
y MySQL son los más utilizados. Si los datos que desea están en uno de estos formatos, la
conversión debería ser fácil. Si el formato de los datos es menos común, es posible que deba
realizar una conversión en dos pasos.

Si los datos están en un formato antiguo, propietario o obsoleto, como último recurso,
puede recurrir a un servicio profesional de traducción de datos. Estas empresas se
especializan en traducir datos informáticos de un formato a otro. Manejan cientos de
formatos, de la mayoría de los cuales nadie ha oído hablar. Entregue a uno de estos
servicios una cinta o disco que contenga los datos en su formato original y obtendrá los
mismos datos traducidos al formato que especifique.

Transferir todas las filas entre tablas

Un problema menos grave que tratar con datos externos es tomar datos que ya
existen en una tabla de su base de datos y combinarlos con datos compatibles en
otra tabla. Este proceso funciona muy bien si la estructura de la segunda tabla es
idéntica a la estructura de la primera tabla; es decir, cada columna de la primera
tabla tiene una columna correspondiente en la segunda tabla y los tipos de datos de
las columnas correspondientes coinciden. En ese caso, puede combinar el contenido
de las dos tablas utilizando elUNIÓNoperador relacional. El resultado es unmesa
virtual(es decir, uno que no tiene existencia independiente) que contiene datos de
ambas tablas fuente. Hablo de los operadores relacionales, incluidosUNIÓN,en el
Capítulo 11.

Transferir columnas y filas seleccionadas entre tablas

Generalmente, la estructura de los datos en la tabla de origen no es idéntica a la
estructura de la tabla en la que desea insertar los datos. Quizás solo coincidan
algunas de las columnas y estas sean las columnas que desea transferir.
CombinandoSELECCIONARdeclaraciones con unUNIÓN,puede especificar qué
columnas de las tablas de origen incluir en la tabla de resultados virtual.
150 Parte III: Almacenamiento y recuperación de datos

IncluyendoDÓNDEcláusulas en elSELECCIONARdeclaraciones, puede restringir las filas que

coloca en la tabla de resultados a aquellas que satisfacen condiciones específicas. (Yo cubro
DÓNDEcláusulas detalladamente en el Capítulo 10.)

Suponga que tiene dos tablas, PROSPECTO y CLIENTE, y desea enumerar a todos los que
viven en el estado de Maine y que aparecen en cualquiera de las tablas. Puede crear una
tabla de resultados virtual que contenga la información deseada; solo usa el siguiente
comando:

SELECCIONE Nombre, Apellido

DEL PROSPECTO
DONDE Estado = 'YO'
UNIÓN
SELECCIONE Nombre, Apellido
DEL CLIENTE
DONDE Estado = 'YO';

Aquí hay una mirada más cercana:

✓ ElSELECCIONARLas declaraciones especifican que las columnas incluidas en la tabla de

resultados sonNombre de pilayApellido.

✓ ElDÓNDELas cláusulas restringen las filas incluidas a aquellas con el valor.

'A MÍ'en elEstadocolumna.
✓ ElEstadoLa columna no está incluida en la tabla de resultados, pero está
presente en las tablas PROSPECT y CLIENTE.
✓ ElUNIÓNEl operador combina los resultados de laSELECCIONARdeclaración en
PROSPECT con los resultados de laSELECCIONARen CLIENTE, elimina las filas
duplicadas y luego muestra el resultado.

Otra forma de copiar datos de una tabla de una base de datos a otra es anidar una
SELECCIONARdeclaración dentro de unINSERTARdeclaración. Este método
(conocido como subseleccionary detallado en el Capítulo 12) no crea una tabla
virtual; en cambio, duplica los datos seleccionados. Puede tomar todas las filas de la
tabla CLIENTE, por ejemplo, e insertarlas en la tabla PROSPECT. Por supuesto, esto
sólo funciona si las estructuras de las tablas CLIENTE y PROSPECTO son idénticas. Si
desea colocar sólo aquellos clientes que viven en Maine en la tabla PROSPECT, una
simpleSELECCIONARcon una condición en elDÓNDELa cláusula funciona, como se
muestra en el siguiente ejemplo:

INSERTAR EN EL PROSPECTO
SELECCIONAR * DEL CLIENTE
DONDE Estado = 'YO';

Aunque esta operación crea datos redundantes (ahora está almacenando datos del cliente
tanto en la tabla PROSPECT como en la tabla CLIENTE), es posible que desee realizarla de todos
modos para mejorar el rendimiento de las recuperaciones. ¡Cuidado con la redundancia, sin
embargo! Para mantener la coherencia de los datos, asegúrese de no insertar, actualizar o
eliminar filas en una tabla sin insertar, actualizar o eliminar.
 Capítulo 6: Manipulación de datos de bases de datos 151

eliminando las filas correspondientes en la otra tabla. Otro problema potencial es la posibilidad
de que elINSERTARLa declaración podría generar claves primarias duplicadas. Si incluso un
prospecto preexistente tiene una clave primaria deID de prospectoque coincide con la clave
primaria correspondiente (Identificación del cliente)de un cliente que está intentando insertar
en la tabla PROSPECT, la operación de inserción fallará. Si ambas tablas tienen claves primarias
autoincrementales, no querrás que comiencen con el mismo número. Asegúrate de que los dos
bloques de números estén muy separados uno del otro.

Actualización de datos existentes

Puedes contar con una cosa en este mundo: el cambio. Si no le gusta la situación actual,
espere un poco. Dentro de poco, las cosas serán diferentes. Debido a que el mundo
cambia constantemente, las bases de datos utilizadas para modelar aspectos del mundo
también deben cambiar. Un cliente puede cambiar su dirección. La cantidad de un
producto en stock puede cambiar (porque, espera, alguien compra un artículo de vez en
cuando). Las estadísticas de rendimiento de la temporada de un jugador de baloncesto
cambian cada vez que juega otro partido. Si su base de datos contiene dichos elementos,
debe actualizarla periódicamente.

SQL proporciona laACTUALIZARDeclaración para cambiar datos en una tabla. Al utilizar un

soloACTUALIZARdeclaración, puede cambiar una, algunas o todas las filas de una tabla. El
ACTUALIZARLa declaración utiliza la siguiente sintaxis:

ACTUALIZAR nombre_tabla
SET columna_1 = expresión_1, columna_2 = expresión_2,. . . ,
columna_n = expresión_n
[DONDE predicados] ;

ElDÓNDELa cláusula es opcional. Esta cláusula especifica las filas que está actualizando. Si
no usas unDÓNDEcláusula, se actualizan todas las filas de la tabla. El COLOCARLa cláusula
especifica los nuevos valores para las columnas que está cambiando.

Considere la tabla CLIENTE que se muestra en la Tabla 6-1.

Tabla 6-1 Tabla CLIENTE

Nombre Ciudad Codigo de AREA Teléfono
Abel Abelson Springfield (714) 555-1111

Bill Bailey Decatur (714) 555-2222

mandril de madera Filón (714) 555-3333

Don Stetson Filón (714) 555-4444

Dolph Stetson Filón (714) 555-5555

152 Parte III: Almacenamiento y recuperación de datos

Las listas de clientes cambian ocasionalmente: a medida que las personas se mudan,
cambian sus números de teléfono, etc. Supongamos que Abe Abelson se muda de
Springfield a Kankakee. Puede actualizar su registro en la tabla utilizando lo siguiente
ACTUALIZARdeclaración:

ACTUALIZAR CLIENTE
Ciudad SET = ‘Kankakee’, Teléfono = ‘666-6666’
DONDE Nombre = 'Abe Abelson';

Esta declaración provoca los cambios que se muestran en la Tabla 6-2.

Tabla 6-2 Tabla CLIENTE después de ACTUALIZAR a una fila

Nombre Ciudad Codigo de AREA Teléfono

Abel Abelson kankakee (714) 666-6666

Bill Bailey Decatur (714) 555-2222

mandril de madera Filón (714) 555-3333

Don Stetson Filón (714) 555-4444

Dolph Stetson Filón (714) 555-5555

Puede utilizar una declaración similar para actualizar varias filas. Supongamos que Philo está
experimentando un crecimiento poblacional explosivo y ahora requiere su propio código de área.
Puede cambiar todas las filas de los clientes que viven en Philo usando un soloACTUALIZAR
declaración, de la siguiente manera:

ACTUALIZAR CLIENTE
ESTABLECER código de área = '(619)'
DONDE Ciudad = 'Filón';

La tabla ahora se parece a la que se muestra en la Tabla 6-3.

Tabla 6-3 Tabla CLIENTE después de ACTUALIZAR a varias filas

Nombre Ciudad Codigo de AREA Teléfono

Abel Abelson kankakee (714) 666-6666

Bill Bailey Decatur (714) 555-2222

mandril de madera Filón (619) 555-3333

Don Stetson Filón (619) 555-4444

Dolph Stetson Filón (619) 555-5555

 Capítulo 6: Manipulación de datos de bases de datos 153

Actualizar todas las filas de una tabla es incluso más fácil que actualizar sólo algunas de las
filas. No es necesario utilizar unDÓNDEcláusula para restringir la declaración. Imagine que
la ciudad de Rantoul ha adquirido una gran influencia política y ahora ha anexado no sólo
Kankakee, Decatur y Philo, sino también todas las ciudades y pueblos de la base de datos.
Puede actualizar todas las filas utilizando una sola declaración, de la siguiente manera:

ACTUALIZAR CLIENTE
ESTABLECER ciudad = 'Rantoul';

La tabla 6-4 muestra el resultado.

Tabla 6-4 Tabla CLIENTE después de ACTUALIZAR todas las filas

Nombre Ciudad Codigo de AREA Teléfono

Abel Abelson rantoul (714) 666-6666

Bill Bailey rantoul (714) 555-2222

mandril de madera rantoul (619) 555-3333

Don Stetson rantoul (619) 555-4444

Dolph Stetson rantoul (619) 555-5555

Cuando usas elDÓNDEcláusula con laACTUALIZARdeclaración para restringir qué filas se

actualizan, el contenido de laDÓNDEcláusula puede ser unasubseleccionar—a SELECCIONAR
declaración, cuyo resultado es utilizado como entrada por otraSELECCIONAR declaración.

Por ejemplo, suponga que es mayorista y su base de datos incluye una tabla VENDOR
que contiene los nombres de todos los fabricantes a los que compra productos. También
tienes una tabla de PRODUCTOS que contiene los nombres de todos los productos que
vendes y los precios que cobras por ellos. La tabla VENDOR tiene [Link] de
proveedor, nombre de proveedor, calle, ciudad, estado, [Link] tabla PRODUCTO
tieneID de producto, Nombre de producto, ID de proveedor, yPrecio de venta.

Su proveedor, Cumulonimbus Corporation, decide aumentar los precios de todos sus

productos en un 10 por ciento. Para mantener su margen de beneficio, debe aumentar
los precios de los productos que obtiene de Cumulonimbus en un 10 por ciento. Puedes
hacerlo usando lo siguienteACTUALIZARdeclaración:

ACTUALIZAR PRODUCTO
SET Precio de oferta = (Precio de oferta * 1.1)
DÓNDE ENTRA EL ID del proveedor
(SELECCIONE ID de proveedor DEL PROVEEDOR
WHERE VendorName = 'Cumulonimbus Corporation');
154 Parte III: Almacenamiento y recuperación de datos

La subselección encuentra elID del proveedorque corresponde a Cumulonimbus. Luego puedes

usar elID del proveedoren la tabla PRODUCTO para encontrar las filas que desea actualizar. Los
precios de todos los productos Cumulonimbus aumentan un 10 por ciento; Los precios de
todos los demás productos siguen siendo los mismos. (Hablo más ampliamente de las
subselecciones en el Capítulo 12.)

Transferencia de datos
Además de utilizar elINSERTARyACTUALIZARdeclaraciones, puede agregar datos a una
tabla o vista utilizando elUNIRdeclaración. PuedeUNIRdatos de una tabla o vista de
origen a una tabla o vista de destino. ElUNIRPuede insertar nuevas filas en la tabla de
destino o actualizar las filas [Link] una forma conveniente de tomar datos
que ya existen en algún lugar de una base de datos y copiarlos en una nueva ubicación.

Por ejemplo, considere la base de datos VetLab que describo en el Capítulo 5.

Supongamos que algunas personas en la tabla EMPLEADO son vendedores que han
recibido pedidos, mientras que otras son empleados que no son vendedores o
vendedores que aún no han recibido un pedido. El año que acaba de concluir ha sido
rentable y desea compartir parte de ese éxito con los empleados. Decides dar un bono de
$100 a todos los que hayan realizado al menos un pedido y un bono de $50 a todos los
demás. Primero, crea una tabla BONUS e inserta en ella un registro para cada empleado
que aparece al menos una vez en la tabla PEDIDOS, asignando a cada registro un valor
de bonificación predeterminado de $100.

A continuación, desea utilizar elUNIRdeclaración para insertar nuevos registros para

aquellos empleados que no han recibido pedidos, dándoles bonos de $50. Aquí hay un
código que crea y completa la tabla BONUS:

CREAR BONIFICACIÓN DE MESA (

Nombre del empleado CARÁCTER (30) CLAVE PRIMARIA,
Bonificación NUMÉRICO PREDETERMINADO 100);

INSERTAR EN BONIFICACIÓN (Nombre del empleado)

(SELECCIONE NombreEmpleado DE EMPLEADO, PEDIDOS DONDE
[Link] = [Link]
GRUPO POR [Link]);

Ahora puede consultar la tabla BONUS para ver qué contiene:

SELECCIONAR * DE BONIFICACIÓN ;

Nombre de empleado Prima

------------ -------------
Brynna Jones 100
Chris Bancroft 100
Greg Bosser 100
Semanas de Kyle 100
 Capítulo 6: Manipulación de datos de bases de datos 155

Ahora, al ejecutar unUNIRdeclaración, puedes dar bonos de $50 al resto de

los empleados:

FUSIONARSE EN BONIFICACIÓN
USANDO EMPLEADO
ON ([Link] = [Link]) CUANDO
NO COINCIDE ENTONCES INSERTAR
([Link] del empleado, [Link])
VALORES ([Link], 50);

Los registros de personas en la tabla EMPLEADO que no coinciden con los registros
de personas que ya están en la tabla BONUS ahora se insertan en la tabla BONUS.
Ahora una consulta de la tabla BONUS da el siguiente resultado:

SELECCIONAR * DE BONIFICACIÓN ;

Nombre de empleado Prima

-------------- -----------
Brynna Jones 100
Chris Bancroft 100
Greg Bosser 100
Semanas de Kyle 100
Neth Doze 50
Matt Bak 50
Sam Saylor 50
Nico Foster 50

Los primeros cuatro registros, que fueron creados con elINSERTARdeclaración, están en
orden alfabético por nombre del empleado. El resto de los registros, añadidos por elUNIR
declaración, aparecen en cualquier orden en que fueron enumerados en la tabla
EMPLEADO.

ElUNIRLa declaración es una adición relativamente nueva a SQL y es posible que aún no sea
compatible con algunos productos DBMS. Aún más nueva es una capacidad adicional de UNIR
agregado en SQL: 2011, lo que paradójicamente le permite eliminar registros con unUNIR
declaración.

Supongamos que después de hacer elINSERTAR,decide que, después de todo, no desea

otorgar bonos a las personas que hayan realizado al menos un pedido, pero sí desea
otorgar un bono de $50 a todos los demás. Puede eliminar los bonos de ventas y
agregar los bonos de no ventas con lo siguienteUNIRdeclaración:

FUSIONARSE EN BONIFICACIÓN
USANDO EMPLEADO
ON ([Link] del empleado = [Link] del empleado)
CUANDO COINCIDA, ELIMINAR CUANDO
NO COINCIDA, LUEGO INSERTAR
([Link] del empleado, [Link])
VALORES ([Link], 50);
156 Parte III: Almacenamiento y recuperación de datos

El resultado es

SELECCIONE * DE BONIFICACIÓN;

Nombre de empleado Prima

-------------- -----------
Neth Doze 50
Matt Bak 50
Sam Saylor 50
Nico Foster 50

Eliminar datos obsoletos

A medida que pasa el tiempo, los datos pueden envejecer y perder su utilidad. Es posible
que desee eliminar estos datos obsoletos de su tabla. Los datos innecesarios en una
tabla ralentizan el rendimiento, consumen memoria y pueden confundir a los usuarios.
Es posible que desee transferir datos más antiguos a una tabla de archivo y luego
desconectar el archivo. De esa manera, en el improbable caso de que necesites volver a
consultar esos datos, podrás recuperarlos. Mientras tanto, no ralentiza tu procesamiento
diario. Ya sea que decida o no que vale la pena archivar los datos obsoletos,
eventualmente llega al punto en el que desea eliminarlos. SQL permite la eliminación de
filas de las tablas de la base de datos mediante el uso deBORRARdeclaración.

Puede eliminar todas las filas de una tabla utilizando un no calificadoBORRARdeclaración, o

puede restringir la eliminación solo a filas seleccionadas agregando una DÓNDEcláusula. La
sintaxis es similar a la sintaxis de unSELECCIONARdeclaración, excepto que no es necesario
especificar columnas. Después de todo, si desea eliminar una fila de la tabla, probablemente
desee eliminar todos los datos de las columnas de esa fila.

Por ejemplo, supongamos que su cliente, David Taylor, se acaba de mudar a

Suiza y ya no va a comprarle nada. Puede eliminarlo de su tabla CLIENTE
utilizando la siguiente declaración:

ELIMINAR DEL CLIENTE

DONDE Nombre = 'David' Y Apellido = 'Taylor';

Suponiendo que solo tiene un cliente llamado David Taylor, esta declaración
constituye la eliminación prevista. Si tienes dos o más clientes que comparten el
nombre David Taylor (que, después de todo, es un nombre bastante común en los
países de habla inglesa), puedes agregar más condiciones alDÓNDE cláusula (como
CALLEoTELÉFONOoIDENTIFICACIÓN DEL CLIENTE)para asegurarse de eliminar solo el
cliente que desea eliminar. Si no agregas unDÓNDE cláusula, todos los clientes
llamados David Taylor serán eliminados.
 Capítulo 7

Manejo de datos temporales

En este capítulo
▶ Definición de tiempos y periodos
▶ Seguimiento de lo que sucedió en momentos específicos
▶ Proporcionar un seguimiento de auditoría de los cambios en los datos.

▶ Manejar tanto lo que sucedió como cuándo se registró el evento.

B Antes de SQL:2011, el estándar ISO/IEC SQL no tenía ningún mecanismo para tratar
datos que fueran válidos en un momento pero no válidos en otro. Cualquier aplicación
que requiera mantener un registro de auditoría necesita esa capacidad. Esto significa que la
carga de realizar un seguimiento de lo que era cierto en un momento determinado recae en el
programador de la aplicación y no en la base de datos. Esto suena como una receta para
aplicaciones complicadas, con un presupuesto excesivo, tardías y plagadas de errores.

Se agregó una nueva sintaxis a SQL:2011 que permite el manejo de datos temporales sin
alterar la forma en que se maneja el código para datos no temporales. Esta es una gran
ventaja para cualquiera que quiera agregar capacidad temporal a una base de datos SQL
existente.

¿Qué quiero decir con el términodatos temporales? El estándar ISO/IEC SQL:2011 no utiliza ese
término en absoluto, pero se utiliza comúnmente en la comunidad de bases de datos. En SQL:2011,
los datos temporales son cualquier dato con uno o más períodos de tiempo asociados durante los
cuales esos datos se consideran efectivos o válidos a lo largo de alguna dimensión de tiempo. En
términos sencillos, eso significa que con la capacidad de datos temporales, puede determinar
cuándo un elemento de datos en particular es verdadero.

En este capítulo introduzco el concepto de período de tiempo, definiéndolo de una

manera muy específica. Se analizan varios tipos de tiempo y el efecto que tienen los
datos temporales en la definición de claves primarias y restricciones de integridad
referencial. Finalmente, analizo la forma en que se pueden almacenar y operar datos
muy complejos en tablas bitemporales.
158 Parte III: Almacenamiento y recuperación de datos

Comprensión de tiempos y
períodos en SQL: 2011
Aunque las versiones del estándar SQL anteriores a SQL:2011 preveíanFECHA, HORA, MARCA
DE TIEMPO,yINTERVALOtipos de datos, no abordaron la idea de unperíodode tiempo con una
hora de inicio definida y una hora de finalización definida. Una forma de abordar esta
necesidad es definir una nuevaPERÍODOtipo de datos. SQL:2011, sin embargo, no hace esto.
Introducir un nuevo tipo de datos en SQL en esta última etapa de su desarrollo causaría
estragos en el ecosistema que se ha creado en torno a SQL. Se requeriría una cirugía mayor en
prácticamente todos los productos de bases de datos existentes para agregar un nuevo tipo de
datos.

En lugar de agregar unPERÍODOtipo de datos, SQL: 2011 resuelve el problema agregando

definiciones de periodocomo metadatos a tablas. Una definición de período es un componente
de tabla con nombre, que identifica un par de columnas que capturan la hora de inicio y
finalización del período. ElCREAR MESAyALTERAR TABLALas declaraciones utilizadas para crear
y modificar tablas se han actualizado con una nueva sintaxis para crear o destruir los períodos
creados por estas nuevas definiciones de período.

APERÍODOestá determinada por dos columnas: una columna inicial y una columna final. Estas
columnas son convencionales, al igual que las columnas de los tipos de datos de fecha existentes,
cada una con su propio nombre exclusivo. Como se mencionó anteriormente, una definición de
período es un componente de tabla con nombre. Ocupa el mismo espacio de nombres que los
nombres de las columnas, por lo que no debe duplicar ningún nombre de columna existente.

SQL sigue un modelo cerrado-abierto para períodos, lo que significa que un período incluye la hora de
inicio pero no la hora de finalización. Para cualquier fila de la tabla, la hora de finalización de un
período debe ser mayor que su hora de inicio. Esta es una restricción impuesta por el DBMS.

Hay dos dimensiones del tiempo que son importantes cuando se trata de datos
temporales:

✓ Tiempo validoEs el periodo de tiempo durante el cual una fila de una tabla refleja correctamente
la realidad.

✓ tiempo de transacciónes el período de tiempo durante el cual una fila se confirma o se

registra en una base de datos.

No es necesario que el tiempo válido y el tiempo de transacción para una fila de una tabla sean
iguales. Por ejemplo, en una base de datos empresarial que registra el período durante el cual un
contrato está en vigor, la información sobre el contrato puede insertarse (y probablemente se
inserta) antes de la hora de inicio del contrato.
 Capítulo 7: Manejo de datos temporales 159
En SQL:2011, se pueden crear y mantener tablas separadas para acomodar los dos tipos
diferentes de tiempo, o una única tabla bitemporal (que se analiza más adelante en este
capítulo) puede servir para este propósito. La información sobre el tiempo de la transacción se
mantiene en tablas versionadas por el sistema, que contienen el período de tiempo del sistema,
indicado por la palabra claveHORA DEL [Link] otra parte, la información de tiempo válida
se mantiene en tablas que contienen un período de tiempo de aplicación. Puede darle al
período de solicitud el nombre que desee, siempre que el nombre no se haya utilizado ya para
otra cosa. Se le permite definir como máximo un período de tiempo del sistema y un período de
tiempo de la aplicación.

Aunque el soporte de datos temporales en SQL se introduce por primera vez en SQL:2011, la
gente ha tenido que lidiar con datos temporales mucho antes de que las construcciones
temporales de SQL:2011 se incluyeran en cualquier producto de base de datos. Por lo general,
esto se hacía definiendo dos columnas de la tabla, una para la fecha y hora de inicio y la otra
para la fecha y hora de finalización. El hecho de que SQL:2011 no defina una nuevaPERÍODO
tipo de datos, sino que utiliza definiciones de períodos como metadatos, significa que las tablas
existentes con dichas columnas de inicio y fin se pueden actualizar fácilmente para incorporar
la nueva capacidad. La lógica para proporcionar información sobre el período se puede eliminar
de los programas de aplicación existentes, simplificándolos, acelerándolos y haciéndolos más
confiables.

Trabajar con tablas de períodos de

tiempo de aplicación
Considere un ejemplo que utiliza tablas de tiempos del período de solicitud. Supongamos que una
empresa quiere realizar un seguimiento de a qué departamento pertenecen sus empleados en
cualquier momento durante su período de empleo. La empresa puede hacer esto creando tablas de
períodos de tiempo de aplicación para empleados y departamentos, como esta:

CREAR TABLA empleado_atpt(

EmpID ENTERO,
Inicio Empezar FECHA,
Empezar FECHA,
VARCHAR(30),
Departamento Emp

PERIODO PARA EmpPeriod (EmpStart, EmpEnd)

);

La fecha y hora de inicio (Inicio Empezaren el ejemplo) se incluye en el período, pero la fecha
y hora de finalización (Empezaren el ejemplo) no lo es. Esto se conoce como semántica
cerrada-abierta.
160 Parte III: Almacenamiento y recuperación de datos

No he especificado una clave principal todavía, porque es un poco más complicado cuando se
trata de datos temporales. Me ocuparé de eso más adelante en este capítulo.

Por ahora, coloque algunos datos en esta tabla y vea cómo se ve:

INSERTAR EN empleado_atpt
VALORES (12345, FECHA '2011-01-01', FECHA '9999-12-31',
'Ventas');

La tabla resultante tiene una fila, como se muestra en la Tabla 7-1.

Tabla 7-1 La tabla de tiempos del período de solicitud contiene una fila

EmpID Inicio Empezar Empezar Departamento Emp

12345 2011-01-01 9999-12-31 Ventas

La fecha de finalización de 9999-12-31 indica que la permanencia de este empleado en la

empresa aún no ha finalizado. Para simplificar, he omitido las horas, minutos, segundos
y fracciones de segundo en este ejemplo y en los siguientes.

Ahora supongamos que el 15 de marzo de 2012, el empleado 12345 es asignado

temporalmente al departamento de Ingeniería hasta el 15 de julio de 2012, regresando
posteriormente al departamento de Ventas. Puedes lograr esto con lo siguiente ACTUALIZAR
declaración:

ACTUALIZAR empleado_atpt
PARA UNA PORCIÓN DEL EmpPeriod
DESDE LA FECHA '2012-03-15'
A LA FECHA '2012-07-15'
SET EmpDept = 'Ingeniería'
DONDE EmpID = 12345;

Después de la actualización, la tabla ahora tiene tres filas, como se muestra en la Tabla 7-2.

Tabla 7-2 Tabla de períodos de tiempo de aplicación después de una actualización

EmpID Inicio Empezar Empezar Departamento Emp

12345 2011-01-01 2012-03-15 Ventas

12345 2012-03-15 2012-07-15 Ingeniería

12345 2012-07-15 9999-12-31 Ventas
 Capítulo 7: Manejo de datos temporales 161
Suponiendo que la empleada 12345 todavía esté empleada en el departamento de Ventas, la tabla
registra con precisión su membresía en el departamento desde el día de Año Nuevo de 2011 hasta el
momento actual.

Si puede insertar datos nuevos en una tabla y actualizar los datos existentes en la tabla, será
mejor que también pueda eliminar datos de la tabla. Sin embargo, eliminar datos de una tabla
de período de tiempo de aplicación puede ser un poco más complicado que simplemente
eliminar filas de una tabla normal y no temporal. Como ejemplo, supongamos que el
empleado 12345, en lugar de ser transferido al departamento de Ingeniería el 15 de marzo de
2012, deja la empresa en esa fecha y es recontratado el 15 de julio del mismo año.
Inicialmente, la tabla del período de tiempo de solicitud tendrá una fila, como se muestra en
la Tabla 7-3.

Tabla 7-3 Tabla de períodos de tiempo de aplicación antes de la actualización o eliminación

EmpID Inicio Empezar Empezar Departamento Emp

12345 2011-01-01 9999-12-31 Ventas

ABORRARLa declaración actualizará la tabla para mostrar el período durante el cual el

empleado 12345 estuvo ausente:

ELIMINAR empleado_atpt
PARA UNA PORCIÓN DEL EmpPeriod
DESDE LA FECHA '2012-03-15'
A LA FECHA '2012-07-15'
DONDE EmpID = 12345;

La tabla resultante será como la Tabla 7-4.

Tabla 7-4 Tabla de períodos de tiempo de aplicación después de la eliminación

EmpID Inicio Empezar Empezar Departamento Emp

12345 2011-01-01 2012-03-15 Ventas

12345 2012-07-15 9999-12-31 Ventas

La tabla ahora refleja los períodos de tiempo durante los cuales la empleada 12345
estuvo empleada por la empresa y muestra el intervalo durante el cual no estuvo
empleada por la empresa.

Es posible que haya notado algo desconcertante en las tablas que se muestran en esta sección. En
una tabla ordinaria y atemporal que enumere a los empleados de una organización, el
162 Parte III: Almacenamiento y recuperación de datos

El número de identificación del empleado es suficiente para servir como clave principal de la tabla porque
identifica de forma única a cada empleado. Sin embargo, una tabla de empleados durante el período de
tiempo de solicitud puede contener varias filas para un solo empleado. El número de identificación del
empleado, por sí solo, ya no se puede utilizar como clave principal de la tabla. Los datos temporales deben
agregarse a la mezcla.

Designación de claves primarias en tablas

de períodos de tiempo de aplicación
En las Tablas 7-2 y 7-4, está claro que el ID del empleado (EmpID)no garantiza la
unicidad. Hay varias filas con el [Link] garantizar que no haya
duplicación de filas, la fecha de inicio (inicio emp)y fecha de finalización (final emp)
debe incluirse en la clave principal. Sin embargo, no basta con incluirlos. Considere
la tabla 7-5, que muestra el caso en el que la empleada 12345 simplemente fue
transferida a Ingeniería durante unos meses y luego regresó a su departamento de
origen.

Tabla 7-5 Una situación que quizás no quieras que ocurra

EmpID Inicio Empezar Empezar Departamento Emp

12345 2011-01-01 9999-12-31 Ventas

12345 2012-03-15 2012-07-15 Ingeniería

Se garantiza que las dos filas de la tabla serán únicas mediante la inclusión de Inicio Empezary
Empezaren la clave principal, pero observe que los dos períodos de tiempo se superponen.
Parece que el empleado 12345 es miembro tanto del departamento de Ventas como del
departamento de Ingeniería desde el 15 de marzo de 2012 hasta el 15 de julio de 2012. En
algunas organizaciones, esto puede ser posible, pero agrega complicaciones y podría
provocar corrupción de datos. Hacer cumplir una restricción que diga que un empleado puede
ser miembro de un solo departamento a la vez es quizás lo que la mayoría de las
organizaciones querrían hacer. Puede agregar dicha restricción a una tabla con unALTERAR
TABLAdeclaración como la siguiente:

ALTER TABLA empleado_atpt

AÑADIR CLAVE PRIMARIA (EmpID, EmpPeriod SIN SUPERPOSICIONES);

Hay una mejor manera de hacer las cosas que crear una tabla primero y agregar su
restricción de clave principal más tarde; en su lugar, puede incluir la restricción de clave
principal en la tabla [Link]ón. Podría parecerse a lo siguiente:
 Capítulo 7: Manejo de datos temporales 163

CREAR TABLA empleado_atpt

EmpID ENTERO NO NULO,
Inicio Empezar FECHA NO NULO,
Empezar FECHA NO NULO,
Departamento Emp VARCHAR(30),
PERIODO PARA EmpPeriod (EmpStart, EmpEnd) CLAVE
PRIMARIA (EmpID, EmpPeriod SIN SUPERPOSICIONES)
);

Ahora está prohibido superponer filas. Mientras estaba en eso, agreguéNO NULO restricciones
a todos los elementos de la clave primaria. Un valor nulo en cualquiera de esos campos sería
una fuente de errores en el futuro. Normalmente, el DBMS se encargará de esto, pero ¿por qué
correr riesgos?

Aplicar restricciones referenciales a tablas

de períodos de tiempo de aplicación
Cualquier base de datos que deba mantener más que una simple lista de elementos
probablemente requerirá varias tablas. Si una base de datos tiene varias tablas, se
deben definir las relaciones entre las tablas y se deben implementar restricciones de
integridad referencial.

En el ejemplo de este capítulo, tiene una tabla de períodos de tiempo de solicitud de empleado
y una tabla de períodos de tiempo de solicitud de departamento. Existe una relación de uno a
muchos entre la tabla de departamentos y la tabla de empleados, porque un departamento
puede tener varios empleados, pero cada empleado pertenece a uno y solo un departamento.
Esto significa que debe colocar una clave externa en la tabla de empleados que haga referencia
a la clave principal de la tabla de departamentos. Con esto en mente, cree nuevamente la tabla
de empleados, esta vez usando una tabla más [Link]ón y cree una tabla de
departamentos de manera similar:

CREAR TABLA empleado_atpt (

EmpID ENTERO NO NULO,
Inicio Empezar FECHA NO NULO,
Empezar FECHA NO NULO,
NombreEmp VARACHAR (30),
VARCHAR (30),
Departamento Emp

PERIODO PARA EmpPeriod (EmpStart, EmpEnd) CLAVE

PRIMARIA (EmpID, EmpPeriod SIN SUPERPOSICIONES) CLAVE
EXTERNA (EmpDept, PERIOD EmpPeriod)
REFERENCIAS dept_atpt (IDDepto, PERIODOPeriodoDepto)
);
164 Parte III: Almacenamiento y recuperación de datos

CREAR TABLA departamento_atpt (

ID de departamento VARCHAR (30) NO NULO,
Gerente VARCHAR (40) NO NULO,
DepartamentoInicio FECHA NO NULO,
Fin del departamento FECHA NO NULO,
PERIODO PARA DeptTime (DeptStart, DeptEnd), CLAVE
PRIMARIA (DeptID, DeptTime SIN SUPERPOSICIONES)
);

Consultar tablas de períodos de tiempo de aplicación

Ahora, se puede recuperar información detallada de la base de datos utilizando
SELECCIONARdeclaraciones que hagan uso de los datos temporales.

Una cosa que quizás desee hacer es enumerar todas las personas que actualmente están
empleadas por la organización. Incluso antes de SQL:2011, podías hacerlo con una
declaración similar a la siguiente:

SELECCIONAR *
DE empleado_atpt
DONDE EmpStart <= CURRENT_DATE()
Y EmpEnd > FECHA ACTUAL();

con el nuevoPERÍODOsintaxis, puedes obtener el mismo resultado un poco más

fácilmente, así:

SELECCIONAR *
DE empleado_atpt
DONDE EmpPeriod CONTIENE CURRENT_DATE();

También puede recuperar empleados que estuvieron empleados durante un período de tiempo
específico, así:

SELECCIONAR *
DE empleado_atpt
DONDE EmpPeriod SE SUPERPONDE
PERIODO (FECHA ('2012-01-01'), FECHA ('2012-09-16'));

Otros predicados ademásCONTIENEySUPERPOSICIONESque puede utilizar en este

contexto incluyenIGUAL, PRECEDE, SUCEDE, INMEDIATAMENTE PRECEDE, yÉXITO
INMEDIATAMENTE.

Estos predicados funcionan de la siguiente manera:

✓ Si un período IGUAL a otro, son exactamente iguales.

✓ Si un período PRECEDE a otro, llega en algún lugar antes que él.
 Capítulo 7: Manejo de datos temporales 165
✓ Si un período SUCEDE a otro, llega en algún momento después.
✓ Si un período PRECEDE INMEDIATAMENTE a otro, viene justo antes y es
contiguo a él.
✓ Si un período sucede INMEDIATAMENTE a otro, viene inmediatamente después y
es contiguo a él.

Trabajar con tablas con versión del sistema

Las tablas con versiones del sistema tienen un propósito diferente que las tablas de períodos de
tiempo de aplicación y, en consecuencia, funcionan de manera diferente. Las tablas de períodos de
tiempo de aplicación le permiten definir períodos de tiempo y operar con los datos que se
encuentran dentro de esos períodos. Por el contrario, las tablas versionadas por el sistema están
diseñadas para crear un registro auditable de exactamente cuándo se agregó, cambió o eliminó un
elemento de datos en una base de datos. Por ejemplo, es importante que un banco sepa
exactamente cuándo se realizó un depósito o un retiro, y esta información debe conservarse durante
un período de tiempo designado por la ley. De manera similar, los corredores de bolsa deben
realizar un seguimiento exacto de cuándo se realizó una transacción de compra. Hay varios casos
similares en los que es importante saber cuándo ocurrió un evento en particular, con una precisión
de fracción de segundo.

Aplicaciones como la aplicación bancaria o la aplicación de corredor de bolsa

tienen requisitos estrictos:

✓ Cualquier operación de actualización o eliminación debe preservar el estado original de la

fila antes de realizar la operación de actualización o eliminación.

✓ El sistema, más que el usuario, mantiene las horas de inicio y finalización de los
períodos de las filas.

Las filas originales que han sido sujetas a una operación de actualización o eliminación
permanecen en la tabla y en adelante se denominaránFilas históricas. Los usuarios no
pueden modificar el contenido de las filas históricas o los períodos asociados con
cualquiera de las filas. Sólo el sistema, no el usuario, puede actualizar los períodos de las
filas en una tabla versionada por el sistema. Esto se hace actualizando las columnas de la
tabla que no son de período o como resultado de la eliminación de filas.

Estas limitaciones garantizan que el historial de cambios de datos sea inmune a la

manipulación, cumpliendo así con los estándares de auditoría y las regulaciones
gubernamentales.
166 Parte III: Almacenamiento y recuperación de datos

Las tablas versionadas por el sistema se distinguen de las tablas de períodos de tiempo
de aplicación por un par de diferencias en elCREARdeclaraciones que los crean:

✓ Mientras que en una tabla de período de tiempo de aplicación el usuario puede darle cualquier
nombre al período, en una tabla versionada por el sistema, el nombre del período debe ser HORA
DEL SISTEMA.

✓ ElCREARLa declaración debe incluir las palabras [Link] VERSIONAMIENTO DEL

[Link] SQL:2011 permite que el tipo de datos para el inicio y el final del
período seanFECHAtipo o uno de los tipos de marca de tiempo, casi siempre querrá
usar uno de los tipos de marca de tiempo, que le brindan un nivel de precisión
mucho mejor que un día. Por supuesto, cualquier tipo que elija para la columna
inicial también debe usarse para la columna final.

Para ilustrar el uso de tablas versionadas por el sistema, sigo usando ejemplos de
empleados y departamentos. Puede crear una tabla versionada por el sistema con el
siguiente código:

CREAR TABLA empleado_sys (

EmpID ENTERO,
Sys_Start TIMESTAMP(12) GENERADO SIEMPRE COMO INICIO DE FILA,
Sys_End TIMESTAMP(12) GENERADO SIEMPRE COMO FINAL DE
FILA, EmpName VARCHAR(30),
PERIODO PARA SYSTEM_TIME (SysStart, SysEnd)
) CON VERSIONAMIENTO DEL SISTEMA;

Una fila en una tabla versionada por el sistema se considera una fila del sistema actual si
la hora actual está contenida en el período de hora del sistema. De lo contrario, se
considera una fila histórica del sistema.

Las tablas con versiones del sistema son similares a las tablas de períodos de tiempo de aplicación en muchos
aspectos, pero también existen diferencias. Aquí hay algunos:

✓ Los usuarios no pueden asignar ni cambiar los valores en las columnas Sys_Start y
Sys_End. Estos valores son asignados y modificados automáticamente por el DBMS. Esta
situación está determinada por las palabras [Link] SIEMPRE.

✓ Cuando utiliza la operación INSERT para agregar algo a una tabla versionada por el
sistema, el valor en la columna Sys_Start se establece automáticamente en la marca
de tiempo de la transacción, que está asociada con cada transacción. El valor
asignado a la columna Sys_End es el valor más alto del tipo de datos de esa
columna.

✓ En las tablas versionadas por el sistema, elACTUALIZARyBORRARlas operaciones operan solo

en las filas actuales del sistema. Los usuarios no pueden actualizar ni eliminar filas históricas
del sistema.
 Capítulo 7: Manejo de datos temporales 167
✓ Los usuarios no pueden modificar la hora de inicio o finalización del período de tiempo del sistema de
las filas actuales o históricas del sistema.

✓ Siempre que utilices elACTUALIZARoBORRARoperación en una fila del sistema

actual, se inserta automáticamente una fila histórica del sistema.

Una declaración de actualización en una tabla versionada por el sistema primero inserta una
copia de la fila anterior, con su hora de finalización del sistema establecida en la marca de
tiempo de la transacción. Esto indica que la fila dejó de estar actual en esa marca de tiempo. A
continuación, el DBMS realiza la actualización y cambia simultáneamente la hora de inicio del
período del sistema a la marca de tiempo de la transacción. Ahora la fila actualizada es la fila
actual del sistema a partir de la marca de tiempo de la transacció[Link] activadores
para las filas en cuestión se activarán, peroINSERTARLos activadores no se activarán aunque se
inserten filas históricas como parte de esta operación. Si se pregunta qué son los
desencadenantes, se tratan ampliamente en el Capítulo 22.

ABORRARLa operación en una tabla versionada por el sistema en realidad no elimina las filas
especificadas. En su lugar, cambia la hora de finalización del período de tiempo del sistema
de esas filas a la marca de tiempo del sistema. Esto indica que esas filas dejaron de estar
vigentes a partir de la marca de tiempo de la transacción. Ahora esas disputas son parte del
sistema histórico y no del sistema actual. Cuando realizas unBORRAR operación, cualquier
BORRARSe activarán los activadores para las filas afectadas.

Designación de claves primarias en

tablas versionadas por el sistema
Designar claves primarias en tablas versionadas por el sistema es mucho más simple que
en tablas de períodos de tiempo de aplicación. Esto se debe a que no tiene que lidiar con
cuestiones de períodos de tiempo. En las tablas versionadas por el sistema, las filas
históricas no se pueden cambiar. Cuando eran filas actuales, se comprobaba su unicidad.
Debido a que ahora no se pueden cambiar, tampoco es necesario verificar su unicidad.

Si agrega una restricción de clave principal a una tabla versionada por el sistema existente
con unaALTERARdeclaración, debido a que se aplica solo a las filas actuales, no es
necesario incluir información del período en la declaración. Por ejemplo:

ALTERAR TABLA empleado_sys

AÑADIR CLAVE PRIMARIA (EmpID);

Eso funciona. Corto y dulce.

168 Parte III: Almacenamiento y recuperación de datos

Aplicar restricciones referenciales a

tablas versionadas por el sistema
Aplicar restricciones referenciales a tablas versionadas por el sistema también es
sencillo por la misma razón. Aquí hay un ejemplo de eso:

ALTERAR TABLA empleado_sys

AÑADIR CLAVE EXTRANJERA (EmpDept)
REFERENCIAS dept_sys (DeptID);

Como solo se ven afectadas las filas actuales, no es necesario incluir las columnas
de inicio y fin del período.

Consultar tablas versionadas por el sistema

La mayoría de las consultas de tablas versionadas por el sistema se refieren a lo que fue cierto
en algún momento del pasado o durante algún período de tiempo en el pasado. Para hacer
frente a estas situaciones, SQL:2011 agrega una sintaxis nueva. Para consultar una tabla para
obtener información sobre lo que era cierto en un momento específico, elSISTEMA_ HORA A
PARTIRSe utiliza la sintaxis. Supongamos que desea saber quién era empleado de la
organización el 15 de julio de 2013. Podría averiguarlo con la siguiente consulta:

SELECCIONE EmpID, EmpName, Sys_Start, Sys_End

DESDE empleado_sys PARA EL SISTEMA_TIME A PARTIR
MARCA DE TIEMPO '2013-07-15 [Link]';

Esta declaración devuelve todas las filas cuya hora de inicio es igual o anterior al valor de la
marca de tiempo y cuya hora de finalización es posterior al valor de la marca de tiempo.

Para encontrar lo que fue cierto durante un período de tiempo, puede utilizar una declaración
similar, con una nueva sintaxis adecuada. He aquí un ejemplo:

SELECCIONE EmpID, EmpName, Sys_Start, Sys_End

DESDE empleado_sys PARA SISTEMA_TIME DESDE
MARCA DE TIEMPO '2013-07-01 [Link]' A
MARCA DE TIEMPO '2013-08-01 [Link]';

Esta recuperación incluirá todas las filas que comienzan en la primera marca de tiempo,
hasta peronoincluida la segunda marca de tiempo. Alternativamente, puedes usar esto:

SELECCIONE EmpID, EmpName, Sys_Start, Sys_End

DESDE empleado_sys PARA EL SISTEMA_TIEMPO ENTRE
MARCA DE TIEMPO '2013-07-01 [Link]' Y
MARCA DE TIEMPO '2013-07-31 [Link]';
 Capítulo 7: Manejo de datos temporales 169
Esta recuperación incluirá todas las filas comenzando en la primera marca de tiempo, hastay
incluida la segunda marca de tiempo.

Si una consulta en una tabla versionada por el sistema no incluye una especificación de
marca de tiempo, el caso predeterminado es devolver solo las filas actuales del sistema. Este
caso se codificaría de forma similar a la siguiente:

SELECCIONE EmpID, EmpName, Sys_Start, Sys_End

DESDE empleado_sys;

Si desea recuperar todas las filas de una tabla versionada por el sistema, tanto históricas
como actuales, puede hacerlo con la siguiente sintaxis:

SELECCIONE EmpID, EmpName, Sys_Start, Sys_End

DESDE empleado_sys PARA SISTEMA_TIME DESDE
MARCA DE TIEMPO '2013-07-01 [Link]' A
MARCA DE TIEMPO '9999-12-31 [Link]';

Seguimiento de aún más datos de

tiempo con tablas bitemporales
A veces desea saber cuándo ocurrió un evento en el mundo real y cuándo se
registró en la base de datos. Para casos como este, puede utilizar una tabla que sea
a la vez una tabla versionada por el sistema y una tabla de períodos de tiempo de la
aplicación. Estas tablas se conocen como tablas bitemporales.

Hay varios casos en los que podría ser necesaria una tabla bitemporal. Supongamos, por
ejemplo, que uno de sus empleados traslada su residencia a través de la frontera estatal de
Oregón a Washington. Debe tener en cuenta el hecho de que su retención del impuesto
estatal sobre la renta debe cambiar a partir de la fecha oficial de la mudanza. Sin embargo, es
poco probable que el cambio en la base de datos se realice exactamente ese mismo día. Es
necesario registrar ambos tiempos, y una tabla bitemporal puede realizar ese registro muy
bien. El período de tiempo versionado por el sistema registra cuándo la base de datos
conoció el cambio y el período de tiempo de la aplicación registra cuándo la medida entró en
vigor legalmente. Aquí hay un código de ejemplo para crear una tabla de este tipo:

CREAR TABLA empleado_bt (

EmpID ENTERO,
Inicio Empezar FECHA,
Empezar FECHA,
Departamento Emp Entero
PERIODO PARA EmpPeriod (EmpStart, EmpEnd),
Sys_Start TIMESTAMP (12) GENERADO SIEMPRE
AL COMIENZO DE LA FILA,
170 Parte III: Almacenamiento y recuperación de datos

Sys_End TIMESTAMP (12) GENERADO SIEMPRE

COMO FINAL DE FILA,
NombreEmp VARCHAR (30),
Calle Emp VARCHAR (40),
EmpCity VARCHAR (30),
EmpStateProv VARCHAR (2),
Código Postal Emp VARCHAR (10),
PERIODO PARA SYSTEM_TIME (Sys_Start, Sys_End), CLAVE
PRIMARIA (EmpID, EPeriod SIN SUPERPOSICIONES), CLAVE
EXTRANJERA (EDept, PERIOD EPeriod)
REFERENCIAS Departamento (DptoID, PERIODO DPerodo)
) CON VERSIONAMIENTO DEL SISTEMA;

Las tablas bitemporales sirven tanto para las tablas con versiones del sistema como para las tablas de
tiempos de aplicación. El usuario proporciona valores para las columnas de inicio y finalización del
período de tiempo de la aplicación. UnINSERTARLa operación en dicha tabla establece
automáticamente el valor del período de tiempo del sistema en la marca de tiempo de la transacción.
El valor de la columna de fin del período de tiempo del sistema se establece automáticamente en el
valor más alto permitido para el tipo de datos de esa columna.

ACTUALIZARyBORRARLas operaciones funcionan como lo hacen para las tablas de períodos de

tiempo de aplicación estándar. Como ocurre con las tablas versionadas por el sistema,ACTUALIZARy
BORRARlas operaciones afectan sólo a las filas actuales y con cada operación de este tipo se inserta
automáticamente una fila histórica.

Una consulta realizada en una tabla bitemporal puede especificar un período de tiempo de
aplicación, un período versionado por el sistema o ambos. Aquí hay un ejemplo del caso
"ambos":

SELECCIONAR ID emp
DESDE empleado_bt PARA EL TIEMPO DEL SISTEMA A PARTIR DE
MARCA DE TIEMPO '2013-07-15 [Link]'
DONDE EmpID = 314159 Y
EmpPeriod CONTIENE FECHA '2013-06-20 [Link]';
 Capítulo 8

Especificación de valores

En este capítulo
▶ Uso de variables para eliminar la codificación redundante
▶ Extraer información frecuentemente requerida de un campo de tabla de base de datos
▶ Combinar valores simples para formar expresiones complejas

t Este libro enfatiza la importancia de la estructura de la base de datos para mantener la

integridad de la base de datos. Aunque a menudo se pasa por alto la importancia de la
estructura de la base de datos, nunca se debe olvidar que lo más importante son los datos en
sí. Después de todo, los valores contenidos en las celdas que forman las intersecciones de las
filas y columnas de la tabla de la base de datos son la materia prima a partir de la cual se
pueden derivar relaciones y tendencias significativas.

Puedes representar valores de varias maneras. Puede representarlos

directamente o derivarlos con funciones o expresiones. Este capítulo describe
los distintos tipos de valores, así como funciones y expresiones.

FuncionesExaminar datos y calcular un valor basado en los [Link] son

combinaciones de elementos de datos que SQL evalúa para producir un valor único.

Valores
SQL reconoce varios tipos de valores:

✓ Valores de fila

✓ Valores literales

✓ variables
✓ variables especiales

✓ Referencias de columna
172 Parte III: Almacenamiento y recuperación de datos

Los átomos tampoco son indivisibles

En el siglo XIX, los científicos creían que un átomo era indivisible. AFECHAEl valor tiene componentes de
la porción de materia más pequeña e irreducible año, mes y día. AMARCA DE TIEMPOEl valor agrega
posible. Por eso le pusieron nombreátomo, que componentes de hora, minuto, segundo, etc. AREALo
proviene de la palabra griegaátomos, lo que significa FLOTAREl valor tiene componentes deexponentey
[Link] los científicos saben que los átomos [Link] valor tiene componentes
no son indivisibles: están formados por protones, a los que puede acceder utilizando SUBSTRACIÓ[Link]
neutrones y electrones. Los protones y neutrones, a lo tanto, llamar a los valores de los campos de la base
su vez, están formados por quarks, gluones y quarks de datosatómicoes fiel a la analogía de los átomos de
virtuales. Incluso estas cosas pueden no ser materia. Ni la aplicación moderna del término
indivisibles. ¿Quién sabe? atómico,sin embargo, es fiel al significado original de
la palabra.
El valor de un campo en una tabla de base de datos
se llamaatómico,aunque muchos campos no lo son

Valores de fila
Los valores más visibles en una base de datos son la [Link] de [Link] son los
valores que contiene cada fila de una tabla de base de datos. Un valor de fila
normalmente se compone de varios componentes porque cada columna de una fila
contiene un valor. Acampoes la intersección de una sola columna con una sola fila. Un
campo contiene unescalar,oatómico,valor. Un valor escalar o atómico tiene un solo
componente.

Valores literales
En SQL, una variable o una constante pueden representar unavalor.Lógicamente, el
valor de unvariablepuede cambiar de vez en cuando, pero el valor de unconstante
nunca cambia. Un tipo importante de constante es lavalor literal. La representación
es en sí misma el valor.

Así como SQL tiene muchos tipos de datos, también tiene muchos tipos de literales. La Tabla 8-1
muestra algunos ejemplos de literales de los distintos tipos de datos.

Observe que las comillas simples encierran los literales de los tipos no numéricos. Estas marcas
ayudan a evitar confusiones; Sin embargo, también pueden causar problemas, como puede ver
en la Tabla 8-1.
 Capítulo 8: Especificación de valores 173

Tabla 8-1 Literales de ejemplo de varios tipos de datos

Tipo de datos Literal de ejemplo

EMPEZANDO 8589934592
ENTERO 186282
PEQUEÑO 186
NUMÉRICO 186282.42
DECIMAL 186282.42
REAL 6.02257E23
PRECISIÓN DOBLE 3.1415926535897E00
FLOTAR 6.02257E23
PERSONAJE(15) 'GRECIA '
Nota:Entre las comillas anteriores hay un total de quince caracteres y espacios.
VARCHAR (CARACTER VARIABLE) 'leptón'
CARÁCTER NACIONAL(15) 'ΕΛΛΑΣ '1
Nota:Entre las comillas anteriores hay un total de quince caracteres y espacios.
CARÁCTER NACIONAL VARIABLE(15) 'λεπτον'2
CARÁCTER OBJETO GRANDE(512) (CLOB(512)) (Una cadena de caracteres muy
larga)

BINARIO(4) '0100110001110000
1111000111001010’
VARBINARIO(4) (VARIACIÓN BINARIA(4)) '0100110001110000'
OBJETO BINARIO GRANDE(512) (BLOB(512)) (Una cadena muy larga
de unos y ceros)

FECHA FECHA '1969-07-20'

TIEMPO(2) TIEMPO
'[Link]'
MARCA DE TIEMPO(0) MARCA DE TIEMPO

'2013-02-25-
13.03.16.000000’
HORA CON ZONA HORARIA(4) HORA '13.41.32.
5000-08.00’
MARCA DE TIEMPO CON ZONA HORARIA (0) MARCA DE TIEMPO '2013-02-
2513.03.16.0000+
02.00’
DÍA DE INTERVALO INTERVALO '7' DÍA
1Este término es la palabra que utilizan los griegos para nombrar a su propio país en su propio idioma. (El equivalente en
inglés es Hellas).

2Este término es la palabra leptón en caracteres nacionales griegos.

174 Parte III: Almacenamiento y recuperación de datos

¿Qué pasa si un literal es una cadena de caracteres que a su vez contiene una frase
entre comillas simples? En ese caso, debe escribir dos comillas simples para mostrar
que una de las comillas que está escribiendo es parte de la cadena de caracteres y
no un indicador del final de la cadena. Escribirías 'Atmósfera terrestre',por ejemplo,
para representar el carácter literal 'Atmósfera terrestre'.

variables
Aunque poder manipular literales y otros tipos de constantes mientras se trabaja
con una base de datos le brinda un gran poder, tener variables también es útil. En
muchos casos, necesitaría trabajar mucho más si no tuviera variables. Avariable,por
cierto, es una cantidad que tiene un valor que puede cambiar. Mire el siguiente
ejemplo para ver por qué las variables son valiosas.

Suponga que es un minorista que tiene varias clases de clientes. Les ofrece a sus
clientes de gran volumen el mejor precio, a sus clientes de volumen medio el
siguiente mejor precio y a sus clientes de bajo volumen el precio más alto. Quiere
indexar todos los precios al costo de sus bienes. Para su producto F-35, decide
cobrar a sus clientes de gran volumen (Clase C) 1,4 veces el costo de los bienes.
Usted cobra a sus clientes de volumen medio (Clase B) 1,5 veces el costo de los
bienes y a sus clientes de volumen bajo (Clase A) 1,6 veces el costo de los bienes.

Almacena el costo de los bienes y los precios que cobras en una tabla llamada
PRECIOS. Para implementar su nueva estructura de precios, emita los siguientes
comandos SQL:

ACTUALIZAR PRECIOS
Precio SET = Costo * 1.4
DONDE Producto = 'F-35'
Y Clase = 'C';
ACTUALIZAR PRECIOS
Precio SET = Costo * 1.5
DONDE Producto = 'F-35'
Y Clase = 'B';
ACTUALIZAR PRECIOS
Precio SET = Costo * 1.6
DONDE Producto = 'F-35'
Y Clase = 'A';

Este código está bien y satisface sus necesidades, por ahora. Pero si una competencia agresiva
comienza a consumir su participación de mercado, es posible que deba reducir sus márgenes
para seguir siendo competitivo. Para cambiar sus márgenes, debe ingresar un código similar a
este:
 Capítulo 8: Especificación de valores 175

ACTUALIZAR PRECIOS
Precio SET = Costo * 1,25
DONDE Producto = 'F-35'
Y Clase = 'C';
ACTUALIZAR PRECIOS
Precio SET = Costo * 1,35
DONDE Producto = 'F-35'
Y Clase = 'B';
ACTUALIZAR PRECIOS
Precio SET = Costo * 1,45
DONDE Producto = 'F-35'
Y Clase = 'A';

Si se encuentra en un mercado volátil, es posible que deba reescribir su código SQL

repetidamente. Esta tarea puede resultar tediosa, especialmente si los precios aparecen en
varios lugares de su código. Puede minimizar su trabajo reemplazando literales (como1.45)
con variables (tales como:multiplicadorA).Luego podrá realizar sus actualizaciones de la
siguiente manera:

ACTUALIZAR PRECIOS
Precio SET = Costo * :multiplicadorC
DONDE Producto = 'F-35'
Y Clase = 'C';
ACTUALIZAR PRECIOS
Precio SET = Costo * :multiplicadorB
DONDE Producto = 'F-35'
Y Clase = 'B';
ACTUALIZAR PRECIOS
Precio SET = Costo * :multiplicadorA
DONDE Producto = 'F-35'
Y Clase = 'A';

Ahora, siempre que las condiciones del mercado te obliguen a cambiar tus precios,
solo necesitarás cambiar los valores de las variables:multiplicadorC, :multiplicadorB,
y :multiplicador [Link] variables son parámetros que pasan al código SQL, que
luego utiliza las variables para calcular nuevos precios.

A veces las variables utilizadas de esta manera se llamanparámetrosovariables del lenguaje

principal. Las variables se llamanparámetrossi aparecen en aplicaciones escritas en lenguaje de
módulo SQL. Ellos se llamanvariables del lenguaje principalcuando se utilizan en SQL incorporado.

SQL incorporadosignifica que las sentencias SQL están integradas en el código de una
aplicación escrita en un lenguaje anfitrión. Alternativamente, puede utilizar el lenguaje del
módulo SQL para crear un módulo completo de código SQL. Luego, la aplicación del idioma
anfitrión llama al módulo. Cualquiera de los métodos puede brindarle las capacidades que
desea. El enfoque que utilice depende de su implementación de SQL.
176 Parte III: Almacenamiento y recuperación de datos

variables especiales
Si un usuario en una máquina cliente se conecta a una base de datos en un servidor, esta
conexión establece unasesió[Link] el usuario se conecta a varias bases de datos, se
considera la sesión asociada a la conexión más [Link]ón actual; sesiones
anterioresson [Link] define variosvariables especialesque son valiosos
en sistemas multiusuario. Estas variables realizan un seguimiento de los diferentes
usuarios. Aquí hay una lista de las variables especiales:

✓ USUARIO_SESIÓN:La variable especialUSUARIO_SESIÓNcontiene un valor

que es igual al identificador de autorización de usuario de la sesión SQL
actual. Si escribe un programa que realiza una función de monitoreo, puede
interrogarUSUARIO_SESIÓNpara saber quién está ejecutando sentencias
SQL.
✓ USUARIO ACTUAL:Un módulo SQL puede tener asociado un identificador de autorización
especificado por el usuario. ElUSUARIO ACTUALLa variable almacena este valor. Si un
módulo no tiene tal identificador,USUARIO ACTUALtiene el mismo valor que
SESIÓN_USUARIO.

✓ USUARIO_SISTEMA:ElUSUARIO_SISTEMALa variable contiene el identificador de usuario

del sistema operativo. Este identificador puede diferir del identificador de ese mismo
usuario en un módulo SQL. Un usuario puede iniciar sesión en el sistema comoLARRY,
por ejemplo, pero identificarse ante un módulo comoPLANTA_MGR.El valor en
USUARIO_SESIÓNesPLANTA_MGR.Si no especifica explícitamente el identificador del
módulo, yUSUARIO ACTUALtambién contienePLANTA_GESTOR, SISTEMA_USUARIO
mantiene el valorLARRY.

ElUSUARIO_SISTEMA, USUARIO_SESIÓN,yUSUARIO ACTUALvariables especiales rastrean

quién está utilizando el sistema. Puede mantener una tabla de registro e insertar
periódicamente en esa tabla los valores queUSUARIO_SISTEMA, USUARIO_SESIÓN,y
USUARIO ACTUALcontener. El siguiente ejemplo muestra cómo:

INSERTAR EN USAGELOG (INSTANTÁNEA)

VALORES ('Usuario' || SISTEMA_USER ||
‘con DNI’ || SESIÓN_USUARIO ||
‘activo en’ || FECHA Y HORA ACTUAL) ;

Esta declaración genera entradas de registro similares al siguiente ejemplo:

Usuario LARRY con ID PLANT_MGR activo el 2013-04-07-23.50.00

Referencias de columna
Cada columna contiene un valor para cada fila de una tabla. Las declaraciones SQL a menudo hacen
referencia a dichos valores. Una referencia de columna totalmente calificada consta de
 Capítulo 8: Especificación de valores 177
nombre de la tabla, un punto y luego el nombre de la columna (por ejemplo,
PRECIOS. Producto).Considere la siguiente afirmación:

SELECCIONAR [Link]
DE PRECIOS
DONDE [Link] = 'F-35';

Aquí[Link] una referencia de columna. Esta referencia contiene el valor '

F-35’. [Link]én es una referencia de columna, pero no se conoce su valor
hasta el punto [Link] ejecuta la declaración.

Debido a que solo tiene sentido hacer referencia a columnas en la tabla actual,
generalmente no es necesario utilizar referencias de columnas completas. La
siguiente afirmación, por ejemplo, es equivalente a la anterior:

SELECCIONAR Costo
DE PRECIOS
DONDE Producto = 'F-35';

A veces es posible que esté tratando con más de una tabla, por ejemplo, cuando dos tablas
de una base de datos contienen una o más columnas con el mismo nombre. En tal caso,
debe calificar completamente las referencias de columna para esas columnas para
garantizar que obtenga la columna que desea.

Por ejemplo, suponga que su empresa mantiene instalaciones tanto en Kingston como en
Jefferson y mantiene registros de empleados separados para cada sitio. Usted nombra la
tabla de empleados de KingstonEMP_KINGSTON,y nombras la tabla de empleados de
JeffersonEMP_JEFFERSON.Quiere una lista de empleados que trabajan en ambos sitios,
por lo que necesita encontrar los empleados cuyos nombres aparecen en ambas tablas.
La siguienteSELECCIONARLa declaración te da lo que quieres:

SELECCIONE EMP_KINGSTON.Nombre, EMP_KINGSTON.Apellido

DE EMP_KINGSTON, EMP_JEFFERSON
DONDE EMP_KINGSTON.EmpID = EMP_JEFFERSON.EmpID;

Debido a que el número de identificación de cada empleado es único y permanece igual

independientemente del lugar de trabajo, puede usar este ID como vínculo entre las dos tablas. Esta
recuperación devuelve sólo los nombres de los empleados que aparecen en ambas tablas.

Expresiones de valor
Una expresión puede ser simple o compleja. La expresión puede contener valores literales,
nombres de columnas, parámetros, variables del lenguaje principal, subconsultas, conectivos
lógicos y operadores aritméticos. Independientemente de su complejidad, una expresión
debe reducirse a un valor único.
178 Parte III: Almacenamiento y recuperación de datos

Por esta razón, las expresiones SQL se conocen comúnmente comoexpresiones de valor.
Es posible combinar varias expresiones de valor en una sola expresión, siempre que las
expresiones de valor del componente se reduzcan a valores que tengan tipos de datos
compatibles.

SQL tiene cinco tipos de expresiones de valor:

✓ Expresiones de valor de cadena

✓ Expresiones de valores numéricos

✓ Expresiones de valor de fecha y hora

✓ Expresiones de valores de intervalo

✓ Expresiones de valor condicional

Expresiones de valor de cadena

Lo más simpleexpresión de valor de cadenaespecifica un único valor de cadena. Otras posibilidades
incluyen una referencia de columna, una función de conjunto, una subconsulta escalar, una CASO
expresión, unELENCOexpresión o una expresión de valor de cadena compleja. (Yo discutoCASOy
ELENCOexpresiones de valor en el Capítulo 9; Entro en las subconsultas en el Capítulo 12.)

Sólo es posible un operador en una expresión de valor de cadena: eloperador de

concatenació[Link] concatenar cualquiera de las expresiones de valor que menciono
en la lista con viñetas de la sección anterior con otra expresión para crear una expresión
de valor de cadena más compleja. Un par de líneas verticales (||) representa el operador
de concatenación. La siguiente tabla muestra algunos ejemplos de expresiones de
valores de cadena.

Expresión produce
'Maní' || 'Jalea' 'quebradiza' || ' ' || 'Cacahuete'
'frijoles' PRIMER_NOMBRE || ' ' || 'Frijolitos confitados'
APELLIDO_NOMBRE B'1100111' || 'Joe Smith'
B'01010011' '110011101010011'
'' || 'Espárragos' 'Espárragos'
‘Espárragos’ || '' 'Espárragos'
'Como' || '' || ‘par’ || '' || 'agus' 'Espárragos'

Como muestra la tabla, si concatena una cadena con una cadena de longitud cero, el
resultado es el mismo que el de la cadena original.
 179
Capítulo 8: Especificación de valores

Expresiones de valores numéricos

Enexpresiones de valores numéricos,puede aplicar los operadores de suma, resta,
multiplicación y división a datos de tipo numérico. La expresión debe reducirse a un valor
numérico. Los componentes de una expresión de valor numérico pueden ser de
diferentes tipos de datos siempre quetodolos tipos de datos son numéricos. El tipo de
datos del resultado depende de los tipos de datos de los componentes de los que deriva
el resultado. Aun así, el estándar SQL no especifica rígidamente el tipo que resulta de
cualquier combinación específica de componentes fuente-expresión. Esto se debe a las
diferencias entre las plataformas de hardware. Consulte la documentación de su
plataforma específica cuando mezcle tipos de datos numéricos.

A continuación se muestran algunos ejemplos de expresiones de valores numéricos:

✓ – 27
✓ 49 + 83
✓ 5 * (12 – 3)
✓ PROTEÍNA + GRASA + CARBOHIDRATO
✓ PIES/5280
✓ COSTO * :multiplicadorA

Expresiones de valor de fecha y hora

Expresiones de valor de fecha y horarealizar operaciones sobre datos que tratan con fechas y
horas. Estas expresiones de valor pueden contener componentes que sean del tipoFECHA,
HORA, MARCA DE TIEMPO,[Link] resultado de una expresión de valor de fecha y
hora es siempre un tipo de fecha y hora (FECHA Y HORA,oMARCA DE TIEMPO).La siguiente
expresión, por ejemplo, da la fecha dentro de una semana:

FECHA_ACTUAL + INTERVALO '7' DÍA

Los horarios se mantienen en hora universal coordinada (UTC), conocida en el Reino Unido como
hora media de Greenwich, pero puede especificar un desplazamiento para que la hora sea correcta
para cualquier zona horaria en particular. Para la zona horaria local de su sistema, puede utilizar la
sintaxis simple que se proporciona en el siguiente ejemplo:

HORA ‘[Link]’ EN LOCAL

180 Parte III: Almacenamiento y recuperación de datos

Alternativamente, puede especificar este valor a lo largo:

HORA '[Link]' EN LA ZONA HORARIA INTERVALO '-08.00' HORA A

MINUTO

Esta expresión define la hora local como la zona horaria de Portland, Oregón, que
es ocho horas más temprana que la de Greenwich, Inglaterra.

Expresiones de valores de intervalo

Si restas una fecha y hora de otra, obtienes [Link] una fecha y
hora a otra no tiene sentido, por lo que SQL no le permite hacerlo. Si suma dos
intervalos o resta un intervalo de otro intervalo, el resultado es un intervalo.
También puedes multiplicar o dividir un intervalo por una constante numérica.

SQL tiene dos tipos de intervalos:año mesytiempo de dí[Link] evitar

ambigüedades, debe especificar cuál usar en una expresión de intervalo. La
siguiente expresión, por ejemplo, da el intervalo en años y meses hasta llegar a la
edad de jubilación:

(CUMPLEAÑOS_65 - FECHA_ACTUAL) AÑO A MES

El siguiente ejemplo da un intervalo de 40 días:

INTERVALO '17' DÍA + INTERVALO '23' DÍA

El ejemplo que sigue se aproxima al número total de meses que una madre de cinco
hijos ha estado embarazada (¡suponiendo que actualmente no esté esperando el
número seis!):

INTERVALO '9' MES * 5

Los intervalos pueden ser tanto negativos como positivos y pueden consistir en cualquier expresión
de valor o combinación de expresiones de valor que se evalúen como un intervalo.

Expresiones de valor condicional

El valor de unexpresión de valor condicionaldepende de una condición. Las expresiones
de valor [Link], NULLIF,yJUNTARSEson significativamente más complejos que
los otros tipos de expresiones de valor. De hecho, estas tres expresiones de valores
condicionales son tan complejas que no tengo suficiente espacio para hablar de ellas
aquí. (En el Capítulo 9 doy una amplia cobertura sobre las expresiones de valores
condicionales.)
 Capítulo 8: Especificación de valores 181

Funciones
Afunciónes una operación simple (bueno, no más que moderadamente compleja) que
los comandos SQL habituales no realizan pero que aparece con frecuencia en la práctica.
SQL proporciona funciones que realizan tareas que el código de la aplicación en el
lenguaje anfitrión (en el que incrusta sus declaraciones SQL) necesitaría realizar de otro
modo. SQL tiene dos categorías principales de funciones:colocar(o agregar)funcionesy
funciones de valor.

Resumir mediante el uso de funciones establecidas

Establecer funcionesaplicar paraconjuntosde filas en una tabla en lugar de a una sola fila.
Estas funciones resumen algunas características del conjunto actual de filas. El conjunto
puede incluir todas las filas de la tabla o un subconjunto de filas especificadas por un
DÓNDEcláusula. (Yo discutoDÓNDEcláusulas extensamente en el Capítulo 10.) Los
programadores a veces llaman funciones setFunciones agregadasporque estas funciones
toman información de varias filas, procesan esa información de alguna manera y
entregan una respuesta de una sola fila. Esa respuesta es unaagregaciónde la
información de las filas que componen el conjunto.

Para ilustrar el uso de las funciones establecidas, considere la Tabla 8-2, una lista de información nutricional
para 100 gramos de alimentos seleccionados.

Tabla 8-2 Información nutricional de 100 gramos de alimentos seleccionados

Alimento calorías Proteína Gordo Carbohidrato

(gramos) (gramos) (gramos)

Almendras tostadas 627 18.6 57,7 19.6

Espárragos 20 2.2 0,2 3.6
Plátanos, crudos 85 1.1 0,2 22.2
Carne de res, hamburguesa magra 219 27.4 11.3
Pollo, carne blanca 166 31,6 3.4
Zarigüeya, asada 221 30.2 10.2
Jamón de cerdo 394 21.9 33.3
frijoles, lima 111 7.6 0,5 19.8
Reajuste salarial 39 10.0
pan, blanco 269 8.7 3.2 50,4
Pan integral 243 10.5 3.0 47,7
(continuado)
182 Parte III: Almacenamiento y recuperación de datos

Tabla 8-2(continuado)
Alimento calorías Proteína Gordo Carbohidrato
(gramos) (gramos) (gramos)

Brócoli 26 3.1 0.3 4.5

Manteca 716 0,6 81.0 0,4
Frijolitos confitados 367 0,5 93.1
Cacahuete 421 5.7 10.4 81.0

Una tabla de base de datos llamada FOODS almacena la información de la Tabla 8-2. Los campos
en blanco contienen el [Link] funciones establecidasCUENTA, PROMEDIO, MÁX, MIN,y
SUMAPuede brindarle datos importantes sobre los datos de esta tabla.

CONTAR
ElCONTARLa función le dice cuántas filas hay en la tabla o cuántas filas de la
tabla cumplen ciertas condiciones. El uso más simple de esta función es el
siguiente:

SELECCIONAR CUENTA (*)

DE LOS ALIMENTOS ;

Esta función produce un resultado de 15, porque cuenta todas las filas de la tabla
ALIMENTOS. La siguiente declaración produce el mismo resultado:

SELECCIONAR RECUENTO (Calorías)

DE LOS ALIMENTOS ;

Porque elcaloríasLa columna en cada fila de la tabla tiene una entrada, el recuento es
el mismo. Sin embargo, si una columna contiene valores nulos, la función no cuenta las
filas correspondientes a esos valores nulos.

La siguiente declaración devuelve un valor de 11 porque 4 de las 15 filas de la tabla

contienen valores nulos en elCarbohidratocolumna.

SELECCIONAR RECUENTO (Carbohidratos)

DE LOS ALIMENTOS ;

Un campo en una tabla de base de datos puede contener un valor nulo por diversos
motivos. Una razón común es que se desconoce el valor real (o no se conoce).todavía
conocido). O el valor puede ser conocido pero aún no ingresado. A veces, si se sabe que
un valor es cero, el operador de entrada de datos no se molesta en introducir nada en
un campo, dejando ese campo como nulo. Esta no es una buena práctica porque cero es
un valor definido y puede incluirlo en los cálculos. Nulo esnoun valor definido y SQL no
incluye valores nulos en los cálculos.
 Capítulo 8: Especificación de valores 183
También puedes utilizar elCONTARfunción, en combinación conDISTINTO,para
determinar cuántos valores distintos existen en una columna. Considere la siguiente
afirmación:

SELECCIONAR RECUENTO (Grasa DISTINTA)

DE LOS ALIMENTOS ;

La respuesta que arroja esta afirmación es 12. Puedes ver que una porción de 100 gramos
de espárragos tiene el mismo contenido de grasa que 100 gramos de plátanos (0,2 gramos)
y que una porción de 100 gramos de habas tiene el mismo contenido de grasa que 100
gramos de gominolas (0,5 gramos). Por lo tanto, la tabla tiene un total de sólo 12 valores de
grasa distintos.

AVG
ElAVGLa función calcula y devuelve el promedio de los valores en la columna
especificada. Por supuesto, puedes utilizar elAVGfuncionan solo en columnas que
contienen datos numéricos, como en el siguiente ejemplo:

SELECCIONAR PROMEDIO (Grasa)

DE LOS ALIMENTOS ;

El resultado es 15,37. Este número es tan alto principalmente debido a la presencia de

mantequilla en la base de datos. Quizás se pregunte cuál sería el contenido promedio de grasa
si no incluyera mantequilla. Para averiguarlo, puedes agregar unDÓNDEcláusula de su
declaración, de la siguiente manera:

SELECCIONAR PROMEDIO (Grasa)

DE ALIMENTOS
DÓNDE Comida <> 'Manteca' ;

El valor medio de grasa desciende a 10,32 gramos por 100 gramos de alimento.

MÁXIMO

ElMÁXIMOLa función devuelve el valor máximo encontrado en la columna especificada. La

siguiente declaración devuelve un valor de 81 (el contenido de grasa en 100 gramos de
mantequilla):

SELECCIONAR MAX (Grasa)

DE LOS ALIMENTOS ;

MÍNIMO

ElMÍNIMOLa función devuelve el valor mínimo encontrado en la columna especificada.

La siguiente declaración devuelve un valor de 0,4, porque la función no trata los valores
nulos como ceros:

SELECCIONAR MIN (Carbohidratos)

DE LOS ALIMENTOS ;
184 Parte III: Almacenamiento y recuperación de datos

SUMA
ElSUMALa función devuelve la suma de todos los valores encontrados en la columna
especificada. La siguiente declaración arroja 3924, que es el contenido calórico total de
los 15 alimentos:

SELECCIONAR SUMA (Calorías)

DE LOS ALIMENTOS ;

Funciones de valor
Varias operaciones se aplican en una variedad de contextos. Debido a que necesita utilizar
estas operaciones con tanta frecuencia, tiene sentido incorporarlas a SQL como funciones de
valor. El SQL estándar ISO/IEC ofrece relativamente pocas funciones de valor en comparación
con implementaciones específicas de sistemas de administración de bases de datos como
Access, Oracle o SQL Server, pero las pocas que tiene el SQL estándar son probablemente las
que usará con más frecuencia. SQL utiliza los siguientes cuatro tipos de funciones de valor:

✓ Funciones de valor de cadena

✓ Funciones de valores numéricos

✓ Funciones de valor de fecha y hora

✓ Funciones de valor de intervalo

Funciones de valor de cadena

Funciones de valor de cadenatome una cadena de caracteres como entrada y produzca

otra cadena de caracteres como salida. SQL tiene diez funciones de este tipo:

✓ SUBCADE
✓ SUBCADE SIMILAR
✓ SUBSTRING_REGEX
✓ TRADUCIR_REGEX
✓ CUBRIR
✓ SUPERIOR

✓ MÁS BAJO

✓ RECORTAR

✓ TRADUCIR
✓ CONVERTIR
Traducido del inglés al español - [Link]

Capítulo 8: Especificación de valores 185

SUBCADE
Utilizar elSUBCADEFunción para extraer una subcadena de una cadena fuente. La
subcadena extraída es del mismo tipo que la cadena de origen. Si la cadena fuente es
unaCARÁCTER VARIABLEcadena, por ejemplo, la subcadena también es una CARÁCTER
VARIABLEcadena. A continuación se muestra la sintaxis delSUBCADE función:

SUBSTRING (valor_cadena DESDE el inicio [PARA longitud])

La cláusula entre corchetes ([ ]) es opcional. La subcadena extraída devalor de

cadenacomienza con el personaje quecomenzarrepresenta y continúa por
longitudcaracteres. Si elPARAcláusula está ausente, la subcadena extraída se
extiende desde lacomenzarcarácter hasta el final de la cadena. Considere el
siguiente ejemplo:

SUBSTRING (‘Pan integral’ DE 8 POR 7)

La subcadena extraída es 'todo w’.Esta subcadena comienza con el octavo carácter

de la cadena de origen y tiene una longitud de siete caracteres. En la superficie,
SUBCADEno parece una función muy valiosa; si tienes un literal como 'Pan
integral”,no necesitas una función para descubrir los caracteres del 8 al 14.
SUBCADESin embargo, realmente es una función valiosa porque el valor de la
cadena no necesita ser literal. El valor puede ser cualquier expresión que se evalúe
como una cadena de caracteres. Por lo tanto, podría tener una variable llamada
alimentoque adquiere diferentes valores en diferentes momentos. La siguiente
expresión extraería la subcadena deseada independientemente de qué cadena de
caracteresalimentoLa variable representa actualmente:

SUBCADE (:fooditem DE 8 POR 7)

Todas las funciones de valor son similares en el sentido de que estas funciones
pueden operar en expresiones que evalúan valores así como en los propios valores
literales.

Debes tener cuidado con un par de cosas si usas elSUBCADEfunción. Asegúrese de que
la subcadena que especifique realmente se encuentre dentro de la cadena de origen. Si
solicita una subcadena que comience en (digamos) el carácter ocho pero la cadena de
origen tiene solo cuatro caracteres, obtendrá un resultado nulo. Por lo tanto, debe tener
alguna idea de la forma de sus datos antes de especificar una función de subcadena.
Tampoco desea especificar una longitud de subcadena negativa, porque el final de una
cadena no puede preceder al principio.

Si una columna es delVARCHARescriba, es posible que no sepa hasta dónde se extiende

el campo para una fila en particular. Esta falta de conocimiento no presenta un
problema para elSUBCADEfunción. Si la longitud que especifica va más allá del borde
derecho del campo,SUBCADEdevuelve todo lo que encuentra. No devuelve un error.
186 Parte III: Almacenamiento y recuperación de datos

Digamos que tiene la siguiente declaración:

SELECCIONAR * DE ALIMENTOS
DONDE SUBSTRING (Comida DE 8 PARA 7) = 'blanco';

Esta declaración devuelve la fila del pan blanco de la tabla ALIMENTOS,

aunque el valor en elAlimentocolumna ('Pan blanco»)tiene menos de 14
caracteres.

Si algunaoperando(valor del cual un operador deriva otro valor) en la función de

subcadena tiene un valor nulo,SUBCADEdevuelve un resultado nulo.

SUBCADE SIMILAR
La función de subcadena de expresión regular es una función triádica (lo que significa que
opera con tres parámetros). Los tres parámetros son una cadena de caracteres de origen, una
cadena de patrón y un carácter de escape. Luego utiliza la coincidencia de patrones (basada en
expresiones regulares basadas en POSIX) para extraer y devolver una cadena de resultado de la
cadena de caracteres de origen.

Se utilizan dos instancias del carácter de escape, cada una seguida del carácter de
comillas dobles, para dividir la cadena del patrón en tres partes. He aquí un
ejemplo:

Supongamos que la cadena de caracteres de origenSes 'Hace cuarenta y siete

años, nuestros padres trajeron a este continente una nueva nación”.
Supongamos además que la cadena del patrónRes 'y ‘/”’siete’/”’ años’,donde la
barra diagonal es el carácter de escape.

Entonces

SUBCADE S SIMILAR A R ;

devuelve un resultado que es la pieza intermedia de la cadena del patrón, 'Siete'en este
caso.

SUBSTRING_REGEX
SUBSTRING_REGEXbusca en una cadena un patrón de expresión regular
XQuery y devuelve una aparición de la subcadena coincidente.

Según el estándar internacional ISO/IEC JTC 1/SC 32, la sintaxis de una expresión
regular de subcadena es la siguiente:

SUBSTRING_REGEX <par izquierdo>

<Patrón XQuery> [ FLAG <Indicador de opción XQuery> ] IN <cadena de
asunto de expresiones regulares>
[ DESDE <posición inicial> ] [ USANDO <unidades de
longitud de caracteres> ] [ OCURRENCIA <ocurrencia
de expresiones regulares> ]
{ GRUPO <grupo de captura de expresiones regulares> ] <padre derecho>
 187
Capítulo 8: Especificación de valores

<Patrón XQuery>es una expresión de cadena de caracteres cuyo valor es una

expresión regular de XQuery.

<Marca de opción XQuery>es una cadena de caracteres opcional, correspondiente

a $banderasargumento del [XQuery F&O]funciónfn: coincidencia.

<cadena de asunto de expresiones regulares>es la cadena de caracteres en la que se

buscarán coincidencias con <Patrón XQuery>.

<posición inicial>es un valor numérico exacto opcional con escala 0, que indica la
posición del carácter en la que iniciar la búsqueda. (El valor predeterminado es 1.)

<unidades de longitud de caracteres>esCARACTERESoOCTETOS,indicando la unidad en la

que <posición inicial>es medido. (El valor predeterminado esCARACTERES.)

<ocurrencia de expresiones regulares>es un valor numérico exacto opcional con escala 0, que indica
qué ocurrencia de coincidencia se desea. (El valor predeterminado es 1.)

<grupo de captura de expresiones regulares>es un valor numérico exacto opcional con escala 0 que
indica qué grupo de captura de una coincidencia se desea. (El valor predeterminado es 0, lo que
indica toda la ocurrencia).

A continuación se muestran algunos ejemplos del uso deSUBSTRING_REGEX:

SUBSTRING_REGEX ('\p{L}*' IN 'Simplemente hazlo.')='Solo'

SUBSTRING_REGEX ('\p{L}*' IN 'Simplemente hazlo.' FROM 2)= 'ust'
SUBSTRING_REGEX ('\p{L}*' IN 'Simplemente hazlo.' OCURRENCIA 2) = 'hacer'
SUBSTRING_REGEX ( '(hacer) (\p{L}*' IN 'Simplemente hazlo'. GRUPO 2) = 'eso'

TRADUCIR_REGEX
TRADUCIR_REGEXbusca en una cadena un patrón de expresión regular de XQuery y
devuelve la cadena con una o todas las apariciones de la expresión regular de
XQuery reemplazada por una cadena de reemplazo de XQuery.

Según el estándar internacional ISO/IEC JTC 1/SC 32, la sintaxis de una transliteración de
expresiones regulares es la siguiente:

TRANSLATE_REGEX <par izquierdo>

<Patrón XQuery> [ FLAG <Indicador de opción XQuery> ] IN <cadena de
asunto de expresiones regulares>
[ CON <cadena de reemplazo de expresiones regulares> ]

[ DESDE <posición inicial> ] [ USANDO

<unidades de longitud de caracteres> ]
[ OCURRENCIA <ocurrencia de transliteración de expresiones regulares> ] <padre derecho>
<ocurrencia de transliteración de expresiones regulares> ::=
<ocurrencia de expresiones regulares>

| TODO
188 Parte III: Almacenamiento y recuperación de datos

dónde:

✓ <cadena de reemplazo de expresiones regulares>es una cadena de caracteres cuyo valor es

adecuado para su uso como $reemplazoargumento del [XQuery F&O] funciónfn: reemplazar.
El valor predeterminado es la cadena de longitud cero.

✓ <ocurrencia de transliteración de expresiones regulares>es la palabra claveTODO, o un

valor numérico exacto con escala 0, que indica qué ocurrencia de coincidencia se desea
(el valor predeterminado esTODO).

A continuación se muestran algunos ejemplos sin cadena de reemplazo:

TRANSLATE_REGEX ('i' IN 'Bill se sentó.') = 'Bll dd st.'

TRANSLATE_REGEX ('i' IN 'Bill se sentó'. OCCURRENCE ALL) = 'Bll dd st.'
TRANSLATE_REGEX ('i' IN 'Bill se sentó' FROM 5) = 'Bill dd st.' TRANSLATE_REGEX ('i'
IN 'Bill se sentó'. Ocurrencia 2) = 'Bill dd se sentó'.

A continuación se muestran algunos ejemplos con cadenas de reemplazo:

TRANSLATE_REGEX ('i' IN 'Bill se sentó.' CON 'a') = 'Ball dad se sentó. ' TRANSLATE_REGEX ('i'
IN 'Bill se sentó'. CON 'a' OCURRENCIA TODAS) = 'Papá se sentó'.
TRANSLATE_REGEX ('i' IN 'Bill se sentó' CON 'a' OCCURRENCE 2) = 'Bill papá se sentó'
TRANSLATE_REGEX ('i' IN 'Bill se sentó' CON 'a' DE 5) = 'Bill papá se sentó' .'

CUBRIR
CUBRIRreemplaza una subcadena determinada de una cadena (especificada por una posición
inicial numérica determinada y una longitud determinada) con una cadena de reemplazo.
Cuando la longitud especificada para la subcadena es cero, no se elimina nada de la cadena
original, pero la cadena de reemplazo se inserta en la cadena original, comenzando en la
posición inicial especificada.

SUPERIOR

ElSUPERIORLa función value convierte una cadena de caracteres en caracteres completamente en

mayúsculas, como en los ejemplos que se muestran en la siguiente tabla.

Esta declaración Devoluciones

SUPERIOR ('e. e. cummings') SUPERIOR 'MI. E. CUMMINGS

('Isaac Newton, Ph.D.') ‘ISAAC NEWTON, PH.D.’

ElSUPERIORLa función no afecta una cadena que ya está escrita exclusivamente en

mayúsculas.
 Capítulo 8: Especificación de valores 189

MÁS BAJO

ElMÁS BAJOLa función value convierte una cadena de caracteres en caracteres completamente en
minúsculas, como en los ejemplos de la siguiente tabla.

Esta declaración Devoluciones

MÁS BAJAS ('IMPUESTOS') 'impuestos'

INFERIOR ('E. E. Cummings') 'mi. mi. cummings

ElMÁS BAJOLa función no afecta una cadena que ya está escrita exclusivamente en
minúsculas.

RECORTAR

Utilizar elRECORTARfunción para recortar los espacios en blanco iniciales o finales (u otros caracteres)
de una cadena de caracteres. Los siguientes ejemplos muestran cómo utilizarRECORTAR.

Esta declaración Devoluciones

RECORTAR (PRENDIENTE ' ' DE ' tratar ') 'tratar '

RECORTAR ( AMBOS ' ' de ' tratar ') RECORTAR ' tratar'
(AMBOS ' ' DE ' tratar ') RECORTAR (AMBOS 't' 'tratar'
de ' tratar ') 'rea'

El carácter de recorte predeterminado es el espacio en blanco, por lo que la siguiente sintaxis también es legal:

RECORTAR (AMBOS DE 'tratar')

Esta sintaxis le brinda el mismo resultado que el tercer ejemplo de la tabla:

'tratar'.

TRADUCIR y CONVERTIR
ElTRADUCIRyCONVERTIRLas funciones toman una cadena fuente en un juego de caracteres y
transforman la cadena original en una cadena en otro juego de caracteres. Algunos ejemplos
pueden ser del inglés al kanji o del hebreo al francés. Las funciones de conversión que
especifican estas transformaciones son específicas de la implementación. Consulte la
documentación de su implementación para obtener más detalles.

Si traducir de un idioma a otro fuera tan fácil como invocar un SQL TRADUCIR
función, eso sería genial. Desafortunadamente, no es tan fácil. TodoTRADUCIRLo
que hace es traducir un carácter del primer conjunto de caracteres al carácter
correspondiente del segundo conjunto de caracteres. La función puede, por
ejemplo, traducir 'Ελλασ' a '[Link] no puede traducir 'Ελλασ' a 'Grecia'.
190 Parte III: Almacenamiento y recuperación de datos

Funciones de valores numéricos

Las funciones de valores numéricos pueden tomar una variedad de tipos de datos como entrada, pero la
salida es siempre un valor numérico. SQL tiene 15 tipos de funciones de valores numéricos:

✓ Expresión de posición (POSICIÓN)

✓ Función de ocurrencias de expresiones regulares (OCURRENCIAS_REGEX)

✓ Expresión de posición de expresiones regulares (POSICIÓN_REGEX)

✓ Extraer expresión (EXTRACTO)

✓ Expresión de longitud (CHAR_LENGTH, CHARACTER_LENGTH, OCTET_LENGTH)
✓ Expresión de cardinalidad (CARDINALIDAD)
✓ Expresión de valor absoluto (ABDOMINALES)

✓ Expresión del módulo (MODIFICACIÓN)

✓ Logaritmo natural (LN)

✓ Funcion exponencial (EXP)
✓ Función de potencia (FUERZA)

✓ Raíz cuadrada (CUADRADO)

✓ Función de suelo (PISO)

✓ Función de techo (TECHO, TECHO)
✓ Función de cubo de ancho (WIDTH_BUCKET)

POSICIÓN
POSICIÓNbusca una cadena de destino especificada dentro de una cadena de origen
especificada y devuelve la posición del carácter donde comienza la cadena de destino. Para una
cadena de caracteres, la sintaxis tiene este aspecto:

POSICIÓN (objetivo EN la fuente [USANDO unidades de longitud de caracteres])

Opcionalmente, puede especificar una unidad de longitud de caracteres distinta de

PERSONAJE, pero esto es raro. Si se utilizan caracteres Unicode, según el tipo, un carácter
podría tener 8, 16 o 32 bits de longitud. En los casos en que un carácter tiene 16 o 32 bits de
longitud, puede especificar explícitamente 8 bits conUSANDO OCTETOS.

Para una cadena binaria, la sintaxis tiene este aspecto:

POSICIÓN (objetivo EN fuente)

 Capítulo 8: Especificación de valores 191
Si el valor del destino es igual a una subcadena de longitud idéntica de octetos
contiguos en la cadena de origen, entonces el resultado es uno mayor que el
número de octetos que preceden al inicio de la primera subcadena.

La siguiente tabla muestra algunos ejemplos.

Esta declaración Devoluciones

POSITION ('B' EN 'Pan integral') POSITION ('Bre' EN 1

'Pan integral') POSITION ('wh' EN 'Pan integral') 1
POSITION ('whi' EN 'Pan integral' ') POSITION ('' IN 8
'Pan integral') 0
1
POSICIÓN ('01001001' EN '001100010100100100100110' 2

Tanto para cadenas de caracteres como para cadenas binarias, si la función no encuentra la
cadena de destino, elPOSICIÓNLa función devuelve un valor cero. Además, para ambos tipos de
cadena, si la cadena de destino tiene una longitud cero (como en el último ejemplo de
caracteres), laPOSICIÓNLa función siempre devuelve un valor de uno. Si algún operando de la
función tiene un valor nulo, el resultado es un valor nulo.

OCURRENCIAS_REGEX
OCURRENCIAS_REGEXes una función numérica que devuelve el número de
coincidencias de una expresión regular en una cadena. La sintaxis es la siguiente:

OCCURRENCES_REGEX <pariente izquierdo>

<Patrón XQuery> [ FLAG <Indicador de opción XQuery> ]
IN <cadena de asunto de expresiones
regulares> [ DESDE <posición inicial> ]
[ USANDO <unidades de longitud de caracteres> ] <padre derecho>

Aquí hay unos ejemplos:

OCCURRENCES_REGEX ('i' IN 'Bill se sentó') = 3

OCCURRENCES_REGEX ('i' IN 'Bill se sentó'. DE 5) = 2
OCCURRENCES_REGEX ('Yo' IN 'Bill se sentó') = 0

POSICIÓN_REGEX
POSICIÓN_REGEXes una función numérica que devuelve la posición del inicio de una
coincidencia, o uno más el final de una coincidencia, para una expresión regular en una
cadena. Aquí está la sintaxis:

POSITION_REGEX <par izquierdo> [ <posición de expresiones regulares inicio o después> ]

<Patrón XQuery> [ FLAG <Indicador de opción XQuery> ]
IN <cadena de asunto de expresiones regulares>
192 Parte III: Almacenamiento y recuperación de datos

[ DESDE <posición inicial> ] [ USANDO

<unidades de longitud de caracteres> ]
[ OCURRENCIA <ocurrencia de expresiones regulares> ]
[ GRUPO <grupo de captura de expresiones regulares> ] <padre derecho>

<posición de expresiones regulares inicio o después> ::= INICIO | DESPUÉS

Quizás algunos ejemplos aclararían esto:

POSITION_REGEX ('i' IN 'Bill se sentó') = 2 POSITION_REGEX (START 'i'

IN 'Bill se sentó') = 2
POSITION_REGEX (DESPUÉS de 'i' EN 'Bill se sentó') = 3 POSITION_REGEX ('i' EN
'Bill se sentó'. DE 5) = 7 POSITION_REGEX ('i' IN 'Bill se sentó' OCURRENCIA 2) =
7
POSITION_REGEX ('Yo' IN 'Bill se sentó') = 0

EXTRACTO

ElEXTRACTOLa función extrae un solo campo de una fecha y hora o un intervalo.

La siguiente declaración, por ejemplo, devuelve 08:

EXTRACTO (MES DESDE LA FECHA '2013-08-20')

CHARACTER_LENGTH
ElCHARACTER_LENGTHLa función devuelve el número de caracteres en una cadena
de caracteres. La siguiente declaración, por ejemplo, devuelve 16:

CHARACTER_LENGTH ('Zarigüeya, asada')

Como observo con respecto a laSUBCADEfunción (en la sección "SUBSTRING",

anteriormente en este capítulo), esta función no es particularmente útil si su argumento
es un literal como 'Zarigüeya asada”.Puedo escribir con la misma facilidaddieciséiscomo
puedo CHARACTER_LENGTH ('Zarigüeya, asada').De hecho, escribirdieciséises mas facil.
Esta función es más útil si su argumento es una expresión en lugar de un valor literal.

OCTET_LENGTH
En música, un conjunto vocal formado por ocho cantantes se llamaocteto. Normalmente, las
partes que representa el conjunto son primera y segunda soprano, primera y segunda
contralto, primer y segundo tenor y primer y segundo bajo. En terminología informática, un
conjunto de ocho bits de datos se denomina [Link] palabrabytees inteligente porque el
término se relaciona claramente conpocopero implica algo más grande que un bit. Un bonito
juego de palabras, pero (desafortunadamente) nada en la palabrabyteTransmite el concepto
de "octava". Tomando prestado el término musical, se hace posible una descripción más
adecuada de una colección de ocho bits.
 Capítulo 8: Especificación de valores 193
Prácticamente todas las computadoras modernas utilizan ocho bits para representar un
único carácter alfanumérico. Los conjuntos de caracteres más complejos (como el chino)
requieren 16 bits para representar un solo carácter. ElOCTET_LENGTHLa función cuenta y
devuelve el número de octetos (bytes) en una cadena. Si la cadena es una cadena de bits,
OCTET_LENGTHdevuelve el número de octetos necesarios para contener ese número de
bits. Si la cadena es una cadena de caracteres en inglés (con un octeto por carácter), la
función devuelve el número de caracteres de la cadena. Si la cadena es una cadena de
caracteres chinos, la función devuelve un número que es el doble de caracteres chinos. La
siguiente cadena es un ejemplo:

OCTET_LENGTH ('Frijoles, lima')

Esta función devuelve 11 porque cada carácter ocupa un octeto.

Algunos juegos de caracteres utilizan un número variable de octetos para diferentes

caracteres. En particular, algunos conjuntos de caracteres que admiten mezclas de
caracteres kanji y latinos utilizanescaparcaracteres para cambiar entre los dos conjuntos
de caracteres. Una cadena que contiene latín y kanji (por ejemplo) puede tener 30
caracteres y requerir 30 octetos si todos los caracteres son latinos; 62 caracteres si
todos los caracteres son Kanji (60 caracteres más un carácter mayúsculo inicial y final); y
150 caracteres si los caracteres alternan entre latín y kanji (porque cada carácter kanji
necesita dos octetos para el carácter y un octeto para cada uno de los caracteres de
cambio inicial y final). ElOCTET_LENGTH La función devuelve el número de octetos que
necesita para el valor actual de la cadena.

CARDINALIDAD
CardinalidadSe ocupa de colecciones de elementos como matrices o conjuntos
múltiples, donde cada elemento es un valor de algún tipo de datos. La cardinalidad
de una colección es el número de elementos que contiene. Un uso del
CARDINALIDADLa función podría ser esta:

CARDINALIDAD (TeamRoster)

Esta función devolvería 12, por ejemplo, si hubiera 12 miembros del equipo en la [Link] del
equipo,una columna en la tabla TEAMS puede ser una matriz o un conjunto múltiple. Un
formaciónes una colección ordenada de elementos, y unconjunto múltiplees una colección
desordenada de elementos. Para una plantilla de equipo, que cambia con frecuencia, el
multiset tiene más sentido.

ARRAY_MAX_CARDINALIDAD
ElCARDINALIDADLa función devuelve el número de elementos de la matriz o
conjunto múltiple que especifique. Lo que no te dice es la cardinalidad máxima
que se asignó a esa matriz. Hay ocasiones en las que quizás quieras saber eso.
194 Parte III: Almacenamiento y recuperación de datos

Como resultado, SQL:2011 ha agregado una nueva funciónARRAY_MAX_CARDINALITY.

Como puedes adivinar, devuelve la cardinalidad máxima de la matriz que especificas. No
existe una cardinalidad máxima declarada para un conjunto múltiple.

TRIM_ARRAY
Mientras que elRECORTARLa función recorta el primer o último carácter de una cadena, el
TRIM_ARRAYLa función recorta los últimos elementos de una matriz.

Para recortar los últimos tres elementos de laLista del equipomatriz, utilice la siguiente
sintaxis:

TRIM_ARRAY (Lista de equipos, 3)

abdominales

ElabdominalesLa función devuelve el valor absoluto de una expresión de valor numérico.

ABS (-273)

En este caso, la función devuelve 273.

MODIFICACIÓN

ElMODIFICACIÓNla función devuelve elmódulode dos expresiones de valor numérico.

MODO (3,2)

En este caso, la función devuelve 1, el módulo de tres dividido por dos.

LN
ElLNLa función devuelve el logaritmo natural de una expresión de valor numérico.

LN (9)

Aquí esta función devuelve algo así como 2.197224577. El número de dígitos más
allá del punto decimal depende de la implementación de SQL.

Exp
ElExpfunción eleva la base de los logaritmos naturalesmia la potencia
especificada por una expresión de valor numérico.

EXP (2)

Aquí la función devuelve algo así como 7,389056. El número de dígitos más
allá del punto decimal depende de la implementación de SQL.
 195
Capítulo 8: Especificación de valores

FUERZA
ElFUERZALa función eleva el valor de la primera expresión de valor numérico a la
potencia de la segunda expresión de valor numérico.

PODER (2,8)

Aquí esta función devuelve 256, que es 2 elevado a la octava potencia.

CUADRADO

ElCUADRADOLa función devuelve la raíz cuadrada del valor de la expresión de valor

numérico.

CUADRADO (4)

En este caso, la función devuelve 2, la raíz cuadrada de 4.

PISO
ElPISOLa función trunca la expresión del valor numérico al número entero más
grande que no sea mayor que la expresión.

PISO (3.141592)

Esta función devuelve 3.

TECHO o TECHO
ElFORTIFICAR TECHOoTECHOLa función aumenta la expresión del valor numérico al
número entero más pequeño no menor que la expresión.

CEIL (3.141592)

Esta función devuelve 4.

WIDTH_BUCKET
ElWIDTH_BUCKETfunción, utilizada enprocesamiento de solicitudes en línea(OLAP),
es una función de cuatro argumentos, que devuelve un número entero entre 0
(cero) y el valor del cuarto argumento más 1 (uno). Asigna el primer argumento a un
partición de ancho equivalentedel rango de números entre el segundo y tercer
argumento. Los valores fuera de este rango se asignan a 0 (cero) o al valor del
cuarto argumento más 1 (uno).

Por ejemplo:

WIDTH_BUCKET (PI, 0, 10, 5)

196 Parte III: Almacenamiento y recuperación de datos

SuponerPies una expresión de valor numérico con un valor de 3,141592. El

ejemplo divide el intervalo de cero a 9,999999. . . en cinco igualescubos, cada
uno con un ancho de dos. La función devuelve un valor de 2, porque 3,141592
cae en el segundo grupo, que cubre el rango de 2 a 3,999999.

Funciones de valor de fecha y hora

SQL incluye tres funciones que devuelven información sobre la fecha actual, la hora
actual o [Link] ACTUALdevuelve la fecha actual;TIEMPO ACTUALdevuelve la
hora actual; yFECHA Y HORA ACTUALdevuelve (¡sorpresa!) tanto la fecha actual
como la hora [Link] ACTUALno requiere argumentos, peroTIEMPO ACTUALy
FECHA Y HORA ACTUALambos toman un solo argumento. El argumento especifica
la precisión de la parte de "segundos" del valor de tiempo que devuelve la función.
(Los tipos de datos de fecha y hora y el concepto de precisión se describen en el
Capítulo 2).

La siguiente tabla ofrece algunos ejemplos de estas funciones de valor de fecha y hora.

Esta declaración Devoluciones

FECHA ACTUAL 2012-12-31

HORA_ACTUAL (1) [Link].3
CURRENT_TIMESTAMP (2) 2012-12-31 [Link].38

la fecha queFECHA ACTUALdevoluciones esFECHAescriba datos. el tiempo que TIEMPO

ACTUAL (pag)devoluciones esTIEMPOtipo de datos y la marca de tiempo que FECHA Y HORA
ACTUAL(pag)devoluciones esMARCA DE TIEMPOescriba datos. Debido a que SQL recupera
información de fecha y hora del reloj del sistema de su computadora, la información es
correcta para la zona horaria en la que reside la computadora.

En algunas aplicaciones, es posible que desee aprovechar funciones que operan con
datos de tipo carácter; para hacerlo, convierta fechas, horas o marcas de tiempo en
cadenas de caracteres. Puede realizar dicha conversión de tipo utilizando el ELENCO
expresión, que describo en el Capítulo 9.

Funciones de valor de intervalo

En SQL:1999 se introdujo una función de valor de intervalo denominada ABS. Es similar a
la función de valor numérico ABS, pero opera con datos de tipo intervalo en lugar de
datos de tipo numérico. ABS toma un único operando y devuelve un intervalo de idéntica
precisión que se garantiza que no tendrá un valor negativo. He aquí un ejemplo:

ABS (HORA '[Link]' – HORA '[Link]')

El resultado es

INTERVALO +’[Link]’ HORA A SEGUNDO

 Capítulo 9

Usando SQL avanzado

Expresiones de valor

En este capítulo
▶ Usando las expresiones condicionales CASE
▶ Convertir un elemento de datos de un tipo de datos a otro
▶ Ahorrar tiempo de entrada de datos mediante el uso de expresiones de valor de fila

S QL se describe en el Capítulo 2 como unsublenguaje de [Link] hecho, la única función

de SQL es operar con datos en una base de datos. SQL carece de muchas de las
características de un lenguaje procedimental convencional. Como resultado, los
desarrolladores que usan SQL deben alternar entre SQL y su lenguaje host para controlar el
flujo de ejecución. Este cambio repetido complica las cosas en el momento del desarrollo y
afecta negativamente el rendimiento en el tiempo de ejecución.

La penalización en el rendimiento impuesta por las limitaciones de SQL provoca la adición

de nuevas características a SQL cada vez que se publica una nueva versión de la
especificación internacional. Una de esas características adicionales, laCASOexpresión,
proporciona una estructura condicional largamente buscada. Una segunda característica,
laELENCO expresión, facilita la conversión de datos en una tabla de un tipo de datos a
otro. Una tercera característica, la expresión de valor de fila, le permite operar con una
lista de valores donde antes solo podía operar con un único valor. Por ejemplo, si su lista
de valores es una lista de columnas en una tabla, ahora puede realizar una operación en
todas esas columnas usando una sintaxis muy simple.

Expresiones condicionales CASO

Todo lenguaje informático completo tiene algún tipo de declaración o comando condicional.
De hecho, la mayoría tiene varios tipos. Probablemente el enunciado o comando condicional
más común es elSI... ENTONCES... DE LO CONTRARIO... ENDIFestructura.
198 Parte III: Almacenamiento y recuperación de datos

Si la condición que sigue a laSILa palabra clave se evalúa como Verdadero, el bloque de
comandos que sigue alENTONCESse ejecuta la palabra clave. Si la condición no se evalúa como
Verdadera, el bloque de comandos después delDEMÁSse ejecuta la palabra clave. El
TERMINARA SILa palabra clave señala el final de la estructura. Esta estructura es excelente para
cualquier decisión que vaya de dos maneras. La estructura no funciona tan bien para
decisiones que pueden tener más de dos resultados posibles.

Los lenguajes más completos tienen unaCASODeclaración que maneja situaciones en las
que es posible que desee realizar más de dos tareas basadas en más de dos valores
posibles de una condición.

SQL tiene unCASOdeclaración y unCASOexpresió[Link] expresión es sólo una parte de

una declaración, no una declaración en sí misma. En SQL, puedes colocar unCASOexpresión
en casi cualquier lugar donde un valor sea legal. En tiempo de ejecución, unCASO La
expresión se evalúa como un valor. SQLCASOla declaración no se evalúa como un valor; más
bien, ejecuta un bloque de declaraciones.

ElCASOLa expresión busca en una tabla, una fila a la vez, tomando el valor de un resultado
específico siempre que una de una lista de condiciones sea Verdadera. Si la primera condición
no se cumple para una fila, se prueba la segunda condición y, si es Verdadera, el resultado
especificado se proporciona a la expresión, y así sucesivamente hasta que se procesen todas
las condiciones. Si no se encuentra ninguna coincidencia, la expresión toma un valor NULL. El
procesamiento luego pasa a la siguiente fila.

Puedes usar elCASOexpresión de las dos formas siguientes:

✓ Utilice la expresión con condiciones de bú[Link] filas en una tabla donde las
condiciones especificadas son verdaderas. SiCASOencuentra que una condición de búsqueda
es Verdadera para una fila de la tabla, la declaración que contiene elCASO La expresión realiza
un cambio específico en esa fila.

✓ Utilice la expresión para comparar un campo de tabla con un valor especificado.

El resultado de la declaración que contiene laCASOLa expresión depende de cuál de
varios valores especificados en el campo de la tabla es igual a cada fila de la tabla.

Las siguientes dos secciones, “UsoCASOcon condiciones de búsqueda” y “UsandoCASO

con valores”, ayudan a aclarar estos conceptos. En la primera sección, dos ejemplos
utilizanCASOcon condiciones de búsqueda. Un ejemplo busca una tabla y realiza cambios
en los valores de la tabla, según una condición. La segunda sección explora dos ejemplos
de la forma de valor deCASO.

Usando CASE con condiciones de búsqueda

Una forma poderosa de utilizar elCASOLa expresión es buscar en una tabla filas en las que
una condición de búsqueda especificada sea Verdadera. Si utilizaCASODe esta forma, la
expresión utiliza la siguiente sintaxis:
 Capítulo 9: Uso de expresiones de valores SQL avanzadas 199

CASO
CUANDO condición1 ENTONCES resultado1
CUANDO condición2 ENTONCES resultado2
...
CUANDO condiciónnorteENTONCES resultadonorte
OTRO resultadoX
FIN

CASOexamina el primerofila de clasificación(la primera fila que cumpla con las

condiciones del cerramientoDÓNDEcláusula, si la hubiera) para ver sicondición1es
verdad. Si es así, elCASOexpresión recibe un valor [Link]ón1no es
verdad,CASOevalúa la fila paracondició[Link]ón2 es cierto, elCASOexpresión
recibe el valor deresultado2,etcétera. Si ninguna de las condiciones establecidas es
verdadera, elCASOexpresión recibe el valor deresultadoX. ElDEMÁSLa cláusula es
opcional. Si la expresión no tieneDEMÁS cláusula y ninguna de las condiciones
especificadas es Verdadera, la expresión recibe un valor nulo. Después de la
declaración SQL que contiene elCASOLa expresión se aplica a la primera fila
calificada de una tabla y realiza la acción adecuada; procesa la siguiente fila. Esta
secuencia continúa hasta que la instrucción SQL termina de procesar toda la tabla.

Actualizar valores basados en una condición

Porque puedes incrustar unCASOexpresión dentro de una declaración SQL en casi cualquier
lugar donde sea posible un valor, esta expresión le brinda una enorme flexibilidad. Puedes
usarCASOdentro de unACTUALIZARdeclaración, por ejemplo, para realizar cambios en los
valores de la tabla, en función de determinadas condiciones. Considere el siguiente ejemplo:

ACTUALIZAR ALIMENTOS
ESTABLECER CLASIFICACIÓN = CASO
CUANDO LA GRASA < 1
ENTONCES “muy bajo en grasa”
CUANDO GRASA < 5
ENTONCES “bajo en grasas”
CUANDO LA GRASA < 20
ENTONCES 'grasa moderada'
CUANDO LA GRASA < 50
ENTONCES “alto en grasas”
ELSE 'ciudad de infarto'
FIN ;

Esta afirmación evalúa laCUANDOcondiciones en orden hasta que se devuelva el primer

valor Verdadero, después de lo cual la declaración ignora el resto de las condiciones.

La tabla 8-2 del Capítulo 8 muestra el contenido de grasa de 100 gramos de ciertos alimentos. Una tabla
de base de datos que contenga esta información puede contener unCLASIFICACIÓNcolumna que ofrece
una evaluación rápida del significado del contenido de grasa. Si ejecutas el
200 Parte III: Almacenamiento y recuperación de datos

anteriorACTUALIZAREn la tabla ALIMENTOS del Capítulo 8, la declaración asigna a los

espárragos un valor demuy bajo en grasas,le da al pollo un valor debajo en grasa,y
pone almendras tostadas en elciudad de ataque al corazóncategoría.

Evitar condiciones que causen errores.

Otro uso valioso deCASOesevitación de excepciones—buscando condiciones
que causen errores.

Considere un caso que determina la compensación de los vendedores. Las empresas que
compensan a sus vendedores mediante comisiones directas a menudo pagan a sus nuevos
empleados dándoles unadibujarcontra las comisiones futuras que se espera que ganen. En el
siguiente ejemplo, los nuevos vendedores reciben un sorteo contra comisión; el sorteo se
elimina gradualmente a medida que aumentan sus comisiones:

ACTUALIZAR VENTAS_COMP
SET COMP = COMISIÓN + CASO
CUANDO LA COMISIÓN> DIBUJAR
ENTONCES 0
CUANDO LA COMISIÓN < DIBUJAR
ENTONCES DIBUJA
FIN ;

Si la comisión del vendedor es cero, la estructura de este ejemplo evita una

operación de división por cero, lo que provocaría un error si se permitiera que
ocurriera. Si el vendedor tiene una comisión distinta de cero, la compensación total
es la comisión más un retiro que se reduce en proporción al tamaño de la comisión.

Toda laENTONCESexpresiones en unCASOLa expresión debe ser del mismo tipo: toda
numérica, toda de caracteres o toda de fecha. El resultado de laCASOLa expresión también es
del mismo tipo.

Usando CASE con valores

Puede utilizar una forma más compacta delCASOexpresión si está comparando la
igualdad de un valor de prueba con una serie de otros valores. Este formulario es útil
dentro de unSELECCIONARoACTUALIZARdeclaración si una tabla contiene un número
limitado de valores en una columna y desea asociar un valor de resultado
correspondiente a cada uno de esos valores de columna. Si utilizaCASOde esta forma, la
expresión tiene la siguiente sintaxis:

CASOvalor_prueba
CUANDO valor1 ENTONCES resultado1
CUANDO valor2 ENTONCES
resultado2. . .
 Capítulo 9: Uso de expresiones de valores SQL avanzadas 201

CUANDO valornorteENTONCES resultadonorte

OTRO resultadoX
FIN

Si el valor de la prueba (valor_prueba)es igual avalor1,entonces la expresión toma el

valorresultado1.Sivalor_pruebasno es igual avalor1pero es igual avalor2,entonces la
expresión toma el [Link] expresión intenta cada valor de comparación por
turno, hasta llegar avalornorte, hasta lograr una coincidencia. Si ninguno de los valores
de comparación es igual al valor de prueba, entonces la expresión toma el valorresultado
X. Nuevamente, si el opcionalDEMÁS La cláusula no está presente y ninguno de los
valores de comparación coincide con el valor de prueba, la expresión recibe un valor
nulo.

Para comprender cómo funciona la forma de valor, considere un caso en el que tenga
una tabla que contenga los nombres y rangos de varios oficiales militares. Desea
enumerar los nombres precedidos por la abreviatura correcta para cada rango. La
siguiente declaración hace el trabajo:

SELECCIONAR RANGO DE CASO

CUANDO 'general' ENTONCES 'Gen.'
CUANDO 'coronel' ENTONCES 'Coronel'
CUANDO 'teniente coronel' ENTONCES 'Teniente. Col.’
CUANDO ‘mayor’ ENTONCES 'Mayor'.
CUANDO 'capitán' ENTONCES 'Capitán'
CUANDO 'primer teniente' ENTONCES '1º. Teniente.'
CUANDO 'segundo teniente' ENTONCES '2do. Teniente.'
ELSE NULL
FIN,
APELLIDO
DE OFICIALES;

El resultado es una lista similar al siguiente ejemplo:

Capitán medianoche
Columna. Lijadoras
Gen. Washington
comandante Desastre
Nimitz

Chester Nimitz fue almirante de la Armada de los Estados Unidos durante la Segunda Guerra
Mundial. Debido a que su rango no figura en elCASOexpresión, laDEMÁSLa cláusula no le da
un título.

Para poner otro ejemplo, supongamos que el Capitán Midnight obtiene un ascenso
a mayor y desea actualizar la base de datos de OFICIALES en consecuencia.
Supongamos que la variableoficial_apellidocontiene el valor 'Medianoche'y que la
variablenuevo_rankcontiene un número entero (4)que corresponde al nuevo rango
de Midnight, según la siguiente tabla.
202 Parte III: Almacenamiento y recuperación de datos

nuevo_rank Rango

1 general
2 coronel
3 teniente coronel
4 importante

5 capitán
6 Primer teniente
7 alférez
8 NULO

Puede registrar la promoción utilizando el siguiente código SQL:

ACTUALIZACIÓN OFICIALES
ESTABLECER RANGO = CASO: nuevo_rank
CUANDO 1 ENTONCES 'general'
CUANDO 2 ENTONCES 'coronel'
CUANDO 3 ENTONCES 'teniente coronel'
CUANDO 4 ENTONCES 'mayor' CUANDO 5
ENTONCES 'capitán' CUANDO 6 ENTONCES
'primer teniente' CUANDO 7 ENTONCES 'segundo
teniente' CUANDO 8 ENTONCES NULO

FIN
DONDE APELLIDO_NOMBRE =: oficial_apellido;

Una sintaxis alternativa para elCASOLa expresión con valores es:

CASO
CUANDOvalor_prueba=valor1 ENTONCES resultado1
CUANDOvalor_prueba=valor2 ENTONCES resultado2
...
CUANDOvalor_prueba=valornorteENTONCES resultadonorte
OTRO resultadoX
FIN

Un CASO especial - NULLIF

De lo único que puedes estar seguro en este mundo es del cambio. A veces las cosas cambian
de un estado conocido a otro. Otras veces, crees que sabes algo, pero luego descubres que,
después de todo, no lo sabías. Tanto la termodinámica clásica como la teoría moderna del
caos nos dicen que los sistemas migran naturalmente de un estado ordenado y bien conocido
a un estado desordenado que nadie puede comprender.
 Capítulo 9: Uso de expresiones de valores SQL avanzadas 203
puede predecir. Cualquiera que haya supervisado alguna vez el estado de la habitación de un
adolescente durante un período de una semana después de limpiarla puede dar fe de la exactitud de
estas teorías.

Las tablas de la base de datos tienen valores definidos en campos que contienen
contenidos conocidos. Normalmente, si se desconoce el valor de un campo, el campo
contiene el valor nulo. En SQL, puedes usar unCASOexpresión para cambiar el
contenido de un campo de tabla de un valor definido a un valor nulo. El valor nulo indica
que ya no conoce el valor del campo. Considere el siguiente ejemplo.

Imagine que es propietario de una pequeña aerolínea que ofrece vuelos entre el sur de
California y el estado de Washington. Hasta hace poco, algunos de sus vuelos hacían escala en
el Aeropuerto Internacional de San José para repostar antes de continuar.
Desafortunadamente, acaba de perder su derecho a volar a San José. A partir de ahora,
deberás realizar tu parada para repostar en el Aeropuerto Internacional de San Francisco o en
el Aeropuerto Internacional de Oakland. En este punto, no sabe qué vuelos hacen escala en
qué aeropuerto, pero sí sabe que ninguno de los vuelos hace escala en San José. Tiene una
base de datos de VUELOS que contiene información importante sobre sus rutas y ahora desea
actualizar la base de datos para eliminar todas las referencias a San José. El siguiente ejemplo
muestra una forma de hacer esto:

ACTUALIZAR VUELO
SET RefuelStop = CASO
CUANDO RefuelStop = 'San José'
ENTONCES NULO
ELSE RepostarParada
FIN ;

Debido a que surgen con frecuencia ocasiones como esta, en las que desea
reemplazar un valor conocido con un valor nulo, SQL ofrece una notación
abreviada para realizar esta tarea. El ejemplo anterior, expresado de esta forma
abreviada, se ve así:

ACTUALIZAR VUELO
SET RefuelStop = NULLIF(RefuelStop, 'San José');

Puede traducir esta expresión al inglés como "Actualice la tabla FLIGHT configurando el
RepostarParadacolumna a nula si el valor existente deRepostarParada es 'San Jose'.De lo
contrario, no hagas ningún cambio”.

NULLIFEs aún más útil si está convirtiendo datos que acumuló originalmente para
usarlos con un programa escrito en un lenguaje de programación estándar como C++ o
Java. Los lenguajes de programación estándar no tienen valores nulos, por lo que una
práctica común es utilizar valores especiales para representar el concepto de "no
conocido" o "no aplicable". Un numérico -1puede representar un valor desconocido para
SALARIO,por ejemplo, y una cadena de caracteres “***” puede representar un valor
desconocido o no aplicable paraCÓDIGO DE [Link] quieres representar estos
204 Parte III: Almacenamiento y recuperación de datos

estados no conocidos y no aplicables en una base de datos compatible con SQL mediante el uso de
valores nulos, debe convertir los valores especiales a valores nulos. El siguiente ejemplo realiza esta
conversión para una tabla de empleados, en la que se desconocen algunos valores salariales:

ACTUALIZAR EMP
SET Salario = CASO Salario
CUANDO -1 ENTONCES
NULL MÁS Salario
FIN ;

Puede realizar esta conversión de manera más conveniente usandoNULLIF,

como sigue:

ACTUALIZAR EMP
SET Salario = NULLIF(Salario, -1);

Otro CASO especial: COALESCER

JUNTARSE,comoNULLIF,es una forma abreviada de un particularCASOexpresión.
JUNTARSEtrata con una lista de valores que pueden o no ser nulos. Así es como
funciona:

✓ Si uno de los valores de la lista no es nulo:ElJUNTARSEla expresión

adquiere ese valor.
✓ Si más de un valor en la lista no es nulo:La expresión toma el valor del
primer elemento no nulo de la lista.
✓ Si todos los valores de la lista son nulos:La expresión toma el valor
nulo.

ACASOLa expresión con esta función tiene la siguiente forma:

CASO
CUANDO el valor1 NO ES NULO
ENTONCES valor1
CUANDO el valor2 NO ES NULO
ENTONCES valor2
...
CUANDO valornorteNO ES NULO
ENTONCES valornorte
DEMÁS NULO
FIN

El correspondienteJUNTARSEla taquigrafía se ve así:

FUSIONAR(valor1, valor2, ..., valornorte)

 Capítulo 9: Uso de expresiones de valores SQL avanzadas 205
Es posible que desee utilizar unJUNTARSEexpresión después de realizar unaUNIÓN EXTERNA
operación (discutido en el Capítulo 11). En esos casos,JUNTARSEpuede ahorrarle mucho tiempo
escribiendo.

Conversiones de tipos de datos CAST

El Capítulo 2 cubre los tipos de datos que SQL reconoce y admite. Idealmente, cada columna de
una tabla de base de datos tiene una elección perfecta de tipo de datos. Sin embargo, en este
mundo no ideal, no siempre está claro cuál puede ser exactamente la elección perfecta. Al
definir una tabla de base de datos, supongamos que asigna un tipo de datos a una columna
que funciona perfectamente para su aplicación actual. Supongamos que más adelante desea
ampliar el alcance de su aplicación o escribir una aplicación completamente nueva que utilice
los datos de manera diferente. Este nuevo uso podría requerir un tipo de datos diferente al que
eligió originalmente.

Es posible que desee comparar una columna de un tipo en una tabla con una columna de
un tipo diferente en una tabla diferente. Por ejemplo, podría almacenar fechas como
datos de caracteres en una tabla y como datos de fechas en otra tabla. Incluso si ambas
columnas contienen el mismo tipo de información (fechas, por ejemplo), el hecho de que
los tipos sean diferentes puede impedirle realizar la comparación.
En los primeros estándares SQL, SQL-86 y SQL-89, la incompatibilidad de tipos planteaba un
gran problema. SQL-92, sin embargo, introdujo una solución fácil de usar en el ELENCO
expresión.

ElELENCOLa expresión convierte datos de tabla o variables del lenguaje principal de un

tipo a otro tipo. Después de realizar la conversión, puede continuar con la operación o
análisis que imaginó originalmente.

Naturalmente, enfrenta algunas restricciones al usar elELENCOexpresión. No se pueden

convertir indiscriminadamente datos de cualquier tipo en cualquier otro tipo. Los datos
que está convirtiendo deben ser compatibles con el nuevo tipo de datos. Puedes, por
ejemplo, utilizarELENCOpara convertir elCARACTERÍSTICA(10)cadena de caracteres '
2007-04-26’haciaFECHAtipo. Pero no puedes usarELENCOpara convertir el
CARACTERÍSTICA(10) cadena de caracteres 'rinoceronte'haciaFECHAtipo. No puedes
convertir un ENTEROhaciaPEQUEÑOtipo si el primero excede el tamaño máximo de un
PEQUEÑO.

Puede convertir un elemento de cualquier tipo de carácter a cualquier otro tipo (como
numérico o de fecha) siempre que el valor del elemento tenga la forma de un literal del nuevo
tipo. Por el contrario, puede convertir un elemento de cualquier tipo a cualquiera de los tipos
de caracteres, siempre que el valor del elemento tenga la forma de un literal del tipo original.
206 Parte III: Almacenamiento y recuperación de datos

La siguiente lista describe algunas conversiones adicionales que puede realizar:

✓ Cualquier tipo numérico a cualquier otro tipo numérico. Si se convierte a un tipo con
menor precisión fraccionaria, el sistema redondea o trunca el resultado.

✓ Cualquier tipo numérico exacto a un intervalo de un solo componente, como

DÍA DE INTERVALOoINTERVALO SEGUNDO.

✓ CualquierFECHAa unMARCA DE [Link] parte del tiempo delMARCA DE TIEMPOcompleta con

ceros.

✓ CualquierTIEMPOa unTIEMPOcon una precisión diferente de fracciones de segundo o una

MARCA DE [Link] fecha parte delMARCA DE TIEMPOse completa con la fecha actual.

✓ CualquierMARCA DE TIEMPOa unFECHA,aTIEMPO,o unMARCA DE TIEMPOcon una precisión

diferente de fracciones de segundo.

✓ Cualquier año-mesINTERVALOa un tipo numérico exacto u otro añomes

INTERVALOcon diferente precisión de campo principal.
✓ cualquier diaINTERVALOa un tipo numérico exacto u otro horario diurno
INTERVALOcon diferente precisión de campo principal.

Usando CAST dentro de SQL

Suponga que trabaja para una empresa que realiza un seguimiento de los empleados
potenciales y de los empleados que realmente ha contratado. Enumera los posibles
empleados en una tabla denominadaPROSPECTO,y los distingues por sus números de
Seguro Social, que guardas como unCARACTERÍSTICA(9)tipo. Usted enumera los
empleados en una tabla llamadaEMPLEADO,y los distingues por sus números de Seguro
Social, que son de laENTEROtipo. Ahora desea generar una lista de todas las personas
que aparecen en ambas tablas. Puedes usarELENCO para realizar la tarea:

SELECCIONAR * DEL EMPLEADO

DONDE [Link] =
CAST([Link] COMO INTEGER);

Usando CAST entre SQL y

el lenguaje anfitrión
El uso clave deELENCOes tratar con tipos de datos que están disponibles en SQL pero no
en el lenguaje principal que utiliza. La siguiente lista ofrece algunos ejemplos de estos
tipos de datos:
 Capítulo 9: Uso de expresiones de valores SQL avanzadas 207
✓ SQL tieneDECIMALyNUMÉRICO,pero FORTRAN y Pascal no.
✓ SQL tieneFLOTARyREAL,pero el COBOL estándar no.
✓ SQL tieneFECHA Y HORA,que ningún otro idioma tiene.

Suponga que desea utilizar FORTRAN o Pascal para acceder a tablas con DECIMALES(5,3)
columnas, y no desea que se produzcan imprecisiones al convertir esos valores alREALtipo de
datos utilizado por FORTRAN y Pascal. Puede realizar esta tarea utilizandoELENCOpara mover
los datos hacia y desde variables del lenguaje principal de cadena de caracteres. Recupera un
salario numérico de 198,37 como CARACTERÍSTICA(10)valor de '0000198.37’.Luego, si deseas
actualizar ese salario a 203,74, puedes colocar ese valor en unCARACTERÍSTICA(10)como '
0000203.74’.Primero usasELENCOpara cambiar el SQLDECIMALES(5,3)tipo de datos al
CARACTERÍSTICA(10) escriba para el empleado cuyo número de identificación está
almacenando en la variable del lenguaje principal :emp_id_var,como sigue:

SELECCIONE CAST(Salario COMO CHAR(10)) EN:salary_var

DESDE EMP
DONDE EmpID = :emp_id_var ;

La aplicación FORTRAN o Pascal examina el valor de la cadena de caracteres resultante

en:var_salario,posiblemente establece la cadena en un nuevo valor de '000203.74',y
luego actualiza la base de datos llamando al siguiente código SQL:

ACTUALIZAR EMP
SET Salario = CAST(:salary_var AS DECIMAL(5,3))
DONDE EmpID = :emp_id_var ;

Tratar con valores de cadenas de caracteres como '000198.37’Es incómodo en FORTRAN o

Pascal, pero puedes escribir un conjunto de subrutinas para realizar las manipulaciones
necesarias. Luego puede recuperar y actualizar cualquier dato SQL desde cualquier idioma
host y obtener (y establecer) valores exactos.

La idea general es queELENCOes más valioso para convertir entre tipos de host y
la base de datos en lugar de convertir dentro de la base de datos.

Expresiones de valor de fila

En los estándares SQL originales, SQL-86 y SQL-89, la mayoría de las operaciones trataban
con un solo valor o una sola columna en una fila de la tabla. Para operar con múltiples
valores, había que construir expresiones complejas usando ló[Link] (que analizo
en el Capítulo 10).
208 Parte III: Almacenamiento y recuperación de datos

SQL-92 introducidoexpresiones de valor de fila,que operan en una lista de valores o

columnas en lugar de en un solo valor o columna. Una expresión de valor de fila es una
lista de expresiones de valor que se encierran entre paréntesis y se separan con comas.
Puede codificar estas expresiones para operar en una fila completa a la vez o en un
subconjunto seleccionado de la fila.

El capítulo 6 cubre cómo utilizar elINSERTARdeclaración para agregar una nueva fila a una
tabla existente. Para hacerlo, la declaración utiliza una expresión de valor de fila. Considere el
siguiente ejemplo:

INSERTAR EN LOS ALIMENTOS

(NOMBRE DEL ALIMENTO, CALORÍAS, PROTEÍNAS, GRASAS, CARBOHIDRATOS)
VALORES
(“Queso, cheddar”, 398, 25, 32.2, 2.1);

En este ejemplo, ('Queso, cheddar’, 398, 25, 32.2, 2.1)es una expresión de valor de fila. Si
utiliza una expresión de valor de fila en unINSERTARdeclaración de esta manera, puede
contener valores nulos y predeterminados. (Avalor por defectoes el valor que asume
una columna de la tabla si no especifica ningún otro valor). La siguiente línea, por
ejemplo, es una expresión de valor de fila legal:

('Queso, cheddar', 398, NULL, 32.2, DEFAULT)

Puede agregar varias filas a una tabla colocando varias expresiones de valor de fila en el
VALOREScláusula, de la siguiente manera:

INSERTAR EN LOS ALIMENTOS

(NOMBRE DEL ALIMENTO, CALORÍAS, PROTEÍNAS, GRASAS, CARBOHIDRATOS)
VALORES
(‘Lechuga’, 14, 1,2, 0,2, 2,5), (‘Mantequilla’,
720, 0,6, 81,0, 0,4), (‘Mostaza’, 75, 4,7, 4,4,
6,4),
("Espaguetis", 148, 5.0, 0.5, 30.1);

Puede utilizar expresiones de valor de fila para evitar tener que ingresar
comparaciones manualmente. Supongamos que tienes dos tablas de valores
nutricionales, una compilada en inglés y otra en español. Desea encontrar aquellas
filas en la tabla en idioma inglés que corresponden exactamente a las filas en la
tabla en idioma español. Sin una expresión de valor de fila, es posible que necesite
formular algo como el siguiente ejemplo:

SELECCIONAR * DE ALIMENTOS
DONDE [Link] = [Link]
Y [Link] = [Link] Y
[Link] = [Link]
Y [Link] = [Link] ;
 Capítulo 9: Uso de expresiones de valores SQL avanzadas 209
Las expresiones de valor de fila le permiten codificar la misma lógica, de la siguiente manera:

SELECCIONAR * DE ALIMENTOS
DONDE ([Link]ÍAS, [Link]ÍNA, [Link],
[Link])
=
([Link], [Link], [Link],
[Link]) ;

En este ejemplo, no ahorra mucho tipeo. Se beneficiaría un poco más si

comparara más columnas. En casos de beneficio marginal como este ejemplo,
puede que sea mejor seguir con la sintaxis anterior porque su significado es
más claro.

Obtiene un beneficio al utilizar una expresión de valor de fila en lugar de su equivalente

codificado: la expresión de valor de fila es mucho más rápida. En principio, una
implementación inteligente puede analizar la versión codificada e implementarla como la
versión de valor de fila. En la práctica, esta operación es una optimización difícil que ningún
DBMS que yo conozca puede realizar.
210 Parte III: Almacenamiento y recuperación de datos
 Capítulo 10

Centrándose en los datos que desea

En este capítulo
▶ Especificación de las tablas con las que desea trabajar
▶ Separar filas de interés del resto
▶ Edificio efectivoDÓNDEclausulas
▶ Manejo de valores nulos
▶ Construyendo expresiones compuestas con conectivos lógicos.
▶ Agrupación de resultados de consultas por columna

▶ Poner en orden la salida de la consulta

▶ Operando en filas relacionadas

A El sistema de gestión de bases de datos tiene dos funciones principales: almacenar

datos y proporcionar un fácil acceso a esos datos. El almacenamiento de datos no es
nada especial; un archivador puede realizar esa tarea. La parte difícil de la gestión de datos es
proporcionar un acceso fácil. Para que los datos sean útiles, debe poder separar la
(normalmente) pequeña cantidad que desea de la enorme cantidad que no desea.

SQL le permite utilizar algunas características de los datos para determinar si una fila de
la tabla en particular es de su interés. ElSELECCIONAR, BORRAR, yACTUALIZAR
declaraciones transmiten a la base de datosmotor(la parte del DBMS que interactúa
directamente con los datos), qué filas seleccionar, eliminar o actualizar. Agrega cláusulas
modificatorias alSELECCIONAR, BORRAR,yACTUALIZARdeclaraciones para refinar la
búsqueda según sus especificaciones.

Cláusulas modificatorias
Las cláusulas modificadoras disponibles en SQL sonDE, DONDE, TENER, AGRUPAR POR, y
ORDENAR [Link] cláusula le dice al motor de base de datos en qué tabla o tablas
operar. ElDÓNDEyTENIENDOLas cláusulas especifican una característica de datos que
determina si se incluye o no una fila particular en la operación actual. ElAGRUPAR PORy
ORDENAR PORLas cláusulas especifican cómo mostrar las filas recuperadas. La Tabla 10-1
proporciona un resumen.
212 Parte III: Almacenamiento y recuperación de datos

Tabla 10-1 Modificación de cláusulas y funciones

Cláusula modificatoria Función

DE Especifica de qué tablas se deben tomar los datos.

DÓNDE Filtra filas que no satisfacen la condición de búsqueda

AGRUPAR POR Separa filas en grupos según los valores de las columnas
de agrupación

TENIENDO Filtra grupos que no satisfacen la condición de búsqueda

ORDENAR POR Ordena los resultados de cláusulas anteriores para producir el resultado final.

Si utiliza más de una de estas cláusulas, deben aparecer en el siguiente

orden:

SELECCIONARlista_columnas
DElista_tabla
[DÓNDEcondición_búsqueda]
[AGRUPAR PORcolumna_agrupación]
[TENIENDOcondición_búsqueda]
[ORDENAR POR condición_pedido];

Aquí está la verdad sobre la ejecución de estas cláusulas:

✓ ElDÓNDELa cláusula es un filtro que pasa las filas que cumplen con la condición de
búsqueda y rechaza las filas que no cumplen con la condición.

✓ ElAGRUPAR PORLa cláusula reordena las filas queDÓNDELa cláusula pasa

según el valor de la columna de agrupación.
✓ ElTENIENDOLa cláusula es otro filtro que toma cada grupo que el AGRUPAR POR
La cláusula forma y pasa aquellos grupos que cumplen la condición de búsqueda,
rechazando el resto.

✓ ElORDENAR PORLa cláusula ordena lo que queda después de que todas las cláusulas
anteriores procesen la tabla.

Como indican los corchetes ([ ]), elDONDE, AGRUPAR POR, TENER,y ORDENAR
PORLas cláusulas son opcionales.

SQL evalúa estas cláusulas en el ordenDE, DÓNDE, AGRUPAR POR, TENER, y finalmente
[Link] cláusulas funcionan como una tubería: cada cláusula recibe el resultado
de la cláusula anterior y produce un resultado para la siguiente cláusula. En notación
funcional, este orden de evaluación aparece de la siguiente manera:

SELECCIONAR(TENIENDO(GRUPO POR(DONDE(DESDE...))))
 Capítulo 10: Centrándose en los datos que desea 213
ORDENAR PORopera despuésSELECCIONAR,lo que explica por quéORDENAR PORsólo puede hacer
referencia a columnas en [Link] PORNo puedo hacer referencia a otras
columnas en elDEmesas).

DE Cláusulas
ElDELa cláusula es fácil de entender si especifica solo una tabla, como en el
siguiente ejemplo:

SELECCIONAR * DE VENTAS ;

Esta declaración devuelve todos los datos en todas las filas de cada columna de la tabla
VENTAS. Sin embargo, puede especificar más de una tabla en unDEcláusula. Considere el
siguiente ejemplo:

SELECCIONAR *
DEL CLIENTE, VENTAS;

Esta declaración forma una tabla virtual que combina los datos de la tabla CLIENTE
con los datos de la tabla VENTAS. (Para obtener más información sobre las tablas
virtuales, consulte el Capítulo 6). Cada fila de la tabla CLIENTE se combina con cada
fila de la tabla VENTAS para formar la nueva tabla. La nueva tabla virtual que forma
esta combinación contiene el número de filas de la tabla CLIENTE multiplicado por el
número de filas de la tabla VENTAS. Si la tabla CLIENTE tiene 10 filas y la tabla
VENTAS tiene 100, entonces la nueva tabla virtual tiene 1000 filas.

Esta operación se llamaproducto cartesianode las dos tablas fuente. El producto

cartesiano es un tipo deUNIRSE. (yo cubroUNIRSEoperaciones en detalle en el
Capítulo 11.)

En la mayoría de las aplicaciones, cuando se toma el producto cartesiano de dos tablas,

la mayoría de las filas que se forman en la nueva tabla virtual no tienen sentido. Esto
también se aplica a la tabla virtual que se forma a partir de las tablas CLIENTES y
VENTAS; sólo las filas dondeIdentificación del clientede la tabla CLIENTE coincide con el
Identificación del clientede la tabla SALES son de interés. Puede filtrar el resto de las filas
utilizando unDÓNDEcláusula.

DÓNDE Cláusulas
Yo uso elDÓNDEcláusula muchas veces a lo largo de este libro sin explicarla
realmente porque su significado y uso son obvios: Una declaración realiza
214 Parte III: Almacenamiento y recuperación de datos

una operación (comoSELECCIONAR, BORRAR,oACTUALIZAR)solo en filas de la tabla DÓNDEuna

condición establecida es verdadera. La sintaxis delDÓNDEcláusula es la siguiente:

SELECCIONARlista_columnas
DEnombre de la tabla
DÓNDEcondición;

BORRAR DEnombre de la tabla

DÓNDEcondición;

ACTUALIZARnombre de la tabla
SET columna =
1
valor, columna
1
= valor,
2
..., columna
2
= valor DONDE
condición;
norte norte

Elcondiciónen elDÓNDELa cláusula puede ser simple o arbitrariamente

compleja. Puede unir varias condiciones utilizando los conectores lógicos Y,
O,yNO (que analizo más adelante en este capítulo) para crear una condición
única.

Los siguientes son algunos ejemplos típicos deDÓNDEcláusulas:

WHERE [Link] = [Link] WHERE

[Link]ías = [Link]
DONDE [Link]ías < 219
DÓNDE [Link]ías > 3 * valor_base
DONDE [Link]ías < 219 Y [Link]ínas > 27.4

Las condiciones que estosDÓNDELas cláusulas expresas se conocen como predicados. A

predicadoes una expresión que afirma un hecho sobre los valores.

el [Link]ías < 219,por ejemplo, es Verdadero si el valor de la fila

actual de la [Link]íases menor que 219. Si la afirmación es
verdadera, satisface la condición. Una afirmación puede ser Verdadera, Falsa o
desconocida. El caso desconocido surge si uno o más elementos de la afirmación son
nulos. Elpredicados de comparación(=, <, >, <>, <=,y >=) son los más comunes, pero SQL
ofrece varios otros que aumentan en gran medida su capacidad para filtrar un elemento
de datos deseado de otros en la misma columna. Estos predicados le brindan esa
capacidad de filtrado:

✓ Predicados de comparación

✓ ENTRE
✓ EN [NO EN]
✓ ME GUSTA [NO ME GUSTA]

✓ NULO
✓ TODOS, ALGUNOS, CUALQUIER

✓ EXISTE
 Capítulo 10: Centrándose en los datos que desea 215
✓ ÚNICO
✓ SUPERPOSICIONES

✓ FÓSFORO

✓ SIMILAR
✓ DISTINTO

Predicados de comparación
Los ejemplos de la sección anterior muestran usos típicos de predicados de
comparación en los que se compara un valor con otro. Para cada fila en la que la
comparación se evalúa como un valor Verdadero, ese valor satisface el DÓNDE
cláusula, y la operación (SELECCIONAR, ACTUALIZAR, BORRAR,o lo que sea) se
ejecuta en esa fila. Filas que la comparación evalúaFALSOse omiten. Considere la
siguiente declaración SQL:

SELECCIONAR * DE ALIMENTOS
DONDE Calorías <219;

Esta declaración muestra todas las filas de la tabla ALIMENTOS que tienen un
valor inferior a 219 en elcaloríascolumna.

En la tabla 10-2 se enumeran seis predicados de comparación.

Tabla 10-2 Predicados de comparación de SQL

Comparación Símbolo

Igual =
No es igual <>
Menos que <
Menor o igual <=
Mas grande que >
Mayor que o igual >=

ENTRE
A veces desea seleccionar una fila si el valor de una columna se encuentra dentro de un rango
específico. Una forma de realizar esta selección es mediante predicados de comparación. Por
ejemplo, puedes formular unaDÓNDEcláusula para seleccionar todas las filas en
216 Parte III: Almacenamiento y recuperación de datos

la tabla ALIMENTOS que tienen un valor en elcaloríascolumna mayor que 100 y menor que
300, de la siguiente manera:

DÓNDE [Link]ías > 100 Y [Link]ías < 300

Esta comparación no incluye alimentos con un recuento de calorías de exactamente 100 o 300,
solo aquellos valores que caenentreestos dos números. Para incluir los puntos finales (en este
caso, 100 y 300), puedes escribir la declaración de la siguiente manera:

DONDE [Link]ías >= 100 Y [Link]ías <= 300

Otra forma de especificar un rango que incluya los puntos finales es utilizar un
ENTREpredicado de la siguiente manera:

DONDE ALIMENTOS. Calorías ENTRE 100 Y 300

Esta cláusula es funcionalmente idéntica al ejemplo anterior, que utiliza predicados

de comparación. Esta formulación ahorra algo de escritura y es un poco más
intuitiva que la que utiliza dos predicados de comparación unidos por el conectivo
lógico.Y.

ElENTRELa palabra clave puede resultar confusa porque no indicaexplícitamente si

la cláusula incluye los puntos finales. De hecho, la cláusulahaceincluir estos puntos
finales. Cuando usas elENTREpalabra clave, un pajarito no desciende para
recordarle que el primer término de la comparación debe ser igual o menor que el
segundo. Si, por ejemplo,[Link]íascontiene un valor de 200, la siguiente
cláusula devuelve un valor Verdadero:

DONDE ALIMENTOS. Calorías ENTRE 100 Y 300

Sin embargo, una cláusula que usted pueda pensar que es equivalente al ejemplo anterior
devuelve el resultado opuesto, Falso:

DONDE ALIMENTOS. Calorías ENTRE 300 Y 100

Si utilizaENTRE,debe poder garantizar que el primer término de su

comparación sea siempre igual o menor que el segundo término.

Puedes usar elENTREpredicado con tipos de datos de carácter, bit y fecha y

hora, así como con tipos numéricos. Es posible que vea algo como el
siguiente ejemplo:

SELECCIONE Nombre, Apellido

DEL CLIENTE
DONDE [Link] ENTRE 'A' Y 'Mzzz';
 Capítulo 10: Centrándose en los datos que desea 217
Este ejemplo devuelve todos los clientes cuyos apellidos se encuentran en la primera mitad
del alfabeto.

EN y NO EN
ElENyNO ENLos predicados tratan de si los valores especificados (como OR, WA e ID)
están contenidos dentro de un conjunto particular de valores (como los estados de los
Estados Unidos). Por ejemplo, es posible que tenga una tabla que enumere los
proveedores de un producto básico que su empresa compra periódicamente. Quiere
saber los números de teléfono de los proveedores ubicados en el noroeste del Pacífico.
Puede encontrar estos números utilizando predicados de comparación, como los que
se muestran en el siguiente ejemplo:

SELECCIONE Empresa, Teléfono

DEL PROVEEDOR
DONDE Estado = 'O' O Estado = 'WA' O Estado = 'ID';

También puedes utilizar elENpredicado para realizar la misma tarea, de la siguiente manera:

SELECCIONE Empresa, Teléfono

DEL PROVEEDOR
DONDE Estado EN ('O', 'WA', 'ID');

Esta formulación es un poco más compacta que la que utiliza predicados de

comparación y ló[Link]én elimina cualquier posible confusión entre la
lógicaOoperador y la abreviatura del estado de Oregón.

ElNO ENLa versión de este predicado funciona de la misma manera. Supongamos que tiene
ubicaciones en California, Arizona y Nuevo México y, para evitar pagar impuestos sobre las ventas,
desea considerar la posibilidad de utilizar proveedores ubicados en cualquier lugar excepto en esos
estados. Utilice la siguiente construcción:

SELECCIONE Empresa, Teléfono

DEL PROVEEDOR
DONDE Estado NO EN ('CA', 'AZ', 'NM');

Utilizando elENLa palabra clave de esta manera le ahorra tener que escribir un poco, aunque
(francamente) eso no es una gran ventaja. Puede hacer el mismo trabajo utilizando predicados de
comparación como se muestra en el primer ejemplo de esta sección.

Es posible que tenga otra buena razón para utilizar elENpredicado en lugar de predicados de
comparación, incluso si se utilizaENno ahorra mucho tipeo: su DBMS probablemente
implemente los dos métodos de manera diferente, y uno de los métodos puede ser
significativamente más rápido que el otro en su sistema. Es posible que desee realizar una
comparación de desempeño entre las dos formas de expresar la inclusión en (o
218 Parte III: Almacenamiento y recuperación de datos

exclusión de) un grupo y luego utilizar la técnica que produzca el resultado más rápido.
Un DBMS con un buen optimizador probablemente elegirá el método más eficiente,
independientemente del predicado que utilice.

ElENLa palabra clave también es valiosa en otra área. SiENes parte de una subconsulta, la
palabra clave le permite extraer información de dos tablas para obtener resultados que no
puede obtener de una sola tabla. Cubro las subconsultas en detalle en el Capítulo 12, pero
aquí hay un ejemplo que muestra cómo una subconsulta usa elEN palabra clave.

Suponga que desea mostrar los nombres de todos los clientes que compraron el producto F-35
en los últimos 30 días. Los nombres de los clientes están en la tabla CLIENTE y los datos de las
transacciones de ventas están en la tabla TRANSACT. Puede utilizar la siguiente consulta:

SELECCIONE Nombre, Apellido

DEL CLIENTE
DONDE CLIENTEID EN
(SELECCIONE ID de cliente
DE TRANSACTAR
DONDE ProductID = 'F-35'
AND TransDate >= (CurrentDate - 30));

El interiorSELECCIONARde la tabla TRANSACT se anida dentro del exteriorSELECCIONAR de

la tabla CLIENTE. El interiorSELECCIONARencuentra elIdentificación del clienteNúmeros de
todos los clientes que compraron el producto F-35 en los últimos 30 días. El exterior
SELECCIONARmuestra el nombre y apellido de todos los clientes cuyos Identificación del
clientees recuperado por el interiorSELECCIONAR.

ME GUSTA Y NO ME GUSTA
Puedes usar elCOMOpredicado para comparar dos cadenas de caracteres para una
coincidencia parcial. Las coincidencias parciales son valiosas si no conoce la forma exacta de
la cadena que está buscando. También puede utilizar coincidencias parciales para recuperar
varias filas que contengan cadenas similares en una de las columnas de la tabla.

Para identificar coincidencias parciales, SQL utiliza dos caracteres comodín. El signo de
porcentaje (%) puede representar cualquier cadena de caracteres que tenga cero o más
caracteres. El guión bajo (_) representa cualquier carácter individual. La Tabla 10-3 proporciona
algunos ejemplos que muestran cómo utilizarCOMO.
 Capítulo 10: Centrándose en los datos que desea 219

Tabla 10-3 Predicado LIKE de SQL

Declaración Valores devueltos

DONDE Palabra COMO 'interno%' interno

interno
internacional
Internet

pasantes

DONDE Palabra COMO '%Paz%' Justicia de la Paz

Guerrero pacífico

DONDE Palabra COMO 'T_p_' Cinta

grifos

tipi
Consejos

Tapas

Tipo

ElDIFERENTE Apredicado recupera todas las filas que no satisfacen una coincidencia
parcial, incluidos uno o más caracteres comodín, como en el siguiente ejemplo:

DONDE El teléfono NO ES COMO '503%'

Este ejemplo devuelve todas las filas de la tabla cuyo número de teléfono
comienza con algo distinto de 503.

Es posible que desee buscar una cadena que incluya un signo de porcentaje o un guión
bajo real. En ese caso, desea que SQL interprete el signo de porcentaje como un signo de
porcentaje y no como un carácter comodín. Puede realizar dicha búsqueda escribiendo
un carácter de escape justo antes del carácter que desea que SQL tome literalmente.
Puede elegir cualquier carácter como carácter de escape siempre que ese carácter no
aparezca en la cadena que está probando, como se muestra en el siguiente ejemplo:

SELECCIONAR Cotización
DE BARLETTS
DONDE Cita COMO '20#%'
ESCAPAR '#' ;
220 Parte III: Almacenamiento y recuperación de datos

El carácter % se escapa mediante el signo # anterior, por lo que la declaración interpreta

este símbolo como un signo de porcentaje en lugar de como un comodín. Puedes
"escapar" de un guión bajo (o del propio carácter de escape) de la misma manera. La
consulta anterior, por ejemplo, encontraría la siguiente cita en Citas familiares de
Bartlett:

El 20% de los vendedores produce el 80% de los resultados.

La consulta también encontraría lo siguiente:

20%

SIMILAR
SQL: 1999 agregó elSIMILARpredicado, que ofrece una manera más poderosa de
encontrar coincidencias parciales que elCOMOpredicado proporciona. Con elSIMILAR
predicado, puede comparar una cadena de caracteres con una expresión regular. Por
ejemplo, supongamos que está buscando elSistema operativocolumna de una tabla de
compatibilidad de software para buscar compatibilidad con Microsoft Windows. Podrías
construir unDÓNDEcláusula como la siguiente:

DONDE Sistema Operativo SIMILAR A

'('Windows '(3.1|95|98|ME|CE|NT|2000|XP|Vista|7|8))'

Este predicado recupera todas las filas que contienen cualquiera de los sistemas operativos de
Microsoft especificados.

NULO
ElNULOEl predicado busca todas las filas donde el valor de la columna seleccionada es
nulo. En la tabla ALIMENTOS del Capítulo 8, varias filas tienen valores nulos en el
Carbohidratocolumna. Puede recuperar sus nombres utilizando una declaración como
la siguiente:

SELECCIONAR (Comida)
DE ALIMENTOS
DONDE Carbohidrato ES NULO;

Esta consulta devuelve los siguientes valores:

Carne de res, hamburguesa magra

Pollo, carne blanca
Zarigüeya, asada
Jamón de cerdo
 Capítulo 10: Centrándose en los datos que desea 221
Como era de esperar, incluido elNOLa palabra clave invierte el resultado, como en el
siguiente ejemplo:

SELECCIONAR (Comida)
DE ALIMENTOS
DONDE Carbohidrato NO ES NULO;

Esta consulta devuelve todas las filas de la tabla excepto las cuatro que devuelve la
consulta anterior.

La declaraciónEl carbohidrato ES NULOesnolo mismo queCarbohidratos = NULO.

Para ilustrar este punto, supongamos que, en la fila actual de la tabla ALIMENTOS,
ambosCarbohidratoyProteínason nulos. De este hecho, se pueden sacar las
siguientes conclusiones:

✓ El carbohidrato ES NULOes verdad.

✓ La proteína es nulaes verdad.
✓ Los carbohidratos son NULOS y las proteínas son NULOSes verdad.
✓ Carbohidratos = Proteínases desconocido.
✓ Carbohidrato = NULOes una expresión ilegal.

Usando la palabra claveNULOen una comparación no tiene sentido porque la respuesta

siempre regresa comodesconocido.

Por que esCarbohidratos = Proteínasdefinido como desconocido a pesar de

CarbohidratoyProteína¿Tiene el mismo valor (nulo)? PorqueNULO simplemente
significa "No lo sé". no sabes queCarbohidratoes, y no sabes lo queProteínaes;
por lo tanto, no sabes si esos valores (desconocidos) son los mismos. Tal vez
Carbohidratoes 37, yProteína es 14, o tal vezCarbohidratoes 93, yProteínaes 93.
Si no conoce el valor de carbohidratosyel valor de proteína, no se puede decir si
los dos son iguales.

TODOS, ALGUNOS, CUALQUIER

Hace miles de años, el filósofo griego Aristóteles formuló un sistema de lógica que se convirtió
en la base de gran parte del pensamiento occidental. La esencia de esta lógica es comenzar con
un conjunto de premisas que sabemos que son verdaderas, aplicar operaciones válidas a estas
premisas y, de ese modo, llegar a nuevas verdades. Un ejemplo de este procedimiento es el
siguiente:

Premisa 1:Todos los griegos son humanos.

Premisa 2:Todos los humanos son mortales.

Conclusión:Todos los griegos son mortales.

222 Parte III: Almacenamiento y recuperación de datos

Otro ejemplo:

Premisa 1:Algunos griegos son mujeres.

Premisa 2:Todas las mujeres son humanas.

Conclusión:Algunos griegos son humanos.

A modo de presentar un tercer ejemplo, permítanme exponer la misma idea lógica del
segundo ejemplo de una manera ligeramente diferente:

Si algunos griegos son mujeres y todas las mujeres son humanas, entonces algunos griegos son
humanos.

El primer ejemplo utiliza el cuantificador [Link] ambas premisas, lo que le

permitirá hacer una deducción sólida sobre todos los griegos en la conclusión. El
segundo ejemplo utiliza el cuantificador [Link] una premisa,
permitiéndote hacer una deducción sobre algunos griegos en la conclusión. El tercer
ejemplo utiliza el cuantificador [Link],que es sinónimo de ALGUNO,
para llegar a la misma conclusión a la que llega en el segundo ejemplo.

mira comoALGUNA CUALQUIERA,yTODOaplicar en SQL.

Consideremos un ejemplo de las estadísticas del béisbol. El béisbol es un deporte físicamente

exigente, especialmente para los lanzadores. Un lanzador debe lanzar la pelota de béisbol
desde el montículo del lanzador hasta el plato entre 90 y 150 veces durante un juego. Este
esfuerzo puede ser agotador y si (como suele ser el caso) el lanzador se vuelve ineficaz antes
de que termine el juego, un lanzador de relevo debe reemplazarlo. Lanzar un juego completo
es un logro sobresaliente, independientemente de si el esfuerzo resulta en una victoria.

CUALQUIER puede ser ambiguo

El SQL original usaba la palabraCUALQUIERpara la es; aquícualquierse utiliza como cuantificador
cuantificación existencial. Este uso resultó ser existencial. La segunda frase, sin embargo, es un
confuso y propenso a errores porque las alarde de que puedo comer más hot dogs que los
connotaciones del idioma inglés decualquierson a que puede comer el que más come entre todos
veces universales y a veces existenciales: ustedes. En este caso,cualquierse utiliza como
cuantificador universal.
✓ “¿Alguno de ustedes sabe dónde está Baker Street?
Por lo tanto, para el estándar SQL-92, los desarrolladores
conservaron la palabraCUALQUIERpara compatibilidad con los
✓ “Puedo comer más hot dogs que cualquiera de ustedes”.
primeros productos, pero también agregaron la palabra
La primera frase probablemente sea preguntar si al ALGUNOcomo sinónimo menos confuso. SQL continúa
menos una persona sabe dónde está Baker Street. admitiendo ambos cuantificadores existenciales.
 Capítulo 10: Centrándose en los datos que desea 223
Supongamos que llevas la cuenta del número de juegos completos que lanzan todos los
lanzadores de las grandes ligas. En una tabla, enumera todos los lanzadores de la Liga
Americana y en otra tabla, enumera todos los lanzadores de la Liga Nacional. Ambas tablas
contienen los nombres, apellidos y el número de juegos completos lanzados de los jugadores.

La Liga Americana permite que un bateador designado (DH) (que no está obligado a jugar en
una posición defensiva) batee en lugar de cualquiera de los nueve jugadores que juegan a la
defensiva. La Liga Nacional no permite bateadores designados, pero sí permite bateadores
emergentes. Cuando el bateador emergente entra al juego por el lanzador, el lanzador no
puede jugar por el resto del juego. Por lo general, el bateador designado batea por el lanzador,
porque los lanzadores son notoriamente malos bateadores. Los lanzadores deben dedicar
tanto tiempo y esfuerzo a perfeccionar su lanzamiento que no tienen tanto tiempo para
practicar el bateo como los demás jugadores.

Suponga que tiene la teoría de que, en promedio, los lanzadores abridores de la Liga
Americana lanzan juegos más completos que los lanzadores abridores de la Liga Nacional. Esta
idea se basa en su observación de que los bateadores designados permiten que los lanzadores
de la Liga Americana que lanzan con fuerza y batean débilmente sigan lanzando mientras
sean efectivos, incluso en un juego cerrado. Debido a que un bateador designado ya está
bateando por estos lanzadores, su mal bateo no es un problema. En la Liga Nacional, sin
embargo, en circunstancias cotidianas el lanzador iría al bate. Cuando estaban perdiendo en las
últimas entradas, la mayoría de los managers pedían un bateador emergente para batear por
el lanzador, juzgando que conseguir un hit en esta situación es más importante que mantener
a un lanzador efectivo en el juego. Para probar su teoría, formula la siguiente consulta:

SELECCIONE Nombre, Apellido

DE LA LIGA_AMERICANA
DONDE CompleteGames > TODO
(SELECCIONE Juegos completos
DE LA LIGA_NACIONAL) ;

La subconsulta (la internaSELECCIONAR)devuelve una lista que muestra, para cada lanzador
de la Liga Nacional, el número de juegos completos que lanzó. La consulta externa devuelve el
nombre y apellido de todos los jugadores de la Liga Americana que lanzaron más juegos
completos queTODOde los jugadores de la Liga Nacional. La consulta completa devuelve los
nombres de los lanzadores de la Liga Americana que lanzaron más juegos completos que el
lanzador que lanzó la mayor cantidad de juegos completos en la Liga Nacional.

Considere la siguiente afirmación similar:

SELECCIONE Nombre, Apellido

DE LA LIGA_AMERICANA
DONDE CompleteGames > CUALQUIER
(SELECCIONE Juegos completos
DE LA LIGA_NACIONAL) ;
224 Parte III: Almacenamiento y recuperación de datos

En este caso se utiliza el cuantificador [Link] lugar del cuantificador

[Link] subconsulta (la consulta interna anidada) es idéntica a la subconsulta del
ejemplo anterior. Esta subconsulta recupera una lista completa de las estadísticas completas
del juego de todos los lanzadores de la Liga Nacional. La consulta externa devuelve el nombre
y apellido de todos los lanzadores de la Liga Americana que lanzaron más juegos completos
queCUALQUIERLanzador de la Liga Nacional. Como puedes estar prácticamente seguro de que
al menos un lanzador de la Liga Nacional no ha lanzado un juego completo, el resultado
probablemente incluye a todos los lanzadores de la Liga Americana que han lanzado al menos
un juego completo.

Si reemplazas la palabra claveCUALQUIERcon la palabra clave equivalenteALGUNO,El

resultado es el mismo. Si la afirmación de que al menos un lanzador de la Liga Nacional no ha
lanzado un juego completo es cierta, entonces se puede decir queALGUNO El lanzador de la
Liga Nacional no ha lanzado un juego completo.

EXISTE
Puedes usar elEXISTEpredicado junto con una subconsulta para determinar si
la subconsulta devuelve alguna fila. Si la subconsulta devuelve al menos una
fila, ese resultado satisface laEXISTEcondición y se ejecuta la consulta externa.
Considere el siguiente ejemplo:

SELECCIONE Nombre, Apellido

DEL CLIENTE
DONDE EXISTE
(SELECCIONE ID de cliente DISTINTO
DE VENTAS
WHERE [Link] = [Link]);

Aquí la tabla VENTAS contiene todas las transacciones de ventas de su empresa. La

tabla incluye elIdentificación del clientedel cliente que realiza cada compra, así
como otra información pertinente. La tabla CLIENTE contiene el nombre y apellido
de cada cliente, pero no información sobre transacciones específicas.

La subconsulta del ejemplo anterior devuelve una fila por cada cliente que
ha realizado al menos una compra. La consulta externa devuelve el nombre
y apellido de los clientes que realizaron las compras que registra la tabla
SALES.

EXISTEes equivalente a una comparación deCONTARcon cero, como muestra la

siguiente consulta:

SELECCIONE Nombre, Apellido

DEL CLIENTE
DONDE 0 <>
 Capítulo 10: Centrándose en los datos que desea 225
(SELECCIONE RECUENTO (*))
DE VENTAS
WHERE [Link] = [Link]);

Por cada fila de la tabla VENTAS que contenga unIdentificación del clienteeso es
igual a unIdentificación del clienteen la tabla CLIENTE, esta declaración muestra el
Nombre de pilayApellidocolumnas de la tabla CLIENTE. Por lo tanto, para cada
venta en la tabla VENTAS, el extracto muestra el nombre del cliente que realizó la
compra.

ÚNICO
Como lo haces con elEXISTEpredicado, se utiliza elÚNICOpredicado con una
subconsulta. Aunque elEXISTEEl predicado se evalúa como Verdadero solo si la
subconsulta devuelve al menos una fila, elÚNICOEl predicado se evalúa como Verdadero
solo si no hay dos filas devueltas por la subconsulta que sean idénticas. En otras
palabras, elÚNICOEl predicado se evalúa como Verdadero solo si todas las filas que
devuelve su subconsulta son únicas. Considere el siguiente ejemplo:

SELECCIONE Nombre, Apellido

DEL CLIENTE
DONDE ÚNICO
(SELECCIONE CustomerID DE VENTAS
WHERE [Link] = [Link]);

Esta declaración recupera los nombres de todos los clientes nuevos para quienes la tabla
SALES registra solo una venta. Como un valor nulo es un valor desconocido, dos valores
nulos no se consideran iguales entre sí; cuando elÚNICOLa palabra clave se aplica a una
tabla de resultados que contiene sólo dos filas nulas, laÚNICOEl predicado se evalúa
como Verdadero.

DISTINTO
ElDISTINTOEl predicado es similar alÚNICOpredicado, excepto en la forma en que trata
los nulos. Si todos los valores en una tabla de resultados sonÚNICO,entonces ellos
también sonDISTINTOde cada uno. Sin embargo, a diferencia del resultado para el
ÚNICO predicado, si elDISTINTOLa palabra clave se aplica a una tabla de resultados que
contiene sólo dos filas nulas, laDISTINTOEl predicado se evalúa como Falso. Dos valores
nulos sonnoSe consideran distintos entre sí, al mismo tiempo que se consideran únicos.

Esta extraña situación parece contradictoria, pero tiene una razón. En algunas
situaciones, es posible que desee tratar dos valores nulos como diferentes entre sí,
en cuyo caso, utilice elÚNICOpredicado. Cuando desee tratar los dos valores nulos
como si fueran iguales, utilice elDISTINTOpredicado.
226 Parte III: Almacenamiento y recuperación de datos

SUPERPOSICIONES

tu usas elSUPERPOSICIONESpredicado para determinar si dos intervalos de tiempo se

superponen entre sí. Este predicado es útil para evitar conflictos de programación. Si los dos
intervalos se superponen, el predicado devuelve un valor Verdadero. Si no se superponen, el
predicado devuelve un valor Falso.

Puede especificar un intervalo de dos maneras: como hora de inicio y hora de

finalización o como hora de inicio y duración. Aquí hay unos ejemplos:

(HORA ‘[Link]’, INTERVALO ‘1’ HORA)

SUPERPOSICIONES

(HORA ‘[Link]’, INTERVALO ‘2’ HORA)

Este primer ejemplo devuelve True porque las 3:30 son menos de una hora después de las 2:55.

(HORA '[Link]', HORA '[Link]')

SUPERPOSICIONES

(HORA '[Link]', HORA '[Link]')

Este ejemplo devuelve True porque hay una superposición de un minuto entre los
dos intervalos.

(HORA '[Link]', HORA '[Link]')

SUPERPOSICIONES

(HORA '[Link]', INTERVALO '3' HORA)

Este ejemplo devuelve False porque los dos intervalos no se superponen.

(HORA '[Link]', HORA '[Link]')

SUPERPOSICIONES

(HORA '[Link]', HORA '[Link]')

Este ejemplo devuelve False porque aunque los dos intervalos son contiguos,
no se superponen.

FÓSFORO
En el Capítulo 5, analizo la integridad referencial, que implica mantener la coherencia en una
base de datos de tablas múltiples. Puede perder integridad agregando una fila a una tabla
secundaria que no tiene una fila correspondiente en la tabla principal de la secundaria. Puede
causar problemas similares eliminando una fila de una tabla principal si las filas
correspondientes a esa fila existen en una tabla secundaria.

Suponga que su empresa tiene una tabla CLIENTE que realiza un seguimiento de
todos sus clientes y una tabla VENTAS que registra todas las transacciones de ventas.
No desea agregar una fila a VENTAS hasta que ingrese el cliente que realiza la
 Capítulo 10: Centrándose en los datos que desea 227
compra en la tabla CLIENTE. Tampoco desea eliminar un cliente de la tabla
CLIENTE si ese cliente realizó compras que existen en la tabla VENTAS.

Antes de realizar una inserción o eliminación, es posible que desee verificar la fila
candidata para asegurarse de que insertar o eliminar esa fila no cause problemas de
integridad. ElFÓSFOROEl predicado puede realizar tal verificación.

Digamos que tiene una tabla CLIENTE y una tabla [Link]ón del clientees la clave
principal de la tabla CLIENTE y actúa como clave externa en la tabla VENTAS. Cada fila de la
tabla CLIENTE debe tener un nombre ú[Link]ón del clienteeso no es nulo.
Identificación del clienteno es único en la tabla VENTAS, porque los clientes habituales compran
más de una vez. Esta situación está bien; no amenaza la integridad porqueIdentificación del
clientees una clave externa en lugar de una clave primaria en esa tabla.

Aparentemente,Identificación del clientepuede ser nulo en la tabla VENTAS, porque

alguien puede entrar desde la calle, comprar algo y salir antes de que usted tenga la
oportunidad de ingresar su nombre y dirección en la tabla CLIENTE. Esta situación puede
crear problemas: una fila en la tabla secundaria sin una fila correspondiente en la tabla
principal. Para superar este problema, puede crear un cliente genérico en la tabla
CLIENTE y asignar todas esas ventas anónimas a ese cliente.

Supongamos que un cliente se acerca a la caja registradora y afirma que compró un

F-35 Strike Fighter el 18 de diciembre de 2012. Aunque perdió su recibo, ahora
quiere devolver el avión porque aparece como un portaaviones en las pantallas de
radar de los oponentes. Puede verificar si compró un F-35 buscando una
coincidencia en su base de datos de VENTAS. Primero, debes recuperarla.
Identificación del clienteen la variablevcustido;entonces puedes usar la siguiente
sintaxis:

. . . DÓNDE (:vcustid, 'F-35', '2012-12-18')

FÓSFORO
(SELECCIONE ID de cliente, ID de producto, Fecha de venta
DE VENTAS)

Si elFÓSFOROEl predicado devuelve un valor Verdadero, la base de datos contiene una venta
del F-35 el 18 de diciembre de 2012 a este [Link]ón del [Link] el
producto defectuoso y reembolsar el dinero al cliente. (Nota:Si algún valor en el primer
argumento delFÓSFOROpredicado son nulos, siempre se devuelve un valor Verdadero.)

Los desarrolladores de SQL agregaron elFÓSFOROpredicado y elÚNICOpredicado por la

misma razón: proporcionan una manera de realizar explícitamente las pruebas definidas
para la integridad referencial implícita (RI) yÚNICOrestricciones.

La forma general de laFÓSFOROpredicado es el siguiente:

valor_filaPARTIDO [ÚNICO] [SIMPLE| PARCIAL | LLENO ]

Subconsulta
228 Parte III: Almacenamiento y recuperación de datos

ElÚNICO, SIMPLE, PARCIAL,yLLENOLas opciones se relacionan con reglas que entran en juego si la
expresión del valor de la filaRtiene una o más columnas que son nulas. (Para obtener más información
sobre el uso de expresiones de valor de fila, consulte el Capítulo 9.) Las reglas para laFÓSFOROEl
predicado es una copia de las correspondientes reglas de integridad referencial.

Reglas de integridad referencial

y el predicado MATCH
Reglas de integridad referencialrequieren que los valores de una columna o columnas de una
tabla coincidan con los valores de una columna o columnas de otra tabla. Usted se refiere a
las columnas de la primera tabla comoclave externay las columnas de la segunda tabla como
Clave primariaollave [Link] ejemplo, puede declarar la columnaEmpDeptoNoen una tabla
EMPLOYEE como una clave externa que hace referencia a laDptoNocolumna de una tabla
DEPT. Este emparejamiento garantiza que si registra a un empleado en la tabla EMPLEADO
como trabajando en el departamento 123, aparecerá una fila en la tabla DEPTO donde
DptoNoes 123.

Si los miembros del par clave externa/clave primaria constan de una sola columna,
la situación es bastante sencilla. Sin embargo, las dos claves pueden constar de
varias columnas. ElDptoNoEl valor, por ejemplo, puede ser único sólo dentro de un
Ubicación;por lo tanto, para identificar de forma única unDEPARTAMENTOfila, debe
especificar tanto unUbicacióny [Link] las oficinas de Boston y Tampa tienen
un departamento 123, debe identificar los departamentos como ("Bostón", "123")y ('
Tampa’, ‘123’).En este caso, la tabla EMPLEADO necesita dos columnas para
identificar unDEPARTAMENTOLlame a esas columnasEmpLocy [Link] un
empleado trabaja en el departamento 123 en Boston, elEmpLoc yEmpDeptoNolos
valores son 'Bostón'y '123'.Y la declaración de clave externa en la tabla EMPLEADO
se ve así:

CLAVE EXTRANJERA (EmpLoc, EmpDeptNo)

DEPARTAMENTO DE REFERENCIAS (Ubicación, [Link])

Sacar conclusiones válidas a partir de sus datos se vuelve inmensamente complicado si

los datos contienen valores nulos. Esto se debe a que a veces desea tratar esos datos de
una manera y otras veces desea tratarlos de otra manera. ElÚNICO, SIMPLE, PARCIAL,y
LLENOLas palabras clave especifican diferentes formas de tratar los datos que contienen
valores nulos. Si sus datos no contienen ningún valor nulo, puede ahorrarse muchos
dolores de cabeza simplemente saltando de aquí a la siguiente sección de este capítulo,
“Conectivos lógicos”. Si tus datoshacecontienen valores nulos, salga del modo de lectura
rápida ahora y lea la siguiente lista lenta y cuidadosamente. Cada entrada en la lista
proporcionada aquí presenta una situación diferente con respecto a los valores nulos y
dice cómoFÓSFOROel predicado lo maneja.
 Capítulo 10: Centrándose en los datos que desea 229

Regla por comité

La versión SQL-89 del estándar especificaba elÚNICO pensó que elPARCIALlas reglas eran oscuras,
regla por defecto, antes de que alguien propusiera o propensas a errores e ineficientes. Aún había otras
debatiera las alternativas. Durante el desarrollo de la personas que preferían la disciplina adicional del
versión SQL-92 del estándar, aparecieron propuestas LLENO normas. El problema finalmente se resolvió
para alternativas. Algunas personas preferían proporcionando las tres palabras clave para que los
fuertemente elPARCIAL reglas y argumentó que esas usuarios pudieran elegir el enfoque que prefirieran.
deberían ser lassolo normas. Estas personas SQL: 1999 agregó elSIMPLEnormas. Por supuesto, la
pensaron que el SQL-89 (ÚNICO)Las reglas eran tan proliferación de reglas hace que tratar con valores
indeseables que querían que esas reglas fueran nulos sea todo menos sencillo. SiSIMPLE, PARCIAL, o
consideradas un error y el PARCIALreglas LLENOno está especificado, elSIMPLESe siguen las
especificadas como corrección. Otras personas reglas.
prefirieron elÚNICOreglas y

A continuación se muestran escenarios que ilustran las reglas para tratar con valores nulos y la
FÓSFOROpredicado:

✓ Los valores son de una forma u [Link] ninguno de los valores de EmpLocy
EmpDeptoNoson nulas (o ambas son nulas), entonces las reglas de integridad
referencial son las mismas que para las claves de una sola columna con valores que son
nulos o no nulos.

✓ Un valor es nulo y el otro [Link], por ejemplo,EmpLoces nulo y

EmpDeptoNono es nulo - oEmpLocno es nulo yEmpDeptoNoes nulo:
necesita nuevas reglas. Al implementar reglas, si inserta o actualiza la
tabla EMPLOYEE conEmpLocyEmpDeptoNovalores de (NULO, '123') o ('
Boston’, NULO),Tienes seis alternativas principales:SIMPLE, PARCIAL, y
LLENO,cada uno con o sin elÚNICOpalabra clave.
✓ ElÚNICOLa palabra clave está [Link] fila coincidente en la tabla de resultados de la
subconsulta debe ser única para que el predicado se evalúe como un valor Verdadero.

✓ Ambos componentes de la expresión de valor de fila R son [Link]ÓSFORO El

predicado devuelve un valor Verdadero independientemente del contenido de la tabla de
resultados de la subconsulta que se compara.

✓ Ninguno de los componentes de la expresión de valor de fila R es nulo,SIMPLEestá

especificado,ÚNICOno se especifica y al menos una fila en la tabla de resultados de la
subconsulta coincide con [Link]ÓSFOROEl predicado devuelve un valor Verdadero. De lo
contrario, devuelve un valor Falso.

✓ Ninguno de los componentes de la expresión de valor de fila R es nulo,SIMPLE

está especificado,ÚNICOse especifica y al menos una fila en la tabla de
resultados de la subconsulta es única y coincide con [Link]ÓSFOROEl predicado
devuelve un valor Verdadero. De lo contrario, devuelve un valor Falso.
230 Parte III: Almacenamiento y recuperación de datos

✓ Cualquier componente de la expresión de valor de fila R es nulo ySIMPLEestá

[Link]ÓSFOROEl predicado devuelve un valor Verdadero.

✓ Cualquier componente de la expresión de valor de fila R no es nulo,PARCIAL está

especificado,ÚNICOno se especifica y la parte no nula de al menos una fila en la tabla de
resultados de la subconsulta coincide con [Link]ÓSFOROEl predicado devuelve un valor
Verdadero. De lo contrario, devuelve un valor Falso.

✓ Cualquier componente de la expresión de valor de fila R no es nulo,PARCIALestá

especificado,ÚNICOse especifica y las partes no nulas de R coinciden con las partes no
nulas de al menos una fila única en la tabla de resultados de la subconsulta. ElFÓSFOROEl
predicado devuelve un valor Verdadero. De lo contrario, devuelve un valor Falso.

✓ Ninguno de los componentes de la expresión de valor de fila R es nulo,LLENOestá

especificado,ÚNICOno se especifica y al menos una fila en la tabla de resultados de la
subconsulta coincide con [Link]ÓSFOROEl predicado devuelve un valor Verdadero. De lo
contrario, devuelve un valor Falso.

✓ Ninguno de los componentes de la expresión de valor de fila R es nulo,LLENOestá

especificado,ÚNICOse especifica y al menos una fila en la tabla de resultados de la
subconsulta es única y coincide con [Link]ÓSFOROEl predicado devuelve un valor
Verdadero. De lo contrario, devuelve un valor Falso.

✓ Cualquier componente de la expresión de valor de fila R es nulo yLLENOestá

[Link]ÓSFOROEl predicado devuelve un valor Falso.

Conectivos Lógicos
A menudo (como muestran varios ejemplos anteriores) aplicar una condición en una
consulta no es suficiente para devolver las filas que desea de una tabla. En algunos casos,
las filas deben cumplir dos o más condiciones. En otros casos, si una fila cumple
cualquiera de dos o más condiciones, califica para su recuperación. En otras ocasiones,
desea recuperar sólo filas que no satisfacen una condición específica. Para satisfacer
estas necesidades, SQL ofrece los conectores lógicosY, O,yNO.

Y
Si varias condiciones deben ser verdaderas antes de poder recuperar una fila, utilice la
opción Yconectivo lógico. Considere el siguiente ejemplo:

SELECCIONE Número de factura, Fecha de venta, Vendedor, Venta total

DE VENTAS
DONDE Fecha de venta>= '2012-12-14'
Y Fecha de venta<= '2012-12-20';
 Capítulo 10: Centrándose en los datos que desea 231
ElDÓNDEcláusula debe cumplir las dos condiciones siguientes:

✓ Fecha de ventadebe ser mayor o igual al 14 de diciembre de 2012.

✓ Fecha de ventadebe ser menor o igual al 20 de diciembre de 2012.

Sólo las filas que registran ventas realizadas durante la semana del 14 de diciembre cumplen
ambas condiciones. La consulta devuelve sólo estas filas.

Note que elYEl conectivo es estrictamente lógico. Esta restricción a veces puede
resultar confusa porque la gente suele utilizar la palabraycon un significado más
vago. Supongamos, por ejemplo, que su jefe le dice: "Me gustaría recuperar los
datos de ventas de Ferguson y Ford". Dijo "Ferguson y Ford", por lo que puede
escribir la siguiente consulta SQL:

SELECCIONAR *
DE VENTAS
DONDE Vendedor = 'Ferguson'
AND Vendedor = 'Ford';

Bueno, no le lleves esa respuesta a tu jefe. La siguiente consulta se parece más a

lo que el gran Kahuna tenía en mente:

SELECCIONAR *
DE VENTAS
DONDE Vendedor EN ('Ferguson', 'Ford');

La primera consulta no devolverá nada, porque ninguna de las ventas en la tabla SALES
fue realizada porambosFerguson y Ford. La segunda consulta devolverá la información
de todas las ventas realizadas porcualquieraFergusonoFord, que probablemente era lo
que quería el jefe.

O
Si cualquiera de dos o más condiciones debe ser Verdadera para calificar una fila para
su recuperación, use elOconectivo lógico, como en el siguiente ejemplo:

SELECCIONE Número de factura, Fecha de venta, Vendedor, Venta total

DE VENTAS
DONDE Vendedor = 'Ford'
O VentaTotal>200;

Esta consulta recupera todas las ventas de Ford, independientemente de su tamaño, así como todas las
ventas de más de $200, independientemente de quién realizó las ventas.
232 Parte III: Almacenamiento y recuperación de datos

NO
ElNOEl conectivo niega una condición. Si la condición normalmente devuelve un valor
Verdadero, sumandoNOhace que la misma condición devuelva un valor Falso. Si una
condición normalmente devuelve un valor Falso, sumandoNOhace que la condición
devuelva un valor Verdadero. Considere el siguiente ejemplo:

SELECCIONE Número de factura, Fecha de venta, Vendedor, Venta total

DE VENTAS
DONDE NO (Vendedor = 'Ford');

Esta consulta devuelve filas para todas las transacciones de ventas completadas por vendedores
distintos de Ford.

cuando usasY, O,oNO,A veces el alcance del conectivo no está claro. Para
estar seguro, use paréntesis para asegurarse de que SQL aplique el conectivo
al predicado que desea. En el ejemplo anterior, elNOEl conectivo se aplica a
todo el predicado (Vendedor = 'Ford').

Cláusulas GROUP BY
A veces, en lugar de recuperar registros individuales, desea saber algo sobre un grupo
de registros. ElAGRUPAR PORLa cláusula es la herramienta que necesitas.

Suponga que es el gerente de ventas de otra ubicación y desea observar el desempeño

de su fuerza de ventas. Si haces un simpleSELECCIONAR,como por ejemplo la siguiente
consulta:

SELECCIONE Número de factura, Fecha de venta, Vendedor, Venta total

DE VENTAS;

recibirá un resultado similar al que se muestra en la Figura 10-1.

Este resultado le da una idea de qué tan bien les está yendo a sus vendedores porque se
trata de muy pocas ventas totales. Sin embargo, en la vida real, una empresa tendría
muchas más ventas y no sería tan fácil saber si se están cumpliendo los objetivos de
ventas. Para hacer el análisis real, puedes combinar losAGRUPAR PORcláusula con uno
de losagregarfunciones (también llamadasestablecer funciones) para obtener una
imagen cuantitativa del desempeño de las ventas. Por ejemplo, puede ver qué vendedor
vende más artículos rentables de alto precio utilizando el promedio (promedio)funcionar
de la siguiente manera:

SELECCIONAR Vendedor, AVG(VentaTotal)

DE VENTAS
GRUPO POR Vendedor;
 Capítulo 10: Centrándose en los datos que desea 233

Figura 10-1:
Un resultado

establecido para

recuperación de

ventas de
01/12/2012 a
07/12/2012.

El resultado de esta consulta, cuando se ejecuta en Microsoft Access 2013, se muestra en la

Figura 10-2. Ejecutar la consulta con un sistema de administración de bases de datos diferente
obtendría el mismo resultado, pero podría parecer un poco diferente.

Figura 10-2:
Promedio
ventas para
cada
vendedor.

Como se muestra en la figura 10-2, el valor promedio de las ventas de Bennett es

considerablemente mayor que el de los otros dos vendedores. Compara las ventas totales con
una consulta similar:

SELECCIONAR Vendedor, SUMA(VentaTotal)

DE VENTAS
GRUPO POR Vendedor;

Esta consulta da el resultado que se muestra en la Figura 10-3.

Bennett también tiene las ventas totales más altas, lo que es consistente con tener el
promedio de ventas más alto.
234 Parte III: Almacenamiento y recuperación de datos

Figura 10-3:
Ventas totales
para cada
vendedor.

TENER Cláusulas
Puede analizar más los datos agrupados utilizando elTENIENDOcláusula. El TENIENDOcláusula
es un filtro que actúa de manera similar a unDÓNDEcláusula, pero en grupos de filas en lugar
de filas individuales. Para ilustrar la función delTENIENDO cláusula, supongamos que el
gerente de ventas considera que Bennett es único en su clase. Su desempeño distorsiona los
datos generales para los demás vendedores. (Ajá, un destructor de curvas). Puede excluir las
ventas de Bennett de los datos agrupados utilizando unTENIENDOcláusula de la siguiente
manera:

SELECCIONAR Vendedor, SUMA(VentaTotal)

DE VENTAS
GRUPO POR Vendedor
TENER Vendedor <>’Bennett’;

Esta consulta le proporciona el resultado que se muestra en la Figura 10-4. Solo se

consideran las filas en las que el vendedor no es Bennett.

Figura 10-4:
Ventas totales
para todos

vendedores
excepto
Bennet.
 Capítulo 10: Centrándose en los datos que desea 235

ORDENAR POR Cláusulas

Utilizar elORDENAR PORcláusula para mostrar la tabla de resultados de una consulta en orden
alfabético ascendente o descendente. Mientras que elAGRUPAR PORLa cláusula reúne filas en
grupos y ordena los grupos en orden alfabético,ORDENAR PORordena filas individuales. El
ORDENAR PORcláusula debe ser la última cláusula que especifique en una consulta. Si la
consulta también contiene unAGRUPAR PORcláusula, la cláusula primero organiza las filas de
salida en grupos. ElORDENAR PORLuego, la cláusula ordena las filas dentro de cada grupo. si no
tienesAGRUPAR PORcláusula, entonces la declaración considera la tabla completa como un
grupo, y laORDENAR PORcláusula ordena todas sus filas de acuerdo con la columna (o
columnas) queORDENAR PORcláusula especifica.

Para ilustrar este punto, considere los datos de la tabla VENTAS. La tabla
VENTAS contiene columnas paraNúmero de factura, Fecha de venta,
Vendedor,y Venta [Link] utiliza el siguiente ejemplo, verá todos los datos en
la tabla VENTAS, pero en un orden arbitrario:

SELECCIONAR * DE VENTAS ;

En una implementación, este puede ser el orden en que insertó las filas en la tabla; en otra
implementación, el orden puede ser el de las actualizaciones más recientes. El orden también
puede cambiar inesperadamente si alguien reorganiza físicamente la base de datos. Ésa es
una de las razones por las que suele ser una buena idea especificar el orden en el que desea
que aparezcan las filas. Es posible que, por ejemplo, desee ver las filas ordenadas porFecha de
ventacomo esto:

SELECCIONE * DEL PEDIDO DE VENTAS POR FechaDeVenta;

Este ejemplo devuelve todas las filas de la tabla VENTAS en orden porFecha de venta.

Para filas con el mismoFecha de venta,el orden predeterminado depende de la

implementación. Sin embargo, puede especificar cómo ordenar las filas que comparten el
mismoFecha de [Link] posible que desees ver las ventas de cada [Link] de ventaen
orden porFactura no,como sigue:

SELECCIONE * DE PEDIDO DE VENTAS POR FechaVenta, NúmeroFactura;

En este ejemplo primero se ordenan las ventas porFecha de venta;entonces para cadaFecha de
venta,ordena las ventas porFactura [Link] no confunda ese ejemplo con la siguiente
consulta:

SELECCIONE * DE PEDIDO DE VENTAS POR Número de factura, Fecha de venta;

Esta consulta primero ordena las ventas porFACTURA [Link] para cada uno diferente
Factura no,la consulta ordena las ventas porFecha de [Link] esto no
produzca el resultado que desea, porque es poco probable que existan varias fechas de
venta para un único número de factura.
236 Parte III: Almacenamiento y recuperación de datos

La siguiente consulta es otro ejemplo de cómo SQL puede devolver datos:

SELECCIONE * DEL PEDIDO DE VENTAS POR Vendedor, FechaVenta;

Este ejemplo primero ordena porvendedory luego porFecha de [Link]és de observar los
datos en ese orden, es posible que desee invertirlos, de la siguiente manera:

SELECCIONE * DE PEDIDO DE VENTAS POR FechaDeVenta, Vendedor;

Este ejemplo ordena las filas primero porFecha de ventay luego porVendedor.

Todos estos ejemplos de orden están en orden ascendente (ASC)orden, que es el orden de
clasificación predeterminado. El últimoSELECCIONARmuestra primero las ventas anteriores y, dentro
de una fecha determinada, muestra las ventas de "Adamsantes 'Panadero'.Si prefieres descender (
DESC)orden, puede especificar este orden para una o más de las columnas de orden, de la siguiente
manera:

SELECCIONAR * DE VENTAS
ORDEN POR Fecha de venta DESC, Vendedor ASC;

Este ejemplo especifica un orden descendente para las fechas de venta, mostrando
primero las ventas más recientes, y un orden ascendente para los vendedores,
colocándolos en orden alfabético. Eso debería darle una mejor idea de cómo se
compara el desempeño de Bennett con el de los demás vendedores.

FETCH limitado
Siempre que se cambia el estándar ISO/IEC SQL, generalmente es para ampliar las
capacidades del lenguaje. Ésto es una cosa buena. Sin embargo, a veces cuando se
realiza un cambio de este tipo no se pueden anticipar todas las posibles
consecuencias. Esto sucedió con la adición de limitadoBUSCARcapacidad en SQL:2008.

La idea de lo [Link] que aunque unSELECCIONARLa declaración puede

devolver un número indeterminado de filas, tal vez solo le importen las tres primeras o
quizás las diez primeras. De acuerdo con esta idea, SQL:2008 agregó la sintaxis que se
muestra en el siguiente ejemplo:

SELECCIONAR Vendedor, AVG(VentaTotal)

DE VENTAS
GRUPO POR Vendedor
ORDEN POR AVG(VentaTotal) DESC
BUSCA SÓLO LAS PRIMERAS 3 FILAS;

Eso se ve bien. Quiere ver quiénes son sus tres principales vendedores en términos de
aquellos que venden principalmente productos de alto precio. Sin embargo, hay un
 Capítulo 10: Centrándose en los datos que desea 237
pequeño problema con esto. ¿Qué pasa si tres personas están empatadas con la misma venta
total promedio, por debajo de los dos mejores vendedores? Sólo uno de esos tres será
devuelto. ¿Cuál? Es indeterminado.

La indeterminación es intolerable para cualquier persona que se precie de bases de datos, por lo que
esta situación se corrigió en SQL:2011. Se agregó nueva sintaxis para incluir vínculos, de esta manera:

SELECCIONAR Vendedor, AVG(VentaTotal)

DE VENTAS
GRUPO POR Vendedor
ORDEN POR AVG(VentaTotal) DESC
BUSQUE LAS PRIMERAS 3 FILAS CON LAZOS;

Ahora el resultado está completamente determinado: si hay un empate, obtienes todas las
filas empatadas. Como antes, si dejas fuera elCON LAZOSmodificador, el resultado es
indeterminado.

Se realizaron un par de mejoras adicionales a la versión [Link]

capacidad en SQL:2011.

Primero, se manejan porcentajes, así como solo un número específico de filas.

Considere el siguiente ejemplo:

SELECCIONAR Vendedor, AVG(VentaTotal)

DE VENTAS
GRUPO POR Vendedor
ORDEN POR AVG(VentaTotal) DESC
BUSCA SÓLO LAS PRIMERAS FILAS DEL 10 POR CIENTO;

Es concebible que pueda haber un problema con los empates cuando se trata de
porcentajes, tal como ocurre con un simple número de registros, por lo que elCON LAZOSLa
sintaxis también se puede utilizar aquí. Puedes incluir ataduras o no, dependiendo de lo que
quieras en cada situación en particular.

En segundo lugar, supongamos que no quiere los tres primeros o el diez por ciento
superior, sino el segundo tres o el segundo diez por ciento. Quizás desee saltar
directamente a algún punto profundo del conjunto de resultados. SQL:2011 también
cubre esta situación. El código sería similar a este:

SELECCIONAR Vendedor, AVG(VentaTotal)

DE VENTAS
GRUPO POR Vendedor
ORDEN POR AVG(VentaTotal) DESC
DESPLAZAMIENTO 3 FILAS
BUSCA SÓLO LAS SIGUIENTES 3 FILAS;

ElCOMPENSARLa palabra clave indica cuántas filas se deben omitir antes de recuperarlas. La
palabra clave NEXT especifica que las filas que se recuperarán son las que siguen
inmediatamente al desplazamiento. Ahora los vendedores con el cuarto, quinto y sexto
238 Parte III: Almacenamiento y recuperación de datos

Se devuelve el total de venta promedio más alto. Como puedes ver, sin elCON
LAZOSsintaxis, todavía existe un problema de indeterminación. Si el tercer, cuarto y
quinto vendedor están empatados, es indeterminado cuáles dos se incluirán en
este segundo lote y cuál habrá sido incluido en el primer lote.

Quizás sea mejor evitar el uso de la capacidad FETCH limitada. Es muy probable que
produzca resultados engañosos.

Mirando a través de una ventana para

crear un conjunto de resultados
Windows y las funciones de ventana se introdujeron por primera vez en SQL:1999. Con una ventana,
un usuario puede opcionalmente dividir un conjunto de datos, ordenar opcionalmente las filas en
cada partición y especificar una colección de filas (el marco de la ventana) que está asociada con una
fila determinada.

El marco de ventana de una fila R es un subconjunto de la partición que contiene R.

Por ejemplo, el marco de ventana puede constar de todas las filas desde el comienzo
de la partición hasta R inclusive, según la forma en que se ordenan las filas en la
partición. .

Una función de ventana calcula un valor para una fila R, basándose en las filas en el marco
de la ventana de R.

Por ejemplo, suponga que tiene una tabla VENTAS que tiene las columnas CustID,
InvoiceNo y TotalSale. Es posible que su gerente de ventas quiera saber cuáles fueron
las ventas totales a cada cliente en un rango específico de números de factura. Puede
obtener lo que quiere con el siguiente código SQL:

SELECCIONE ID de cliente, Número de factura,

SUMA (VentaTotal) SOBRE
( PARTICIÓN POR CustID
ORDEN POR FacturaNo
FILAS ENTRE
ANTECEDENTES ILIMITADOS
Y FILA ACTUAL)
DE VENTAS;

ElENCIMALa cláusula determina cómo se dividen las filas de la consulta antes de ser
procesadas, en este caso por elSUMAfunción. Se asigna una partición a cada cliente.
Dentro de cada partición habrá una lista de números de factura, y asociado a cada
uno de ellos estará la suma de todos losVenta total valores en el rango especificado
de filas, para cada cliente.

SQL:2011 ha agregado varias mejoras importantes a la funcionalidad de la ventana

original, incorporando nuevas palabras clave.
 Capítulo 10: Centrándose en los datos que desea 239

Dividir una ventana en

cubos con NTILE
ElNTILELa función de ventana distribuye una partición de ventana ordenada en algún
número entero positivonortede cubos, numerando los cubos del 1 alnorte. Si el número
de filas en una particiónmetrono es divisible pornorte, luego, después de que la función
NTILE llene los cubos de manera uniforme, el resto deMinnesota, llamador, se reparte
entre el primerorcubos, haciéndolos más grandes que los otros cubos.

Suponga que desea clasificar a sus empleados por salario, dividiéndolos en

cinco grupos, de mayor a menor. Puedes hacerlo con el siguiente código:

SELECCIONE Nombre, Apellido, NTILE (5)

SOBRE (ORDENAR POR Salario DESC)
COMO CUBO
DE Empleado;

Si hay, por ejemplo, 11 empleados, cada cubo se llena con dos excepto el
primer cubo, que se llena con tres. El primer grupo contendrá a los tres
empleados mejor pagados y el quinto grupo contendrá a los dos empleados
peor pagados.

Navegando dentro de una ventana

En SQL:2011 se agregaron cinco funciones de ventana que evalúan una expresión en una fila
R2 que se encuentra en algún lugar del marco de la ventana de la fila actual R1. Las
funciones sonRETRASO, AVANZAMIENTO, NTH_VALUE, FIRST_VALUE,yLAST_VALUE.

Estas funciones le permiten extraer información de filas específicas que se encuentran

dentro del marco de la ventana de la fila actual.

Mirando hacia atrás con la función LAG

ElRETRASOLa función le permite recuperar información de la fila actual en la
ventana que está examinando, así como información de otra fila que
especifique y que preceda a la fila actual.

Supongamos, por ejemplo, que tiene una tabla que registra las ventas totales de cada
día del año actual. Una cosa que quizás quieras saber es cómo se comparan las ventas
de hoy con las de ayer. Podrías hacer esto con elRETRASOfunción, de la siguiente
manera:

SELECCIONE TotalSale COMO TodaySale,

LAG (VentaTotal) OVER
(ORDENAR POR Fecha de venta) COMO DíaPrevSale
DESDE TotalesDiarios;
240 Parte III: Almacenamiento y recuperación de datos

Para cada fila enTotales diarios,esta consulta devolvería una fila que enumera la cifra de ventas
totales de esa fila y la cifra de ventas totales del día anterior. El desplazamiento predeterminado es 1,
por lo que se devuelve el resultado del día anterior en lugar de cualquier otro.

Para comparar las ventas del día actual con las de la semana anterior, puede utilizar lo
siguiente:

SELECCIONE TotalSale COMO TodaySale,

LAG (TotalSale, 7) OVER (ORDER BY SaleDate)
COMO PrevDaySale
DESDE TotalesDiarios;

Las primeras siete filas en el marco de una ventana no tendrán un predecesor que sea una
semana mayor. La respuesta predeterminada a esta situación es devolver un resultado nulo
[Link] prefiere algún otro resultado a un resultado nulo, por ejemplo cero,
puede especificar lo que desea que se devuelva en esta situación en lugar del valor nulo
predeterminado, por ejemplo, 0 (cero), como se muestra aquí:

SELECCIONE TotalSale COMO TodaySale,

LAG (TotalSale, 7, 0) OVER (ORDER BY
SaleDate) COMO PrevDaySale
DESDE TotalesDiarios;

El comportamiento predeterminado es contar las filas que tienen un grado de retraso,

que en este caso esVenta total,que contiene un valor nulo. Si desea omitir dichas filas y
contar solo las filas que tienen un valor real en la extensión del retraso, puede hacerlo
agregando las palabras claveIGNORAR NULLScomo se muestra en la siguiente variante
del ejemplo:

SELECCIONE TotalSale COMO TodaySale,

LAG (TotalSale, 7, 0) IGNORAR NULLS OVER (ORDER
BY SaleDate) COMO PrevDaySale
DESDE TotalesDiarios;

Mirando hacia el futuro con la función LEAD

ElDIRIGIRLa función de ventana funciona exactamente de la misma manera que laRETRASOLa función
funciona excepto que, en lugar de mirar hacia atrás a una fila anterior, mira hacia adelante a una fila
que sigue a la fila actual en el marco de la ventana. Un ejemplo podría ser:

SELECCIONE TotalSale COMO TodaySale,

PLOMO (TotalSale, 7, 0) IGNORAR NULLS SOBRE
(ORDENAR POR FechaDeVenta) COMO NextDaySale
DESDE TotalesDiarios;

Buscando una fila específica con la función NTH_VALUE

ElNTH_VALUEfunción es similar a laRETRASOyDIRIGIRfunciones, excepto que en lugar
de evaluar una expresión en una fila que precede o sigue a la fila actual, evalúa una
expresión en una fila que está en un desplazamiento específico desde la primera o la
última fila en el marco de la ventana.
 Capítulo 10: Centrándose en los datos que desea 241
He aquí un ejemplo:

SELECCIONE TotalSale COMO ChosenSale,

NTH_VALUE (VentaTotal, 2)
DESDE PRIMERO
IGNORAR NULLS
TERMINADO (ORDENAR POR Fecha de venta)
FILAS ENTRE 10 ANTERIORES Y 10 SIGUIENTES )
AS Venta anterior
DESDE TotalesDiarios;

En este ejemplo,Venta anteriorse evalúa de la siguiente manera:

✓ Se forma el marco de ventana asociado con la fila actual. Incluye las diez
filas anteriores y las diez siguientes.
✓ Venta totalse evalúa en cada fila del marco de la ventana.
✓ IGNORAR NULLSse especifica, por lo que cualquier fila que contenga un valor nulo
para Venta totalse omiten.

✓ A partir del primer valor restante después de la exclusión de las filas que
contienen un valor nulo para TotalSale, avance dos filas (adelante porque
DESDE PRIMEROfue especificado).

El valor deVenta anteriores el valor deVenta totalde la fila especificada.

Si no desea omitir filas que tienen un valor nulo paraVenta total,especificar RESPETO
NULOSen vez deIGNORAR NULLS.ElNTH_VALUELa función funciona de manera similar si
especificaDESDE LA ULTIMAen lugar deDESDE PRIMERO,excepto que en lugar de contar
hacia adelante desde el primer registro en el marco de la ventana, se cuenta hacia atrás
desde el último registro en el marco de la ventana. El número que especifica el número
de filas a contar sigue siendo positivo, aunque esté contando hacia atrás en lugar de
hacia adelante.

Buscando un valor muy específico con FIRST_VALUE y LAST_VALUE

ElFIRST_VALUEyLAST_VALUELas funciones son casos especiales de la NTH_VALUE
función.FIRST_VALUEes equivalente aNTH_VALUEdóndeDESDE PRIMEROse
especifica y el desplazamiento es 0 (cero).LAST_VALUEes equivalente a NTH_VALUE
dóndeDESDE LA ULTIMAse especifica y el desplazamiento es 0. Con ambos, puede
elegir ignorar o respetar los valores nulos.

Funciones de ventana anidada

A veces, para obtener el resultado que necesita, la forma más sencilla es anidar una función
dentro de otra. SQL:2011 agregó la capacidad de realizar dicho anidamiento con funciones
de ventana.
242 Parte III: Almacenamiento y recuperación de datos

Como ejemplo, consideremos un caso en el que un inversor en acciones intenta determinar si

es un buen momento para comprar una acción en particular. Para entender esto, decide
comparar el precio actual de las acciones con el precio al que se vendieron en las 100
operaciones inmediatamente anteriores. Se pregunta cuántas veces en las 100 operaciones
anteriores se vendió por menos del precio actual. Para llegar a una respuesta, hace la siguiente
consulta:

SELECCIONE Hora de venta,

SUMA ( CASO CUANDO Precio de venta < VALOR DE
(Precio de venta EN LA FILA ACTUAL)
ENTONCES 1 MÁS 0 )
TERMINADO (ORDENAR POR SaleTime
FILAS ENTRE 100 FILA ANTERIOR Y ACTUAL)
DE StockSales;

La ventana abarca las 100 filas que preceden a la fila actual, que corresponden
a las 100 ventas inmediatamente anteriores al momento actual. Cada vez que
se evalúa una fila donde el valor dePrecio de ventaes menor que el precio más
reciente, se suma 1 a la suma. El resultado final es un número que indica el
número de ventas de las cien anteriores que se realizaron a un precio inferior
al precio actual.

Evaluación de grupos de filas

A veces, la clave de clasificación que ha elegido para colocar una partición en orden tendrá
duplicados. Es posible que desee evaluar todas las filas que tienen la misma clave de
clasificación como grupo. En tales casos puede utilizar elGRUPOSopción. Con él puedes contar
grupos de filas donde las claves de clasificación son idénticas.

He aquí un ejemplo:

SELECCIONE ID de cliente, Fecha de venta,

SUMA (TotalFactura) SOBRE
( PARTICIÓN POR ID de cliente
ORDENAR POR Fecha de venta
GRUPOS ENTRE 2 ANTERIORES Y 2 SIGUIENTES )
DE Clientes;

El marco de la ventana en este ejemplo consta de hasta cinco grupos de filas:

dos grupos antes del grupo que contiene la fila actual, el grupo que contiene la
fila actual y dos grupos después del grupo que contiene la fila actual. Las filas
de cada grupo tienen el mismoFecha de venta,y elFecha de ventaasociado con
cada grupo es diferente delFecha de ventavalores para los otros grupos.
 Capítulo 11

Usando operadores relacionales

En este capítulo
▶ Combinando tablas con estructuras similares
▶ Combinando mesas con diferentes estructuras.
▶ Derivar datos significativos de múltiples tablas

Y Probablemente ya sepa que SQL es un lenguaje de consulta para bases de datos

relacionales. En capítulos anteriores, presento bases de datos simples y, en la mayoría
de los casos, mis ejemplos tratan solo de una tabla. En este capítulo pongo el relacionalen
“base de datos relacional”. Después de todo, el nombre significa "una base de datos que
consta de varias tablas relacionadas". Aquí es donde se analizan esas relaciones.

Debido a que los datos de una base de datos relacional se distribuyen en varias tablas,
una consulta normalmente extrae datos de más de una tabla. SQL tiene operadores que
combinan datos de múltiples fuentes en una única tabla de resultados. Estos son los
UNIÓN, INTERSECCIÓN,yEXCEPTOoperadores, así como una familia de UNIRSE
operadores. Cada operador combina datos de varias tablas de forma diferente.

UNIÓN
ElUNIÓNoperador es la implementación SQL del operador de unión del álgebra
relacional. ElUNIÓNEl operador le permite extraer información de dos o más
tablas que tienen la misma [Link] estructuramedio

✓ Todas las tablas deben tener el mismo número de columnas.

✓ Todas las columnas correspondientes deben tener tipos de datos y longitudes idénticos.

Cuando se cumplen estos criterios, las tablas secompatible con la unión:La unión de las dos
tablas devuelve todas las filas que aparecen en cualquiera de las tablas y elimina duplicados.
244 Parte III: Almacenamiento y recuperación de datos

Supongamos que crea una base de datos de estadísticas de béisbol (como la del Capítulo 12).
Contiene dos tablas compatibles con sindicatos denominadas AMERICAN y NATIONAL.
Ambas tablas tienen tres columnas y las columnas correspondientes son todas del mismo
tipo. De hecho, las columnas correspondientes tienen nombres de columna idénticos
(aunque esta condición no es necesaria para la compatibilidad de la unión).

NACIONAL enumera los nombres de los jugadores y la cantidad de juegos completos lanzados
por los lanzadores de la Liga Nacional. AMERICAN enumera la misma información sobre los
lanzadores de la Liga Americana. ElUNIÓNde las dos tablas le brinda una tabla de resultados
virtual que contiene todas las filas de la primera tabla más todas las filas de la segunda tabla.
Para este ejemplo, puse sólo unas pocas filas en cada tabla para ilustrar la operación:

SELECCIONAR * DE NACIONAL ;
Nombre de pila Apellido Juegos Completos
--------- -------- -------------
Sal maglia 11
Don Newcombe 9
Arenoso Koufax 13
Don Drysdale 12

SELECCIONAR * DE AMERICANO ;

Nombre de pila Apellido Juegos Completos

--------- -------- -------------
Blanquito Vado 12
Don larson 10
Beto Turley 8
allie reynolds 14

SELECCIONAR * DE UNIÓN
NACIONAL
SELECCIONAR * DE AMERICANO ;

Nombre de pila Apellido Juegos Completos

--------- -------- -------------
Allie reynolds 14
Beto Turley 8
Don Drysdale 12
Don larson 10
Don Newcombe 9
Sal maglia 11
Arenoso Koufax 13
Persona blanca Vado 12

ElUNIÓN DISTINTAEl operador funciona de forma idéntica alUNIÓNoperador sin el

DISTINTOpalabra clave. En ambos casos, las filas duplicadas se eliminan del
conjunto de resultados.
 Capítulo 11: Uso de operadores relacionales 245
He estado usando el asterisco (*) como abreviatura de todas las columnas de una tabla. Este
atajo está bien la mayor parte del tiempo, pero puede causarle problemas cuando usa
operadores relacionales en SQL incorporado o en lenguaje modular. Si agrega una o más
columnas nuevas a una tabla y no a otra, o agrega columnas diferentes a las dos tablas, las dos
tablas ya no son compatibles con la unión y su programa no será válido la próxima vez que se
vuelva a compilar. Incluso si se agregan las mismas columnas nuevas a ambas tablas para que
sigan siendo compatibles con la unión, su programa probablemente no esté preparado para
manejar los datos adicionales. Debe enumerar explícitamente las columnas que desea, en
lugar de confiar en la taquigrafía *. Cuando ingresa consultas SQL ad hoc desde la consola, el
asterisco probablemente funcione bien, porque puede mostrar rápidamente una estructura de
tabla para verificar la compatibilidad de la unión si su consulta no tiene éxito.

La operación UNION TODOS

Como mencioné anteriormente, elUNIÓNLa operación generalmente elimina cualquier fila
duplicada que resulte de su operación, que es el resultado deseado la mayor parte del tiempo.
A veces, sin embargo, es posible que desee conservar filas duplicadas. En esas ocasiones,
utiliceUNIÓN TODOS.

Refiriéndose al ejemplo, supongamos que “Bullet” Bob Turley hubiera sido canjeado a
mitad de temporada de los Yankees de Nueva York en la Liga Americana a los Dodgers
de Brooklyn en la Liga Nacional. Ahora supongamos que durante la temporada lanzó
ocho juegos completos para cada equipo. Lo ordinario UNIÓNque se muestra en el
ejemplo descarta una de las dos líneas que contienen los datos de Turley. Aunque
pareció lanzar sólo 8 juegos completos en la temporada, en realidad lanzó la notable
cantidad de 16 juegos completos. La siguiente consulta le proporciona los hechos
reales:

SELECCIONAR * DE NACIONAL
UNIÓN TODOS
SELECCIONAR * DE AMERICANO ;

A veces puedes formar unUNIÓNde dos tablas incluso si no son compatibles con la
unión. Si las columnas que desea en su tabla de resultados están presentesy
compatiblesEn ambas tablas, puedes realizar unaUNIÓN CORRESPONDIENTEoperación.
Solo se consideran las columnas especificadas y son las únicas columnas que se
muestran en la tabla de resultados.

La operación CORRESPONDIENTE
Los estadísticos del béisbol mantienen estadísticas diferentes sobre los lanzadores que
sobre los jardineros. En ambos casos, nombres, apellidos, publicaciones, errores y
246 Parte III: Almacenamiento y recuperación de datos

Se registran los porcentajes de fildeo. Los jardineros, por supuesto, no tienen un récord de
victorias o derrotas, un récord de salvamentos ni otras estadísticas que se refieren únicamente
al lanzamiento. Todavía puedes realizar unUNIÓNque toma datos de la tabla OUTFIELDER y de
la tabla LANZADOR para brindarle información general sobre la habilidad defensiva:

SELECCIONAR *
DEL JARDINERO
UNIÓN CORRESPONDIENTE
(Nombre, Apellido, Salidas, Errores, Porcentaje de campo)
SELECCIONAR *
DEL LANZADOR ;

La tabla de resultados contiene los nombres y apellidos de todos los jardineros y

lanzadores, junto con los outs, errores y porcentaje de fildeo de cada jugador.
Al igual que con los simplesUNIÓN,Se eliminan los duplicados. Así, si un jugador pasó
algún tiempo en los jardines y también lanzó en uno o más juegos, elUNIÓN
CORRESPONDIENTELa operación pierde algunas de sus estadísticas. Para evitar este
problema, utiliceUNIÓN TODO CORRESPONDIENTE.

Cada nombre de columna en la lista que sigue alCORRESPONDIENTELa palabra clave debe ser
un nombre que exista en ambas tablas unidas. Si omite esta lista de nombres, se utiliza una
lista implícita de todos los nombres que aparecen en ambas tablas. Pero esta lista implícita de
nombres puede cambiar cuando se agregan nuevas columnas a una o ambas tablas. Por lo
tanto, es mejor enumerar explícitamente los nombres de las columnas que si los omite.

INTERSECARSE
ElUNIÓNLa operación produce una tabla de resultados que contiene todas las filas que
aparecen encualquierde las tablas fuente. Si desea solo filas que aparecen entodolas
tablas fuente, puede utilizar elINTERSECARSEoperación, que es la implementación SQL de
la operación de intersección del álgebra relacional. yo ilustroINTERSECARSE regresando al
mundo de fantasía en el que Bob Turley fue traspasado a los Dodgers a mitad de
temporada:

SELECCIONAR * DE NACIONAL;
Nombre de pila Apellido Juegos Completos
--------- -------- -------------
Sal maglia 11
Don Newcombe 9
Arenoso Koufax 13
Don Drysdale 12
Beto Turley 8
 Capítulo 11: Uso de operadores relacionales 247

SELECCIONE * DE AMERICANO;
NOMBRE DE PILA APELLIDO JUEGOS_COMPLETOS
---------- --------- --------------
Persona blanca Vado 12
Don larson 10
Beto Turley 8
allie reynolds 14

Sólo las filas que aparecen en todas las tablas de origen aparecen en elINTERSECARSEtabla de
resultados de la operación:

SELECCIONAR *
DE NACIONAL
INTERSECARSE
SELECCIONAR *
DE AMERICANO;

Nombre de pila Apellido Juegos Completos

--------- -------- -------------
Beto Turley 8

La tabla de resultados le dice que Bob Turley fue el único lanzador que lanzó la misma
cantidad de juegos completos en ambas ligas (una distinción bastante oscura para el
viejo Bullet Bob).Nota:Como fue el caso deUNIÓN, INTERSECCIÓN DISTINTAproduce el
mismo resultado que elINTERSECARSEOperador utilizado solo. En este ejemplo, sólo una
de las filas idénticas que presentaBob Turleyes regresado.

ElTODOyCORRESPONDIENTELas palabras clave funcionan en unaINTERSECARSEfuncionamiento de la

misma manera que lo hacen en unUNIÓNoperación. Si utilizaTODO,los duplicados se conservan en la
tabla de resultados. Si utilizaCORRESPONDIENTE,No es necesario que las tablas intersecadas sean
compatibles con uniones, aunque las columnas correspondientes deben tener tipos y longitudes
coincidentes.

Esto es lo que obtienes conINTERSECCIONAR TODOS:

SELECCIONAR *
DE NACIONAL
INTERSECTAR TODOS
SELECCIONAR *
DE AMERICANO;

Nombre de pila Apellido Juegos Completos

--------- -------- -------------
Beto Turley 8
Beto Turley 8

Consideremos otro ejemplo: un municipio realiza un seguimiento de los teléfonos móviles que llevan
los agentes de policía, los bomberos, los barrenderos y otros empleados de la ciudad. Una tabla de
base de datos llamada PHONES contiene datos de todos los teléfonos activos.
248 Parte III: Almacenamiento y recuperación de datos

usar. Otra tabla denominada OUT, con idéntica estructura, contiene datos de todos los
teléfonos que han sido puestos fuera de servicio. Nunca deberían existir teléfonos en
ambas tablas. Con unINTERSECARSEoperación, puede probar para ver si se ha
producido una duplicación no deseada:

SELECCIONAR *
DESDE TELÉFONOS
INTERSECCIÓN CORRESPONDIENTE (PhoneID)
SELECCIONAR *
DESDE FUERA ;

Si esta operación le proporciona una tabla de resultados que contiene alguna fila, sabrá que
tiene un problema. Deberías investigar cualquierID de teléfonoentradas que aparecen en la
tabla de resultados. El teléfono correspondiente está activo o fuera de servicio; no pueden ser
ambas cosas. Después de detectar el problema, puede realizar unaBORRAR operación en una
de las dos tablas para restaurar la integridad de la base de datos.

EXCEPTO
ElUNIÓNLa operación actúa sobre dos tablas de origen y devuelve todas las filas que
aparecen en cualquiera de las tablas. ElINTERSECARSELa operación devuelve todas las filas
que aparecen tanto en la primera como en la segunda tabla. En contraste, elEXCEPTO (o
EXCEPTO DISTINTO)La operación devuelve todas las filas que aparecen en la primera tabla
pero quenoTambién aparecen en la segunda tabla.

Volviendo al ejemplo de la base de datos de teléfonos municipales (consulte la sección

“INTERSECT”, anteriormente en este capítulo), digamos que un grupo de teléfonos que
habían sido declarados fuera de servicio y devueltos al proveedor para su reparación
ahora han sido reparados y puestos nuevamente en servicio. . La tabla PHONES se
actualizó para reflejar los teléfonos devueltos, pero los teléfonos devueltos no se
eliminaron de la tabla OUT como deberían haber sido. Puedes mostrar elID de teléfono
números de los teléfonos en la tabla OUT, eliminando los reactivados, utilizando un
EXCEPTOoperación:

SELECCIONAR *
DESDE FUERA
EXCEPTO CORRESPONDIENTE (PhoneID)
SELECCIONAR *
DESDE TELÉFONOS;

Esta consulta devuelve todas las filas de la tabla OUT cuyasID de teléfonotampoco está
presente en la tabla PHONES.
 Capítulo 11: Uso de operadores relacionales 249

Únase a los operadores

ElUNIÓN, INTERSECCIÓN,yEXCEPTOLos operadores son valiosos en bases de datos de
varias tablas que contienen tablas compatibles con uniones. Sin embargo, en muchos
casos querrás extraer datos de varias tablas que tienen muy poco en común. Las uniones
son poderosos operadores relacionales que combinan datos de varias tablas en una
única tabla de resultados. Las tablas fuente pueden tener poco (o incluso nada) en
común entre sí.

SQL admite varios tipos de combinaciones. El mejor para elegir en una situación
determinada depende del resultado que intentas lograr. Las siguientes secciones
le brindan los detalles.

Unión básica
Cualquier consulta de varias tablas es un tipo de unión. Las tablas de origen están unidas en
el sentido de que la tabla de resultados incluye información extraída de todas las tablas de
origen. La unión más simple es una de dos [Link] no tieneDÓNDE
Calificadores de cláusula: cada fila de la primera tabla se une a cada fila de la segunda tabla.
La tabla de resultados es el producto cartesiano de las dos tablas fuente. El número de filas de
la tabla de resultados es igual al número de filas de la primera tabla de origen multiplicado
por el número de filas de la segunda tabla de origen.

Por ejemplo, imagina que eres el director de personal de una empresa y que parte de tu
trabajo es mantener los registros de los empleados. La mayoría de los datos de los empleados,
como la dirección particular y el número de teléfono, no son particularmente confidenciales.
Pero algunos datos, como el salario actual, deberían estar disponibles sólo para el personal
autorizado. Para mantener la seguridad de la información confidencial, manténgala en una
tabla separada protegida con contraseña. Considere el siguiente par de tablas:

EMPLEADO COMPENSACIÓN
-------- ------------
EmpID Emplear
FNombre Salario
LNombre Prima
Ciudad
Teléfono

Complete las tablas con algunos datos de muestra:

EmpID FNombre LNombre Ciudad Teléfono

----- ----- ----- ---- -----
1 Persona blanca Vado Naranja 555-1001
2 Don larson Nueva York 555-3221
250 Parte III: Almacenamiento y recuperación de datos

3 Sal maglia Nutley 555-6905

4 Beto Turley Passaico 555-8908

Emplear Salario Prima

------ ------ -----
1 33000 10000
2 18000 2000
3 24000 5000
4 22000 7000

Cree una tabla de resultados virtual con la siguiente consulta:

SELECCIONAR *
DEL EMPLEADO, COMPENSACIÓN ;

Esto es lo que produce la consulta:

EmpID FNombre LNombre Ciudad Teléfono Bonificación salarial por empleo

- - - - - - - - - - 1 Ford
----- ---- ----- -----------------1
blanquito Naranja 555-1001 33000 10000
1 Ford blanquito Naranja 555-1001 2 18000 2000
1 Ford blanquito Naranja 555-1001 3 24000 5000
1 Ford blanquito Naranja 555-1001 4 22000 7000
2 Don Larson Newark 555-3221 1 33000 10000
2 Don Larson Newark 555-3221 2 18000 2000
2 Don Larson Newark 555-3221 3 24000 5000
2 Don Larson Newark 555-3221 4 22000 7000
3 sal Maglie Nutley 555-6905 1 33000 10000
3 sal Maglie Nutley 555-6905 2 18000 2000
3 sal Maglie Nutley 555-6905 3 24000 5000
3 sal Maglie Nutley 555-6905 4 22000 7000
4 Bob Turley Passaic 555-8908 Turley 1 33000 10000
4 Bob Passaic 555-8908 Turley 2 18000 2000
4 Bob Passaic 555-8908 3 24000 5000
4 Bob Turley Passaic 555-8908 4 22000 7000

La tabla de resultados, que es el producto cartesiano de las tablas EMPLEADO

y COMPENSACIÓN, contiene una redundancia considerable. Además, no tiene
mucho sentido. Combina cada fila de EMPLEADO con cada fila de
COMPENSACIÓN. Las únicas filas que transmiten información significativa
son aquellas en las queEmpIDEl número que vino del EMPLEADO coincide con
elEmplearnúmero que vino de COMPENSACIÓN. En esas filas, el nombre y la
dirección de un empleado están asociados con su compensación.

Cuando se intenta obtener información útil de una base de datos de varias tablas, el
producto cartesiano producido por una unión básica es casinuncalo que quieres,
pero ya casisiempreel primer paso hacia lo que quieres. Aplicando restricciones a la
UNIRSEcon unDÓNDEcláusula, puede filtrar las filas no deseadas. La siguiente
sección explica cómo filtrar las cosas que no necesita ver.
 Capítulo 11: Uso de operadores relacionales 251

unión equivalente

La unión más común que utiliza elDÓNDEEl filtro de cláusula es el equi-join. Un unión equies
una unión básica con unDÓNDEcláusula que contiene una condición que especifica que el valor
de una columna de la primera tabla debe ser igual al valor de la columna correspondiente de la
segunda tabla. La aplicación de una combinación equivalente a las tablas de ejemplo de la
sección anterior produce un resultado más significativo:

SELECCIONAR *
DEL EMPLEADO, COMPENSACIÓN
DONDE [Link] = COMPENSACIÓ[Link];

Esta consulta produce los siguientes resultados:

EmpID FNombre LNombre Ciudad Teléfono Bonificación salarial por empleo

---------------- ---- ----- -----------------
1 Ford blanquito Naranja 555-1001 1 33000 10000
2 Don Larson Newark 555-3221 2 18000 2000
3 sal Maglie Nutley 555-6905 3 24000 5000
4 Bob Turley Passaic 555-8908 4 22000 7000

En esta tabla de resultados, los salarios y bonificaciones de la derecha se aplican a los

empleados nombrados a la izquierda. La tabla todavía tiene cierta redundancia porque el
EmpIDLa columna duplica laEmplearcolumna. Puede solucionar este problema
reformulando ligeramente la consulta, así:

SELECCIONAR EMPLEADO.*,COMPENSACIÓ[Link],COMPENSACIÓ[Link]ón
DEL EMPLEADO, COMPENSACIÓN
DONDE [Link] = COMPENSACIÓ[Link];

Esta consulta produce la siguiente tabla de resultados:

EmpID FNombre LNombre Ciudad Teléfono Salario Prima

---------- ----- ---- ----- ------ -----
1 Ford blanquito Naranja 555-1001 33000 10000
2 Don Larson Newark 555-3221 18000 2000
3 sal Maglie Nutley 555-6905 24000 5000
4 Bob Turley Passaic 555-8908 22000 7000

Esta tabla le dice lo que quiere saber pero no lo sobrecarga con datos superfluos. Sin embargo,
la consulta es algo tediosa de escribir. Para evitar ambigüedades, puede calificar los nombres
de las columnas con los nombres de las tablas de donde provienen. Escribir los nombres de las
tablas repetidamente proporciona un buen ejercicio para los dedos, pero no tiene ningún otro
beneficio.
252 Parte III: Almacenamiento y recuperación de datos

Puede reducir la cantidad de escritura utilizando alias (onombres de correlación). Un

aliases un nombre corto que representa el nombre de una tabla. Si utiliza alias al
reformular la consulta anterior, el resultado será el siguiente:

SELECCIONE E.*, [Link], [Link]ón

DEL EMPLEADO E, COMPENSACIÓN C
DONDE [Link] = [Link];

En este ejemplo, E es el alias de EMPLEADO y C es el alias de COMPENSACIÓN. El alias es

local de la declaración en la que se encuentra. Después de declarar un alias (en elDE
cláusula), debe utilizarla en toda la declaración. No puede utilizar tanto el alias como la
forma larga del nombre de la tabla en la misma declaración.

Incluso si pudiera mezclar la forma larga de los nombres de las tablas con alias, no
querría hacerlo, porque hacerlo crea una gran confusión. Considere el siguiente
ejemplo:

SELECCIONAR T1.C, T2.C

DESDE T1 T2, T2 T1
DONDE T1.C> T2.C;

En este ejemplo, el alias de T1 es T2 y el alias de T2 es T1. Es cierto que esta no es

una selección inteligente de alias, pero las reglas no lo prohíben. Si mezcla alias con
nombres de tablas de formato largo, no podrá distinguir cuál tabla es cuál.

El ejemplo anterior con alias es equivalente al siguienteSELECCIONAR

declaración sin alias:

SELECCIONAR T2.C, T1.C

DESDE T1 , T2
DONDE T2.C> T1.C;

SQL le permite unir más de dos tablas. El número máximo varía de una
implementación a otra. La sintaxis es análoga al caso de dos tablas; así es
como se ve:

SELECCIONE E.*, [Link], [Link]ón, [Link]

DEL EMPLEADO E, COMPENSACIÓN C, YTD_SALES Y WHERE
[Link] = [Link]
AND [Link] = [Link];

Esta declaración realiza una combinación equivalente en tres tablas, extrayendo datos de las filas
correspondientes de cada una para producir una tabla de resultados que muestra los nombres de
los vendedores, la cantidad de ventas de las que son responsables y su compensación. El director de
ventas puede comprobar rápidamente si la remuneración está en consonancia con la producción.
 Capítulo 11: Uso de operadores relacionales 253
Almacenar las ventas del año hasta la fecha de un vendedor en una tabla YTD_SALES separada
garantiza un mejor rendimiento de la computadora y confiabilidad de los datos que mantener esos
datos en la tabla EMPLOYEE. Los datos de la tabla EMPLEADO son relativamente estáticos. El nombre,
la dirección y el número de teléfono de una persona no cambian con mucha frecuencia. Por el
contrario, las ventas del año hasta la fecha cambian con frecuencia (eso espera). Debido a que la tabla
YTD_SALES tiene menos columnas que la tabla EMPLOYEE, es posible que pueda actualizarla más
rápidamente. Si, durante la actualización de los totales de ventas, no toca la tabla EMPLEADO,
disminuye el riesgo de modificar accidentalmente la información del empleado que debería
permanecer igual.

unión cruzada
UNIÓN CRUZADAes la palabra clave para la unión básica sinDÓNDEcláusula. Por
lo tanto

SELECCIONAR *
DEL EMPLEADO, COMPENSACIÓN ;

también se puede escribir como

SELECCIONAR *
DE LA COMPENSACIÓN CRUZADA DE EMPLEADOS;

El resultado es el producto cartesiano (también llamadoproducto cruzado) de las dos tablas

[Link]ÓN CRUZADArara vez le brinda el resultado final que desea, pero puede ser útil
como primer paso en una cadena de operaciones de manipulación de datos que finalmente
producen el resultado deseado.

unión natural
Elunión naturales un caso especial de unión equi. En elDÓNDEcláusula de una unión equi,
una columna de una tabla fuente se compara con una columna de una segunda tabla
fuente para determinar la igualdad. Las dos columnas deben ser del mismo tipo y longitud
y deben tener el mismo nombre. De hecho, en una unión natural, todas las columnas de
una tabla que tienen los mismos nombres, tipos y longitudes que las columnas
correspondientes de la segunda tabla se comparan para comprobar su igualdad.

Imagine que la tabla COMPENSACIÓN del ejemplo anterior tiene columnas

empid, salario,yPrimaen vez deempleo, salario,yPrima. En ese caso, puede
realizar una unión natural de la tabla COMPENSACIÓN con la tabla EMPLEADO.
Lo tradicionalUNIRSEla sintaxis se vería así:

SELECCIONE E.*, [Link], [Link]ón

DEL EMPLEADO E, COMPENSACIÓN C
DONDE [Link] = [Link];
254 Parte III: Almacenamiento y recuperación de datos

Esta consulta es un caso especial de unión natural. ElSELECCIONARLa declaración

devolverá filas unidas [Link] = [Link] lo siguiente:

SELECCIONE E.*, [Link], [Link]ón

DEL EMPLEADO E COMPENSACIÓN NATURAL DE UNIÓN C ;

Esta consulta unirá filas [Link] = [Link],dó[Link] = [Link],y

dondeBonificación E = Bonificación [Link] tabla de resultados contendrá sólo filas
dondetodoLas columnas correspondientes coinciden. En este ejemplo, los
resultados de ambas consultas serán los mismos porque la tabla EMPLEADO no
contiene ni unSalarioo unPrimacolumna.

Unión condición
Acondición unirsees como una unión equi, excepto que la condición que se está
probando no tiene que ser una igualdad (aunque puede serlo). Puede ser cualquier
predicado bien formado. Si se cumple la condición, la fila correspondiente pasa a formar
parte de la tabla de resultados. La sintaxis es un poco diferente de lo que ha visto hasta
ahora: la condición está contenida en unENcláusula en lugar de en unaDÓNDEcláusula.

Digamos que un estadístico del béisbol quiere saber qué lanzadores de la Liga Nacional han
lanzado la misma cantidad de juegos completos que uno o más lanzadores de la Liga
Americana. Esta pregunta es un trabajo para una equi-join, que también se puede expresar con
la sintaxis de condición-join:

SELECCIONAR *
DE NACIONAL ÚNETE A AMERICANO
EN [Link] = [Link];

Unión de nombre de columna

Elunión de nombre de columnaEs como una unión natural, pero es más flexible. En una combinación
natural, todas las columnas de la tabla de origen que tienen el mismo nombre se comparan entre sí
para determinar la igualdad. Con la combinación de nombre de columna, usted selecciona qué
columnas del mismo nombre comparar. Puede elegirlos todos si lo desea, haciendo que la unión del
nombre de la columna (efectivamente) sea una unión natural. O puede elegir menos de todas las
columnas del mismo nombre. De esta manera, tiene un alto grado de control sobre qué filas de
productos cruzados califican para ser colocadas en su tabla de resultados.

Supongamos que es un fabricante de juegos de ajedrez y tiene una tabla de inventario que realiza
un seguimiento de sus existencias de piezas blancas y otra que realiza un seguimiento de las piezas
negras. Las tablas contienen datos como sigue:
 Capítulo 11: Uso de operadores relacionales 255

BLANCO NEGRO
----- -----
Pieza Quant Madera Pedazo Madera cuantitativa
-------------- ----- ---------
Rey 502 Roble Rey 502 ébano
Reina 398 Roble Reina 397 ébano
Torre 1020 Roble Torre 1020 ébano
obispo 985 Roble obispo 985 ébano
Caballero 950 Roble Caballero 950 ébano
Empeñar 431 Roble Empeñar 453 ébano

Para cada tipo de pieza, la cantidad de piezas blancas debe coincidir con la cantidad de piezas
negras. Si no coinciden, algunas piezas de ajedrez se perderán o serán robadas y será
necesario reforzar las medidas de seguridad.

Una combinación natural compara todas las columnas con el mismo nombre para determinar
la igualdad. En este caso, se genera una tabla de resultados sin filas porque no hay filas en el
MADERA columna de la tabla BLANCA coincide con cualquier fila de laMADERAcolumna de la
tabla NEGRA. Esta tabla de resultados no le ayuda a determinar si falta alguna mercancía. En su
lugar, haga una combinación de nombre de columna que excluya elMADERAcolumna de
consideración. Puede tomar la siguiente forma:

SELECCIONAR *
DEL BLANCO ÚNETE AL NEGRO
USANDO (Pieza, Cuant.) ;

La tabla de resultados muestra solo las filas para las cuales el número de piezas blancas en
stock es igual al número de piezas negras:

Pieza Quant Madera Pieza Madera cuantitativa

------------------- ---------
Rey 502 Roble Rey502 Ébano
Torre Torre
1020 Roble 1020 Ébano
Obispo 985 Roble Obispo 985 Ébano
Knight 950 Roble Knight 950 Ébano

La persona astuta puede deducir que la Reina y el Peón faltan en la lista, lo que
indica una escasez en algún lugar para esos tipos de piezas.

Unir internamente

A estas alturas, probablemente ya te habrás dado cuenta de que las uniones son bastante
esotéricas y que se necesita un nivel poco común de discernimiento espiritual para abordarlas
adecuadamente. Es posible que incluso hayas oído hablar del misteriosounir internamentey
especuló que probablemente representa el núcleo o esencia de las operaciones relacionales.
Bueno, ¡ja! La broma es tuya: no hay nada misterioso en las uniones internas.
256 Parte III: Almacenamiento y recuperación de datos

De hecho, todas las uniones cubiertas hasta ahora en este capítulo son uniones internas. Podría haber
formulado la combinación de nombre de columna en el último ejemplo como una combinación interna
usando la siguiente sintaxis:

SELECCIONAR *
DESDE BLANCO UNIÓN INTERIOR NEGRO
USANDO (Pieza, Cuant.) ;

El resultado es el mismo.

La unión interna se denomina así para distinguirla de la unión externa. Una combinación
interna descarta todas las filas de la tabla de resultados que no tienen filas correspondientes
en ambas tablas de origen. Una unión externa conserva filas no coincidentes. Esa es la
diferencia. No hay nada metafísico en ello.

unión externa
Cuando unes dos tablas, la primera (llámala la de la izquierda) puede tener filas que no
tienen contrapartes coincidentes en la segunda tabla (la de la derecha). Por el contrario,
la tabla de la derecha puede tener filas que no tienen contrapartes coincidentes en la
tabla de la izquierda. Si realiza una combinación interna en esas tablas, todas las filas no
coincidentes se excluyen de la salida. uniones exteriores,sin embargo, no excluya las filas
no coincidentes. Las uniones externas vienen en tres tipos: la unión exterior izquierda, la
unión exterior derecha y la unión exterior completa.

Izquierda combinación externa

En una consulta que incluye una combinación, la tabla de la izquierda es la que precede a la palabra
claveUNIRSE,y la tabla de la derecha es la que le sigue. Elizquierda combinación externa conserva las
filas no coincidentes de la tabla de la izquierda pero descarta las filas no coincidentes de la tabla de
la derecha.

Para comprender las uniones externas, considere una base de datos corporativa que mantenga
registros de los empleados, departamentos y ubicaciones de la empresa. Las tablas 11-1, 11-2 y
11-3 contienen los datos de ejemplo de la base de datos.

Tabla 11-1 UBICACIÓN

UBICACIÓN_ID CIUDAD

1 Bostón
3 tampa
5 chicago
 Capítulo 11: Uso de operadores relacionales 257

Tabla 11-2 DEPARTAMENTO

DEPT_ID UBICACIÓN_ID NOMBRE

21 1 Ventas

24 1 Administración

27 5 Reparar

29 5 Existencias

Tabla 11-3 EMPLEADO

EMP_ID DEPT_ID NOMBRE

61 24 Iglesia

63 27 mccoy

Ahora suponga que desea ver todos los datos de todos los empleados, incluidos el departamento y la
ubicación. Obtienes esto con una unión equivalente:

SELECCIONAR *
DESDE LA UBICACIÓN L, DEPARTAMENTO D,
EMPLEADO E DONDE [Link] = [Link]
AND [Link] = [Link] ;

Esta declaración produce el siguiente resultado:

1 Bostón 24 1 Administración 61 24 Iglesia

5 chicago 27 5 Reparar 63 27 mccoy

Esta tabla de resultados proporciona todos los datos de todos los empleados, incluida la ubicación y
el departamento. La equi-unión funciona porque cada empleado tiene una ubicación y un
departamento.

A continuación, supongamos que desea los datos sobre las ubicaciones, con los datos relacionados
del departamento y de los empleados. Este es un problema diferente porque puede existir una
ubicación sin departamentos asociados. Para obtener lo que desea, debe utilizar una combinación
externa, como en el siguiente ejemplo:

SELECCIONAR *
DESDE LA UBICACIÓN L UNIÓN EXTERIOR IZQUIERDA AL DEPARTAMENTO D
ENCENDIDO ([Link] = [Link])
IZQUIERDA EXTERIOR UNIRSE AL EMPLEADO E
ENCENDIDO ([Link] = [Link]);
258 Parte III: Almacenamiento y recuperación de datos

Esta combinación extrae datos de tres tablas. Primero, la tabla UBICACIÓN se une a la tabla
DEPTO. Luego, el conjunto de resultados se une a la tabla EMPLEADO. Filas de la tabla a la
izquierda delIZQUIERDA COMBINACIÓN EXTERNALos operadores que no tienen una fila
correspondiente en la tabla de la derecha se incluyen en el resultado. Por tanto, en la primera
unión se incluyen todas las ubicaciones, incluso si no existe ningún departamento asociado a
ellas. En la segunda unión, se incluyen todos los departamentos, incluso si no existe ningún
empleado asociado a ellos. El resultado es el siguiente:

1 Bostón 24 1 Administración 61 24 Iglesia

5 chicago 27 5 Reparar 63 27 mccoy
3 tampa NULO NULO NULO NULO NULO NULO
5 chicago 29 5 Existencias NULO NULO NULO
1 Bostón 21 1 Ventas NULO NULO NULO

Las dos primeras filas son iguales a las dos filas de resultados del ejemplo anterior.
La tercera fila (3 Tampa)tiene valores nulos en las columnas de departamento y
empleado porque no hay departamentos definidos para Tampa y no hay
empleados destinados allí. La cuarta y quinta filas (5Chicagoy1 Boston)contener
datos sobre elExistenciasy elVentasdepartamentos, pero elEmpleado las columnas
de estas filas contienen valores nulos porque estos dos departamentos no tienen
empleados. Esta unión externa le dice todo lo que le dijo la unión equi, más lo
siguiente:

✓ Todas las ubicaciones de la empresa, tengan o no departamentos

✓ Todos los departamentos de la empresa, tengan o no empleados

No se garantiza que las filas devueltas en el ejemplo anterior estén en el orden

deseado. El orden puede variar de una implementación a otra. Para asegurarse de
que las filas devueltas estén en el orden deseado, agregue unORDENAR POR
cláusula a suSELECCIONARdeclaración, como esta:

SELECCIONAR *
DESDE LA UBICACIÓN L UNIÓN EXTERIOR IZQUIERDA AL DEPARTAMENTO D
ENCENDIDO ([Link] = [Link])
IZQUIERDA EXTERIOR UNIRSE AL EMPLEADO E
ENCENDIDO ([Link] = [Link])
ORDEN POR [Link], [Link], [Link];

Puede abreviar el idioma de unión exterior izquierdo comoUNIRSE A LA IZQUIERDAporque no

existe la izquierdainternounirse.

Unión exterior derecha

Apuesto a que descubriste cómo se comporta la unión externa correcta. ¡Bien! Elunión exterior
derechaconserva filas no coincidentes de la tabla derecha pero descarta las no coincidentes
 Capítulo 11: Uso de operadores relacionales 259
filas de la tabla de la izquierda. Puede usarlo en las mismas tablas y obtener el mismo
resultado invirtiendo el orden en que presenta las tablas en la combinación:

SELECCIONAR *
DEL EMPLEADO E EXTERIOR DERECHO UNIRSE AL DEPARTAMENTO D
ENCENDIDO ([Link] = [Link])
UBICACIÓN DE UNIÓN EXTERIOR DERECHA L
ON ([Link]ón = [Link]ón);

En esta formulación, la primera combinación produce una tabla que contiene todos los
departamentos, tengan o no un empleado asociado. La segunda combinación produce
una tabla que contiene todas las ubicaciones, tengan o no un departamento asociado.

Puede abreviar el lenguaje de unión externo derecho comoÚNETE DERECHO

porque no existe el derechointernounirse.

Unión exterior completa

Elunión externa completaCombina las funciones de la unión exterior izquierda y la

unión exterior derecha. Conserva las filas no coincidentes de las tablas izquierda y
derecha. Considere el caso más general de la base de datos de la empresa utilizada en
los ejemplos anteriores. Podría haber

✓ Ubicaciones sin departamentos

✓ Departamentos sin ubicación
✓ Departamentos sin empleados
✓ Empleados sin departamentos

Para mostrar todas las ubicaciones, departamentos y empleados, independientemente de si tienen

filas correspondientes en las otras tablas, utilice una combinación externa completa del siguiente
formulario:

SELECCIONAR *
DESDE LA UBICACIÓN L UNIÓN EXTERIOR COMPLETA DEL DEPARTAMENTO D
ON ([Link] = [Link]) UNIÓN
EXTERNA COMPLETA EMPLEADO E
ENCENDIDO ([Link] = [Link]);

Puede abreviar el idioma de unión externa completa comoÚNETE COMPLETOporque (esto puede
sonar inquietantemente familiar) no existe tal cosa como un completointernounirse.

unirse a la unión

A diferencia de los otros tipos de unión, elunirse al sindicatono intenta hacer coincidir
una fila de la tabla fuente izquierda con ninguna fila en la tabla fuente derecha.
260 Parte III: Almacenamiento y recuperación de datos

Crea una nueva tabla virtual que contiene la unión de todas las columnas de ambas
tablas fuente. En la tabla de resultados virtual, las columnas que provienen de la tabla
fuente izquierda contienen todas las filas que estaban en la tabla fuente izquierda. Para
esas filas, todas las columnas que provienen de la tabla fuente correcta tienen el valor
nulo. De manera similar, las columnas que provienen de la tabla fuente derecha
contienen todas las filas que estaban en la tabla fuente derecha. Para esas filas, todas
las columnas que provienen de la tabla fuente izquierda tienen el valor nulo. Por lo
tanto, la tabla resultante de una unión contiene todas las columnas de ambas tablas de
origen, y el número de filas que contiene es la suma del número de filas de las dos
tablas de origen.

El resultado de una unión sindical por sí solo no es inmediatamente útil en la mayoría

de los casos; produce una tabla de resultados con muchos valores nulos. Pero puede
obtener información útil de una unión sindical cuando la utiliza junto con elJUNTARSE
expresión analizada en el Capítulo 9. Mire un ejemplo.

Suponga que trabaja para una empresa que diseña y construye cohetes experimentales.
Tienes varios proyectos en marcha. También cuenta con varios ingenieros de diseño que
tienen habilidades en múltiples áreas. Como gerente, usted quiere saber qué empleados,
con qué habilidades, han trabajado en qué proyectos. Actualmente, estos datos se
encuentran dispersos entre la tabla EMPLEADO, la tabla PROYECTOS y la tabla
HABILIDADES.

La tabla EMPLOYEE contiene datos sobre los empleados, [Link] es su

clave principal. La tabla PROYECTOS tiene una fila para cada proyecto en el que ha
trabajado un [Link] una clave externa que hace referencia a
la tabla EMPLOYEE. La tabla HABILIDADES muestra la experiencia de cada empleado.
[Link] una clave externa que hace referencia a la tabla EMPLOYEE.

La tabla EMPLEADO tiene una fila para cada empleado; la tabla PROYECTOS y la
tabla HABILIDADES tienen cero o más filas.

Las tablas 11-4, 11-5 y 11-6 muestran datos de ejemplo en las tres tablas.

Tabla 11-4 Mesa EMPLEADO

EmpID Nombre

1 Ferguson
2 escarcha

3 Toyón
 Capítulo 11: Uso de operadores relacionales 261

Tabla 11-5 Tabla PROYECTOS

Nombre del proyecto EmpID

Estructura X-63 1
Estructura X-64 1
Orientación X-63 2
Orientación X-64 2
Telemetría X-63 3
Telemetría X-64 3

Tabla 11-6 Tabla de HABILIDADES

Habilidad EmpID

Diseño mecanico 1
Carga aerodinámica 1
Diseño analógico 2
Diseño de giroscopio 2
Diseño digital 3
Diseño RF 3

En las tablas se puede ver que Ferguson ha trabajado en el diseño de

estructuras X-63 y X-64 y tiene experiencia en diseño mecánico y carga
aerodinámica.

Ahora suponga que, como gerente, desea ver toda la información sobre todos los
empleados. Decide aplicar una combinación equivalente a las tablas EMPLEADO,
PROYECTOS y HABILIDADES:

SELECCIONAR *
DEL EMPLEADO E, PROYECTOS P, HABILIDADES S
DONDE [Link] = [Link]
Y [Link] = [Link] ;

Puede expresar esta misma operación como una unión interna utilizando la siguiente
sintaxis:

SELECCIONAR *
DEL EMPLEADO E PROYECTOS DE UNIÓN INTERNA P
ON ([Link] = [Link])
HABILIDADES DE UNIÓN INTERNA S
ON ([Link] = [Link]);
262 Parte III: Almacenamiento y recuperación de datos

Ambas formulaciones dan el mismo resultado, como se muestra en la Tabla 11-7.

Tabla 11-7 Resultado de la unión interna

[Link] Nombre [Link] Nombre del proyecto [Link] Habilidad

1 Ferguson 1 Estructura X-63 1 Mecánico

Diseño
1 Ferguson 1 Estructura X-63 1 Aerodinámico
Cargando

1 Ferguson 1 Estructura X-64 1 Mecánico

Diseño
1 Ferguson 1 Estructura X-64 1 Aerodinámico
Cargando

2 escarcha 2 Orientación X-63 2 Cosa análoga

Diseño
2 escarcha 2 Orientación X-63 2 Giroscopio
Diseño
2 escarcha 2 Orientación X-64 2 Cosa análoga

Diseño
2 escarcha 2 Orientación X-64 2 Giroscopio
Diseño
3 Toyón 3 Telemetría X-63 3 Diseño digital
3 Toyón 3 Telemetría X-63 3 Diseño RF
3 Toyón 3 Telemetría X-64 3 Diseño digital
3 Toyón 3 Telemetría X-64 3 Diseño RF

Esta disposición de los datos no es particularmente esclarecedora. Los números de

identificación de los empleados aparecen tres veces y los proyectos y habilidades se duplican
para cada empleado. En pocas palabras: las uniones internas no son adecuadas para responder
este tipo de preguntas. Puedes poner a trabajar la unión sindical aquí, junto con algunos
elegidos estraté[Link], para producir un resultado más
adecuado. Comienzas con la unión básica:

SELECCIONAR *
DEL SINDICATO DE EMPLEADOS E ÚNASE A PROYECTOS P
UNIÓN ÚNETE A HABILIDADES S ;

Observe que la unión sindical no tieneENcláusula. No filtra los datos, por lo queEN La cláusula
no es necesaria. Esta afirmación produce el resultado que se muestra en la tabla 11-8.
 Capítulo 11: Uso de operadores relacionales 263

Tabla 11-8 Resultado de la unión sindical

[Link] Nombre [Link] Nombre del proyecto [Link] Habilidad

1 Ferguson NULO NULO NULO NULO

NULO NULO 1 Estructura X-63 NULO NULO
NULO NULO 1 Estructura X-64 NULO NULO
NULO NULO NULO NULO 1 Mecánico
Diseño
NULO NULO NULO NULO 1 Aerodinámico
Cargando

2 escarcha NULO NULO NULO NULO

NULO NULO 2 Orientación X-63 NULO NULO
NULO NULO 2 Orientación X-64 NULO NULO
NULO NULO NULO NULO 2 Cosa análoga

Diseño
NULO NULO NULO NULO 2 Giroscopio
Diseño
3 Toyón NULO NULO NULO NULO
NULO NULO 3 Telemetría X-63 NULO NULO
NULO NULO 3 Telemetría X-64 NULO NULO
NULO NULO NULO NULO 3 Digital
Diseño
NULO NULO NULO NULO 3 Diseño RF

Cada tabla se ha extendido hacia la derecha o hacia la izquierda con valores nulos, y esas
filas extendidas con valores nulos se han unido. El orden de las filas es arbitrario y
depende de la implementación. Ahora puedes manipular los datos para ponerlos en una
forma más útil.

Observe que la tabla tiene tres columnas de ID, dos de las cuales son nulas en cualquier
fila. Puede mejorar la visualización fusionando las columnas de ID. Como señalo en el
Capítulo 9, elJUNTARSELa expresión toma el valor del primer valor no nulo en una lista
de valores. En el presente caso, toma el valor del único valor no nulo en una lista de
columnas:

SELECCIONE COALESCE ([Link], [Link], [Link]) COMO ID,

[Link], [Link], [Link]
DEL SINDICATO DE EMPLEADOS E ÚNASE A PROYECTOS P
UNIÓN ÚNETE A HABILIDADES S
PEDIR POR ID ;
264 Parte III: Almacenamiento y recuperación de datos

ElDELa cláusula es la misma que en el ejemplo anterior, pero ahora las tres EMP_IDLas columnas
se fusionan en una sola columna llamadaIDENTIFICACIÓ[Link]én estás ordenando el resultado
porIDENTIFICACIÓ[Link] tabla 11-9 muestra el resultado.

Tabla 11-9 Resultado de la unión con la expresión COALESCE

IDENTIFICACIÓN Nombre Nombre del proyecto Habilidad

1 Ferguson Estructura X-63 NULO

1 Ferguson Estructura X-64 NULO
1 Ferguson NULO Diseño mecanico
1 Ferguson NULO Carga aerodinámica
2 escarcha Orientación X-63 NULO
2 escarcha Orientación X-64 NULO
2 escarcha NULO Diseño analógico

2 escarcha NULO Diseño de giroscopio

3 Toyón Telemetría X-63 NULO

3 Toyón Telemetría X-64 NULO
3 Toyón NULO Diseño digital
3 Toyón NULO Diseño RF

Cada fila de este resultado tiene datos sobre un proyecto o una habilidad, pero no ambos.
Cuando lees el resultado, primero debes determinar qué tipo de información hay en cada fila
(proyecto o habilidad). Si elNombre del proyectoLa columna tiene un valor no nulo, la fila
nombra un proyecto en el que ha trabajado el empleado. Si elHabilidad La columna no es nula,
la fila nombra una de las habilidades del empleado.

Puedes hacer el resultado un poco más claro añadiendo otroJUNTARSEhacia SELECCIONAR

declaración, de la siguiente manera:

SELECCIONE COALESCE ([Link], [Link], [Link]) COMO ID,

[Link], COALESCE ([Link], [Link]) COMO Tipo,
[Link], [Link]
DEL EMPLEADO E
UNIÓN UNIÓN (SELECCIONE “Proyecto” COMO Tipo, P.*
DE PROYECTOS) P
UNIÓN UNIÓN (SELECCIONE “Habilidad” COMO Tipo, S.*
DE HABILIDADES) S
ORDENAR POR ID, Tipo;
 Capítulo 11: Uso de operadores relacionales 265
En esta unión, la tabla PROJECTS del ejemplo anterior se reemplaza con una tabla
[Link] añade una columna [Link] un valor constante”
Proyecto"a las columnas provenientes de la tabla PROYECTOS. De manera similar, la tabla
SKILLS se reemplaza con una tabla [Link] añade una columna
llamadaTipo Scon un valor constante”Habilidad"a las columnas provenientes de la tabla
HABILIDADES. En cada fila,[Link] nulo o "Proyecto",y
Tipo Ses nulo o "Habilidad".

El exteriorSELECCIONARlista especifica unJUNTARSEde esos dosTipocolumnas en una sola

columna [Link] especificasTipoen elORDENAR PORcláusula, que ordena las filas
que tienen el mismo ID en un orden que coloca todos los proyectos primero, seguidos de todas
las habilidades. El resultado se muestra en la Tabla 11-10.

Tabla 11-10 Resultado refinado de la unión con

Expresiones fusionadas
IDENTIFICACIÓNNombre Tipo Nombre del proyecto Habilidad

1 Ferguson Proyecto Estructura X-63 NULO

1 Ferguson Proyecto Estructura X-64 NULO
1 Ferguson Habilidad NULO Diseño mecanico
1 Ferguson Habilidad NULO Carga aerodinámica
2 escarcha Proyecto Orientación X-63 NULO
2 escarcha Proyecto Orientación X-64 NULO
2 escarcha Habilidad NULO Diseño analógico

2 escarcha Habilidad NULO Diseño de giroscopio

3 Toyón Proyecto Telemetría X-63 NULO

3 Toyón Proyecto Telemetría X-64 NULO
3 Toyón Habilidad NULO Diseño digital
3 Toyón Habilidad NULO Diseño RF

La tabla de resultados ahora presenta una descripción muy legible de la experiencia en el proyecto y
las habilidades de todos los empleados en la tabla EMPLEADO.

Teniendo en cuenta el número deUNIRSEoperaciones disponibles, relacionar datos de diferentes

tablas no debería ser un problema, independientemente de la estructura de las tablas. Puede confiar
en que si los datos sin procesar existen en su base de datos, SQL tiene los medios para sacarlos y
mostrarlos de forma significativa.
266 Parte III: Almacenamiento y recuperación de datos

EN versus DONDE
La función delENyDÓNDEcláusulas en los distintos tipos de uniones es
potencialmente confusa. Estos datos pueden ayudarle a mantener las cosas claras:

✓ ElENLa cláusula es parte de las uniones interna, izquierda, derecha y completa. La unión
cruzada y la unión sindical no tienenENcláusula porque ninguno de ellos realiza ningún
filtrado de los datos.

✓ ElENcláusula en una unión interna es lógicamente equivalente a unaDÓNDEcláusula; la

misma condición podría especificarse ya sea en unENcláusula o unaDÓNDE cláusula.

✓ ElENLas cláusulas en uniones externas (uniones izquierda, derecha y completa) son

diferentes de DÓNDEcláusulas. ElDÓNDEcláusula simplemente filtra las filas devueltas
por el DEcláusula. Las filas rechazadas por el filtro no se incluyen en el resultado. ElENLa
cláusula en una combinación externa primero filtra las filas de un producto cruzado y
luego incluye las filas rechazadas, extendidas con nulos.
 Capítulo 12

Profundizando con consultas anidadas

En este capítulo
▶ Extraer datos de varias tablas con una única declaración SQL
▶ Comparar un valor de una tabla con un conjunto de valores de otra tabla
▶ Usar la instrucción SELECT para comparar un valor de una tabla con un valor único de
otra tabla
▶ Comparar un valor de una tabla con todos los valores correspondientes en otra tabla
▶ Realizar consultas que correlacionen filas en una tabla con filas correspondientes en otra tabla

▶ Determinar qué filas actualizar, eliminar o insertar mediante una subconsulta

oh Una de las mejores formas de proteger la integridad de sus datos es evitar anomalías
de modificación (consulte el Capítulo 5 para conocer los detalles sangrientos de ellas)
normalizando su base de [Link]ónImplica dividir una única tabla en varias tablas,
cada una de las cuales tiene un único tema. No desea que la información del producto esté en
la misma tabla que la información del cliente, por ejemplo, incluso si los clientes han comprado
productos.

Si normaliza una base de datos correctamente, los datos se encuentran dispersos en varias
tablas. La mayoría de las consultas que desee realizar deben extraer datos de dos o más
tablas. Una forma de hacerlo es utilizar un operador de unión o uno de los otros operadores
relacionales (UNIÓN, INTERSECCIÓN,oEXCEPTO).Los operadores relacionales toman
información de varias tablas y la combinan en un único conjunto de resultados. Diferentes
operadores combinan los datos de diferentes maneras.

Otra forma de extraer datos de dos o más tablas es utilizar una consulta anidada. En SQL, un
consulta anidadaes aquel en el que una declaración adjunta externa contiene una subconsulta.
Esa subconsulta puede servir como una declaración adjunta para una subconsulta de nivel
inferior que está anidada dentro de ella. No existen límites teóricos para la cantidad de niveles
de anidamiento que puede tener una consulta anidada, pero sí enfrenta algunos límites
prácticos que dependen de su implementación de SQL.

Las subconsultas son invariablementeSELECCIONARdeclaraciones, pero la declaración adjunta más

externa también puede ser unaINSERTAR, ACTUALIZAR,oBORRARdeclaración.
268 Parte III: Almacenamiento y recuperación de datos

Una subconsulta puede operar en una tabla distinta de la tabla en la que opera la
declaración adjunta, por lo que las consultas anidadas le brindan otra forma de extraer
información de varias tablas.

Por ejemplo, suponga que desea consultar su base de datos corporativa para encontrar todos
los gerentes de departamento que tengan más de 50 años. Con las uniones que analizo en el
Capítulo 11, puede utilizar una consulta como esta:

SELECCIONE [Link], [Link], [Link], [Link]

DEL DEPARTAMENTO D, EMPLEADO E
DONDE [Link] = [Link] Y [Link] >50;

Des el alias de la tabla DEPT, ymies el alias de la tabla EMPLOYEE. La tabla EMPLEADO tiene una
IDENTIFICACIÓNcolumna que es la clave principal, y la tabla DEPT tiene una columna
ManagerID que es laIDENTIFICACIÓNValor del empleado que es el gerente del departamento.
Una combinación simple (la lista de tablas en elDE cláusula) empareja las tablas relacionadas, y
unaDÓNDELa cláusula filtra todas las filas excepto aquellas que cumplen con los criterios.
Tenga en cuenta que elSELECCIONARLa lista de parámetros de la declaración incluye el
DepartamentoyNombrecolumnas de la tabla DEPT y laNombre yEdadcolumnas de la tabla
EMPLEADO.

A continuación, supongamos que está interesado en el mismo conjunto de filas pero

solo desea las columnas de la tabla DEPT. En otras palabras, le interesan los
departamentos cuyos gerentes tienen 50 años o más, pero no le importa quiénes son
esos gerentes ni qué edad tienen exactamente. Luego podrías escribir la consulta con
unsubconsultaen lugar de una unión:

SELECCIONE [Link], [Link]

DEL DEPARTAMENTO D
DONDE EXISTE (SELECCIONE * DEL EMPLEADO E
DONDE [Link] = [Link] Y [Link] > 50);

Esta consulta tiene dos nuevos elementos: elEXISTEpalabra clave y elSELECCIONAR *en el
DÓNDEcláusula del [Link] interiorSELECCIONARes una subconsulta (o
subseleccionar), y elEXISTELa palabra clave es una de varias herramientas para usar con una
subconsulta que se describe en este capítulo.

Qué hacen las subconsultas

Las subconsultas se encuentran dentro delDÓNDEcláusula de su declaración adjunta. Su
función es establecer las condiciones de búsqueda delDÓNDEcláusula. Cada tipo de
subconsulta produce un resultado diferente. Algunas subconsultas producen una lista de
valores que luego la declaración adjunta utiliza como entrada. Otras subconsultas
producen un valor único que la declaración adjunta luego evalúa con un operador de
comparación. Un tercer tipo de subconsulta devuelve un valor de Verdadero o Falso.
 Capítulo 12: Profundizando con consultas anidadas 269

Consultas anidadas que devuelven conjuntos de filas

Para ilustrar cómo una consulta anidada devuelve un conjunto de filas, imagine que trabaja
para un integrador de sistemas de equipos informáticos. Su empresa, Zetec Corporation,
ensambla sistemas a partir de componentes que usted compra y luego los vende a empresas y
agencias gubernamentales. Realiza un seguimiento de su negocio con una base de datos
relacional. La base de datos consta de muchas tablas, pero en este momento solo le interesan
tres de ellas: la tabla PRODUCTO, la tabla COMP_USED y la tabla COMPONENTE. La tabla
PRODUCTO (que se muestra en la Tabla 12-1) contiene una lista de todos sus productos
estándar. La tabla COMPONENT (que se muestra en la Tabla 12-2) enumera los componentes
que se incluyen en sus productos, y la tabla COMP_USED (que se muestra en la Tabla 12-3)
rastrea qué componentes se incluyen en cada producto.

Tabla 12-1 Tabla de PRODUCTOS

Columna Tipo Restricciones

Modelo CARACTER (6) CLAVE PRIMARIA

Nombre del producto CARACTERÍSTICA (35)

ProdDesc CARACTERÍSTICA (31)

Precio de lista NUMÉRICO (9,2)

Tabla 12-2 Tabla de COMPONENTES

Columna Tipo Restricciones

IDcomp CARACTER (6) CLAVE PRIMARIA

Tipo Comp CARACTERÍSTICA (10)

CompDesc CARACTERÍSTICA (31)

Tabla 12-3 Tabla COMP_USED

Columna Tipo Restricciones

Modelo CARACTER (6) CLAVE EXTERNA (paraPRODUCTO)

IDcomp CARACTER (6) CLAVE EXTERNA (paraCOMPONENTE)

Un componente se puede utilizar en varios productos y un producto puede contener

varios componentes (una relación de muchos a muchos). Esta situación puede causar
problemas de integridad. Para evitar los problemas, cree la tabla de vinculación.
270 Parte III: Almacenamiento y recuperación de datos

COMP_USED para relacionar COMPONENTE con PRODUCTO. Un componente puede aparecer

en muchas filas de la tabla COMP_USED, pero cada una de esas filas hará referencia solo a un
componente (una relación de uno a muchos). De manera similar, un producto puede aparecer
en muchas filas en COMP_USED, pero cada fila hace referencia solo a un producto (otra
relación de uno a muchos). Agregar la tabla de vinculación transforma una relación
problemática de muchos a muchos en dos relaciones relativamente simples de uno a muchos.
Este proceso de reducción de la complejidad de las relaciones es un ejemplo de normalización.

Subconsultas introducidas por la palabra clave IN

Una forma de consulta anidada compara un valor único con el conjunto de valores
devueltos por unSELECCIONARdeclaración. Utiliza elENpredicado con la siguiente
sintaxis:

SELECCIONARlista_columnas
DEmesa
DONDE expresión EN (subconsulta);

La expresión en elDÓNDELa cláusula se evalúa como un valor. Si ese valor esEN la lista devuelta por la
subconsulta, luego elDÓNDELa cláusula devuelve un valor Verdadero. Las columnas especificadas de
la fila de la tabla que se está procesando se agregan a la tabla de resultados. La subconsulta puede
hacer referencia a la misma tabla a la que hace referencia la consulta externa o puede hacer
referencia a una tabla diferente.

En el siguiente ejemplo, utilizo la base de datos de Zetec para demostrar este tipo de
consulta. Supongamos que hay escasez de monitores de computadora en la industria
informática, de modo que cuando se quede sin monitores, ya no pueda entregar
productos que los incluyan. Quiere saber qué productos se ven afectados. Mirando
agradecido a su propio monitor, ingrese la siguiente consulta:

SELECCIONAR modelo
DESDE COMP_USED
DONDE COMPID EN
(SELECCIONE CompID
DEL COMPONENTE
DONDE CompType = 'Monitor');

SQL procesa primero la consulta más interna, por lo que procesa la tabla COMPONENTE
y devuelve el valor deIDcomppara cada fila dondeTipo Compes 'Monitor'.El resultado es
una lista de losIDENTIFICACIÓNnúmeros de todos los monitores. La consulta externa
luego compara el valor deIDcompen cada fila de la tabla COMP_USED contra la lista. Si
la comparación tiene éxito, el valor de laModelo La columna para esa fila se agrega al
[Link]'s tabla de resultados. El resultado es una lista de todos los
modelos de productos que incluyen un monitor. El siguiente ejemplo muestra lo que
sucede cuando ejecuta la consulta:

Modelo
-----
CX3000
 Capítulo 12: Profundizando con consultas anidadas 271

CX3010
CX3020
MB3030
MX3020
MX3030

Ahora sabes qué productos pronto estarán agotados. Es hora de acudir a la fuerza de ventas y
decirles que disminuyan la velocidad en la promoción de estos productos.

Cuando se utiliza esta forma de consulta anidada, la subconsulta debe especificar una sola
columna y el tipo de datos de esa columna debe coincidir con el tipo de datos del argumento
que precede alENpalabra clave.

Estoy seguro de que recuerdas el principio de [Link] las cosas simplesEs

importante cuando se trata de software de cualquier tipo, pero es especialmente importante
cuando se trata de software de bases de datos. Declaraciones que incluyen anidadas
SELECCIONARPuede ser difícil hacerlo bien. Una forma de hacer que funcionen como deberían
es ejecutar el sistema internoSELECCIONARprimero todo por sí solo y luego verifique que el
resultado que obtiene es el resultado que espera. Cuando estás seguro de que el interior
SELECCIONAR está funcionando correctamente, puede incluirlo en la parte exterior de la
declaración y tener más posibilidades de que todo funcione como se anuncia.

Subconsultas introducidas por la palabra clave NOT IN

Así como puedes introducir una subconsulta con elENpalabra clave, puedes hacer lo
contrario e introducirla con elNO ENpalabras clave. De hecho, ahora es un buen
momento para que la dirección de Zetec haga esa consulta. Al utilizar la consulta de la
sección anterior, la gerencia de Zetec descubrió qué productos no vender. Esa es
información valiosa, pero no paga el alquiler. Lo que realmente quiere saber la dirección
de Zetec es qué productosavender. La gerencia quiere enfatizar la venta de productos
quenocontener monitores. Una consulta anidada que presenta una subconsulta
introducida por elNO ENpalabras clave proporciona la información solicitada:

SELECCIONAR modelo
DESDE COMP_USED
DONDE CompID NO ESTÁ
(SELECCIONE CompID
DEL COMPONENTE
DONDE CompType = 'Monitor')) ;

Esta consulta produce el siguiente resultado:

Modelo
-----
PX3040
PB3050
PX3040
PB3050
272 Parte III: Almacenamiento y recuperación de datos

Vale la pena señalar el hecho de que el conjunto de resultados contiene duplicados. La

duplicación se produce porque un producto que contiene varios componentes que no son
monitores tiene una fila en la tabla COMP_USED para cada componente. La consulta crea una
entrada en la tabla de resultados para cada una de esas filas.

En el ejemplo, el número de filas no crea un problema porque la tabla de resultados es

corta. Sin embargo, en el mundo real, una tabla de resultados de este tipo puede tener
cientos o miles de filas. Para evitar confusiones, lo mejor es eliminar los duplicados.
Puedes hacerlo fácilmente agregando elDISTINTOpalabra clave para la consulta. Sólo las
filas que son distintas (diferentes) de todas las filas recuperadas anteriormente se
agregan a la tabla de resultados:

SELECCIONAR MODELO DISTINTO

DESDE COMP_USED
DONDE CompID NO ESTÁ
(SELECCIONE CompID
DEL COMPONENTE
DONDE CompType = 'Monitor')) ;

Como era de esperar, el resultado es el siguiente:

Modelo
-----
PX3040
PB3050

Consultas anidadas que devuelven un valor único

A menudo resulta útil introducir una subconsulta con uno de los seis operadores de
comparación (=, <>, <,<=, >, >=). En tal caso, la expresión que precede al operador se
evalúa como un valor único y la subconsulta que sigue al operador también debe
evaluarse como un valor único. Una excepción es el caso de laoperador de comparación
cuantificado,que es un operador de comparación seguido de un cuantificador
(CUALQUIER COSA,oTODO).

Para ilustrar un caso en el que una subconsulta devuelve un valor único, observe otra parte de
la base de datos de Zetec Corporation. Contiene una tabla CLIENTE que contiene información
sobre las empresas que compran productos Zetec. También contiene una tabla CONTACTO que
contiene datos personales sobre personas de cada una de las organizaciones de clientes de
Zetec. Las tablas están estructuradas como se muestra en las Tablas 12-4 y 12-5.
 Capítulo 12: Profundizando con consultas anidadas 273

Tabla 12-4 Tabla CLIENTE

Columna Tipo Restricciones

ID de cliente ENTERO CLAVE PRIMARIA

Compañía CARACTERÍSTICA (40) ÚNICO

Dirección del cliente CARACTERÍSTICA (30)

CustCity CARACTERÍSTICA (20)

Estado del cliente CARACTER (2)

PersonalizadoZip CARACTERÍSTICA (10)

Teléfono personalizado CARACTERÍSTICA (12)

Nivel de modificación ENTERO

Tabla 12-5 Mesa CONTACTO

Columna Tipo Restricciones

ID de cliente ENTERO CLAVE PRIMARIA

NombreContF CARACTERÍSTICA (10)

NombreContL CARACTERÍSTICA (16)

ContPhone CARACTERÍSTICA (12)

Información continua CARACTERÍSTICA (50)

Supongamos que desea consultar la información de contacto de Olympic Sales, pero no

recuerda la dirección de esa [Link] de [Link] una consulta anidada como esta
para recuperar la información que desea:

SELECCIONAR *
DE CONTACTO
DONDE ID de cliente =
(SELECCIONE ID de cliente
DEL CLIENTE
DONDE Empresa = ‘Ventas Olímpicas’);

El resultado se parece a esto:

ClienteContFName NombreContL ContPhone Información continua

--------------- --------- --------- --------

118 Jerry Atwater 505-876-3456 jugará
papel importante en
aditivo
fabricación.
274 Parte III: Almacenamiento y recuperación de datos

Ahora puede llamar a Jerry en Olympic y contarle sobre la venta especial de

impresoras 3D de este mes.

Cuando utiliza una subconsulta en una comparación "=", la subconsultaSELECCIONARLa

lista debe especificar una sola columna (ID de clienteen el ejemplo). Cuando se ejecuta la
subconsulta, debe devolver una sola fila para tener un valor único para la comparación.

En este ejemplo, asumo que la tabla CLIENTE tiene solo una fila con unCompañía
valor de 'Ventas Olímpicas”.ElCREAR MESAdeclaración para CLIENTE especifica un
ÚNICOrestricción paraCompañía,y esta declaración garantiza que la subconsulta del
ejemplo anterior devuelva un valor único (o ningún valor). Sin embargo, las
subconsultas como la de este ejemplo se usan comúnmente en columnas que no
están especificadas comoÚ[Link] tales casos, debe confiar en el conocimiento
previo del contenido de la base de datos para creer que la columna no tiene
duplicados.

Si más de un cliente tiene un valor de 'Ventas olímpicasen elCompañía columna

(quizás en diferentes estados), la subconsulta genera un error.

Si no existe ningún cliente con ese nombre de empresa, la subconsulta se trata como si fuera
nula y la comparación se convierte [Link] este caso, elDÓNDELa cláusula no
devuelve ninguna fila (porque solo devuelve filas con la condición Verdadero y filtra filas con
la condición Falso o desconocido). Esto probablemente sucedería, por ejemplo, si alguien
escribiera mal la palabraCompañíacomo 'Ventas Olímpicas’.

Aunque el operador igual (=) es el más común, puedes utilizar cualquiera de los
otros cinco operadores de comparación en una estructura similar. Para cada fila de
la tabla especificada en la declaración adjuntaDEcláusula, el valor único devuelto
por la subconsulta se compara con la expresión en la declaración adjuntaDÓNDE
cláusula. Si la comparación da un valor Verdadero, se agrega una fila a la tabla de
resultados.

Puede garantizar que una subconsulta devolverá un valor único si incluye una función
agregada en [Link] agregadassiempre devuelve un único valor. (Las funciones
agregadas se describen en el Capítulo 3.) Por supuesto, esta forma de devolver un valor
único es útil sólo si desea el resultado de una función agregada.

Suponga que usted es un vendedor de Zetec y necesita ganar un cheque de comisión

grande para pagar algunas facturas inesperadas. Decide concentrarse en vender el
producto más caro de Zetec. Puede averiguar cuál es ese producto con una consulta
anidada:

SELECCIONAR modelo, nombre de producto, precio de lista

DEL PRODUCTO
DONDE Precio de lista =
(SELECCIONAR MAX(Precio de lista)
DEL PRODUCTO);
 Capítulo 12: Profundizando con consultas anidadas 275
En la consulta anidada anterior, tanto la subconsulta como la declaración adjunta operan
en la misma tabla. La subconsulta devuelve un valor único: el precio de lista máximo en
la tabla PRODUCTO. La consulta externa recupera todas las filas de la tabla PRODUCTO
que tienen ese precio de lista.

El siguiente ejemplo muestra una subconsulta de comparación que utiliza un operador de

comparación distinto de =:

SELECCIONAR modelo, nombre de producto, precio de lista

DEL PRODUCTO
DONDE Precio de lista <
(SELECCIONE PROMEDIO (Precio de lista)
DEL PRODUCTO);

La subconsulta devuelve un valor único: el precio de lista promedio en la tabla PRODUCTO. La

consulta externa recupera todas las filas de la tabla PRODUCTO que tienen un precio de lista
más bajo que el precio de lista promedio.

En el estándar SQL original, una comparación sólo podía tener una subconsulta y tenía que
estar en el lado derecho de la comparación. SQL:1999 permitió que uno o ambos operandos de
la comparación fueran subconsultas, y las versiones posteriores de SQL conservan esa
expansión de capacidad.

Los cuantificadores TODOS, ALGUNOS y CUALQUIER

Otra forma de asegurarse de que una subconsulta devuelva un valor único es introducirla con
un operador de comparación cuantificado. El cuantificador universalTODO, y los cuantificadores
existencialesALGUNOyCUALQUIER,cuando se combina con un operador de comparación,
procesa la lista devuelta por una subconsulta, reduciéndola a un solo valor.

Verá cómo estos cuantificadores afectan una comparación al observar la base de datos completa de
los juegos de los lanzadores de béisbol del Capítulo 11, que se enumera a continuación.

El contenido de las dos tablas viene dado por las dos consultas siguientes:

SELECCIONAR * DE NACIONAL

Nombre de pila Apellido Juegos Completos

--------- -------- -------------
Sal maglia 11
Don Newcombe 9
Arenoso Koufax 13
Don Drysdale 12
Beto Turley 8

SELECCIONAR * DE AMERICANO
276 Parte III: Almacenamiento y recuperación de datos

Nombre de pila Apellido Juegos Completos

--------- -------- -------------
Persona blanca Vado 12
Don larson 10
Beto Turley 8
allie reynolds 14

La presunción es que los lanzadores con más juegos completos deberían estar en la Liga
Americana debido a la presencia de bateadores designados en esa liga. Una forma de verificar
esta presunción es crear una consulta que devuelva todos los lanzadores de la Liga Americana
que han lanzado más juegos completos que todos los lanzadores de la Liga Nacional. La
consulta se puede formular de la siguiente manera:

SELECCIONAR *
DE AMERICANO
DONDE CompleteGames > TODO
(SELECCIONE CompleteGames DE NACIONAL);

Este es el resultado:

Nombre de pila Apellido Juegos Completos

---------- --------- --------------
allie reynolds 14

La subconsulta (SELECCIONE CompleteGames DE NACIONAL)devuelve los valores en el

Juegos Completoscolumna para todos los lanzadores de la Liga Nacional. El
> TODOEl cuantificador dice que se devuelvan sólo aquellos valores deJuegos Completos
en la tabla AMERICAN que son mayores que cada uno de los valores devueltos por la
subconsulta. Esta condición se traduce en "mayor que el valor más alto devuelto por la
subconsulta". En este caso, el valor más alto devuelto por la subconsulta es 13 (Sandy
Koufax). La única fila en la tabla AMERICANA por encima de eso es el récord de Allie
Reynolds, con 14 juegos completos.

¿Qué pasa si su presunción inicial era incorrecta? ¿Qué pasaría si el líder de las Grandes
Ligas en juegos completos fuera un lanzador de la Liga Nacional, a pesar de que la Liga
Nacional no tiene un bateador designado? Si ese fuera el caso, la consulta

SELECCIONAR *
DE AMERICANO
DONDE CompleteGames > TODO
(SELECCIONE CompleteGames DE NACIONAL);

devolvería una advertencia de que ninguna fila satisface las condiciones de la consulta, lo que
significa que ningún lanzador de la Liga Americana ha lanzado más juegos completos que el
lanzador que ha lanzado la mayor cantidad de juegos completos en la Liga Nacional.
 Capítulo 12: Profundizando con consultas anidadas 277

Consultas anidadas que son una prueba de existencia.

Una consulta devuelve datos de todas las filas de la tabla que satisfacen las condiciones
de la consulta. A veces se devuelven muchas filas; a veces solo uno regresa. A veces,
ninguna de las filas de la tabla cumple las condiciones y no se devuelve ninguna fila.
Puedes usar elEXISTEyNO EXISTEpredicados para introducir una subconsulta. Esa
estructura le indica si alguna fila de la tabla ubicada en el directorio de la subconsultaDE
cláusula cumple con las condiciones en suDÓNDE cláusula.

Subconsultas introducidas conEXISTEyNO EXISTEson fundamentalmente diferentes de las

otras subconsultas de este capítulo hasta ahora. En todos los casos anteriores, SQL
primero ejecuta la subconsulta y luego aplica el resultado de esa operación a la
declaración [Link] EXISTElas subconsultas, por otro lado, son ejemplos de
subconsultas correlacionadas.

Asubconsulta correlacionadaprimero encuentra la tabla y la fila especificadas por la

declaración adjunta y luego ejecuta la subconsulta en la fila de la tabla de la subconsulta
que se correlaciona con la fila actual de la tabla de la declaración adjunta.

La subconsulta devuelve una o más filas o no devuelve ninguna. Si devuelve al

menos una fila, elEXISTEEl predicado tiene éxito (consulte la siguiente sección)
y la declaración adjunta realiza su acción. En las mismas circunstancias, elNO
EXISTEEl predicado falla (consulte la sección siguiente) y la declaración adjunta
no realiza su acción. Después de procesar una fila de la tabla de la declaración
adjunta, se realiza la misma operación en la siguiente fila. Esta acción se repite
hasta que se haya procesado cada fila de la tabla de la declaración adjunta.

EXISTE
Suponga que es vendedor de Zetec Corporation y desea llamar a sus personas de
contacto principal en todas las organizaciones de clientes de Zetec en California.
Pruebe la siguiente consulta:

SELECCIONAR *
DE CONTACTO
DONDE EXISTE
(SELECCIONAR *
DEL CLIENTE
DONDE EstadoCust = 'CA'
Y [Link] = [Link]) ;

Nótese la referencia [Link],que hace referencia a una columna

de la consulta externa y la compara con otra columna,CLIENTE. ID de cliente,de
la consulta interna. Para cada fila candidata de la consulta externa,
278 Parte III: Almacenamiento y recuperación de datos

usted evalúa la consulta interna, utilizando elID de clientevalor de la corriente

CONTACTOfila de la consulta externa en elDÓNDEcláusula de la consulta interna.

Esto es lo que sucede:

1. ElID de clienteLa columna vincula la tabla CONTACTO con la tabla CLIENTE.

2. SQL mira el primer registro en la tabla CONTACTO, encuentra la fila en la tabla
CLIENTE que tiene el mismoID de cliente,y comprueba esa fila Estado del cliente
campo.

3. [Link] = 'CA',la corrienteCONTACTOLa fila se agrega a la tabla de

resultados.
4. El próximoCONTACTOLuego, el registro se procesa de la misma manera, y así
sucesivamente, hasta que se haya procesado toda la tabla CONTACT.

5. Porque la consulta especificaSELECCIONAR * DEL CONTACTO,Se devuelven todos los

campos de la tabla de contactos, incluido el nombre y el número de teléfono del
contacto.

NO EXISTE
En el ejemplo anterior, el vendedor de Zetec quiere saber los nombres y números
de las personas de contacto de todos los clientes en California. Imagine que un
segundo vendedor es responsable de todo Estados Unidos excepto California.
Puede recuperar sus personas de contacto usandoNO EXISTEen una consulta
similar a la anterior:

SELECCIONAR *
DE CONTACTO
DONDE NO EXISTE
(SELECCIONAR *
DEL CLIENTE
DONDE EstadoCust = 'CA'
Y [Link] = [Link]) ;

Cada fila de CONTACT para la cual la subconsulta no devuelve una fila se agrega a
la tabla de resultados.

Otras subconsultas correlacionadas

Como se señaló en una sección anterior de este capítulo, las subconsultas introducidas porEN o mediante un
operador de comparación no es necesario que sean consultas correlacionadas, pero pueden serlo.

Subconsultas correlacionadas introducidas con IN

En la sección anterior “Subconsultas introducidas por la palabra claveEN,"Analizo cómo
se puede utilizar una subconsulta no correlacionada con elENpredicado. Mostrar
 Capítulo 12: Profundizando con consultas anidadas 279
cómo una subconsulta correlacionada puede utilizar elENpredicado, haga la misma
pregunta que surgió con elEXISTEPredicado: ¿Cuáles son los nombres y números de
teléfono de los contactos de todos los clientes de Zetec en California? Puedes responder
a esta pregunta con una correlaciónENsubconsulta:

SELECCIONAR *
DE CONTACTO
DÓNDE ENTRA 'CA'
(SELECCIONE Estado del Cliente
DEL CLIENTE
DONDE [Link] = [Link]);

La declaración se evalúa para cada registro en la tabla CONTACTO. Si, para ese registro,
elID de clientenúmeros en CONTACTO y CLIENTE coinciden, entonces el valor de
[Link] compara con 'CALIFORNIA'.El resultado de la subconsulta es una
lista que contiene, como máximo, un elemento. Si ese elemento es 'CALIFORNIA',el
DÓNDESe cumple la cláusula de la declaración adjunta y se agrega una fila a la tabla de
resultados de la consulta.

Subconsultas introducidas con operadores de comparación.

Uno de los seis operadores de comparación también puede introducir una subconsulta
correlacionada, como se muestra en el siguiente ejemplo.

Zetec paga bonificaciones a sus vendedores en función de su volumen total de ventas mensuales.
Cuanto mayor sea el volumen, mayor será el porcentaje de bonificación. La lista de porcentajes de
bonificación se mantiene en la tabla BONUSRATE:

Cantidad mínima Cantidad máxima BonoPct

--------- --------- --------
0,00 24999,99 0.
25000.00 49999.99 0.1
50000.00 99999.99 0,2
100000.00 249999,99 0.3
250000.00 499999.99 0,4
500000.00 749999.99 0,5
750000.00 999999.99 0,6

Si las ventas mensuales de una persona están entre $100.000,00 y $249.999,99, la bonificación
es del 0,3 por ciento de las ventas.

Las ventas se registran en una tabla maestra de transacciones denominada TRANSMASTER:

TRANSMASTER
-----------
Columna Tipo Restricciones
------ ---- -----------
TransID ENTERO CLAVE PRIMARIA
ID de cliente ENTERO CLAVE EXTERNA
EmpID ENTERO CLAVE EXTERNA
280 Parte III: Almacenamiento y recuperación de datos

TransDate FECHA
Importe neto NUMÉRICO
Transporte NUMÉRICO
Impuesto NUMÉRICO
Total de la factura NUMÉRICO

Los bonos de ventas se basan en la suma de losImporte netocampo para todas las transacciones de
una persona en el mes. Puede encontrar la tasa de bonificación de cualquier persona con una
subconsulta correlacionada que utiliza operadores de comparación:

SELECCIONAR BonoPct
DE BONIFICACIÓN
DONDE Cantidad mínima <=
(SELECCIONAR SUMA (Monto Neto)
DE TRANSMASTER
DONDE EmpID = 133) Y
MaxAmount >=
(SELECCIONAR SUMA (Monto Neto)
DE TRANSMASTER
DONDE EmpID = 133);

Esta consulta es interesante porque contiene dos subconsultas, haciendo uso del
conectivo ló[Link] subconsultas utilizan elSUMAoperador agregado, que devuelve
un valor único: las ventas mensuales totales del empleado número 133. Ese valor luego
se compara con elCantidad mínimay el Cantidad máximacolumnas en la tabla
BONUSRATE, lo que produce la tasa de bonificación para ese empleado.

Si no hubieras conocido elEmpIDpero había conocido elNombreEmpl,podrías llegar a

la misma respuesta con una consulta más compleja:

SELECCIONAR BonoPct
DE BONIFICACIÓN
DONDE Cantidad mínima <=
(SELECCIONAR SUMA (Monto Neto)
DE TRANSMASTER
DONDE EmpID =
(SELECCIONE EmpID
DEL EMPLEADO
DONDE EmplName = 'Ataúd'))
Y Cantidad Máxima >=
(SELECCIONAR SUMA (Monto Neto)
DE TRANSMASTER
DONDE EmpID =
(SELECCIONE EmpID
DEL EMPLEADO
DONDE EmplName = 'Ataúd'));

Este ejemplo utiliza subconsultas anidadas dentro de subconsultas que, a su vez, están
anidadas dentro de una consulta adjunta para llegar a la tasa de bonificación para el empleado
llamado Coffin. Esta estructura funciona sólo si sabes con seguridad que el
 Capítulo 12: Profundizando con consultas anidadas 281
La empresa tiene un, y sólo uno, empleado cuyo apellido es Coffin. Si sabe que
más de un empleado tiene el mismo apellido, puede agregar términos alDÓNDE
cláusula de la subconsulta más interna hasta que esté seguro de que solo está
seleccionada una fila de la tabla EMPLEADO.

Subconsultas en una cláusula HAVING

Puede tener una subconsulta correlacionada en unTENIENDOcláusula tal como puedas en un
DÓNDEcláusula. Como menciono en el Capítulo 10, unTENIENDOLa cláusula suele ir precedida
de unaAGRUPAR PORcláusula. ElTENIENDOLa cláusula actúa como un filtro para restringir los
grupos creados por elAGRUPAR PORcláusula. Grupos que no cumplen la condición del
TENIENDOcláusula no se incluyen en el resultado. Cuando se usa de esta manera, elTENIENDO
La cláusula se evalúa para cada grupo creado por elAGRUPAR PORcláusula.

En ausencia de unAGRUPAR PORcláusula, laTENIENDOLa cláusula se evalúa para el

conjunto de filas pasadas por elDÓNDEcláusula: que se considera un solo grupo. Si ni
unDÓNDEcláusula ni unaAGRUPAR PORcláusula está presente, el TENIENDOLa cláusula
se evalúa para toda la tabla:

SELECCIONE [Link]
DE TRANSMASTER TM1
GRUPO POR [Link]
TENER MAX ([Link]) >= TODOS
(SELECCIONE 2 * PROMEDIO ([Link])
DE TRANSMASTER TM2
DONDE [Link] <> [Link]);

Esta consulta utiliza dos alias para la misma tabla, lo que le permite recuperar el EmpIDNúmero de
todos los vendedores que tuvieron una venta de al menos el doble de la venta promedio de todos los
demás vendedores. La consulta funciona de la siguiente manera:

1. La consulta externa agrupa las filas de TRANSMASTER pordepartamento de

[Link] se hace con elSELECCIONAR DE,yAGRUPAR POR cláusulas.

2. ElTENIENDOLa cláusula filtra estos grupos. Para cada grupo, calcula el MÁXIMO
delImporte netocolumna para las filas de ese grupo.
3. La consulta interna evalúa el doble del [Link] netode todas las
filas de TRANSMASTER cuyoEmpIDes diferente delEmpIDdel grupo actual de
la consulta externa.
En la última línea, debes hacer referencia a dos [Link], por lo
que utiliza diferentes alias para TRANSMASTER en elDEcláusulas de las consultas
externas e internas.

4. Utiliza esos alias en la comparación de la última línea de la consulta para

indicar que estás haciendo referencia tanto alEmpIDde la fila actual de la
subconsulta interna ([Link])yelEmpIDdel grupo actual de la
subconsulta externa ([Link]).
282 Parte III: Almacenamiento y recuperación de datos

ACTUALIZAR, BORRAR e INSERTAR

Además deSELECCIONARdeclaraciones,ACTUALIZAR, BORRAR,yINSERTARLas declaraciones también
pueden incluirDÓNDEcláusulas. AquellosDÓNDELas cláusulas pueden contener subconsultas de la
misma manera queSELECCIONARdeclaraciones'DÓNDElas cláusulas lo hacen.

Por ejemplo, Zetec acaba de cerrar un acuerdo de compra por volumen con Olympic Sales y
quiere otorgarle a Olympic un crédito retroactivo del 10 por ciento por todas sus compras en
el último mes. Puedes dar este crédito con unACTUALIZARdeclaración:

ACTUALIZAR TRANSMASTER
SET Monto Neto = Monto Neto * 0.9
DONDE Fecha de venta> (Fecha actual – 30) DÍA Y ID de cliente =
(SELECCIONE ID de cliente
DEL CLIENTE
DONDE Empresa = ‘Ventas Olímpicas’);

También puede tener una subconsulta correlacionada en unACTUALIZARdeclaración.

Supongamos que la tabla CLIENTE tiene una columnaúltimos meses máx.,y Zetec quiere
otorgar dicho crédito por compras que excedanÚltimos meses má[Link] el cliente:

ACTUALIZAR TRANSMASTERTM
SET Monto Neto = Monto Neto * 0.9
DONDE Importe Neto>
(SELECCIONE ÚltimosMesesMax
DEL CLIENTE C
DONDE [Link] = [Link]);

Tenga en cuenta que esta subconsulta está correlacionada:DÓNDEcláusula en la última

línea hace referencia tanto a laID de clientede la fila CLIENTE de la subconsulta y el ID de
clientede la fila TRANSMASTER actual que es candidata para actualización.

Una subconsulta en unACTUALIZARLa declaración también puede hacer referencia a la tabla que se
está actualizando. Supongamos que Zetec quiere dar un crédito del 10 por ciento a los clientes cuyas
compras hayan excedido los $10,000:

ACTUALIZAR TRANSMASTER TM1

SET Monto Neto = Monto Neto * 0.9
DONDE 10000 < (SELECCIONE SUMA (Monto Neto)
DE TRANSMASTER TM2
DONDE [Link] = [Link]);

La subconsulta interna calcula elSUMAdelImporte netocolumna para todas las filas de

TRANSMASTER para el mismo cliente. ¿Qué quiere decir esto? Supongamos que el
cliente conID de cliente = 37tiene cuatro filas en TRANSMASTER con valores paraImporte
neto: 3000, 5000, 2000,[Link] neto para estoID de clientees11000.

El orden en que elACTUALIZARLa declaración procesa las filas está definida

por su implementación y generalmente no es predecible. La orden puede
 Capítulo 12: Profundizando con consultas anidadas 283
difieren dependiendo de cómo estén dispuestas las filas en el disco. Supongamos que la
implementación procesa las filas para estoID de clienteen este orden: primero el
TRANSMASTER con unImporte netode3000,luego el que tieneImporte neto = 5000,
etcétera. Después de las primeras tres filas paraID cliente 37han sido actualizados, su
Importe netolos valores son2700 (90 por ciento de $3,000),4500 (90 por ciento de
$5,000), y1800 (90 por ciento de $2,000). Luego, cuando procese la última fila de
TRANSMASTER paraID cliente 37 (cuyoImporte netoes1000),elSUMA devuelto por la
subconsulta seríaparecerser10000-eso es elSUMAde lo nuevoImporte netovalores de las
tres primeras filas paraID cliente 37,y el viejo Importe netovalor de la última fila paraID
cliente [Link] lo tanto, parecería que la última fila paraID cliente 37no está actualizado,
porque la comparación con esoSUMA no es cierto; después de todo,10000no es menos
[Link] no es así como ACTUALIZARLa declaración se define cuando una
subconsulta hace referencia a la tabla que se está actualizando.

Todoevaluaciones de subconsultas en unACTUALIZARLa declaración hace referencia a los

valores antiguos de la tabla, los que se están actualizando. En el anteriorACTUALIZARpara ID
cliente 37,la subconsulta regresa11000—el originalSUMA.

La subconsulta en unDÓNDEcláusula opera igual que unaSELECCIONARdeclaración o una

ACTUALIZARdeclaración. Lo mismo es cierto [Link] eliminar todas las
transacciones de Olympic, utilice esta declaración:

ELIMINAR DE TRANSMASTER
DONDE ID de cliente =
(SELECCIONE ID de cliente
DEL CLIENTE
DONDE Empresa = ‘Ventas Olímpicas’);

Al igual que conACTUALIZAR, ELIMINARlas subconsultas también se pueden correlacionar y también

pueden hacer referencia a la tabla que se está eliminando. Las reglas son similares a las reglas para
ACTUALIZAR subconsultas. Suponga que desea eliminar todas las filas de TRANSMASTER para los
clientes cuyo totalImporte netoes mayor que $10,000:

ELIMINAR DE TRANSMASTER TM1

DONDE 10000 < (SELECCIONE SUMA (Monto Neto)
DE TRANSMASTER TM2
DONDE [Link] = [Link]);

Esta consulta elimina todas las filas de TRANSMASTER que tienenID cliente 37,así como
cualquier otro cliente con compras superiores a $10,000. Todas las referencias a
TRANSMASTER en la subconsulta denotan el contenido de TRANSMASTER antes de
cualquier eliminación por parte de la declaración actual. Entonces, incluso cuando
eliminas la última fila de TRANSMASTER paraID cliente 37,la subconsulta se evalúa en la
tabla TRANSMASTER original y devuelve11000.

Cuando actualiza, elimina o inserta registros de una base de datos, corre el riesgo de que los
datos de una tabla sean inconsistentes con otras tablas de la base de datos. Tal inconsistencia
se llamaanomalía de modificación,discutido en el Capítulo 5. Si elimina registros
TRANSMASTER y una tabla TRANSDETAIL depende de TRANSMASTER,
284 Parte III: Almacenamiento y recuperación de datos

también debe eliminar los registros correspondientes de TRANSDETAIL. Esta operación se

llamaeliminación en cascada,porque la eliminación de un registro principal debe realizarse en
cascada a sus registros secundarios asociados. De lo contrario, los registros secundarios
recuperados quedarán huérfanos. En este caso, serían líneas de detalle de factura que están
en el limbo porque ya no están conectadas a un registro de factura.

Si su implementación de SQL no admite eliminaciones en cascada, debe realizar las

eliminaciones usted mismo. En este caso, elimine los registros apropiados de la tabla
secundaria antes de eliminar el registro correspondiente de la tabla principal. De esa manera,
no tendrá registros huérfanos en la tabla secundaria, ni siquiera por un segundo.

Recuperar cambios con DML canalizado

En la sección anterior, muestro cómo unACTUALIZAR, BORRAR,oINSERTAR La declaración
puede incluir un [Link]ón dentro de unDÓNDEcláusula. SQL:2011
introduce una capacidad relacionada, en la que un comando de manipulación de datos (como
ACTUALIZAR, INSERTAR, BORRAR,oUNIRdeclaraciones) se pueden anidar dentro de un
SELECCIONARdeclaración. Esta capacidad se llamaDML canalizado.

Una forma de ver una operación de cambio de datos es imaginar una tabla antes de
cambiarla con unBORRAR, INSERTAR,oACTUALIZARoperación. Puede llamar a la tabla
antes del cambio la tabla anterior y a la tabla después del cambio, la nueva tabla. Durante
la operación de cambio de datos, se crean tablas auxiliares, llamadastablas delta, son
creados. ABORRARLa operación crea una tabla delta antigua, que contiene las filas que se
eliminarán. UnINSERTARLa operación crea una nueva tabla delta, que contiene las filas
que se insertarán. UnACTUALIZARLa operación crearía una tabla delta nueva y antigua, la
antigua para las filas que se reemplazan y la nueva para las filas que las reemplazan.

Con DML canalizado, puede recuperar la información en las tablas delta.

Supongamos que desea eliminar de su línea de productos todos los productos
con ID de producto entre 1000 y 1399 y desea un registro de exactamente qué
productos en ese rango se eliminan. Podrías usar el siguiente código:

SELECCIONAR [Link]
DE LA TABLA ANTIGUA (ELIMINAR DEL Producto
DONDE ProductID ENTRE 1000 Y 1399)
COMO Mesa antigua;

En este ejemplo, las palabras claveMESA ANTIGUAespecificar que el resultado de la

SELECCIONARproviene de la antigua tabla delta. El resultado es la lista de números de ID de
producto para los productos que se están eliminando.

De manera similar, puede recuperar una lista de la nueva tabla delta usando elNUEVA
MESApalabras clave, que muestra los números de ID de producto de las filas insertadas
por unINSERTARoperación o actualizado por unACTUALIZARoperación. porque un
ACTUALIZARLa operación creó una tabla delta antigua y una tabla delta nueva, puede
recuperar el contenido de una o ambas mediante DML canalizado.
Traducido del inglés al español - [Link]

Capítulo 13

Consultas recursivas

En este capítulo
▶ Comprender el procesamiento recursivo
▶ Definición de consultas recursivas
▶ Encontrar formas de utilizar consultas recursivas

oh Una de las principales críticas a SQL, hasta SQL-92 inclusive, fue su incapacidad para
implementarprocesamiento [Link] problemas importantes que son difíciles
de resolver por otros medios ceden fácilmente a soluciones recursivas. Las extensiones
incluidas en SQL:1999 permiten consultas recursivas, lo que amplía enormemente el poder del
lenguaje. Si su implementación de SQL incluye extensiones de recursividad, puede resolver
eficientemente una gran clase nueva de problemas. Sin embargo, debido a que la recursividad
no es parte del núcleo de SQL, muchas implementaciones disponibles actualmente no la
incluyen.

¿Qué es la recursividad?
La recursividad es una característica que existe desde hace años en lenguajes de
programación como Logo, LISP y C++. En estos idiomas, puede definir unfunción(un
conjunto de uno o más comandos) que realiza una operación específica. El programa
principal invoca la función emitiendo un comando llamadoLlamada de funció[Link] la
función se llama a sí misma como parte de su operación, tiene la forma más simple de
recursividad.

Un programa sencillo que utiliza la recursividad en una de sus funciones proporciona un

ejemplo de los beneficios y los inconvenientes de la recursividad. El siguiente programa, escrito
en C++, dibuja una espiral en la pantalla de la computadora. Se supone que la herramienta de
dibujo apunta inicialmente hacia la parte superior de la pantalla e incluye tres funciones:

✓ La funciónlínea(norte)dibuja una líneanorteunidades de largo.

✓ La funcióngiro a la izquierda(d)gira la herramienta de dibujodgrados en

sentido antihorario.
286 Parte III: Almacenamiento y recuperación de datos

✓ Puedes definir la funció[Link] (segmento)como sigue:

espiral vacía (segmento int) {

segmento de línea)
giro_izquierda(90)
espiral(segmento + 1)
};

si llamasespiral(1)Desde el programa principal se realizan las siguientes

acciones:

espiral(1)Dibuja una línea de una unidad de largo hacia la parte superior de la

pantalla. espiral(1)gira 90 grados a la izquierda. espiral(1)llamadasespiral(2).

espiral(2)Dibuja una línea de dos unidades de largo hacia el lado izquierdo de la pantalla.

espiral(2)gira 90 grados a la izquierda. espiral(2)llamadasespiral(3). Etcétera. . . .

Finalmente, el programa genera la espiral que se muestra en la Figura 13-1.

Figura 13-1:
Consecuencia de

vocación
espiral(1).
 Capítulo 13: Consultas recursivas 287

Houston, tenemos un problema

Bueno, está bien, la situación aquí no es tan grave como lo fue en el caso del Apolo 13, cuando
el tanque principal de oxígeno explotó mientras la nave espacial se dirigía a la luna. Su
problema es que el programa de dibujo en espiral sigue llamándose a sí mismo y dibujando
líneas cada vez más largas. Continuará haciéndolo hasta que la computadora que lo ejecuta
se quede sin recursos y (si tiene suerte) muestre un desagradable mensaje de error en la
pantalla. Si no tienes suerte, la computadora simplemente falla.

El fracaso no es una opción

El escenario descrito en la sección anterior muestra uno de los peligros de utilizar la
recursividad. Un programa escrito para llamarse a sí mismo invoca una nueva instancia de sí
mismo, que a su vez llama a otra instancia má[Link] esto no es lo
que quieres. (Piense en cierto ratón de dibujos animados con sombrero de mago tratando de
detener todas esas escobas que marchan...)

Para abordar este problema, los programadores incluyen uncondición de terminacióndentro

de la función recursiva (un límite sobre la profundidad que puede alcanzar la recursividad) para
que el programa realice la acción deseada y luego finalice correctamente. Puede incluir una
condición de terminación en su programa de dibujo en espiral para ahorrar recursos
informáticos y evitar mareos en los programadores:

espiral vacía2 (segmento int) {

si (segmento <= 10) {

segmento de línea)
giro_izquierda(90)
espiral2(segmento + 1)
}
};

Cuando usted llamaespiral2(1),se ejecuta y luego (recursivamente) se llama a sí

mismo hasta que el valor desegmentoexcede 10. En el punto dondesegmentoes
igual a 11, elsi (segmento <=10)La construcción devuelve un valor Falso y se omite
el código dentro de las llaves interiores. El control vuelve a la invocación anterior
deespiral2y, desde allí, regresa hasta la primera invocación, después de la cual el
programa finaliza. La Figura 13-2 muestra la secuencia de llamadas y devoluciones
que ocurren.
288 Parte III: Almacenamiento y recuperación de datos

Figura 13-2:
Descendente
a través de

recursivo
llamadas, y
luego sube-
haciendo una copia de seguridad

para terminar.

Cada vez que una función se llama a sí misma, te aleja un nivel más del programa
principal que fue el punto de partida de la operación. Para que el programa principal
continúe, la iteración más profunda debe devolver el control a la iteración que lo
llamó. Esa iteración tendrá que hacer lo mismo, regresando al programa principal
que realizó la primera llamada a la función recursiva.

La recursión es una herramienta poderosa para ejecutar código repetidamente cuando

no se sabe desde el principio cuántas veces se debe repetir el código. Es ideal para
buscar en estructuras en forma de árbol, como árboles genealógicos, circuitos
electrónicos complejos o redes de distribución multinivel.

¿Qué es una consulta recursiva?

Aconsulta recursivaes una consulta que depende funcionalmente de sí misma. La forma más
simple de dicha dependencia funcional funciona así: la consulta Q1 se invoca a sí misma en el
cuerpo de la expresión de la consulta. Un caso más complejo es cuando la consulta Q1
depende de la consulta Q2, que a su vez depende de la consulta Q1. Todavía hay una
dependencia funcional y la recursividad todavía está involucrada, sin importar cuántas
consultas haya entre la primera y la segunda invocación de la misma consulta. Si esto suena
raro, no te preocupes: así es como funciona. . .
 Capítulo 13: Consultas recursivas 289

¿Dónde podría utilizar una consulta recursiva?

Las consultas recursivas pueden ayudarle a ahorrar tiempo y frustración al abordar
diversos tipos de problemas. Supongamos, por ejemplo, que tiene un pase que le
permite viajar gratis en cualquier vuelo de la (ficticia) Vannevar Airlines. Muy fresco. La
siguiente pregunta que te haces es: "¿A dónde puedo ir gratis?" La tabla FLIGHT contiene
todos los vuelos que ejecuta Vannevar. La Tabla 13-1 muestra el número de vuelo y el
origen y destino de cada vuelo.

Tabla 13-1 Vuelos ofrecidos por Vannevar Airlines

Vuelo No. Fuente Destino
3141 portland condado de Orange

2173 portland charlotte

623 portland Playa de Daytona

5440 condado de Orange montgomery

221 charlotte Menfis
32 Menfis champán
981 montgomery Menfis

La figura 13-3 ilustra las rutas en un mapa de Estados Unidos.

Figura 13-3:
Ruta
mapa para

vannevar
Aerolíneas.
290 Parte III: Almacenamiento y recuperación de datos

Para comenzar con su plan de vacaciones, cree una tabla de base de datos para FLIGHT usando
SQL de la siguiente manera:

CREAR VUELO DE TABLA (

VueloNo ENTERO NO NULO,
Fuente CARACTERÍSTICA (30),

Destino CARACTERÍSTICA (30) );

Una vez creada la tabla, puede completarla con los datos que se muestran en la Tabla 13-1.

Suponga que parte de Portland y desea visitar a un amigo en Montgomery. Naturalmente te

preguntarás: "¿A qué ciudades puedo llegar a través de Vannevar si empiezo desde Portland?" y "¿A
qué ciudades puedo llegar a través de la misma aerolínea si empiezo desde Montgomery?" Se puede
llegar a algunas ciudades de un solo salto; otros no lo son. Algunos pueden requerir dos o más
saltos. Puede encontrar todas las ciudades a las que puede llegar a través de Vannevar,
comenzando desde cualquier ciudad determinada en su mapa de ruta, pero si lo hace una consulta
a la vez, estará. . .

Consultando por las malas

Para saber lo que quieres saber, siempre que tengas tiempo y paciencia,
puedes realizar una serie de consultas, primero utilizandoportlandcomo ciudad
inicial:

SELECCIONE Destino DESDE EL VUELO DONDE Fuente = 'Portland';

La primera consulta regresaCondado de Orange, Charlotte,yPlaya de Daytona. Su

segunda consulta utiliza el primero de estos resultados como punto de partida:

SELECCIONE Destino DESDE EL VUELO DONDE Fuente = 'Naranja

Condado';

La segunda consulta [Link] tercera consulta vuelve a los resultados de

la primera consulta y utiliza el segundo resultado como punto de partida:

SELECCIONE Destino DESDE EL VUELO DONDE Fuente = 'Charlotte';

La tercera consulta [Link] cuarta consulta vuelve a los resultados de la

primera consulta y utiliza el resultado restante como punto de partida:

SELECCIONE Destino DESDE EL VUELO DONDE Fuente = 'Daytona

Playa';

Lo sentimos, la cuarta consulta devuelve un resultado nulo porquevannevarno ofrece vuelos

salientes desdePlaya de [Link] la segunda consulta devolvió otra ciudad. (Montgomery)como
posible punto de partida, por lo que su quinta consulta utiliza ese resultado:

SELECCIONE Destino DESDE EL VUELO DONDE Fuente = 'Montgomery';

 Capítulo 13: Consultas recursivas 291
Esta consulta regresaMenfis,pero ya sabes que está entre las ciudades a las que puedes
llegar (en este caso, a través deCarlota).Pero siga adelante y pruebe este último
resultado como punto de partida para otra consulta:

SELECCIONE Destino DESDE EL VUELO DONDE Fuente = 'Memphis';

La consulta regresachampán -que puedes agregar a la lista de ciudades accesibles

(incluso si tienes que llegar en dos saltos). Siempre que estés considerando varios
saltos, conectaschampáncomo punto de partida:

SELECCIONE Destino DESDE EL VUELO DONDE Fuente = 'Champaign';

Ups. Esta consulta devuelve un valor nulo; Vannevar no ofrece vuelos de salida
desde Champaign. (Siete consultas hasta ahora. ¿Aún estás inquieto?)

Vannevar tampoco ofrece un vuelo desde Daytona Beach, por lo que si vas allí, te quedas
atrapado, lo que puede no ser una dificultad si es la semana de vacaciones de primavera. (Por
supuesto, si dedica una semana a realizar consultas individuales para saber adónde ir a
continuación, es posible que tenga un dolor de cabeza peor que el de una semana de fiesta). O
podría quedarse atrapado en Champaign, en cuyo caso , podrías inscribirte en la Universidad
de Illinois y tomar algunos cursos de bases de datos.

Por supuesto, este método (eventualmente) responderá a la pregunta: "¿A qué ciudades se
puede llegar desde Portland?" Pero ejecutar una consulta tras otra, haciendo que cada una
dependa de los resultados de una consulta anterior, es complicado, requiere mucho tiempo y
es inquietante.

Ahorrar tiempo con una consulta recursiva

Una forma más sencilla de obtener la información que necesita es crear una única consulta recursiva
que haga todo el trabajo en una sola operación. Aquí está la sintaxis para dicha consulta:

CON RECURSIVO
REACHABLEFROM (Origen, Destino)
AS (SELECCIONAR Origen, Destino
DESDE EL VUELO
UNIÓN
SELECCIONAR [Link], [Link]
DESDE ALCANZABLEDESDE entrada, VUELO
salida DONDE [Link] = [Link]
)
SELECCIONAR * DESDE ALCANZABLE DESDE
DONDE Fuente = 'Portland';

La primera vez que realiza la recursividad, FLIGHT tiene siete filas y

REACHABLEFROM no tiene ninguna. ElUNIÓNtoma las siete filas de FLIGHT y las
copia en REACHABLEFROM. En este punto, REACHABLEFROM tiene los datos que se
muestran en la Tabla 13-2.
292 Parte III: Almacenamiento y recuperación de datos

Como mencioné anteriormente, la recursividad no es parte del núcleo de SQL y, por lo tanto, es posible que algunas
implementaciones no la incluyan.

Tabla 13-2 ALCANZABLEDESDE Después de un paso a través de la recursividad

Fuente Destino
portland condado de Orange

portland charlotte
portland Playa de Daytona

condado de Orange montgomery

charlotte Menfis
Menfis champán
montgomery Menfis

La segunda vez a través de la recursividad, las cosas empiezan a ponerse

interesantes. ElDÓNDEcláusula (DONDE [Link] = [Link])
significa que estás mirando sólo las filas dondeDestinoEl campo de la tabla
REACHABLEFROM es igual alFuentecampo de la tabla FLIGHT. Para esas filas,
estás tomando dos campos: elFuentecampo de REACHABLEFROM y elDestino
campo de FLIGHT y agregarlos a REACHABLEFROM como una nueva fila. La
tabla 13-3 muestra el resultado de esta iteración de la recursividad.

Tabla 13-3 ALCANZABLE DESDE Después de dos pases

la recursividad
Fuente Destino
portland condado de Orange

portland charlotte
portland Playa de Daytona

condado de Orange montgomery

charlotte Menfis
Menfis champán
montgomery Menfis
portland montgomery
portland Menfis
condado de Orange Menfis
charlotte champán
 Capítulo 13: Consultas recursivas 293
Los resultados parecen más útiles. REACHABLEFROM ahora contiene todos los Destino
ciudades a las que se puede llegar desde cualquierFuenteciudad en dos saltos o menos. A
continuación, la recursividad procesa viajes de tres saltos, y así sucesivamente, hasta llegar a
todas las ciudades de destino posibles.

Una vez completada la recursividad, el tercer y últimoSELECCIONARLa declaración (que está

fuera de la recursividad) extrae de REACHABLEFROM solo aquellas ciudades a las que se puede
llegar desde Portland volando en Vannevar. En este ejemplo, se puede llegar a las otras seis
ciudades desde Portland, en unos cuantos saltos que no te sentirás como si estuvieras
viajando en un saltador.

Si examina el código en la consulta recursiva, nomirarmás simple que las

siete consultas individuales que reemplaza. Sin embargo, tiene dos ventajas:

✓ Cuando lo pones en movimiento, completa toda la operación sin ninguna

intervención adicional.
✓ Puede hacer el trabajo rápidamente.

Imagine una aerolínea del mundo real con muchas más ciudades en su mapa de
rutas. Cuantos más destinos posibles estén disponibles, mayor será la ventaja de
utilizar el método recursivo.

¿Qué hace que esta consulta sea recursiva? El hecho de que estés definiendo REACHABLEFROM
en términos de sí mismo. La parte recursiva de la definición es la [Link]
declaración, la que está justo después deUNIÓ[Link] es una tabla temporal que
se llena de datos progresivamente a medida que avanza la recursividad. El procesamiento
continúa hasta que se hayan agregado todos los destinos posibles a REACHABLEFROM. Se
eliminan los duplicados, porque elUNIÓN El operador no agrega duplicados a la tabla de
resultados. Una vez que la recursión ha terminado de ejecutarse, REACHABLEFROM contiene
todas las ciudades a las que se puede llegar desde cualquier ciudad inicial. El tercero y último.
SELECCIONARLa declaración devuelve solo aquellas ciudades de destino a las que puede llegar
desde Portland. Buen viaje.

¿En qué otro lugar podría utilizar

una consulta recursiva?
Cualquier problema que pueda diseñar como una estructura en forma de árbol puede resolverse
potencialmente mediante una consulta recursiva. La aplicación industrial clásica esprocesamiento de
materiales(el proceso de convertir materias primas en productos terminados). Supongamos que su
empresa está construyendo un nuevo automóvil híbrido de gasolina y electricidad. Una máquina de
este tipo está construida a partir de subconjuntos (motor, baterías, etc.), que a su vez se construyen a
partir de subconjuntos más pequeños (cigüeñal, electrodos, etc.), que están hechos de piezas aún
más pequeñas.
294 Parte III: Almacenamiento y recuperación de datos

Hacer un seguimiento de todas las partes puede resultar difícil en una base de
datos relacional que no utiliza la recursividad. La recursión le permite comenzar con
la máquina completa y recorrer cualquier camino para llegar a la parte más
pequeña. ¿Quieres conocer las especificaciones del tornillo de sujeción que sujeta la
pinza al electrodo negativo de la batería auxiliar? ElCON RECURSIVOLa estructura le
da a SQL la capacidad de abordar un problema tan complicado.

La recursividad también es natural paraY siProcesando. En el ejemplo de Vannevar

Airlines, ¿qué pasa si la gerencia interrumpe el servicio de Portland a Charlotte? ¿Cómo
afecta eso a las ciudades a las que se puede llegar desde Portland? Una consulta
recursiva le dará rápidamente la respuesta.
 Parte IV

Control de operaciones

[Link]/extras/sqlpara obtener excelente contenido para principiantes en línea.

 En esta parte…
✓ Controlar el acceso

✓ Proteger los datos de la corrupción

✓ Aplicar lenguajes procesales

✓ [Link]/extras/sqlpara obtener excelente contenido para
principiantes en línea.
 Capítulo 14

Proporcionar seguridad de base de datos

En este capítulo
▶ Controlar el acceso a las tablas de la base de datos
▶ Decidir quién tiene acceso a qué
▶ Conceder privilegios de acceso
▶ Quitar privilegios de acceso
▶ Derrotar intentos de acceso no autorizado
▶ Transmisión del poder de conceder privilegios

A El administrador del sistema debe tener conocimientos especiales sobre cómo

funciona una base de datos. Es por eso que, en los capítulos anteriores, analizo las
partes de SQL que crean bases de datos y manipulan datos y (en el Capítulo 3) presento las
funciones de SQL para proteger las bases de datos contra daños o uso indebido. En este
capítulo, profundizo en el tema del uso indebido y en cómo prevenirlo mediante el uso
inteligente de las funciones de SQL.

La persona a cargo de una base de datos puede determinar quién tiene acceso a ella y puede
establecer los niveles de acceso de los usuarios, otorgando o revocando acceso a aspectos del
sistema. El administrador del sistema puede incluso otorgar o revocar el derecho a otorgar y revocar
privilegios de acceso. Si las usa correctamente, las herramientas de seguridad que proporciona SQL
son poderosos protectores de datos importantes. Si se usan incorrectamente, estas mismas
herramientas pueden entorpecer los esfuerzos de los usuarios legítimos en un gran nudo de trámites
burocráticos cuando simplemente intentan hacer su trabajo.

Debido a que las bases de datos a menudo contienen información confidencial que no debería
estar disponible para todos, SQL proporciona diferentes niveles de acceso, desde completo
hasta ninguno, con varios niveles intermedios. Al controlar qué operaciones puede realizar
cada usuario autorizado, el administrador de la base de datos puede poner a disposición todos
los datos que los usuarios necesitan para realizar su trabajo, pero restringir el acceso a partes
de la base de datos que no todos deberían ver o cambiar.
298 Parte IV: Control de operaciones

El lenguaje de control de datos SQL

Las sentencias SQL que utiliza para crear bases de datos forman un grupo conocido como
Lenguaje de definición de datos(DDL). Después de crear una base de datos, puede utilizar otro
conjunto de sentencias SQL, conocidas colectivamente comoLenguaje de manipulación de
datos(DML): para agregar, cambiar y eliminar datos de la base de datos. SQL incluye
declaraciones adicionales que no entran en ninguna de estas categorías. Los programadores a
veces se refieren a estas declaraciones colectivamente comoLenguaje de control de datos(DCL).
Las declaraciones DCL protegen principalmente la base de datos del acceso no autorizado, de
la interacción dañina entre múltiples usuarios de la base de datos y de fallas de energía y mal
funcionamiento del equipo. En este capítulo, analizo la protección contra el acceso no
autorizado.

Niveles de acceso de usuario

SQL proporciona acceso controlado a nueve funciones de administración de bases de datos:

✓ Crear, ver, modificar y eliminar:Estas funciones corresponden a las

INSERTAR, SELECCIONAR, ACTUALIZAR,yBORRARoperaciones que analizo en el
Capítulo 6.
✓ Referenciando:Utilizando elREFERENCIASLa palabra clave (que analizo en los
Capítulos 3 y 5) implica aplicar restricciones de integridad referencial a una tabla
que depende de otra tabla en la base de datos.

✓ Usando:ElUSOLa palabra clave pertenece a dominios, juegos de caracteres,

intercalaciones y traducciones. (Defino dominios, juegos de caracteres, intercalaciones y
traducciones en el Capítulo 5).

✓ Definición de nuevos tipos de datos:Usted trata con nombres de tipos definidos por el usuario
con elBAJOpalabra clave.

✓ Respondiendo a un evento:El uso de laDESENCADENARLa palabra clave hace que se

ejecute una declaración SQL o un bloque de declaraciones cada vez que ocurre un
evento predeterminado.

✓ Ejecutando:Utilizando elEJECUTARLa palabra clave hace que se ejecute una rutina.

El administrador de la base de datos

En la mayoría de las instalaciones con más de unos pocos usuarios, la autoridad suprema de
la base de datos es eladministrador de base de datos(DBA). El DBA tiene todos los derechos y
privilegios sobre todos los aspectos de la base de datos. Ser DBA puede darle una sensación
de poder y responsabilidad. Con todo ese poder a tu disposición, puedes
 Capítulo 14: Proporcionar seguridad a la base de datos 299

arruina fácilmente su base de datos y destruye miles de horas de trabajo. Los DBA deben
pensar clara y cuidadosamente sobre las consecuencias de cada acción que realizan.

El DBA no sólo tiene todos los derechos sobre la base de datos, sino que también controla los
derechos que tienen otros usuarios. Por lo tanto, las personas de gran confianza pueden
acceder a más funciones (y, tal vez, a más tablas) que la mayoría de los usuarios.

Una forma segura de convertirse en DBA es instalar el sistema de gestión de bases de

datos. La persona que instala una base de datos es automáticamente un DBA. El manual
de instalación le proporciona una cuenta, oacceso,y una contraseña. Ese inicio de sesión
lo identifica como un usuario con privilegios especiales. A veces, el sistema llama a este
usuario privilegiado el DBA, a veces eladministrador de sistema,y a veces elsuperusuario(
lo siento, no se proporcionan capa ni botas). Como primer acto oficial después de iniciar
sesión, debe cambiar su contraseña predeterminada a una secreta propia.

Si no cambia la contraseña, cualquier persona que lea el manualTambién puede iniciar sesión con
privilegios completos de [Link]és de cambiar la contraseña, solo las personas que conozcan la
nueva contraseña podrán iniciar sesión como DBA. Le sugiero que comparta la nueva contraseña de
DBA solo con un pequeño número de personas de gran confianza. Después de todo, la caída de un
meteorito podría impactarte mañana; podrías ganar la lotería; o puede dejar de estar disponible para
la empresa de alguna otra manera. Tus compañeros deben poder continuar en tu ausencia.
Cualquiera que conozca el nombre de usuario y la contraseña del DBA se convierte en DBA después
de utilizar esa información para acceder al sistema.

Si tiene privilegios de DBA, inicie sesión como DBA solo si necesita realizar una tarea específica que
requiera privilegios de DBA. Después de terminar, cierre sesión. Para el trabajo de rutina, inicie sesión
utilizando su ID de inicio de sesión y contraseña personales. Este enfoque puede evitar que usted
cometa errores que tengan graves consecuencias para las tablas de otros usuarios (así como para las
suyas propias).

Propietarios de objetos de base de datos

Otra clase de usuario privilegiado, junto con el DBA, es elpropietario del objeto de base de
[Link] tablas y vistas, por ejemplo, sonobjetos de base de [Link] usuario que cree
dicho objeto puede especificar su propietario. El propietario de una mesa disfruta de todos los
privilegios posibles asociados con esa mesa, incluido el privilegio de otorgar acceso a la mesa a
otras personas. Como puede basar vistas en tablas subyacentes, alguien que no sea el
propietario de una tabla puede crear una vista basada en esa tabla. Sin embargo, el
propietario de la vista sólo recibe los privilegios que tiene para la tabla subyacente. En pocas
palabras: un usuario no puede eludir la protección en la tabla de otro usuario simplemente
creando una vista basada en esa tabla.
300 Parte IV: Control de operaciones

El público
En términos de red, "el público" está formado por todos los usuarios que no son usuarios
especialmente privilegiados (es decir, DBA o propietarios de objetos) y a quienes un usuario
privilegiado no ha concedido específicamente derechos de acceso. Si un usuario privilegiado otorga
ciertos derechos de acceso aPÚBLICO,entonces todos los que puedan acceder al sistema obtienen
esos derechos.

En la mayoría de las instalaciones, existe una jerarquía de privilegios de usuario, en la que el

DBA se encuentra en el nivel más alto y el público en el más bajo. La Figura 14-1 ilustra la
jerarquía de privilegios.

Figura 14-1:
El acceso-
privilegio
jerarquía.

Otorgar privilegios a los usuarios

El DBA, en virtud de su cargo, tiene todos los privilegios sobre todos los objetos de la
base de datos. Después de todo, el propietario de un objeto tiene todos los privilegios
con respecto a ese objeto, y la base de datos en sí misma es un objeto. Nadie más tiene
privilegios con respecto a ningún objeto, a menos que alguien que ya tenga esos
privilegios (y la autoridad para transmitirlos) los conceda específicamente. Otorgas
privilegios a alguien usando elCONCEDERdeclaración, que tiene la siguiente sintaxis:

CONCEDERlista de privilegios
ENobjeto
ALista de usuarios
[CON OPCIÓN DE JERARQUÍA] [CON
OPCIÓN DE SUBVENCIÓN]
[CONCEDIDO POR el otorgante] ;
 301
Capítulo 14: Proporcionar seguridad a la base de datos

En esta declaración,lista de privilegiosse define de la siguiente manera:

privilegio [, privilegio] ...

TODOS LOS PRIVILEGIOS

Aquíprivilegiose define de la siguiente manera:

SELECCIONAR

| BORRAR
| INSERTAR [(nombre-columna[,nombre-columna]...)] |
ACTUALIZAR [(nombre-columna[,nombre-columna]...)]
| REFERENCIAS [(nombre-columna[,nombre-columna]...)] |
USO
| BAJO
| DESENCADENAR
| EJECUTAR

En la declaración original,objetose define de la siguiente manera:

[ TABLA ] <nombre de la tabla> | DOMINIO

<nombre de dominio> | COLABORACIÓN
<nombre de intercalación>
| JUEGO DE CARACTERES <nombre del juego de
caracteres> | TRADUCCIÓN <nombre de transliteración>
| TIPO <nombre de tipo definido por el usuario resuelto por esquema> |
SECUENCIA <nombre del generador de secuencia>
| <designador de rutina específico>

YLista de usuariosen la declaración se define de la siguiente manera:

ingresar identificación [,ingresar identificación]...

| PÚBLICO

Elcedentees elUSUARIO ACTUALo elROL ACTUAL.

La sintaxis anterior considera que una vista es una tabla. ElSELECCIONAR, BORRAR, INSERTAR,
ACTUALIZAR, DISPARAR,yREFERENCIASLos privilegios se aplican sólo a tablas y vistas. ElUSOEl
privilegio se aplica a dominios, juegos de caracteres, intercalaciones y traducciones. ElBAJOEl
privilegio se aplica sólo a los tipos, y elEJECUTAR El privilegio se aplica sólo a las rutinas. Las
siguientes secciones ofrecen ejemplos de las diversas formas en que puede utilizar el
CONCEDERdeclaración y los resultados de esos usos.

Roles
Anombre de usuarioes un tipo de identificador de autorización, pero no es el único.
Identifica a una persona (o un programa) autorizada para realizar una o más
302 Parte IV: Control de operaciones

funciones en una base de datos. En una organización grande con muchos usuarios,
otorgar privilegios a cada empleado individual puede resultar tedioso y llevar mucho
tiempo. SQL aborda este problema introduciendo la noción de roles.

Arole,identificado por un nombre de función, es un conjunto de cero o más privilegios que se

pueden otorgar a varias personas y todas requieren el mismo nivel de acceso a la base de
datos. Por ejemplo, todos los que desempeñan el [Link] de seguridadtiene los mismos
privilegios. Estos privilegios son diferentes de los otorgados a las personas que tienen el rol
Empleado de ventas.

Como siempre, no todas las funciones mencionadas en la última versión de la especificación

SQL están disponibles en todas las implementaciones. Consulte la documentación de su DBMS
antes de intentar utilizar roles.

Puede crear roles utilizando una sintaxis similar a la siguiente:

CREAR PAPEL VendedorDependiente;

Una vez que haya creado un rol, puede asignar personas al rol con elCONCEDER
declaración, similar a la siguiente:

OTORGAR vendedora a Becky;

Puede otorgar privilegios a una función exactamente de la misma manera que otorga
privilegios a los usuarios, con una excepción: no discutirá ni se quejará.

Insertando datos
Para otorgarle a un rol el privilegio de agregar datos a una tabla, siga este ejemplo:

INSERCIÓN DE SUBVENCIÓN

EN EL CLIENTE
AL vendedor;

Este privilegio permite a cualquier empleado del departamento de ventas agregar nuevos
registros de clientes a la tabla CLIENTE.

mirando datos
Para permitir que las personas vean los datos de una tabla, utilice el siguiente ejemplo:

CONCEDER SELECCIONAR
SOBRE EL PRODUCTO
AL PÚBLICO ;
 Capítulo 14: Proporcionar seguridad a la base de datos 303

Este privilegio permite a cualquier persona con acceso al sistema (PÚBLICO)para ver
el contenido de la tabla PRODUCTO.

Esta afirmación puede ser peligrosa. Las columnas de la tabla PRODUCTO pueden contener
información que no todos deberían ver, comoCoste de [Link] proporcionar acceso a la
mayor parte de la información y al mismo tiempo retener el acceso a información confidencial,
defina una vista en la tabla que no incluya las columnas confidenciales. Entonces concede
SELECCIONARprivilegios en la vista en lugar de en la tabla subyacente. El siguiente ejemplo
muestra la sintaxis de este procedimiento:

CREAR VER MERCANCÍA COMO

SELECCIONAR Modelo, NombreProd, DescrProd, PrecioLista
DEL PRODUCTO ;
CONCEDER SELECCIONAR
SOBRE MERCANCÍAS
AL PÚBLICO ;

Utilizando elMERCANCÍASvista, el público no puede ver la tabla PRODUCTOCoste

de bienescolumna o cualquier otra columna. El público ve sólo las cuatro columnas
enumeradas en elCREAR VISTAdeclaración.

Modificar datos de la tabla

En cualquier organización activa, los datos de las tablas cambian con el tiempo. Es necesario
otorgar a algunas personas el derecho y el poder de realizar cambios, y también impedir que
todos los demás lo hagan. Para otorgar privilegios de cambio, como actualización, siga este
ejemplo:

ACTUALIZACIÓN DE SUBVENCIÓN (BonusPct)

EN BONIFICACIÓN
AL director de ventas;

El gerente de ventas puede ajustar la tasa de bonificación que reciben los vendedores por las ventas
(laBonoPctcolumna), basado en cambios en las condiciones del mercado. Sin embargo, el gerente de
ventas no puede modificar los valores en elCantidad mínimay Cantidad máximacolumnas que definen
los rangos para cada paso en el programa de bonificación. Para habilitar las actualizaciones de todas
las columnas, debe especificar todos los nombres de las columnas o ningún nombre de columna,
como se muestra en el siguiente ejemplo:

ACTUALIZACIÓN DE LA SUBVENCIÓN

EN BONIFICACIÓN
A VPSales;
304 Parte IV: Control de operaciones

Eliminar filas obsoletas de una tabla

Los clientes cierran el negocio o dejan de comprar productos por algún otro motivo. Los
empleados renuncian, se jubilan, son despedidos o mueren. Los productos se vuelven
obsoletos. La vida continúa y es posible que las cosas que rastreaste en el pasado ya no sean de
tu interés. Alguien necesita eliminar registros obsoletos de sus tablas. Desea controlar
cuidadosamente quién puede eliminar qué registros. Regular tales privilegios es otra tarea que
corresponde a laCONCEDERdeclaración, como se muestra en el siguiente ejemplo:

CONCEDER ELIMINAR
EN EMPLEADO
AL director de personal;

El gerente de personal puede eliminar registros de la tabla EMPLEADO. También pueden

hacerlo el DBA y el propietario de la tabla EMPLEADO (que probablemente también sea el
DBA). Nadie más puede eliminar registros de personal (a menos que otroCONCEDER
declaración le da a esa persona el poder para hacerlo).

Hacer referencia a tablas relacionadas

Si una tabla incluye la clave principal de una segunda tabla como clave externa, la información
de la segunda tabla queda disponible para los usuarios de la primera tabla. Esta situación crea
potencialmente una puerta trasera peligrosa a través de la cual usuarios no autorizados
pueden extraer información confidencial. En tal caso, un usuario no necesita derechos de
acceso a una tabla para descubrir algo sobre su contenido. Si el usuario tiene derechos de
acceso a una tabla que hace referencia a la tabla de destino, esos derechos a menudo también
le permiten acceder a la tabla de destino.

Supongamos, por ejemplo, que la tabla LAYOFF_LIST contiene los nombres de los
empleados que serán despedidos el próximo mes. Sólo la gestión autorizada tiene
SELECCIONARacceso a la mesa. Sin embargo, un empleado no autorizado deduce que la
clave principal de la tabla [Link], el empleado crea una nueva tabla SNOOP, que
tieneEmpIDcomo clave externa, lo que le permite echar un vistazo a LAYOFF_LIST.
(Describo cómo crear una clave externa con unREFERENCIAS cláusula del Capítulo 5.
Ocupa un lugar destacado en la lista de técnicas que todo administrador de sistemas
debería saber cómo usar (y cómo detectar). Aquí está el código que crea la tabla furtiva:

CREAR SNOOP DE MESA

(EmpID INTEGER REFERENCIAS LAYOFF_LIST);

Ahora todo lo que el empleado necesita hacer es intentarINSERTARfilas correspondientes a todos los
números de identificación de los empleados en SNOOP. La tabla acepta los insertos solo para los empleados
en la lista de despidos. Todas las inserciones rechazadas son para empleados que no están en la lista.
 Capítulo 14: Proporcionar seguridad a la base de datos 305

No todo está perdido. No corre el riesgo de exponer todos los datos privados que desea conservar.
Las versiones recientes de SQL evitan esta violación de seguridad al requerir que los usuarios
privilegiados otorguenexplícitamentecualquier derecho de referencia a otros usuarios, como se
muestra en el siguiente ejemplo:

REFERENCIAS DE SUBVENCIÓN (EmpID)

EN LAYOFF_LIST
AL PERSONNEL_CLERK;

Es posible que desee verificar que su DBMS tenga esta característica actualizada.

Usando dominios
Los dominios, los juegos de caracteres, las intercalaciones y las traducciones también
influyen en los problemas de seguridad. Debe vigilar de cerca todo esto, en particular
los dominios creados, para evitar que se utilicen para socavar sus medidas de
seguridad.

Puede definir un dominio que abarque un conjunto de columnas. Al hacerlo, desea que
todas estas columnas tengan el mismo tipo y compartan las mismas restricciones. Las
columnas que creas en tuCREAR DOMINIOLa declaración hereda el tipo y las
restricciones del dominio. Puede anular estas características para columnas específicas,
si lo desea, pero los dominios proporcionan una forma conveniente de aplicar
numerosas características a varias columnas con una sola declaración.

Los dominios resultan útiles si tiene varias tablas que contienen columnas con
características similares. La base de datos de su empresa, por ejemplo, puede constar de
varias tablas, cada una de las cuales contiene unaPreciocolumna que debe tener un tipo
deDECIMALES(10,2)y valores que no sean negativos y no sean superiores a 10.000. Antes
de crear tablas que contengan estas columnas, cree un dominio que especifique las
características de las columnas, como este:

CREAR DOMINIO PrecioTipoDominio DECIMAL (10,2)

VERIFICAR (Precio >= 0 Y Precio <= 10000);

Quizás identifique sus productos en varias tablas porCódigo de producto, que

siempre es de tipoCARACTER (5),con un primer personaje deX,C,ohy un último
personaje de [Link]én puedes crear un dominio para estas columnas,
como en el siguiente ejemplo:

CREAR DOMINIO CódigoProductoDominio CHAR (5)

VERIFICAR (SUBSTR (VALOR, 1,1) EN ('X', 'C', 'H')
Y SUBSTR (VALOR, 5, 1) EN (9, 0) );
306 Parte IV: Control de operaciones

Con los dominios en su lugar, ahora puede proceder a crear tablas de la siguiente manera:

CREAR PRODUCTO DE TABLA (

Código de producto dominio de código de producto,
Nombre del producto CARACTERÍSTICA (30),

Precio PrecioTipoDominio);

Como mencioné anteriormente para otras funciones SQL estándar ISO/IEC, ningún
producto DBMS las admite [Link] DOMINIOes uno que no cuenta con el apoyo
universal. El DBMS iAnywhere de Sybase lo admite, al igual que PostgreSQL, pero
Oracle 11g y SQL Server 2012 no.

En la definición de la tabla, en lugar de dar el tipo de datos paraCódigo de productoy

Precio,especifique el dominio apropiado. Esta acción le da a esas columnas el tipo
correcto y también aplica las restricciones que especifique en suCREAR DOMINIO
declaraciones.

Cuando utiliza dominios, abre su base de datos a ciertas implicaciones de seguridad.

¿Qué pasa si alguien más quiere utilizar los dominios que usted crea? ¿Esto puede causar
problemas? Sí. ¿Qué pasa si alguien crea una tabla con una columna que tiene un
dominio dePrecioTipoDominio?Esa persona puede asignar valores progresivamente
mayores a esa columna hasta que rechace un valor. Al hacerlo, el usuario puede
determinar el límite superior enTipo de precioque usted especifique en elCONTROLAR
cláusula de suCREAR DOMINIOdeclaración. Si considera que ese límite superior es
información privada, no querrá que otros accedan a [Link] de precio dominio. Para
proteger las tablas en tales situaciones, SQL permite usar dominios solo a aquellos a
quienes el propietario del dominio otorga explícitamente permiso. Por lo tanto, sólo el
propietario del dominio (así como el DBA) puede otorgar dicho permiso. Después de que
considere que es seguro hacerlo, puede otorgar permiso a los usuarios mediante una
declaración como la que se muestra en el siguiente ejemplo:

OTORGAR USO EN DOMINIO PriceType A SalesMgr;

Pueden surgir diferentes problemas de seguridad siGOTAdominios. Las tablas que contienen
columnas que usted define en términos de un dominio causan problemas si intenta GOTAel
dominio. Es posible que necesitesGOTAtodas esas tablas primero. O puede que te encuentres
incapaz deGOTAel dominio. como un dominioGOTAse maneja puede variar de una
implementación a otra. iAnywhere puede hacerlo de una manera, mientras que PostgreSQL
puede hacerlo de otra. En cualquier caso, es posible que desees restringir quién puedeGOTA
dominios. Lo mismo se aplica a los juegos de caracteres, las intercalaciones y las traducciones.

Hacer que se ejecuten sentencias SQL

A veces, la ejecución de una declaración SQL desencadena la ejecución de otra declaración
SQL, o incluso de un bloque de declaraciones. SQL admite desencadenadores.
 Capítulo 14: Proporcionar seguridad a la base de datos 307

Adesencadenarespecifica un evento desencadenante, un tiempo de acción desencadenante y una o más acciones

desencadenadas:

✓ Elacontecimiento desencadenantehace que el disparador se ejecute o dispare.

✓ Eltiempo de acción del disparadorDetermina cuándo ocurre la acción desencadenada, ya

sea justo antes o justo después del evento desencadenante.

✓ Elacción desencadenadaes la ejecución de una o más sentencias SQL.

Si se activa más de una declaración SQL, todas las declaraciones deben estar contenidas
dentro de unCOMIENZO ATÓMICO...FINestructura. La acción desencadenante puede ser
unaINSERTAR, ACTUALIZAR,oBORRARdeclaración.

Por ejemplo, puede utilizar un disparador para ejecutar una declaración que verifique la validez de
un nuevo valor antes de unaACTUALIZAResta permitido. Si se determina que el nuevo valor no es
válido, se puede cancelar la actualización.

Un usuario o rol debe tener laDESENCADENARprivilegio para crear un disparador. He

aquí un ejemplo:

CREAR DISPARADOR ClienteEliminar ANTES DE ELIMINAR

EN EL CLIENTE PARA CADA FILA
CUANDO Estado = 'NY'
INSERT INTO CUSTLOG VALUES ('eliminó un cliente de Nueva York');

Siempre que se elimina un cliente de Nueva York de la tabla CLIENTE, una entrada
en la tabla de registro CUSTLOG registra la eliminación.

Otorgar privilegios en todos los niveles

En el Capítulo 2, describí los tipos estructurados como un tipo de tipo definido por el
usuario (UDT). Gran parte de la arquitectura de tipos estructurados se deriva de las
ideas de la programación orientada a objetos. Una de las ideas que surge de esto es
la idea de unajerarquía,en el que un tipo puede tenersubtiposque derivan algunos
de sus atributos del tipo del que provienen (susupertipo). Además de esos atributos
heredados, también pueden tener atributos exclusivamente propios. Puede haber
múltiples niveles de dicha jerarquía, y el tipo en la parte inferior se denominatipo de
hoja.

Una tabla con tipo es una tabla en la que cada fila almacenada en la tabla es una
instancia del tipo estructurado asociado. Una tabla escrita tiene una columna para cada
atributo de su tipo estructurado asociado. El nombre y el tipo de datos de la columna son
los mismos que el nombre y el tipo de datos del atributo.

Como ejemplo, supongamos que es un creador de pinturas que vende a través de

galerías. Además de obras de arte originales, también vendes firmadas, numeradas,
308 Parte IV: Control de operaciones

ediciones limitadas, ediciones abiertas sin firmar y sin numerar y carteles. Puede crear un
tipo estructurado para su obra de arte de la siguiente manera:

CREAR TIPO de obra de arte (

artista CARÁCTER VARIABLE (30),
título CARÁCTER VARIABLE (50),
descripción CARÁCTER VARIADO (256),
medio CARÁCTER VARIADO (20),
fecha de creación FECHA)
NO FINAL

Aquí hay otro caso de una característica que no está presente en todos los productos DBMS.
Sin embargo, PostgreSQL tiene laCREAR TIPOdeclaración, al igual que Oracle 11g y SQL Server
2012.

Como artista que intenta realizar un seguimiento de su inventario, desea distinguir

entre originales y reproducciones. Es posible que desee además distinguir entre
diferentes tipos de reproducciones. La figura 14-2 muestra un posible uso de una
jerarquía para facilitar las distinciones necesarias. El tipo de obra de arte puede tener
subtipos, que a su vez pueden tener sus propios subtipos.

Figura 14-2:
Obra de arte

mesa
jerarquía.

Existe una correspondencia uno a uno entre los tipos de la jerarquía de tipos y las tablas
de la jerarquía de tablas con tipo. Las tablas estándar, como se analiza en los Capítulos 4
y 5, no se pueden colocar en una jerarquía similar a la que se analiza aquí para las tablas
tipificadas.

En lugar de una clave principal, una tabla escrita tiene una columna de autorreferencia
que garantiza la unicidad, no sólo para la supertabla máxima de una jerarquía,
 Capítulo 14: Proporcionar seguridad a la base de datos 309

sino también para todas sus subtablas. La columna de autorreferencia se especifica mediante
un REFERENCIA EScláusula en la supertabla máximaCREARdeclaración. Cuando la referencia
se genera por el sistema, se garantiza la unicidad en todos los ámbitos.

Otorgar la facultad de otorgar privilegios

El DBA puede otorgar privilegios a cualquiera. El propietario de un objeto puede otorgar
privilegios sobre ese objeto a cualquiera. Pero los usuarios que reciben privilegios de esta
manera no pueden a su vez otorgar esos privilegios a otra persona. Esta restricción ayuda al
DBA o al propietario de la tabla a conservar el control. Sólo los usuarios que el DBA o
propietario del objeto habilite para ello podrán realizar la operación en cuestión.

Desde el punto de vista de la seguridad, poner límites a la capacidad de delegar privilegios de

acceso tiene mucho sentido. Sin embargo, surgen muchas ocasiones en las que los usuarios
necesitan el poder de delegar su autoridad. El trabajo no puede detenerse bruscamente cada
vez que alguien está enfermo, de vacaciones o sale a almorzar.

Puedes confiaralgunousuarios con el poder de delegar sus derechos de acceso a suplentes

designados confiables. Para transferir tal derecho de delegación a un usuario, el CONCEDER
utiliza elCON OPCIÓN DE SUBVENCIÓNcláusula. La siguiente declaración muestra un ejemplo
de cómo puede utilizar esta cláusula:

ACTUALIZACIÓN DE SUBVENCIÓN (BonusPct)

EN BONIFICACIÓN
AL director de ventas
CON OPCIÓN DE SUBVENCIÓN ;

Ahora el gerente de ventas puede delegar laACTUALIZARprivilegio emitiendo la

siguiente declaración:

ACTUALIZACIÓN DE SUBVENCIÓN (BonusPct)

EN BONIFICACIÓN
A AsstSalesMgr;

Después de la ejecución de esta declaración, cualquier persona con el rol de asistente del
gerente de ventas puede realizar cambios en laBonoPctcolumna en la tabla BONUSRATE.

Por supuesto, usted hace un equilibrio entre seguridad y conveniencia cuando delega los
derechos de acceso a una persona alternativa designada. El propietario de la tabla
BONUSRATE cede un control considerable a la hora de conceder elACTUALIZAR privilegio al
gerente de ventas mediante el uso delCON OPCIÓN DE SUBVENCIÓ[Link] dueño de la mesa
espera que el gerente de ventas tome en serio esta responsabilidad y tenga cuidado al
transmitir el privilegio.
310 Parte IV: Control de operaciones

Quitando privilegios
Si tiene una manera de otorgar privilegios de acceso a las personas, también debería tener una
manera de quitarles esos privilegios. Las funciones laborales de las personas cambian y, con estos
cambios, también cambian sus necesidades de acceso a los datos. Digamos que un empleado deja la
organización para unirse a un competidor. Probablemente deberías revocar todos los privilegios de
acceso a esa persona, inmediatamente.

SQL le permite eliminar privilegios de acceso utilizando elREVOCARdeclaración. Esta

declaración actúa como laCONCEDERdeclaración lo hace, excepto que tiene el efecto
inverso. La sintaxis de esta declaración es la siguiente:

REVOCAR [OPCIÓN DE CONCESIÓN PARA]lista de privilegios

Objeto ON
FROM lista de usuarios [RESTRICT|CASCADE] ;

Puede utilizar esta estructura para revocar privilegios específicos y dejar otros
intactos. La principal diferencia entre elREVOCARdeclaración y el CONCEDER
declaración es la presencia de la opcionalRESTRINGIRoCASCADApalabra clave en el
REVOCARdeclaración.

Por ejemplo, supongamos que usasCON OPCIÓN DE SUBVENCIÓNcuando otorgaste ciertos

privilegios a un usuario. Eventualmente, cuando desee revocar esos privilegios, puede usar
CASCADAen elREVOCARdeclaración. Cuando revocas los privilegios de un usuario de esta
manera, también le quitas los privilegios a cualquier persona a quien esa persona le haya
otorgado privilegios.

Por otra parte, elREVOCARdeclaración con elRESTRINGIRLa opción funciona sólo si el

beneficiariono tienedelegado los privilegios especificados. En ese caso, el REVOCARLa
declaración revoca perfectamente los privilegios del beneficiario. Pero si el cesionario
transmitió los privilegios especificados, elREVOCARdeclaración con elRESTRINGIR La
opción no revoca nada y, en cambio, devuelve un código de error. Esta es una clara
advertencia para usted de que necesita averiguar a quién le concedieron privilegios la
persona cuyos privilegios está intentando revocar. Es posible que desee o no revocar los
privilegios de esa persona.

Puedes usar unREVOCARdeclaración con el opcionalOPCIÓN DE SUBVENCIÓN PARA cláusula

para revocar sólo la opción de concesión de privilegios específicos y al mismo tiempo permitir
al beneficiario conservar esos privilegios para sí mismo. Si elOPCIÓN DE SUBVENCIÓN PARA
cláusula y laCASCADAAmbas palabras clave están presentes, revoca todos los privilegios que
el beneficiario otorgó, junto con el derecho del beneficiario a otorgar dichos privilegios, como
si nunca hubiera otorgado la opción de otorgamiento en primer lugar. Si el
 Capítulo 14: Proporcionar seguridad a la base de datos 311

OPCIÓN DE SUBVENCIÓN PARAcláusula y laRESTRINGIRambas cláusulas están presentes,

sucede una de dos cosas:

✓ Si el beneficiario no le otorgó a nadie más ninguno de los privilegios que usted está
revocando, entonces elREVOCARLa declaración ejecuta y elimina la capacidad del
cesionario para otorgar privilegios.

✓ Si el beneficiario ya ha otorgado al menos uno de los privilegios que usted está

revocando, elREVOCARLa declaración no se ejecuta y en su lugar devuelve un código
de error.

El hecho de que puedas otorgar privilegios usandoCON OPCIÓN DE SUBVENCIÓN,Combinado con

el hecho de que también puede revocar privilegios de forma selectiva, hace que la seguridad del
sistema sea mucho más compleja de lo que parece a primera vista. Es posible que varios
otorgantes, por ejemplo, puedan otorgar un privilegio a un solo usuario.
Si uno de esos otorgantes revoca el privilegio, el usuario aún conserva ese privilegio debido a
la concesión aún existente de otro otorgante. Si un privilegio pasa de un usuario a otro a
través delCON OPCIÓN DE SUBVENCIÓN,esta situación crea unacadena de dependencia,en el
que los privilegios de un usuario dependen de los de otro usuario. Si es un DBA o propietario
de un objeto, tenga siempre en cuenta que después de otorgar un privilegio mediante el uso
delCON OPCIÓN DE SUBVENCIÓNcláusula, ese privilegio puede aparecer en lugares
inesperados. Revocar el privilegio de usuarios no deseados y permitir que los usuarios
legítimos conserven el mismo privilegio puede resultar un desafío. En general, elOPCIÓN DE
SUBVENCIÓNyCASCADALas cláusulas abarcan numerosas sutilezas. Si utiliza estas cláusulas,
consulte cuidadosamente tanto el estándar SQL como la documentación de su producto para
asegurarse de comprender cómo funcionan las cláusulas.

Usar GRANT y REVOKE juntos para

ahorrar tiempo y esfuerzo
Habilitar múltiples privilegios para múltiples usuarios en columnas de tabla seleccionadas
puede requerir escribir mucho. Considere este ejemplo: el vicepresidente de ventas quiere que
todos en el departamento de ventas vean todo lo que hay en la tabla CLIENTE, pero solo los
gerentes de ventas deben actualizar, eliminar o insertar [Link] debería actualizar elID de
clientecampo. Los nombres de los gerentes de ventas son Tyson, Keith y David. Puede otorgar
privilegios apropiados a estos administradores con CONCEDERdeclaraciones, de la siguiente
manera:

OTORGAR SELECCIONAR, INSERTAR, ELIMINAR

EN EL CLIENTE
A Tyson, Keith, David;
312 Parte IV: Control de operaciones

ACTUALIZACIÓN DE LA SUBVENCIÓN

EN EL CLIENTE (Empresa, Dirección Cliente, Ciudad Cliente,

CustState, CustZip, CustPhone, ModLevel) A Tyson,
Keith, David;
CONCEDER SELECCIONAR
EN EL CLIENTE
A Jen, Val, Mel, Neil, Rob, Sam, Walker, Ford,
Brandon, Cliff, Joss, MichelleT, Allison, Andrew,
Scott, MichelleB, Jaime, Lynleigh, Matthew, Amanda;

Eso debería hacer el truco. Todos tienenSELECCIONARderechos en la tabla CLIENTE.

Los gerentes de ventas tienen plenoINSERTARyBORRARderechos en la tabla, y pueden
actualizar cualquier columna excepto laID de clientecolumna.

Aquí hay una manera más fácil de obtener el mismo resultado:

CONCEDER SELECCIONAR
EN EL CLIENTE
A los representantes de ventas;

CONCEDER INSERTAR, ELIMINAR, ACTUALIZAR

EN EL CLIENTE
PARA Gerentes ;
REVOCAR ACTUALIZACIÓN
EN EL CLIENTE (CustID)
DE Gerentes ;

Suponiendo que haya asignado roles adecuadamente, aún se necesitan tres

declaraciones en este ejemplo para obtener la misma protección que brindaron las tres
declaraciones en el ejemplo anterior. Nadie podrá cambiar datos en elID de cliente
columna; soloTyson, Keith,yDavidtenerINSERTAR, ELIMINAR,yACTUALIZARprivilegios.
Estas últimas tres declaraciones son significativamente más cortas que las del ejemplo
anterior porque no nombra a todos los usuarios del departamento de ventas, a todos los
gerentes ni a todas las columnas de la tabla.
 Capítulo 15

Protección de datos

En este capítulo
▶ Evitar daños en la base de datos
▶ Comprender los problemas causados por operaciones concurrentes
▶ Tratar problemas de concurrencia a través de mecanismos SQL
▶ Adaptando la protección a sus necesidades con SET TRANSACTION
▶ Protegiendo tus datos sin paralizar operaciones

mi Todo el mundo ha oído hablar de la Ley de Murphy, que suele decirse: "En todo caso
poderir mal, esovoluntad.” La gente bromea con esta pseudoley porque la mayoría
de las veces las cosas van bien. A veces, puedes sentirte afortunado porque no te afecta
lo que pretende ser una de las leyes básicas del universo. Cuando surgen problemas
inesperados, probablemente simplemente reconozca lo que sucedió y lo solucione.

En una estructura compleja, la posibilidad de que surjan problemas imprevistos se dispara. (Un
matemático podría decir que “aumenta aproximadamente como el cuadrado de la
complejidad”). Por lo tanto, los grandes proyectos de software casi siempre se entregan tarde y
a menudo están cargados de errores. Una aplicación DBMS multiusuario no trivial es una
estructura grande y compleja. Durante el funcionamiento, muchas cosas pueden salir mal. Se
han desarrollado métodos para minimizar el impacto de estos problemas, pero nunca se
pueden eliminar por completo. Esta es una buena noticia para los profesionales que realizan
mantenimiento y reparación de bases de datos: probablemente nunca será posible
automatizarlos en un trabajo. Este capítulo analiza los principales aspectos que pueden salir
mal con una base de datos y las herramientas que SQL proporciona para solucionar los
problemas que surjan.

Amenazas a la integridad de los datos

El ciberespacio (incluida su red) es un lugar agradable para visitar, pero para los datos que allí
se encuentran, no es nada fácil. Los datos pueden dañarse o corromperse de diversas formas.
El Capítulo 5 analiza los problemas resultantes de datos de entrada incorrectos, errores del
operador y destrucción deliberada. Declaraciones SQL mal formuladas y
314 Parte IV: Control de operaciones

Las aplicaciones mal diseñadas también pueden dañar sus datos, y descubrir cómo no
requiere mucha imaginación. Dos amenazas relativamente obvias (la inestabilidad de la
plataforma y las fallas del equipo) también pueden destruir sus datos. Ambos peligros
se detallan en las siguientes secciones, así como los problemas que pueden surgir por
el acceso simultáneo.

inestabilidad de la plataforma
inestabilidad de la plataformaEs una categoría de problema que ni siquiera debería existir,
pero, lamentablemente, existe. Es más frecuente cuando ejecuta uno o más componentes
nuevos y relativamente no probados en su sistema. Los problemas pueden acechar en una
nueva versión de DBMS, una nueva versión del sistema operativo o un nuevo hardware.
Condiciones o situaciones que nunca antes habían aparecido pueden aparecer mientras
realiza un trabajo crítico. Su sistema se bloquea y sus datos están dañados. Más allá de dirigir
algunas palabras selectas a su computadora y a las personas que la construyeron, no puede
hacer mucho excepto esperar que su última copia de seguridad sea buena.

Nunca ponga trabajo de producción importante en un sistema que tienecualquier

Componentes no probados. Resista la tentación de dedicar su trabajo principal a una
versión beta no probada de la versión más nueva y con más funciones de su DBMS o
sistema operativo. Si necesita adquirir experiencia práctica con un nuevo producto de
software, hágalo en una máquina que esté completamente aislada de su red de
producción.

Falla en el equipo
Incluso los equipos altamente confiables y bien probados fallan a veces, enviando
sus datos al más allá. Todo lo físico se desgasta con el tiempo, incluso las
computadoras modernas de estado sólido. Si tal falla ocurre mientras su base de
datos está abierta y activa, puede perder datos y, a veces (aún peor) no darse
cuenta. Un fracaso así ocurrirá tarde o temprano. Si ese día está en vigor la Ley de
Murphy, el fallo se producirá en el peor momento posible.

Una forma de proteger los datos contra fallas del equipo [Link] copias
adicionales de todo. Para obtener la máxima seguridad (siempre que su organización pueda
hacerlo financieramente), configure hardware duplicado exactamente como su sistema de
producción. Tenga copias de seguridad de bases de datos y aplicaciones que puedan cargarse
y ejecutarse en su hardware de copia de seguridad cuando sea necesario. Si las limitaciones de
costos le impiden duplicar todo (lo que efectivamente duplica sus costos), al menos asegúrese
de hacer copias de seguridad de su base de datos y aplicaciones con suficiente frecuencia para
que una falla inesperada no requiera volver a ingresar una gran cantidad de datos. Muchos
productos DBMS incluyen capacidades de replicación. Eso está muy bien, pero no ayudará a
menos que configure su sistema para usarlos.
 Capítulo 15: Protección de datos 315
Otra forma de evitar las peores consecuencias de una falla del equipo es utilizar
procesamiento de transacciones—un tema que ocupa un lugar central más adelante en este
capítulo. Atransacciónes una unidad de trabajo indivisible, por lo que cuando utiliza el
procesamiento de transacciones, se ejecuta una transacción completa o no se ejecuta
ninguna. Este enfoque de todo o nada puede parecer drástico, pero los peores problemas
surgen cuando una serie de operaciones de base de datos sólo se procesan parcialmente. Por
lo tanto, es mucho menos probable que pierda o corrompa sus datos, incluso si la máquina
en la que reside la base de datos falla.

Acceso simultáneo
Suponga que está ejecutando hardware y software probados, que sus datos son buenos, su
aplicación está libre de errores y su equipo es inherentemente confiable. Utopía de datos,
¿verdad? No exactamente. Aún pueden surgir problemas cuando varias personas intentan
utilizar la misma tabla de base de datos al mismo tiempo.(acceso simultáneo),y sus
computadoras discuten sobre quién va primero(contención).Los sistemas de bases de datos
de múltiples usuarios deben poder manejar el alboroto de manera eficiente.

Problemas de interacción de transacciones

Los problemas de contención pueden acechar incluso en aplicaciones que parecen sencillas.
Considere este ejemplo. Estás escribiendo una aplicación de procesamiento de pedidos que
incluye cuatro tablas: ORDER_MASTER, CUSTOMER, LINE_ITEM e INVENTORY. Se aplican las
siguientes condiciones:

✓ La tabla ORDER_MASTER tieneNúmero de ordencomo clave principal y Número de

clientecomo una clave externa que hace referencia a la tabla CLIENTE.

✓ La tabla LINE_ITEM tieneNúmero de líneacomo clave principal,Número de artículo como

una clave externa que hace referencia a la tabla INVENTARIO, yCantidadcomo una de sus
columnas.

✓ La tabla INVENTARIO tieneNúmero de artículocomo clave primaria; también tiene un

campo llamadoCantidad en mano.

✓ Las tres tablas tienen otras columnas, pero no entran en este

ejemplo.

La política de su empresa es enviar cada pedido en su totalidad o no enviarlo en absoluto.

No se permiten envíos parciales ni pedidos atrasados. (Relájate. Es una situación
hipotética.) Escribes elPROCESANDO ORDENaplicación para procesar cada pedido
entrante en la tabla ORDER_MASTER de la siguiente manera: Primero determina si su
empresa puede enviartodolas líneas de pedido. Si es así, escribe el pedido y luego
disminuye elCantidad en manocolumna de la tabla INVENTARIO según sea necesario.
(Esta acción elimina las entradas afectadas del ORDER_MASTER
316 Parte IV: Control de operaciones

y tablas LINE_ITEM.) Hasta ahora, todo bien. Usted configura la aplicación para procesar pedidos de
una de dos maneras cuando los usuarios acceden a la base de datos simultáneamente:

✓ El método 1 procesa la fila INVENTARIO que corresponde a cada fila de la tabla

LINE_ITEM. SiCantidad en manoes lo suficientemente grande, la aplicación
disminuye ese campo. SiCantidad en manono es lo suficientemente grande,
revierte la transacción para restaurar todas las reducciones de inventario
realizadas en otros LINE_ITEM en este pedido.

✓ El método 2 verifica cada fila de INVENTARIO que corresponde a una fila en los
LINE_ITEM del pedido. Si ellos estantodolo suficientemente grande, luego procesa
esos elementos disminuyéndolos.

Generalmente, el Método 1 es más eficiente cuando logra procesar el pedido; El método 2 es más
eficiente cuando fallas. Por lo tanto, si la mayoría de los pedidos se pueden completar la mayor parte
del tiempo, será mejor que utilice el Método 1. Si la mayoría de los pedidos no se pueden completar la
mayor parte del tiempo, será mejor que utilice el Método 2. Supongamos que esta aplicación
hipotética ya no existe. y ejecutarse en un sistema multiusuario que no tiene un control de
concurrencia adecuado. Sí. Se están gestando problemas, de acuerdo. Considere este escenario:

1. Un cliente se comunica con un procesador de pedidos de su empresa (Usuario 1)

para solicitar diez cortapernos y cinco llaves ajustables anchas.

2. El usuario 1 utiliza el Método 1 para procesar el pedido. El primer artículo del pedido son
diez piezas del artículo 1 (cortapernos).

Da la casualidad de que su empresa tiene diez cortadores de pernos en stock y el pedido del Usuario
1 se los lleva todos.

La función de procesamiento de pedidos avanza, disminuyendo la cantidad de

cortadores de pernos a cero. Entonces las cosas se ponen (como dice el proverbio
chino) [Link] cliente se pone en contacto con su empresa para procesar un
pedido y habla con el Usuario 2.

3. El usuario 2 intenta procesar el pedido pequeño del cliente de un cortador de

pernos y descubre que no hay cortadores de pernos en stock.

El pedido del usuario 2 se revierte porque no se puede completar.

4. Mientras tanto, el Usuario 1 intenta completar el pedido de su cliente y revisa el

sistema en busca de cinco piezas del Artículo 37 (llaves ajustables anchas).

Desafortunadamente, su empresa sólo tiene en stock cuatro llaves ajustables

anchas. El pedido completo del usuario 1 (incluidos los cortapernos) se revierte
porque no se puede completar por completo.

La tabla INVENTARIO ahora ha vuelto al estado que tenía antes de que cualquiera de los
usuarios comenzara a operar. Ninguno de los pedidos se ha completado, aunque el pedido
del Usuario 2 podría haberlo sido.
 Capítulo 15: Protección de datos 317
En un escenario ligeramente diferente, al método 2 le va un poco mejor, aunque por una razón
diferente. El usuario 1 verifica todos los artículos pedidos y decide que todos los artículos
pedidossondisponible. Luego, el Usuario 2 entra y procesa un pedido de uno de esos artículos.
antesEl usuario 1 realiza la operación de disminución; La transacción del usuario 1 falla.

La serialización elimina interacciones dañinas

No se produce ningún conflicto si se ejecutan transaccionesen serieen lugar de al mismo
tiempo. (Tomar turnos, qué concepto). En el primer ejemplo, si la transacción fallida del
Usuario 1 se completó antes de que comenzara la transacción del Usuario 2, elRETROCEDERLa
función habría hecho que el cortador de pernos único solicitado por el Usuario 2 estuviera
disponible. (ElRETROCEDERLa función revierte o deshace toda la transacción). Si las
transacciones se hubieran ejecutado en serie en el segundo ejemplo, el Usuario 2 no habría
tenido oportunidad de cambiar la cantidad de ningún artículo hasta que se completara la
transacción del Usuario 1. La transacción del Usuario 1 se completa, con éxito o sin éxito, y el
Usuario 2 ve cuántas cortadoras de pernos quedan en stock.

Si las transacciones se ejecutan en serie (una tras otra), no tienen ninguna posibilidad
de interactuar de manera destructiva. La ejecución de transacciones concurrentes es
serializablesi el resultado es el mismo que si las transacciones se ejecutaran en serie.

Serializar transacciones simultáneas no es una panacea. Debe hacer un equilibrio entre

rendimiento y protección contra interacciones dañinas. Cuanto más aísle las
transacciones entre sí, más tiempo llevará realizar cada función. (En el ciberespacio, como
en la vida real, hacer cola lleva tiempo). Tenga en cuenta las ventajas y desventajas para
poder configurar su sistema para una protección adecuada, pero no más protección de la
que necesita. Controlar demasiado el acceso simultáneo puede afectar al rendimiento
general del sistema.

Reducir la vulnerabilidad
a la corrupción de datos
Puede tomar precauciones en varios niveles para reducir las posibilidades de perder
datos debido a algún percance o interacción imprevista. Puede configurar su DBMS para
que tome algunas de estas precauciones por usted. Cuando configura su DBMS
adecuadamente, actúa como un ángel guardián para protegerlo de cualquier daño,
operando detrás de escena; Ni siquiera sabes que el DBMS te está ayudando. Su
administrador de base de datos (DBA) puede tomar otras precauciones a su discreción
que usted quizás no conozca. Como desarrollador, puedes tomar precauciones al escribir
tu código.
318 Parte IV: Control de operaciones

Para evitar muchos dolores de cabeza, adquiera el hábito de adherirse automáticamente a algunos
principios simples para que siempre estén incluidos en su código o en sus interacciones con su base
de datos:

✓ Utilice transacciones SQL.

✓ Adapte el nivel de aislamiento para equilibrar el rendimiento y la protección.

✓ Sepa cuándo y cómo configurar transacciones, bloquear objetos de bases de datos y realizar copias de
seguridad.

Los detalles están por llegar.

Usando transacciones SQL

La transacción es una de las principales herramientas de SQL para mantener la integridad de la base
de datos. Untransacción SQLencapsula todas las declaraciones SQL que pueden tener un efecto en la
base de datos. Una transacción SQL se completa con unCOMPROMETERSE oRETROCEDERdeclaración:

✓ Si la transacción finaliza con unCOMPROMETERSE,Los efectos de todas las

declaraciones de la transacción se aplican a la base de datos en una secuencia
rápida.

✓ Si la transacción finaliza con unRETROCEDER,los efectos de todas las declaraciones son

retrotraído(es decir, deshecha) y la base de datos vuelve al estado en el que se
encontraba antes de que comenzara la transacción.

En esta discusión, el términosolicitudsignifica una ejecución de un programa (ya sea en

Java, C++ o algún otro lenguaje de programación) o una serie de acciones realizadas en
una terminal durante un único inicio de sesión.

Una aplicación puede incluir una serie de transacciones SQL. La primera transacción
SQL comienza cuando comienza la aplicación; la última transacción SQL finaliza cuando
finaliza la aplicación. CadaCOMPROMETERSEoRETROCEDERque realiza la aplicación
finaliza una transacción SQL y comienza la siguiente. Por ejemplo, una aplicación con
tres transacciones SQL tiene la siguiente forma:

Inicio de la aplicación
Varias declaraciones SQL(Transacción SQL-1) COMMIT
o ROLLBACK
Varias declaraciones SQL(Transacción SQL-2) COMMIT
o ROLLBACK
Varias declaraciones SQL(Transacción SQL-3) COMMIT
o ROLLBACK
Fin de la aplicación
 Capítulo 15: Protección de datos 319
yo uso la frasetransacción SQLporque la aplicación puede estar utilizando otras
capacidades (como el acceso a la red) que realizan otros tipos de transacciones. En la
siguiente discusión, usotransacciónsignificartransacción SQLespecíficamente.

Una transacción SQL normal tiene un modo de acceso que esLEER ESCRIBIRo SOLO
LECTURA;tiene un nivel de aislamiento que esSERIALIZABLE, LECTURA REPETIBLE,
LECTURA COMPROMETIDA,oLEER SIN COMPROMISO. (Puede encontrar las
características de las transacciones en la sección “Niveles de aislamiento”, más adelante
en este capítulo). Las características predeterminadas sonLEER ESCRIBIRySERIALIZABLE.
Si quieres alguna otra característica, tienes que especificarla con unESTABLECER
TRANSACCIÓN declaración como la siguiente:

ESTABLECER TRANSACCIÓN SÓLO LECTURA;

ESTABLECER TRANSACCIÓN SOLO LECTURA LECTURA REPETIBLE;

ESTABLECER TRANSACCIÓN LEÍDA COMPROMETIDA;

Puedes tener múltiplesESTABLECER TRANSACCIÓNdeclaraciones en una aplicación, pero

solo puede especificar una en cada transacción y debe ser la primera declaración SQL
ejecutada en la transacción. Si quieres usar unESTABLECER TRANSACCIÓNdeclaración,
ejecútela ya sea al comienzo de la aplicación o después de unCOMPROMETERSEo
RETROCEDER.

Debes realizar unESTABLECER TRANSACCIÓNal comienzo de cada transacción para la que desea
propiedades no predeterminadas, porque cada nueva transacción después de unCOMPROMETERSEo
RETROCEDERrecibe las propiedades predeterminadas automáticamente.

AESTABLECER TRANSACCIÓNLa declaración también puede especificar unaTAMAÑO DEL

DIAGNÓSTICO, lo que determina el número de condiciones de error para las cuales la
implementación debe estar preparada para guardar información. (Este límite numérico es necesario
porque una implementación puede detectar más de un error durante una declaración). El valor
predeterminado de SQL para este límite está definido por la implementación, y ese valor
predeterminado casi siempre es adecuado.

La transacción predeterminada
La transacción SQL predeterminada tiene características que resultan satisfactorias para la mayoría
de los usuarios la mayor parte del tiempo. Si es necesario, puede especificar diferentes características
de transacción con unESTABLECER TRANSACCIÓNdeclaración, como se describe en la sección
anterior. (ESTABLECER TRANSACCIÓNrecibe su propio tratamiento destacado más adelante en el
capítulo).
320 Parte IV: Control de operaciones

La transacción predeterminada hace un par de suposiciones implícitas más:

✓ La base de datos cambiará con el tiempo.

✓ Siempre es mejor prevenir que lamentar.

Establece el modo enLEER ESCRIBIR,que, como es de esperar, le permite emitir

declaraciones que cambian la base de datos. También establece el nivel de aislamiento en
SERIALIZABLE,que es el nivel más alto de aislamiento posible (por lo tanto, el más seguro). El
tamaño de diagnóstico predeterminado depende de la implementación. Mire su
documentación de SQL para ver cuál es ese tamaño para su sistema.

Niveles de aislamiento
Idealmente, el sistema maneja sus transacciones independientemente de cualquier otra
transacción, incluso si esas transacciones ocurren al mismo tiempo que la suya. Este concepto
se conoce [Link] embargo, en el mundo real de los sistemas multiusuario en
red con requisitos de acceso en tiempo real, el aislamiento completo no siempre es factible. El
aislamiento puede suponer una penalización demasiado grande en el rendimiento. Surge una
pregunta de compensación: "¿Cuánto aislamiento desea realmente y cuánto está dispuesto a
pagar por él en términos de rendimiento?"

Ser arruinado por una lectura sucia

El nivel más débil de aislamiento se llamaLEER SIN COMPROMISO,lo que permite la lectura
sucia, a veces problemática. Alectura suciaEs una situación en la que un cambio realizado por
un usuario puede ser leído por un segundo usuario antes de que el primer usuario complete
su transacción con unCOMPROMETERSEdeclaración.

El problema surge si el primer usuario cancela y revierte su transacción. Las operaciones

del segundo usuario ahora se basan en un valor incorrecto. El ejemplo clásico de este
error puede aparecer en una solicitud de inventario. En “Problemas de interacción de
transacciones”, anteriormente en este capítulo, describo un posible escenario de este
tipo, pero aquí hay otro ejemplo: un usuario reduce el inventario; un segundo usuario
lee el nuevo valor (inferior). El primer usuario revierte su transacción (restaurando el
inventario a su valor inicial), pero el segundo usuario, pensando que el inventario es
bajo, pide más existencias y posiblemente crea un exceso de existencias grave. Y eso es
si tienes suerte.

No uses elLEER SIN COMPROMISOnivel de aislamiento a menos que no le importen los

resultados precisos.
 Capítulo 15: Protección de datos 321
TúpoderusarLEER SIN COMPROMISOsi desea generar datos estadísticos
aproximados, como estos ejemplos:

✓ Retraso máximo en el cumplimiento de pedidos.

✓ Edad promedio de los vendedores que no cumplen con la cuota

✓ Edad media de los nuevos empleados

En muchos de estos casos, la información aproximada es suficiente; El costo adicional del

control de concurrencia requerido para dar un resultado exacto (principalmente una
desaceleración del rendimiento) puede no valer la pena.

Dejarse engañar por una lectura irrepetible

El siguiente nivel más alto de aislamiento esLEER COMPROMETIDO:Un cambio realizado
por otra transacción no es visible para su transacción hasta que el otro usuario haya
finalizado la otra transacción con elCOMPROMETERSEdeclaración. Este nivel te da un
mejor resultado del que puedes obtenerLEER SIN COMPROMISO,pero todavía está
sujeto a unlectura no repetible—Problema grave que sucede como una comedia de
errores.

Considere el ejemplo clásico de inventario:

1. El usuario 1 consulta la base de datos para ver cuántos artículos de un producto en

particular hay en stock. El número es diez.

2. Casi al mismo tiempo, el Usuario 2 inicia y luego finaliza una transacción con el
COMPROMETERSEDeclaración que registra un pedido de diez unidades de ese
mismo producto, disminuyendo el inventario a cero.

3. Ahora el Usuario 1, al ver que hay diez disponibles, intenta pedir cinco de ellos.
Sin embargo, ya no quedan cinco porque el Usuario 2 ha asaltado la despensa.

La lectura inicial del usuario 1 de la cantidad disponible no es repetible. Debido a que

la cantidad ha cambiado desde el Usuario 1, cualquier suposición hecha sobre la base
de la lectura inicial no es válida.

Arriesgando la lectura fantasma

Un nivel de aislamiento deLECTURA REPETIBLEgarantiza que el problema de lectura no
repetible no ocurre. Este nivel de aislamiento, sin embargo, todavía se ve afectado por la
lectura fantasma—un problema que surge cuando los datos que un usuario está leyendo
cambian en respuesta a otra transacción (y no muestra el cambio en pantalla)mientras el
usuario lo lee.

Supongamos, por ejemplo, que el Usuario 1 emite un comando cuya condición de búsqueda
(laDÓNDEcláusula oTENIENDOcláusula) selecciona un conjunto de filas e, inmediatamente
322 Parte IV: Control de operaciones

Luego, el Usuario 2 realiza y confirma una operación que cambia los datos enalgunode esas
filas. Esos elementos de datos cumplían con la condición de búsqueda del Usuario 1 al
comienzo de este problema, pero ahora ya no lo hacen. Quizás algunas otras filas que lo
hicieron primeronocumplir con la condición de búsqueda original ahorahacerconocerlo. El
usuario 1, cuya transacción aún está activa, no tiene idea de estos cambios; la aplicación se
comporta como si nada hubiera pasado. El desventurado Usuario 1 emite otra declaración SQL
con las mismas condiciones de búsqueda que la original, esperando recuperar las mismas
filas. En cambio, la segunda operación se realiza en filas distintas a las utilizadas en la primera
operación. Los resultados confiables se van por la ventana, desaparecidos por la lectura
fantasma.

Obtener una lectura confiable (aunque más lenta)

Un nivel de aislamiento deSERIALIZABLEno está sujeto a ninguno de los problemas que

aquejan a los otros tres niveles. En este nivel, las transacciones simultáneas se pueden
ejecutar sin interferir entre sí, y los resultados son los mismos que si las transacciones se
hubieran ejecutado en serie (una tras otra) en lugar de en paralelo. Si está ejecutando en
este nivel de aislamiento, los problemas de hardware o software aún pueden causar que
su transacción falle, pero al menos no tiene que preocuparse por la validez de sus
resultados si sabe que su sistema está funcionando correctamente.

Por supuesto, una confiabilidad superior puede tener el precio de un rendimiento más lento, por lo
que está de regreso en Tradeoff City. La Tabla 15-1 muestra cómo se comparan los diferentes
niveles de aislamiento.

Tabla 15-1 Niveles de aislamiento y problemas resueltos

Nivel de aislamiento Problemas resueltos Irrepetible | Fantasma

lectura sucia Leer | Leer

LEER SIN COMPROMISO No No | No
LEER COMPROMETIDO Sí No | No
LECTURA REPETIBLE Sí Sí | No
SERIALIZABLE Sí Sí | Sí

La declaración implícita de inicio de transacción

Algunas implementaciones de SQL requieren que indique el comienzo de una
transacción con una declaración explícita, comoCOMENZARoCOMENZAR [Link]
SQL estándar no. Si no tiene una transacción activa y emite una declaración que
solicita una, SQL estándar inicia una transacción predeterminada por [Link]
 Capítulo 15: Protección de datos 323
TABLA, SELECCIONAR,yACTUALIZARson ejemplos de declaraciones que requieren el
contexto de una transacción. Emita una de estas declaraciones y SQL estándar iniciará una
transacción por usted.

ESTABLECER TRANSACCIÓN
En ocasiones, es posible que desee utilizar características de transacción diferentes a las
establecidas de forma predeterminada. Puede especificar diferentes características con un
ESTABLECER TRANSACCIÓNdeclaración antes de emitir su primera declaración que realmente
requiere una transacción. ElESTABLECER TRANSACCIÓNLa declaración le permite especificar el
modo, el nivel de aislamiento y el tamaño de diagnóstico.

Para cambiar los tres, por ejemplo, puede emitir la siguiente declaración:

ESTABLECER TRANSACCIÓN
SOLO LECTURA,
NIVEL DE AISLAMIENTO LEÍDO NO COMPROMETIDO,
DIAGNÓSTICO TAMAÑO 4 ;

Con esta configuración, no puede emitir ninguna declaración que cambie la base de datos.
(SOLO LECTURA),y ha establecido el nivel de aislamiento más bajo y más peligroso (LEER NO
COMPROMETIDO).El área de diagnóstico tiene un tamaño de 4. Las exigencias mínimas a los
recursos del sistema son mínimas.

En cambio, podrá emitir esta declaración:

ESTABLECER TRANSACCIÓN
LEER ESCRIBIR,
NIVEL DE AISLAMIENTO SERIALIZABLE,
DIAGNÓSTICO TAMAÑO 8 ;

Estas configuraciones le permiten cambiar la base de datos; también le brindan el más alto
nivel de aislamiento y un área de diagnóstico más amplia. La desventaja es que también
exigen mayores recursos del sistema. Dependiendo de su implementación, estas
configuraciones pueden resultar ser las mismas que las utilizadas por la transacción
predeterminada. Naturalmente, puedes emitirESTABLECER TRANSACCIÓNdeclaraciones con
otras opciones para el nivel de aislamiento y el tamaño del diagnóstico.

Establezca el nivel de aislamiento de su transacción tan alto como necesite, pero no más.
Estableciendo siempre su nivel de aislamiento enSERIALIZABLESólo estar seguro puede parecer
razonable, pero no lo es para todos los sistemas. Dependiendo de su implementación (y de lo
que esté haciendo), es posible que no necesite hacerlo y el rendimiento puede verse afectado
significativamente si lo hace. Si no tiene intención de cambiar la base de datos en su
transacción, por ejemplo, configure el modo enSOLO LECTURA. En pocas palabras: no ocupe
ningún recurso del sistema que no necesite.
324 Parte IV: Control de operaciones

COMPROMETERSE

Aunque SQL no requiere una palabra clave explícita para iniciar una transacción, tiene dos que
finalizan una transacción:[Link] haya
llegado al final de la transacción y desee hacer permanentes los cambios (si los hay) que
realizó en la base de datos. Puede incluir la palabra clave opcionalTRABAJAR (COMPROMISO
DE TRABAJO)si quieres. Si la base de datos encuentra un error o el sistema falla mientras se
COMPROMETERSEestá en progreso, es posible que tengas que revertir la transacción e
intentarla nuevamente.

RETROCEDER
Cuando llega al final de una transacción, puede decidir que no desea que los cambios
que se produjeron durante la transacción sean permanentes. En tal caso, debe
restaurar la base de datos al estado en el que se encontraba antes de que comenzara
la transacción. Para ello, emita unRETROCEDERdeclaración. RETROCEDERes un
mecanismo a prueba de fallos.

Incluso si el sistema falla mientrasRETROCEDERestá en progreso, puede reiniciar el

RETROCEDERdespués de restaurar el sistema; la reversión continuará su trabajo,
restaurando la base de datos a su estado anterior a la transacción.

Bloquear objetos de base de datos

El nivel de aislamiento, establecido de forma predeterminada o mediante unESTABLECER
TRANSACCIÓNdeclaración: le dice al DBMS cuán celoso debe ser para proteger su trabajo de la
interacción con el trabajo de otros usuarios. La principal protección contra transacciones
dañinas que le brinda el DBMS es la aplicación de bloqueos a los objetos de la base de datos
que está utilizando. Aquí están algunos ejemplos:

✓ La fila de la tabla a la que accede está bloqueada, lo que impide que otros accedan
a ese registro mientras usted lo usa.

✓ Una tabla completa está bloqueada si está realizando una operación que podría
afectar a toda la tabla.

✓ Se permite leer, pero no escribir. A veces se permite escribir pero no

leer.

Cada implementación maneja el bloqueo a su manera. Algunas implementaciones son más

resistentes que otras, pero la mayoría de los sistemas actualizados lo protegen de los peores
problemas que pueden surgir en una situación de acceso simultáneo.
 Capítulo 15: Protección de datos 325

Copia de seguridad de tus datos

Hacer una copia de seguridad de los datos es una acción de protección que su DBA debe realizar de forma
regular. Se debe realizar una copia de seguridad de todos los elementos del sistema a intervalos que
dependan de la frecuencia con la que se actualizan. Si su base de datos se actualiza diariamente, se debe
realizar una copia de seguridad de ella diariamente. Sus aplicaciones, formularios e informes también pueden
cambiar, aunque con menos frecuencia. Siempre que realice cambios en ellos, su DBA debe hacer una copia
de seguridad de las nuevas versiones.

Mantenga varias generaciones de copias de seguridad. A veces, el daño a la base de datos no se

hace evidente hasta que ha pasado un tiempo. Para volver a la última versión buena, es posible
que tengas que retroceder varias versiones de copia de seguridad.

Puede realizar una copia de seguridad de varias maneras diferentes:

✓ Utilice SQL para crear tablas de respaldo y copiar datos en ellas.

✓ Utilice un mecanismo definido por la implementación que haga una copia de seguridad de
toda la base de datos o de partes de ella. Usar un mecanismo de este tipo es generalmente
más conveniente y eficiente que usar SQL.

✓ Es posible que su instalación tenga un mecanismo para realizar copias de seguridad de

todo, incluidas bases de datos, programas, documentos, hojas de cálculo, utilidades y
juegos de computadora. Si es así, es posible que no tenga que hacer nada más que
asegurarse de que las copias de seguridad se realicen con la frecuencia suficiente para
protegerlo.

Puntos de guardado y subtransacciones

Idealmente, las transacciones deberían ser atómicas, tan indivisibles como los antiguos griegos
pensaban que eran los átomos. Sin embargo, los átomos no son realmente indivisibles y, a
partir de SQL:1999, las transacciones de bases de datos no son realmente atómicas. Una
transacción es divisible en mú[Link] subtransacción finaliza con una
PUNTO DE GUARDADOdeclaración. ElPUNTO DE GUARDADOLa declaración se utiliza junto con
laRETROCEDERdeclaración. Antes de la introducción depuntos de guardado (el punto en el
programa donde elPUNTO DE GUARDADOdeclaración entre en vigor), la RETROCEDERLa
declaración solo podría usarse para cancelar una transacción completa. Ahora se puede utilizar
para revertir una transacción a un punto de guardado dentro de la transacción. ¿De qué sirve
esto?, te preguntarás.

Por supuesto, el uso principal de laRETROCEDERLa declaración es para evitar la corrupción de

datos si una transacción se interrumpe por una condición de error. Y no, volver a un punto de
guardado no tiene sentido si se produjo un error mientras se estaba realizando una
transacción; querrías revertir elcompletotransacción para devolver la base de datos al estado
en el que se encontraba antes de que comenzara la transacción. Pero es posible que tenga
otras razones para revertir parte de una transacción.
326 Parte IV: Control de operaciones

Tener una base de datos ACID

Es posible que escuche a los diseñadores de bases de las cuentas al final de la transacción sean las
datos decir que quieren que sus bases de datos tengan mismas que al comienzo de la transacción. En
ACID. Bueno, no, no planean arruinar sus creaciones con una aplicación diferente, su criterio de
un psicodélico de los años 60 ni disolver los datos que coherencia podría ser diferente.
contienen en un lío burbujeante. ACID es simplemente un
✓ Aislamiento:Idealmente, las transacciones de la
acrónimo de Atomicidad, Consistencia, Aislamiento y
base de datos deberían estar totalmente aisladas de
Durabilidad. Estas cuatro características son necesarias
otras transacciones que se ejecutan al mismo
para proteger una base de datos de la corrupción:
tiempo. Si las transacciones son serializables,
entonces se logra un aislamiento total. Si el sistema
✓ Atomicidad:Las transacciones de la base de tiene que procesar transacciones a máxima
datos deben ser atómicoen el sentido clásico de velocidad, a veces niveles más bajos de aislamiento
la palabra: toda la transacción se trata como una pueden mejorar el rendimiento.
unidad indivisible. O se ejecuta en su totalidad
✓ Durabilidad:Después de que una transacción se
(confirmada) o la base de datos se restaura
haya confirmado o revertido, debería poder contar
(revierte) al estado en el que habría estado si la
con que la base de datos estará en el estado
transacción no se hubiera ejecutado.
adecuado: bien abastecida con datos incorruptos,
✓ Consistencia:Por extraño que parezca, el confiables y actualizados. Incluso si su sistema sufre
significado deconsistenciano es consistente; una falla grave después de una confirmación, pero
varía de una aplicación a otra. Cuando antes de que la transacción se almacene en el disco,
transfieres fondos de una cuenta a otra en un DBMS duradero puede garantizar que, al
una aplicación bancaria, por ejemplo, quieres recuperarse de la falla, la base de datos pueda
la cantidad total de dinero de ambas. restaurarse a su estado adecuado.

Suponga que está realizando una serie compleja de operaciones con sus datos. A mitad
del proceso, recibes resultados que te llevan a concluir que estás yendo por un camino
improductivo. Si estuvieras pensando lo suficiente en el futuro como para poner un
PUNTO DE GUARDADOdeclaración justo antes de comenzar en esa ruta, puede
retroceder al punto de guardado y probar otra opción. Siempre que el resto de su
código estuviera en buen estado antes de establecer el punto de guardado, este
enfoque funciona mejor que cancelar la transacción actual e iniciar una nueva solo para
probar una nueva ruta.

Para insertar un punto de guardado en su código SQL, utilice la siguiente sintaxis:

SAVEPOINT nombre_punto_guardado ;
 Capítulo 15: Protección de datos 327
Puede hacer que la ejecución retroceda a ese punto de guardado con código como el
siguiente:

VOLVER AL PUNTO DE GUARDADO nombre_punto_guardado;

Es posible que algunas implementaciones de SQL no incluyan laPUNTO DE

GUARDADOdeclaración. Si su implementación es una de esas, no podrá usarla.

Restricciones dentro de las transacciones

Garantizar la validez de los datos de su base de datos significa hacer más que simplemente
asegurarse de que los datos sean del tipo correcto. Quizás algunas columnas, por ejemplo, nunca
deberían contener un valor nulo, y quizás otras deberían contener sólo valores que se encuentren
dentro de un rango determinado. Tales restricciones sonrestricciones, como se analiza en el
Capítulo 5.

Las restricciones son relevantes para las transacciones porque posiblemente

puedan impedirle hacer lo que desea. Por ejemplo, suponga que desea agregar
datos a una tabla que contiene una columna con unNO NULOrestricción. Un
método común para agregar un registro es agregar una fila en blanco a su tabla y
luego insertar valores en ella más tarde. ElNO NULOSin embargo, la restricción en
una columna hace que la operación de agregar falle. SQL no le permite agregar
una fila que tenga un valor nulo en una columna con unNO NULOrestricción,
aunque planee agregar datos a esa columna antes de que finalice su transacción.
Para solucionar este problema, SQL le permite designar restricciones como
APLAZABLEoNO APLAZABLE.

Restricciones que sonNO APLAZABLEse aplican inmediatamente. Puedes configurar

APLAZABLErestricciones para ser [Link] un APLAZABLEla
restricción se establece enINMEDIATO,actúa como unNO APLAZABLE restricción: se
aplica inmediatamente. si unAPLAZABLEla restricción se establece en DIFERIDO,no se
hace cumplir. (No, su código no tiene un problema de actitud; simplemente se trata de
seguir órdenes).

Para agregar registros en blanco o realizar otras operaciones que puedan violar
APLAZABLErestricciones, puede utilizar una declaración similar a la siguiente:

ESTABLECER RESTRICCIONES TODAS DIFERIDAS;

Esta afirmación pone a todosAPLAZABLErestricciones en elDIFERIDOcondición.

No afecta laNO APLAZABLErestricciones. Una vez que haya realizado todas las
operaciones que podrían violar sus restricciones (y la tabla alcance un estado
que no las viole), puede volver a aplicarlas. La declaración que vuelve a aplicar
sus restricciones se ve así:

ESTABLECER RESTRICCIONES TODAS INMEDIATAS;

328 Parte IV: Control de operaciones

Si cometió un error y aún se viola alguna de sus restricciones, lo sabrá tan

pronto como esta declaración entre en vigor.

Si no configura explícitamente suDIFERIDOrestricciones aINMEDIATO,SQL lo hace por

usted cuando intentaCOMPROMETERSEsu transacción. Si una infracción todavía está
presente en ese momento, la transacción noCOMPROMETERSE;en cambio, SQL le
muestra un mensaje de error.

El manejo de restricciones por parte de SQL lo protege de ingresar datos no válidos (o

unausenciade datos, que es igualmente importante), al mismo tiempo que le brinda la
flexibilidad de violar restricciones temporalmente mientras una transacción aún está
activa.

Consideremos un ejemplo de nómina para ver por qué es importante poder diferir la
aplicación de restricciones.

Supongamos que una tabla EMPLEADO tiene columnasEmpNo, EmpName, DepartamentoNo,

ySalario. [Link] una clave externa que hace referencia a la tabla DEPT.
Supongamos también que la tabla DEPT tiene columnasDptoNoyNombreDepto. DptoNoes la
clave principal.

Además, desea tener una tabla como DEPT que también contenga unaNómina de sueldos
columna que (a su vez) contiene la suma de losSalariovalores para los empleados de cada
departamento.

Suponiendo que está utilizando un DBMS que admita esta funcionalidad estándar
de SQL, puede crear el equivalente de esta tabla con la siguiente vista:

CREAR VER DEPT2 COMO

SELECCIONE D.*, SUMA([Link]) COMO Nómina
DEL DEPARTAMENTO D, EMPLEADO E
DONDE [Link] = [Link]
GRUPO POR [Link] ;

También puede definir esta misma vista de la siguiente manera:

CREAR VER DEPT3 COMO

SELECCIONAR D.*,
(SELECCIONAR SUMA([Link])
DEL EMPLEADO E
WHERE D.NºDpto = E.NºDpto) AS Nómina
DESDE EL DEPARTAMENTO D;

Pero supongamos que, por motivos de eficiencia, no desea calcular elSUMAcada vez
que haces referenciaDEPT3.Nó[Link] lugar de ello, desea almacenar un valor real
Nómina de sueldoscolumna en la tabla DEPTO. Luego actualizará esa columna cada vez
que cambie unSalario.
 Capítulo 15: Protección de datos 329
Para asegurarse de que elSalariocolumna es precisa, puede incluir una
RESTRICCIÓNen la definición de la tabla:

CREAR DEPARTAMENTO DE TABLA

(Nº de departamento CHAR(5),
[Link](20),
Nómina DECIMAL(15,2),
VERIFICAR (Nómina = (SELECCIONAR SUMA(Salario)
DEL EMPLEADO E
DONDE [Link]= [Link])));

Ahora supongamos que desea aumentar elSalariode empleado123por 100. Puedes

hacerlo con la siguiente actualización:

ACTUALIZAR EMPLEADO
SET Salario = Salario + 100
DONDE EmpNo = '123';

Con este enfoque, debes recordar hacer también lo siguiente:

ACTUALIZACIÓN DEPARTAMENTO D

SET Nómina = Nómina + 100

DONDE D.NºDpto = (SELECCIONAR E.NºDpto
DEL EMPLEADO E
DONDE [Link] = ‘123’) ;

(Se utiliza la subconsulta para hacer referencia a laDptoNode empleado123.)

Pero hay un problema: las restricciones se verifican después de cada declaración. En principio,
todoSe verifican las restricciones. En la práctica, las implementaciones verifican solo las
restricciones que hacen referencia a los valores modificados por la declaración.

Después del primer precedenteACTUALIZARdeclaración, la implementación verifica todas

las restricciones que hacen referencia a cualquier valor que la declaración modifique.
Esto incluye la restricción definida en la tabla DEPT, porque esa restricción hace
referencia a laSalariocolumna de la tabla EMPLEADO y laACTUALIZAR La declaración está
modificando esa columna. Después del primeroACTUALIZARdeclaración, esa restricción
se viola. Asumes que antes de ejecutar elACTUALIZARdeclaración la base de datos es
correcta, y cadaNómina de sueldosEl valor en la tabla DEPT es igual a la suma de los
Salariovalores en las columnas correspondientes de la tabla EMPLEADO. cuando el
primeroACTUALIZARdeclaración aumenta unSalario valor, esta igualdad ya no es cierta.
El segundoACTUALIZARLa declaración corrige esto y nuevamente deja los valores de la
base de datos en un estado para el cual la restricción es Verdadera. Entre las dos
actualizaciones, la restricción es False.

ElESTABLECER RESTRICCIONES APLAZADASLa declaración le permite desactivar temporalmente o

suspendertodas las restricciones, o sólo las restricciones especificadas. Las restricciones son
330 Parte IV: Control de operaciones

diferido hasta que ejecute unESTABLECER RESTRICCIONES INMEDIATAMENTEdeclaración o

ejecuta unaCOMPROMETERSEoRETROCEDERdeclaración. Entonces rodeas a los dos anteriores.
ACTUALIZARdeclaraciones conESTABLECER RESTRICCIONESdeclaraciones. El código se ve así:

ESTABLECER RESTRICCIONES APLAZADAS;

ACTUALIZAR EMPLEADO
SET Salario = Salario + 100 WHERE
EmpNo = '123';
ACTUALIZACIÓN DEPARTAMENTO D

SET Nómina = Nómina + 100 DONDE

D.NºDpto = (SELECCIONE E.NºDpto
DEL EMPLEADO E
DONDE [Link] = ‘123’) ;
ESTABLECER RESTRICCIONES INMEDIATAMENTE;

Este procedimiento difiere todas las restricciones. Si inserta nuevas filas en DEPT, no se
verificarán las claves principales; has eliminado la protección que tal vez quieras
conservar. En su lugar, debe especificar las restricciones que desea aplazar. Para hacer
esto, asigne un nombre a las restricciones cuando las cree:

CREAR DEPARTAMENTO DE TABLA

(Nº de departamento CHAR(5),
NombreDepto. CHAR(20),
Nómina DECIMAL(15,2),
RESTRICCIÓN PayEqSumsal
VERIFICAR (Nómina = SELECCIONAR SUMA
(Salario) DEL EMPLEADO E
DONDE E.NºDpto = DEPTO.NºDpto)) ;

Con los nombres de las restricciones implementados, puede hacer referencia a sus restricciones
individualmente:

ESTABLECER RESTRICCIONES PayEqSumsal DIFERIDO;

ACTUALIZAR EMPLEADO
SET Salario = Salario + 100 WHERE
EmpNo = '123';
ACTUALIZACIÓN DEPARTAMENTO D

SET Nómina = Nómina + 100 DONDE

D.NºDpto = (SELECCIONE E.NºDpto
DEL EMPLEADO E
DONDE [Link] = ‘123’) ;
ESTABLECER RESTRICCIONES PayEqSumsal INMEDIATO;

Sin un nombre de restricción en elCREARdeclaración, SQL genera una implícitamente.

Ese nombre implícito está en las tablas de información del esquema (catálogo). Pero
especificar los nombres explícitamente es más sencillo.
 Capítulo 15: Protección de datos 331
Ahora suponga que especificó por error un valor de incremento de1000en el segundo
ACTUALIZARdeclaración. Este valor está permitido en elACTUALIZARdeclaración porque la
restricción ha sido diferida. Pero cuando ejecutasESTABLECER RESTRICCIONES . . .
INMEDIATO,Se verifican las restricciones especificadas. Si fallan,ESTABLECER RESTRICCIONES
plantea una excepción. Si en lugar de unESTABLECER RESTRICCIONES . . . INMEDIATO
declaración, usted ejecutaCOMPROMETERSEy se encuentra que las restricciones son falsas,
COMPROMETERSEen lugar de eso realiza unRETROCEDER.

En pocas palabras: solo puede diferir las restriccionesdentrouna transacción. Cuando la

transacción es terminada por unRETROCEDERo unCOMPROMETERSE,las restricciones
están habilitadas y marcadas. La capacidad de SQL de diferir restricciones está
destinada a usarse dentro de una transacción. Si se usa correctamente, la transacción
cancelada no crea ningún dato que viole una restricción disponible para otras
transacciones.
332 Parte IV: Control de operaciones
 Capítulo 16

Usando SQL dentro de las aplicaciones

En este capítulo
▶ Usando SQL dentro de una aplicación
▶ Combinando SQL con lenguajes procedimentales
▶ Evitar incompatibilidades entre idiomas
▶ Incrustar SQL en su código procesal
▶ Llamar módulos SQL desde su código de procedimiento
▶ Invocar SQL desde una herramienta RAD

PAG Los capítulos anteriores abordan sentencias SQL principalmente de forma aislada. Por
ejemplo, se hacen preguntas sobre datos y se desarrollan consultas SQL que recuperan
respuestas a las preguntas. Este modo de operación,SQL interactivo,está bien para descubrir lo
que SQL puede hacer, pero no es así como se usa normalmente SQL.

Aunque la sintaxis SQL puede describirse como similar a la del inglés, no es un lenguaje fácil
de dominar. La abrumadora mayoría de los usuarios de computadoras no dominan SQL, y se
puede suponer razonablemente que nunca lo serán, incluso si este libro tiene un gran éxito.
Cuando surge una pregunta sobre una base de datos, Joe User probablemente no se sentará
en su terminal e ingresará un código [Link]ón para encontrar la
respuesta. Los analistas de sistemas y desarrolladores de aplicaciones son las personas que
probablemente se sientan cómodas con SQL y, por lo general, no hacen carrera ingresando
consultas ad hoc en bases de datos. En cambio, desarrollan aplicaciones para realizar esas
consultas.

Si planea realizar la misma operación repetidamente, no debería tener que

reconstruirla cada vez desde su teclado. Escriba una aplicación para hacer el trabajo y
luego ejecútela tantas veces como desee. SQL puede ser parte de una aplicación, pero
cuando lo es, funciona de manera un poco diferente que en un modo interactivo.

SQL en una aplicación

En el Capítulo 2, SQL se presenta como un lenguaje de programación
incompleto. Para utilizar SQL en una aplicación, debe combinarlo con un
procesallenguaje como Visual Basic, C, C++, C#, Java, COBOL o Python.
334 Parte IV: Control de operaciones

Debido a la forma en que está estructurado, SQL tiene algunas fortalezas y debilidades. Los
lenguajes procedimentales están estructurados de manera diferente a SQL y, en
consecuencia, tienendiferentefortalezas y debilidades.

Afortunadamente, las fortalezas de SQL tienden a compensar las debilidades de los

lenguajes procedimentales, y las fortalezas de los lenguajes procedimentales se
encuentran en aquellas áreas donde SQL es débil. Al combinar los dos, puede crear
aplicaciones potentes con una amplia gama de capacidades. Recientemente,desarrollo
rápido de aplicaciones orientado a objetos(RAD), como Visual Studio de Microsoft y el
entorno de código abierto Eclipse, han aparecido, que incorporan código SQL en
aplicaciones desarrolladas manipulando objetos en pantalla en lugar de escribir código
de procedimiento.

Estando atento al asterisco

En las discusiones interactivas sobre SQL en capítulos anteriores, el asterisco (*) sirve como
sustituto abreviado de "todas las columnas de la tabla". Si la tabla tiene numerosas columnas,
el asterisco puede ahorrarle mucho trabajo de escritura. Sin embargo, usar el asterisco de
esta manera es problemático cuando usa SQL en un programa de aplicación. Una vez escrita
su solicitud, usted u otra persona pueden agregar nuevas columnas a una tabla o eliminar las
antiguas. Al hacerlo, se cambia el significado de "todas las columnas". Cuando su aplicación
especifica "todas las columnas" con un asterisco, puede recuperar columnas distintas de las
que cree que está obteniendo.

Un cambio de este tipo en una tabla no afecta a los programas existentes hasta que es
necesario volver a compilarlos para corregir un error o realizar algún cambio, tal vez meses
después de que se realizó el cambio. Luego, el efecto del comodín * se expande para incluir
todas las columnas actuales. Este cambio puede hacer que la aplicación falle de una manera no
relacionada con la corrección del error (u otro cambio realizado), creando su propia pesadilla de
depuración personal.

Para estar seguro, especifique todos los nombres de las columnas explícitamente en una aplicación en lugar de utilizar
el comodín asterisco. (Para obtener más información sobre los caracteres comodín, consulte el Capítulo 6).

Fortalezas y debilidades de SQL

SQL es fuerte en la recuperación de datos. Si información importante está oculta en algún
lugar de una base de datos de una o varias tablas, SQL le brinda las herramientas que
necesita para recuperarla. No es necesario conocer el orden de las filas o columnas de la tabla
porque SQL no trata las filas o columnas individualmente. Las funciones de procesamiento de
transacciones de SQL garantizan que las operaciones de su base de datos no se vean
afectadas por ningún otro usuario que pueda estar accediendo simultáneamente a las
mismas tablas que usted.
 Capítulo 16: Uso de SQL dentro de las aplicaciones 335
Una debilidad importante de SQL es su rudimentaria interfaz de usuario. No tiene ninguna
disposición para formatear pantallas o informes. Acepta líneas de comando desde el teclado y
envía los valores recuperados a la pantalla del monitor, una fila a la vez.

A veces una fortaleza en un contexto es una debilidad en otro. Uno de los puntos
fuertes de SQL es que puede operar en una tabla completa a la vez. Ya sea que la tabla
tenga una fila, cien filas o cien mil filas, una solaSELECCIONAR La declaración puede
extraer los datos que desee. Sin embargo, SQL no puede operar fácilmente en una fila a
la vez y, a veces, es necesario tratar cada fila individualmente. En tales casos, puede
utilizar la función de cursor de SQL (descrita en el Capítulo 19) o puede utilizar un
lenguaje anfitrión procedimental.

Fortalezas y debilidades de los lenguajes

procedimentales
A diferencia de SQL, los lenguajes de procedimientos están diseñados para operaciones de
una fila a la vez, lo que brinda al desarrollador de aplicaciones un control preciso sobre la
forma en que se procesa una tabla. Este control detallado es una gran fortaleza de los
lenguajes procedimentales. Pero una debilidad correspondiente es que el desarrollador de la
aplicación debe tener un conocimiento detallado sobre cómo se almacenan los datos en las
tablas de la base de datos. El orden de las columnas y filas de la base de datos es importante y
debe tenerse en cuenta.

Debido a la naturaleza paso a paso de los lenguajes de procedimiento, tienen la flexibilidad de

producir pantallas fáciles de usar para la entrada y visualización de datos. También puede
producir informes impresos sofisticados con cualquier diseño que desee.

Problemas al combinar SQL

con un lenguaje procedimental
Tiene sentido intentar combinar SQL y lenguajes procedimentales de tal manera
que pueda beneficiarse de sus fortalezas mutuas y no verse penalizado por sus
debilidades combinadas. Por muy valiosa que pueda ser esa combinación, debes
superar algunos desafíos antes de poder lograr este matrimonio perfecto de una
manera práctica.

Modos de funcionamiento contrastantes

Un gran problema al combinar SQL con un lenguaje procedimental es que SQL opera en tablas
un conjunto a la vez, mientras que los lenguajes procedimentales trabajan en ellas una fila a la
vez. A veces este problema no es gran cosa. Puede separar las operaciones de conjunto de las
operaciones de fila, realizando cada una con la herramienta adecuada.
336 Parte IV: Control de operaciones

Pero si desea buscar en una tabla registros que cumplan ciertas condiciones y realizar
diferentes operaciones en los registros dependiendo de si cumplen con las condiciones, puede
tener un problema. Un proceso de este tipo requiere tanto el poder de recuperación de SQL
como la capacidad de ramificación de un lenguaje procedimental. SQL incorporado le ofrece
esta combinación de capacidades. Puedes simplemente empotrarDeclaraciones SQL en
ubicaciones estratégicas dentro de un programa que haya escrito en un lenguaje de
procedimiento convencional. (Consulte “SQL incorporado” más adelante en este capítulo para
obtener más información).

Incompatibilidades de tipos de datos

Otro obstáculo para la integración fluida de SQL con cualquier lenguaje procedimental
es que los tipos de datos de SQL difieren de los tipos de datos de los principales
lenguajes procedimentales. Esta circunstancia no debería sorprender, porque los tipos
de datos definidos para cualquier lenguaje procedimental son diferentes de los tipos de
otros lenguajes procedimentales.

Puede buscar arriba y abajo, pero no encontrará ninguna estandarización de tipos de datos en
todos los idiomas. En las versiones de SQL anteriores a SQL-92, la incompatibilidad de tipos de
datos era una preocupación importante. En SQL-92 (y también en versiones posteriores del
estándar SQL), elELENCOdeclaración aborda el problema. El capítulo 9 explica cómo puede
utilizarELENCOconvertir un elemento de datos del tipo de datos del lenguaje procedimental a
uno reconocido por SQL, siempre que el elemento de datos en sí sea compatible con el nuevo
tipo de datos.

Conectando SQL a lenguajes procesales

Aunque enfrenta algunos obstáculos potenciales al integrar SQL con lenguajes
procedimentales, recuerde mis palabras: la integración se puede realizar con éxito. De
hecho, en muchos casos, usteddebeintegre SQL con lenguajes de procedimiento si tiene
la intención de producir el resultado deseado en el tiempo asignado, o producirlo.
Afortunadamente, puedes utilizar cualquiera de varios métodos para combinar SQL con
lenguajes de procedimiento. Tres de los métodos (SQL incorporado, lenguaje de módulo
y herramientas RAD) se describen en las siguientes secciones.

SQL incorporado
El método más común para mezclar SQL con lenguajes procedimentales se llama
SQL incorporado.¿Se pregunta cómo funciona SQL incorporado? Eche un vistazo al
nombre y comprenderá lo básico: coloque declaraciones SQL en medio de un
programa de procedimiento, donde las necesite.
 Capítulo 16: Uso de SQL dentro de las aplicaciones 337
Por supuesto, como es de esperar, una declaración SQL que aparece repentinamente en medio
de un programa en C puede presentar un desafío para un compilador que no se lo espera. Por
esa razón, los programas que contienen SQL incorporado generalmente pasan a través de un
preprocesadorantes de ser compilado o interpretado. El SQL EJECUTIVOLa directiva advierte al
preprocesador de la inminente aparición de código SQL.

Como ejemplo de SQL incorporado, mire un programa escrito en la versión Pro*C del
lenguaje C de Oracle. El programa, que accede a la información de una empresa
EMPLEADOtabla, solicita al usuario el nombre de un empleado y luego muestra el
salario y la comisión de ese empleado. Luego solicita al usuario nuevos datos sobre
salarios y comisiones y actualiza la tabla de empleados con ellos:

EXEC SQL COMIENZA LA SECCIÓN DE DECLARACIÓN;

VARCHAR uid[20];
VARCHAR contraseña[20];
Nombre VARCHAR[10];
Salario FLOTANTE, comunicación;
SHORT salario_ind, comm_ind; SECCIÓN
DE DECLARACIÓN FINAL DE EXEC SQL;
principal()
{
int sret; /* código de retorno scanf */
/* Acceso */
strcpy([Link],”FRED”); /* copia el nombre de usuario */
[Link]=strlen([Link]);
strcpy([Link],“TORRE“); /* copia la contraseña */
[Link]=strlen([Link]); EXEC SQL CUANDO
SE DETIENE SQLERROR; EXEC SQL CUANDO
NO SE ENCUENTRA DETENER; CONEXIÓN
EXEC SQL :uid;
printf("Conectado al usuario: porcentajes \n",[Link]);
printf("Ingrese el nombre del empleado para actualizar: ");
scanf("porcentajes",[Link]);
[Link]=strlen([Link]);
EXEC SQL SELECCIONAR SALARIO, COMM INTO :salario,:comm
DEL EMPLEO
DONDE ENAME=:ename;
printf("Empleado: porcentajes de salario: porcentaje6.2f comunicación:
porcentaje6.2f \n“,
[Link], salario, comm);
printf("Ingrese el nuevo salario: ");
sret=scanf("porcentaje",&salario);
ind_salario = 0;
si (sret == EOF!! sret == 0) /* establecer indicador */
ind_salario =-1; /* Establecer indicador para NULL */
printf(“Ingrese nueva comisión: “);
sret=scanf("porcentaje",&comm); comando_ind
= 0; /* establecer indicador */
338 Parte IV: Control de operaciones

si (sret == EOF!! sret == 0)

comm_ind=-1; /* Establecer indicador para NULL */
EMPLEO DE ACTUALIZACIÓN DE SQL EXEC
ESTABLECER SALARIO=:salario:salario_ind
SET COMM=:comm:comm_ind
WHERE ENAME=:ename;
printf(«Porcentajes de empleados actualizados. \n«,[Link]);
TRABAJO DE COMMIT EXEC SQL;
salir(0);
}

No es necesario ser un experto en C para comprender la esencia de lo que hace este programa
(y cómo pretende hacerlo). A continuación se muestra un resumen del orden en que se
ejecutan las declaraciones:

1. SQL declara variables del lenguaje principal.

2. El código C controla el procedimiento de inicio de sesión del usuario.

3. SQL configura el manejo de errores y se conecta a la base de datos.

4. El código C solicita el nombre de un empleado al usuario y lo coloca en una variable.

5. Un SQLSELECCIONARLa declaración recupera los datos del salario y la comisión del

empleado nombrado, y la declaración almacena los datos en las variables del
lenguaje principal:salarioy :com.

6. Luego, C vuelve a tomar el control y muestra el nombre, el salario y la

comisión del empleado y luego solicita nuevos valores para el salario y la
comisión. También verifica si se ha realizado una entrada y, si no es así,
establece un indicador.
7. SQL actualiza la base de datos con los nuevos valores.

8. C luego muestra unOperación completamensaje.

9. SQL confirma la transacción y C finalmente sale del programa.

Puede mezclar los comandos de dos idiomas de esta manera gracias al preprocesador.
El preprocesador separa las sentencias SQL de los comandos del lenguaje principal y
coloca las sentencias SQL en una rutina externa independiente. Cada declaración SQL se
reemplaza con un lenguaje anfitriónLLAMARde la rutina externa correspondiente. El
compilador de lenguaje ahora puede hacer su trabajo.

La forma en que se pasa la parte SQL a la base de datos depende de la implementación.

Usted, como desarrollador de la aplicación, no tiene que preocuparse por nada de esto.
El preprocesador se encarga de ello. TúdeberíaSin embargo, debe preocuparse por
algunas cosas que no aparecen en SQL interactivo, como variables del lenguaje
principal y tipos de datos incompatibles.
 Capítulo 16: Uso de SQL dentro de las aplicaciones339

Declaración de variables del lenguaje principal

Se debe pasar cierta información entre el programa del lenguaje anfitrión y los segmentos
SQL. Pasas estos datos convariables del lenguaje [Link] que SQL reconozca las
variables del lenguaje principal, debe declararlas antes de utilizarlas. Las declaraciones se
incluyen en un segmento de declaración que precede al segmento del programa. El segmento
de declaración se anuncia mediante la siguiente directiva:

EXEC SQL COMENZAR DECLARAR SECCIÓN;

El final del segmento de declaración está señalado por esta línea:

SECCIÓN DE DECLARACIÓN FINAL DE EXEC SQL;

Cada declaración SQL debe estar precedida por unEJECUTIVODirectiva SQL. El final de
un segmento SQL puede o no ser señalado por una directiva terminadora. En COBOL,
la directiva terminadora es "EJECUTIVO FINAL”,y en C, es un punto y coma.

Convertir tipos de datos

Dependiendo de la compatibilidad de los tipos de datos admitidos por el lenguaje host y
aquellos admitidos por SQL, es posible que deba utilizarELENCOpara convertir ciertos tipos.
Puede utilizar variables del lenguaje principal que se hayan declarado en el DECLARAR
SECCIÓ[Link] anteponer los nombres de las variables del host con dos puntos (:)cuando
los usa en sentencias SQL, como en el siguiente ejemplo:

INSERTAR EN LOS ALIMENTOS

(NOMBRE DEL ALIMENTO, CALORÍAS, PROTEÍNAS, GRASAS, CARBOHIDRATOS)
VALORES
(:nombre del alimento, :calorías, :proteína, :grasa, :carbo) ;

Idioma del módulo

Idioma del móduloproporciona otro método para usar SQL con un lenguaje de programación
procedimental. Con el lenguaje del módulo, usted coloca explícitamente todas las
declaraciones SQL en un módulo SQL separado.

un SQLmóduloes simplemente una lista de declaraciones SQL. Cada declaración SQL está
incluida en un SQLprocedimientoy está precedido por una especificación del nombre del
procedimiento y el número y tipos de parámetros.

Cada procedimiento SQL contiene sólo una declaración SQL. En el programa host, usted
llama explícitamente a un procedimiento SQL en cualquier punto del programa host en el
que desee ejecutar la instrucción SQL en ese procedimiento. Se llama al procedimiento SQL
como si fuera un subprograma en el lenguaje anfitrión.
340 Parte IV: Control de operaciones

Por lo tanto, puede utilizar un módulo SQL y el programa host asociado para codificar
explícitamente a mano el resultado del preprocesador SQL para la sintaxis incorporada.

El SQL incorporado es mucho más común que el lenguaje de módulo. La mayoría de los
proveedores ofrecen algún tipo de lenguaje de módulo, pero pocos lo enfatizan en su
documentación. El lenguaje del módulo tiene varias ventajas:

✓ Los programadores de SQL no necesitan ser expertos en el lenguaje

[Link] a que SQL está completamente separado del lenguaje
procedimental, puede contratar a los mejores programadores SQL disponibles
para escribir sus módulos SQL, tengan o no experiencia con su lenguaje
procedimental. De hecho, incluso puede posponer la decisión de qué lenguaje de
procedimiento utilizar hasta que sus módulos SQL estén escritos y depurados.

✓ Puede contratar a los mejores programadores que trabajen en su lenguaje

procedimental, incluso si no saben nada sobre [Link] lógico que si sus expertos
en SQL no tienen que ser expertos en lenguajes procedimentales, ciertamente los
expertos en lenguajes procedimentales no tienen que preocuparse por aprender
SQL.

✓ No se mezcla ningún SQL con el código de procedimiento, por lo que su depurador de lenguaje de
procedimiento [Link] puede ahorrarle un tiempo de desarrollo considerable.

Una vez más, lo que puede considerarse una ventaja desde una perspectiva puede ser
una desventaja desde otra. Debido a que los módulos SQL están separados del código de
procedimiento, seguir el flujo de la lógica no es tan fácil como lo es en SQL incorporado
cuando se intenta comprender cómo funciona el programa.

Declaraciones de módulos
La sintaxis de las declaraciones en un módulo es la siguiente:

MÓDULO [nombre-módulo]
[LOS NOMBRES SON nombre-conjunto-de-caracteres]
IDIOMA {ADA|C|COBOL|FORTRAN|MUMPS|PASCAL|PLI|SQL}
[ESQUEMA nombre-esquema]
[AUTORIZACIÓN id-autorización]
[declaraciones-de-tabla-temporales...]
[declaraciones-de-cursor...]
[declaraciones-de-cursor-dinámico...]
procedimientos...

Los corchetes indican que el nombre del módulo es opcional. Nombrarlo de todos modos es
una buena idea si quieres evitar que las cosas se vuelvan demasiado confusas.
 Capítulo 16: Uso de SQL dentro de las aplicaciones 341

el opcionalLOS NOMBRES SONLa cláusula especifica un juego de caracteres. Si no incluyes un

LOS NOMBRES SONcláusula, se utiliza el conjunto predeterminado de caracteres SQL para su
implementación. ElIDIOMALa cláusula le dice al módulo desde qué idioma será llamado. El
compilador debe saber cuál es el lenguaje de llamada, porque hará que las sentencias SQL
aparezcan ante el programa que llama como si fueran subprogramas en el lenguaje de ese
programa.

Aunque elESQUEMAcláusula y laAUTORIZACIÓNAmbas cláusulas son opcionales, debe

especificar al menos una de ellas. O puede especificar ambos. El ESQUEMALa cláusula
especifica el esquema predeterminado y elAUTORIZACIÓNLa cláusula especifica el
identificador de autorización. Elidentificador de autorizaciónestablece los privilegios que
tienes. Si no especifica un ID de autorización, el DBMS utiliza el ID de autorización
asociado con su sesión para determinar los privilegios que tiene permitido su módulo. Si
no tiene los privilegios necesarios para realizar la operación que requiere su
procedimiento, su procedimiento no se ejecuta.

Si su procedimiento requiere tablas temporales, declarelas con la cláusula de declaración de

tabla temporal. Declare cursores y cursores dinámicos antes de declarar cualquier
procedimiento que los utilice. Declarar un cursor después de que un procedimiento comienza
a ejecutarse está permitido siempre que ese procedimiento no utilice el cursor. Puede tener
sentido declarar cursores para que los utilicen procedimientos posteriores. (Puede encontrar
información más detallada sobre los cursores en el Capítulo 19).

Procedimientos del módulo

Siguiendo todas las declaraciones que analicé en la sección anterior, las partes funcionales del
módulo son los procedimientos. Un procedimiento de lenguaje de módulo SQL tiene un
nombre, declaraciones de parámetros y declaraciones SQL ejecutables. El programa en
lenguaje procesal llama al procedimiento por su nombre y le pasa valores a través de los
parámetros declarados. La sintaxis del procedimiento se ve así:

PROCEDIMIENTO nombre-procedimiento
(declaración-parámetro [, declaración-parámetro]... declaración SQL;

[declaraciones SQL];

La declaración de parámetros debe tener la siguiente forma:

nombre-parámetro tipo-datos

ESTADOSQL
342 Parte IV: Control de operaciones

Los parámetros que declare pueden ser parámetros de entrada, parámetros de salida o
[Link] un parámetro de estado a través del cual se informan errores.
(Puede profundizar en los parámetros dirigiéndose al Capítulo 21).

Herramientas RAD orientadas a objetos

Al utilizar herramientas RAD de última generación, puede desarrollar aplicaciones
sofisticadas sin saber cómo escribir una sola línea de código en C++, C#, Python,
Java o cualquier lenguaje de procedimientos. En su lugar, elige objetos de una
biblioteca y los coloca en los lugares apropiados de la pantalla.

Los objetos de diferentes tipos estándar tienen propiedades características y los

eventos seleccionados son apropiados para cada tipo de objeto. También puedes
asociar un método con un objeto. Elmétodoes un procedimiento escrito en (bueno, sí)
un lenguaje procesal. Sin embargo, es posible crear aplicaciones útiles sin escribir
ningún método.

Aunque puede crear aplicaciones complejas sin utilizar un lenguaje de procedimientos,

tarde o temprano probablemente necesitará SQL. SQL tiene una riqueza de expresión
que es difícil, si no imposible, de duplicar con la programación orientada a objetos.
Como resultado, las herramientas RAD con todas las funciones le ofrecen un mecanismo
para inyectar declaraciones SQL en sus aplicaciones orientadas a objetos. Visual Studio
de Microsoft es un ejemplo de un entorno de desarrollo orientado a objetos que ofrece
capacidad SQL. Microsoft Access es otro entorno de desarrollo de aplicaciones que le
permite utilizar SQL junto con su lenguaje de procedimientos, VBA.

El Capítulo 4 le muestra cómo crear tablas de bases de datos con Access. Esa operación
representa sólo una pequeña fracción de las capacidades de Access. Access es una
herramienta y su objetivo principal es desarrollar aplicaciones que procesen los datos en
tablas de bases de datos. Con Access, puede colocar objetos en formularios y luego
personalizarlos dándoles propiedades, eventos y métodos. Puede manipular los
formularios y objetos con código VBA, que puede contener SQL incorporado.

Aunque las herramientas RAD como Access pueden ofrecer aplicaciones de alta calidad en
menos tiempo, normalmente no funcionan en todas las plataformas. Access, por ejemplo, sólo
se ejecuta con el sistema operativo Microsoft Windows. Es posible que tenga suerte y descubra
que la herramienta RAD que eligió funciona en algunas plataformas, pero si para usted es
importante crear una funcionalidad independiente de la plataforma, o si cree que
eventualmente querrá migrar su aplicación a una plataforma diferente, tenga cuidado.
 Capítulo 16: Uso de SQL dentro de las aplicaciones 343
Las herramientas RAD como Access representan el comienzo de la eventual fusión del
diseño de bases de datos relacionales y orientadas a objetos. Las fortalezas estructurales
del diseño relacional y SQL sobrevivirán. Se verán incrementados por el desarrollo rápido
(y comparativamente libre de errores) que proviene de la programación orientada a
objetos.

Usando SQL con Microsoft Access

El público principal de Microsoft Access son las personas que desean desarrollar
aplicaciones relativamente simples sin programación. Si eso te describe, quizás quieras
ponerAcceso para principiantesen su estante como libro de referencia. El lenguaje de
procedimientos VBA (Visual Basic para Aplicaciones) y SQL están integrados en Access,
pero no se destacan ni en la publicidad ni en la documentación. Si desea utilizar VBA y
SQL para desarrollar aplicaciones más sofisticadas, pruebe mi libro,Acceda a la
programación de energía 2003 con VBA, también publicado por Wiley. El aspecto de
programación de Access no ha cambiado mucho durante la última década. Sin
embargo, tenga en cuenta que SQL en Access no es una implementación completa y
casi necesita las habilidades de detective de Sherlock Holmes para encontrarlo.

Menciono los tres componentes de SQL (lenguaje de definición de datos, lenguaje de manipulación de
datos y lenguaje de control de datos) en el capítulo 3. El subconjunto de SQL contenido en Access
implementa principalmente el lenguaje de manipulación de datos. Puede realizar operaciones de
creación de tablas con Access SQL, pero son mucho más fáciles de realizar con la herramienta RAD
que describo en el Capítulo 4. Lo mismo se aplica a la implementación de funciones de seguridad, que
cubro en el Capítulo 14.

Para echar un vistazo a algo de Access SQL, debes acercarte sigilosamente desde atrás.
Consideremos un ejemplo tomado de la base de datos de la ficticia Sociedad Lunar de Oregón,
una organización de investigación sin fines de lucro. La Sociedad cuenta con varios equipos de
investigación, uno de los cuales es el Equipo de Investigación de la Base Lunar (MBRT). Ha
surgido una pregunta sobre qué artículos académicos han escrito los miembros del equipo. Se
formuló una consulta utilizando la función Consulta por ejemplo (QBE) de Access para
recuperar los datos deseados. La consulta, que se muestra en la Figura 16-1, extrae datos de las
tablas RESEARCHTEAMS, AUTHORS y PAPERS con la ayuda de las tablas de intersección AUTH-
RES y AUTH-PAP que se agregaron para romper las relaciones de muchos a muchos.
344 Parte IV: Control de operaciones

Figura 16-1:
El diseño
Vista de
MBRT
Documentos

consulta.

Después de hacer clic en la pestaña Inicio para acceder a la barra de herramientas, puede hacer clic
en el menú desplegable del ícono Ver en la esquina superior izquierda de la ventana para revelar
las otras vistas disponibles de la base de datos. Una de las opciones es Vista SQL. (Ver Figura 16-2.)

Figura 16-2:
Uno de tus
Ver menú
opciones es
Vista SQL.

Cuando hace clic en Vista SQL, aparece la ventana de edición de SQL, que muestra la
declaración SQL que ha generado Access, según las elecciones que realizó utilizando
QBE.

Esta declaración SQL, que se muestra en la Figura 16-3, es lo que realmente se envía al motor
de la base de datos. El motor de la base de datos, que interactúa directamente con la propia
base de datos, sólo entiende SQL. Cualquier información ingresada en el entorno QBE debe
traducirse a SQL antes de enviarse al motor de la base de datos para su procesamiento.
 Capítulo 16: Uso de SQL dentro de las aplicaciones 345

Figura 16-3:
un SQL
declaración
eso
recupera el
nombres de todos

los papeles
escrito por
miembros de
el MBRT.

Puede notar que la sintaxis de la declaración SQL que se muestra en la Figura 16-3
difiere algo de la sintaxis del SQL estándar ANSI/ISO. Tome en serio el viejo dicho:
“Cuando estés en Roma, haz lo que hacen los romanos”. Cuando trabaje con Access,
utilice el dialecto Access de SQL. Ese consejo también se aplica a cualquier otro entorno
en el que esté trabajando. Todas las implementaciones de SQL difieren del estándar en
un aspecto u otro.

Si desea escribir una nueva consulta en Access SQL, es decir, una que aún no se haya creado usando
QBE, simplemente puede borrar alguna consulta existente de la ventana de edición de SQL y escribir
un nuevo [Link]ón. Haga clic en la pestaña DISEÑO y luego en el ícono rojo del
signo de exclamación (Ejecutar) en la barra de herramientas en la parte superior de la pantalla para
ejecutar su nueva consulta. El resultado aparece en pantalla en la Vista Hoja de datos.
346 Parte IV: Control de operaciones
 Parte V

Llevando SQL al mundo real

[Link]/extras/sqlpara obtener excelente contenido para principiantes en línea.

 En esta parte…
✓ Usando ODBC

✓ Usando JDBC

✓ Operando con datos XML

✓ [Link]/extras/sqlpara obtener excelente contenido para

principiantes en línea.
 Capítulo 17

Accediendo a datos con

ODBC y JDBC
En este capítulo
▶ Conociendo ODBC
▶ Echando un vistazo a las partes de ODBC
▶ Usar ODBC en un entorno cliente/servidor
▶ Usando ODBC en Internet
▶ Usando ODBC en una intranet
▶ Usando JDBC

I n los últimos años, las computadoras se han interconectado cada vez más, tanto
dentro como entre organizaciones. Con esta conexión surge la necesidad de
compartir información de bases de datos a través de redes. El principal obstáculo para el
libre intercambio de información entre redes es la incompatibilidad del software
operativo y las aplicaciones que se ejecutan en diferentes máquinas. La creación de SQL y
su continua evolución han sido pasos importantes para superar la incompatibilidad de
hardware y software.

Desafortunadamente, el SQL "estándar" no es tan estándar. Incluso los proveedores de

DBMS que afirman cumplir con el estándar internacional SQL han incluido extensiones
propietarias en sus implementaciones SQL, lo que las hace incompatibles con las
extensiones propietarias enotroimplementaciones de los proveedores. Los proveedores
se resisten a renunciar a sus extensiones porque sus clientes las han diseñado en sus
aplicaciones y se han vuelto dependientes de ellas. Las organizaciones de usuarios,
particularmente las grandes, necesitan otra forma de hacer posible la comunicación
entre DBMS: una herramienta que no requiera que los proveedores reduzcan sus
implementaciones al mínimo común denominador. Esta otra forma es ODBC (Open
DataBase Connectivity).
350 Parte V: Llevando SQL al mundo real

ODBC
ODBCEs una interfaz estándar entre una base de datos y una aplicación que accede
a los datos de la base de datos. Tener un estándar permite que cualquier interfaz
de aplicación acceda a cualquier base de datos mediante SQL. El único requisito es
que tanto el front-end como el back-end cumplan con el estándar ODBC. ODBC 4.0
es la versión actual del estándar.

Una aplicación accede a una base de datos utilizando unconductor(en este caso, el
controlador ODBC), que está diseñado específicamente para interactuar con esa base de
datos en particular. La parte delantera del conductor, el lado que va a la aplicación, cumple
estrictamente el estándar ODBC. La aplicación tiene el mismo aspecto, independientemente
del motor de base de datos que se encuentre en el back-end. El back-end del controlador
está personalizado para el motor de base de datos específico al que se dirige. Con esta
arquitectura, las aplicaciones no tienen que personalizarse (ni siquiera tener en cuenta) qué
motor de base de datos back-end controla realmente los datos que están utilizando. El
conductor enmascara las diferencias entre los extremos.

La interfaz ODBC
Elinterfaz ODBCEs esencialmente un conjunto de definiciones, cada una de las cuales se
acepta como estándar. Las definiciones cubren todo lo necesario para establecer
comunicación entre una aplicación y una base de datos. La interfaz ODBC define lo
siguiente:

✓ Una biblioteca de llamadas a funciones

✓ Sintaxis SQL estándar

✓ Tipos de datos SQL estándar

✓ Un protocolo estándar para conectarse a un motor de base de datos.

✓ Códigos de error estándar

El ODBCllamadas a funcioneshacer posible la conexión a un motor de base de

datos back-end; ejecutan sentencias SQL y devuelven los resultados a la aplicación.

Para realizar una operación en una base de datos, incluya la declaración SQL adecuada como
argumento de una llamada de función ODBC. Siempre que utilice la sintaxis SQL estándar
especificada por ODBC, la operación funciona, independientemente del motor de base de datos
que se encuentre en el back-end.
 Capítulo 17: Acceso a datos con ODBC y JDBC 351
Componentes de ODBC
La interfaz ODBC consta de cuatro componentes funcionales, denominados capas ODBC. Cada
componente desempeña un papel para hacer que ODBC sea lo suficientemente flexible como para
proporcionar una comunicación transparente desde cualquier front-end compatible hasta cualquier
back-end compatible. Las cuatro capas de la interfaz ODBC se encuentran entre el usuario y los datos
que el usuario desea, de la siguiente manera:

✓ Solicitud:La aplicación es la parte de la interfaz ODBC más cercana al usuario.

Por supuesto, incluso los sistemas que no utilizan ODBC incluyen una
aplicación. No obstante, tiene sentido incluir la aplicación como parte de la
interfaz ODBC. La aplicación debe saber que se está comunicando con su
fuente de datos a través de ODBC. Debe conectarse sin problemas con el
administrador de controladores ODBC, en estricta conformidad con el estándar
ODBC.
✓ Administrador de conductores:El administrador del conductor es unbiblioteca de enlaces
dinámicos (DLL), que generalmente es proporcionado por Microsoft. Carga los controladores
apropiados para las fuentes de datos (posiblemente múltiples) del sistema y dirige las llamadas a
funciones que provienen de la aplicación a las fuentes de datos apropiadas a través de sus
controladores. El administrador de controladores también maneja algunas llamadas a funciones
ODBC directamente y detecta y maneja algunos tipos de errores. Aunque Microsoft creó el estándar
ODBC, ahora es universalmente aceptado, incluso por los partidarios de la línea dura del código
abierto.

✓ DLL del controlador:Debido a que las fuentes de datos pueden ser diferentes entre sí
(en algunos casos,muydiferente), necesita una forma de traducir las llamadas a
funciones ODBC estándar al idioma nativo de cada fuente de datos. La traducción es
tarea del controlador DLL. Cada DLL de controlador acepta llamadas a funciones a través
de la interfaz ODBC estándar y luego las traduce a código que sea comprensible para sus
[Link] de [Link] la fuente de datos responde con un conjunto de
resultados, el controlador lo reformatea en dirección inversa a un conjunto de resultados
ODBC estándar. El controlador es el elemento crucial que permite que cualquier
aplicación compatible con ODBC manipule la estructura y el contenido de una fuente de
datos compatible con ODBC.

✓ Fuente de datos:La fuente de datos puede ser una de muchas cosas diferentes. Puede
ser un DBMS relacional y una base de datos asociada que reside en la misma
computadora que la aplicación. Puede ser una base de datos de este tipo en una
computadora remota. Puede ser unmétodo de acceso secuencial indexado(ISAM) sin
DBMS, ya sea en la computadora local o remota. Puede incluir o no una red. Las
innumerables formas diferentes que puede adoptar la fuente de datos requieren que
haya un controlador personalizado disponible para cada una.
352 Parte V: Llevando SQL al mundo real

ODBC en un entorno cliente/servidor

En un sistema cliente/servidor, la interfaz entre la parte cliente y la parte servidor se llama
Interfaz de programación de aplicaciones(API). Un controlador ODBC, por ejemplo,
incluye una API. Las API pueden ser propietarias o estándar. ApropiedadAPI es aquella en
la que la parte cliente de la interfaz ha sido diseñada específicamente para funcionar con
un back-end particular en el servidor. El código real que forma esta interfaz es un
controlador y, en un sistema propietario, se llamaconductor [Link] controlador nativo
está optimizado para su uso con un cliente front-end específico y su fuente de datos back-
end asociada. Debido a que los controladores nativos están optimizados tanto para la
aplicación de front-end específica como para el back-end de DBMS específico con el que
están trabajando, los controladores tienden a pasar comandos e información de un lado
a otro rápidamente, con un mínimo de retraso.

Si su sistema cliente/servidor siempre accede al mismo tipo de fuente de datos y está seguro
de que nunca necesitará acceder a datos de otro tipo de fuente de datos, entonces es posible
que desee utilizar el controlador nativo suministrado con su DBMS. Sin embargo, si es posible
que necesite acceder a datos almacenados en una forma diferente en algún momento en el
futuro, usar una API ODBC ahora podría ahorrarle una gran cantidad de trabajo posterior.

Los controladores ODBC también están optimizados para funcionar con fuentes de datos de back-end
específicas, pero todos tienen la misma interfaz de front-end para el administrador de controladores. Por lo
tanto, cualquier controlador que no haya sido optimizado para una interfaz en particular probablemente no
sea tan rápido como unnativocontrolador que está diseñado específicamente para esa parte delantera. Una
queja importante sobre la primera generación de controladores ODBC fue su bajo rendimiento en
comparación con los controladores nativos. Sin embargo, pruebas comparativas recientes han demostrado
que los controladores ODBC 4.0 son bastante competitivos en rendimiento con respecto a los controladores
nativos. La tecnología es lo suficientemente madura como para que ya no sea necesario sacrificar el
rendimiento para obtener las ventajas de la estandarización.

ODBC e Internet
Las operaciones de bases de datos a través de Internet difieren en varios aspectos
importantes de las operaciones de bases de datos en un sistema cliente/servidor, aunque es
posible que el usuario no note ninguna diferencia. La diferencia más visible desde el punto de
vista del usuario es la parte del cliente del sistema, que incluye la interfaz de usuario. En un
sistema cliente/servidor, la interfaz de usuario es la parte de una aplicación que se comunica
con la fuente de datos en el servidor, mediante declaraciones SQL compatibles con ODBC. En
la web, la parte cliente del sistema todavía está en la computadora local, pero se comunica con
la fuente de datos en el servidor mediante el protocolo estándar HTTP.
 Capítulo 17: Acceso a datos con ODBC y JDBC 353
Cualquiera que tenga el software de cliente adecuado (y la autorización adecuada) puede
acceder a los datos almacenados en la web. Esto significa que puede crear una
aplicación en la computadora de su trabajo y luego acceder a ella con su dispositivo
móvil. La Figura 17-1 compara los sistemas cliente/servidor con los sistemas basados en
web.

Figura 17-1:
Un cliente/
servidor
sistema
versus un
basado en web
base de datos

sistema.

Extensiones de servidor
En el sistema basado en web, la comunicación entre la interfaz de la aplicación en la
máquina cliente y el servidor web en la máquina servidor se realiza mediante HTTP. Un
componente del sistema llamadoextensión del servidortraduce los comandos que llegan
a través de la red a SQL compatible con ODBC. Luego, el servidor de la base de datos
actúa sobre el SQL, que a su vez trata directamente con la fuente de datos. En la
dirección inversa, la fuente de datos envía el conjunto de resultados generado por una
consulta a través del servidor de la base de datos a la extensión del servidor, que luego
lo traduce a un formato que el servidor web pueda manejar. Luego, los resultados se
envían a través de la web al front-end de la aplicación en la máquina cliente, donde se
muestran al usuario. La figura 17-2 muestra la anatomía de este tipo de sistema.
354 Parte V: Llevando SQL al mundo real

Figura 17-2:
basado en la web

base de datos

sistema con
un servidor

extensión.

Extensiones de cliente
Aplicaciones como Mircosoft Access 2013 están diseñadas para funcionar con datos
almacenados localmente en la máquina del usuario, en un servidor ubicado en una red
local o de área amplia (LAN o WAN), o en Internet en la nube. El repositorio en la nube de
Microsoft se llama SkyDrive. También es posible acceder a una aplicación en la nube
usando nada más que un navegador web. Los navegadores web fueron diseñados (y
ahora están optimizados) para proporcionar interfaces fáciles de entender y usar para
sitios web de todo tipo. Los navegadores más populares, Google Chrome, Mozilla Firefox,
Microsoft Internet Explorer y Apple Safari, no fueron diseñados ni optimizados para ser
interfaces de bases de datos. Para que se produzca una interacción significativa con una
base de datos a través de Internet, el lado cliente del sistema necesita una funcionalidad
que el navegador no proporciona.
Para satisfacer esta necesidad, existen varios tipos deextensiones de clienteha sido
desarrollado. Estas extensiones incluyen controles ActiveX, subprogramas de Java y
scripts. Las extensiones se comunican con el servidor vía HTTP, utilizando HTML, que
es el lenguaje de la web. La extensión del servidor traduce cualquier código HTML que
se ocupe del acceso a la base de datos a SQL compatible con ODBC antes de reenviarlo
a la fuente de datos.
 Capítulo 17: Acceso a datos con ODBC y JDBC 355
controles ActiveX
Los controles ActiveX de Microsoft funcionan con Internet Explorer de Microsoft, que es un
navegador muy popular. Sin embargo, recientemente ha perdido cuota de mercado frente a
Google Chrome y Firefox de Mozilla.

Guiones
Los scripts son las herramientas más flexibles para crear extensiones de cliente. El uso de un lenguaje
de secuencias de comandos, como el omnipresente JavaScript o VBScript de Microsoft, le brinda el
máximo control sobre lo que sucede en el lado del cliente. Puede realizar comprobaciones de
validación en los campos de entrada de datos, lo que permite rechazar o corregir entradas no válidas
sin tener que acceder a la web. Esto puede ahorrarle tiempo y reducir el tráfico en la web,
beneficiando así también a otros usuarios. Por supuesto, las comprobaciones de validación también
se pueden realizar en el extremo del servidor aplicando restricciones a los valores que pueden tomar
los elementos de datos. Al igual que con los subprogramas de Java, los scripts están integrados en una
página HTML y se ejecutan cuando el usuario interactúa con esa página.

ODBC y una Intranet

Unintranetes una red de área local o amplia que funciona como una versión más simple
de Internet. Debido a que una intranet está contenida dentro de una sola organización,
no necesita medidas de seguridad complejas como firewalls. Todas las herramientas
diseñadas para el desarrollo de aplicaciones en la web funcionan igualmente bien como
herramientas de desarrollo para aplicaciones de intranet. ODBC funciona en una intranet
de la misma manera que en Internet. Si tiene varias fuentes de datos, los clientes que
utilizan navegadores web (y las extensiones de cliente y servidor adecuadas) pueden
comunicarse con ellos mediante SQL que pasa por las etapas HTML y ODBC. En el
controlador, el SQL compatible con ODBC se traduce al lenguaje de comandos nativo de
la base de datos y se ejecuta.

JDBC
JDBC (Java DataBase Connectivity) es similar a ODBC, pero difiere en algunos aspectos
importantes. Una de esas diferencias se insinúa en su nombre. JDBC es una interfaz de
base de datos que siempre tiene el mismo aspecto para el programa cliente,
independientemente de qué fuente de datos se encuentre en el servidor (back-end). La
diferencia es que JDBC espera que la aplicación cliente esté escrita en el lenguaje Java en
lugar de otro lenguaje como C++ o Visual Basic. Otra diferencia es que Java y JDBC fueron
diseñados específicamente para ejecutarse en la web o en una intranet.
356 Parte V: Llevando SQL al mundo real

Java es un lenguaje similar a C++ desarrollado por Sun Microsystems específicamente para el
desarrollo de programas de cliente web. Cuando se establece una conexión entre un servidor
y un cliente a través de la web, el subprograma de Java apropiado se descarga al cliente,
donde el subprograma comienza a ejecutarse. El subprograma, que está integrado en una
página HTML, proporciona la funcionalidad específica de la base de datos que el cliente
necesita para proporcionar acceso flexible a los datos del servidor. La Figura 17-3 es una
representación esquemática de una aplicación de base de datos web con un subprograma
Java ejecutándose en la máquina cliente.

Figura 17-3:
Una red
base de datos

solicitud,
usando un Java
subprograma.

UnsubprogramaEs una pequeña aplicación que reside en un servidor. Cuando un cliente se

conecta a ese servidor a través de la web, el subprograma se descarga y comienza a ejecutarse
en la computadora cliente. Los subprogramas de Java están especialmente diseñados para que
puedan ejecutarse en unsalvadera—un área bien definida (y aislada) en la memoria de la
computadora cliente reservada para ejecutar subprogramas. El subprograma no puede afectar
nada fuera del sandbox. Esta arquitectura está diseñada para proteger la máquina cliente de
subprogramas potencialmente hostiles que pueden intentar extraer información confidencial o
causar daños maliciosos.
 Capítulo 17: Acceso a datos con ODBC y JDBC 357
Una gran ventaja de utilizar subprogramas de Java es que siempre están actualizados.
Debido a que los subprogramas se descargan del servidor cada vez que se utilizan (en
lugar de retenerse en el cliente), siempre se garantiza que el cliente tendrá la última
versión cada vez que ejecute un subprograma de Java.

Si es responsable del mantenimiento del servidor de su organización, nunca tendrá que

preocuparse por perder la compatibilidad con algunos de sus clientes cuando actualice el
software del servidor. Sólo asegúrese de que su subprograma de Java descargable sea
compatible con la nueva configuración del servidor, porque, siempre que sus navegadores web
hayan sido configurados para habilitar subprogramas de Java, todos sus clientes también serán
compatibles automáticamente. Java es un lenguaje de programación con todas las funciones y
es completamente posible escribir aplicaciones robustas con Java que puedan acceder a bases
de datos en algún tipo de sistema cliente/servidor. Cuando se usa de esta manera, una
aplicación Java que accede a una base de datos mediante JDBC es similar a una aplicación C++
que accede a una base de datos mediante ODBC. Pero una aplicación Java actúa de manera
muy diferente a una aplicación C++ cuando se trata de Internet (o una intranet).

Cuando el sistema que le interesa está en la Red, las condiciones de funcionamiento son
diferentes a las condiciones en un sistema cliente/servidor. El lado cliente de una aplicación
que opera a través de Internet es un navegador, con capacidades computacionales mínimas.
Estas capacidades deben aumentarse para que se pueda realizar un procesamiento
significativo de la base de datos; Los subprogramas de Java proporcionan estas capacidades.

Te enfrentas a cierto peligro cuando descargas algo de un servidor que no sabes si es

confiable. Si descarga un subprograma de Java, ese peligro se reduce
considerablemente, pero no se elimina por completo. Tenga cuidado al permitir que un
código ejecutable ingrese a su máquina desde un servidor cuestionable.

Al igual que ODBC, JDBC pasa sentencias SQL desde la aplicación de front-end (applet)
que se ejecuta en el cliente a la fuente de datos en el back-end. También sirve para pasar
conjuntos de resultados o mensajes de error desde la fuente de datos a la aplicación. El
valor de usar JDBC es que el escritor del subprograma puede escribir en la interfaz JDBC
estándar sin necesidad de saber o preocuparse qué base de datos se encuentra en el
back-end. JDBC realiza cualquier conversión necesaria para que se produzca una
comunicación bidireccional precisa. Aunque está diseñado para funcionar en la web,
JDBC también funciona en entornos cliente/servidor donde una aplicación escrita en Java
se comunica con un servidor de base de datos a través de la interfaz JDBC.
358 Parte V: Llevando SQL al mundo real
 Capítulo 18

Operando sobre datos XML con SQL

En este capítulo
▶ Usando SQL con XML
▶ Explorando la relación entre XML, bases de datos e Internet

S A partir de SQL:2008, el estándar ISO/IEC SQL admite XML. Los archivos XML
(eXtensible Markup Language) se han convertido en un estándar universalmente
aceptado para el intercambio de datos entre plataformas diferentes. Con XML, no
importa si la persona con la que comparte datos tiene un entorno de aplicación
diferente, un sistema operativo diferente o incluso hardware diferente. XML puede
formar un puente de datos entre ustedes dos.

Cómo se relaciona XML con SQL

XML, como HTML, es un lenguaje de marcado, lo que significa que no es un lenguaje con
todas las funciones como C++ o Java. Ni siquiera es un sublenguaje de datos como SQL.
Sin embargo, a diferencia de esos lenguajes, conoce el contenido de los datos que
transporta. Mientras que HTML se ocupa únicamente del formato del texto y los gráficos
de un documento, XML da estructura al contenido del documento. XML en sí no se ocupa
del formato. Para hacer eso, debe aumentar XML con unhoja de [Link] igual que ocurre
con HTML, una hoja de estilos aplica formato a un documento XML.

La estructura de un documento XML la proporciona su esquema XML, que es un ejemplo

demetadatos(datos que describen datos). Un esquema XML describe dónde pueden
aparecer los elementos en un documento y en qué orden. También puede describir el
tipo de datos de un elemento y restringir los valores que un tipo puede incluir.
360 Parte V: Llevando SQL al mundo real

SQL y XML proporcionan dos formas diferentes de estructurar datos para que pueda
guardarlos y recuperar información seleccionada de ellos:

✓ SQL es una excelente herramienta para manejar datos numéricos y de texto que
pueden clasificarse por tipo de datos y tener un tamaño bien definido.

SQL se creó como una forma estándar de mantener y operar con datos guardados en
bases de datos relacionales.

✓ XML es mejor para manejar datos de formato libre que no se pueden

categorizar fácilmente.

Las motivaciones que impulsaron la creación de XML fueron proporcionar un

estándar universal para transferir datos entre computadoras diferentes y
mostrarlos en la web.

Las fortalezas y objetivos de SQL y XML son complementarios. Cada uno reina en
su propio dominio y forma alianzas con el otro para brindar a los usuarios la
información que desean, cuando la desean y donde la desean.

El tipo de datos XML

El tipo XML se introdujo con SQL:2003. Esto significa que las implementaciones
conformes pueden almacenar y operar con datos con formato XML directamente, sin
convertirlos primero a XML desde uno de los otros tipos de datos SQL.

El tipo de datos XML, incluidos sus subtipos, aunque es intrínseco a cualquier implementación
que lo admita, actúa como un tipo definido por el usuario (UDT). Los subtipos son:

✓ XML(DOCUMENTO(SIN TIPO))
✓ XML(DOCUMENTO(CUALQUIER))

✓ XML(DOCUMENTO(XMLSCHEMA))
✓ XML(CONTENIDO(SIN TIPO))
✓ XML(CONTENIDO(CUALQUIER))

✓ XML(CONTENIDO(XMLSCHEMA))
✓ XML(SECUENCIA)

El tipo XML acerca a SQL y XML porque permite que las aplicaciones realicen
operaciones SQL en contenido XML y operaciones XML en contenido SQL. Puede
incluir una columna del tipo XML con columnas de cualquiera de los otros tipos
predefinidos cubiertos en el Capítulo 2 en una operación de unión en elDÓNDE
cláusula de una consulta. Al estilo de una verdadera base de datos relacional, su
DBMS determinará la forma óptima de ejecutar la consulta y luego la hará.
 Capítulo 18: Operar con datos XML con SQL 361

Cuándo utilizar el tipo XML

Si debe o no almacenar datos en formato XML depende de lo que planee hacer con
esos datos. A continuación se muestran algunos casos en los que tiene sentido
almacenar datos en formato XML:

✓ Cuando desee almacenar un bloque completo de datos y recuperarlo

más tarde.
✓ Cuando desee poder consultar todo el documento XML. Algunas
implementaciones han ampliado el alcance de laEXTRACTOoperador para
permitir la extracción del contenido deseado de un documento XML.
✓ Cuando necesita una tipificación segura de datos dentro de declaraciones SQL. El uso del tipo
XML garantiza que los valores de datos sean valores XML válidos y no solo cadenas de texto
arbitrarias.

✓ Para garantizar la compatibilidad con sistemas de almacenamiento futuros, aún no

especificados, que podrían no admitir tipos existentes comoPERSONAJE OBJETO GRANDE,o
CLOB. (Consulte el Capítulo 2 para obtener más información sobreCLOB.)

✓ Para aprovechar futuras optimizaciones que admitirán solo el tipo XML.

A continuación se muestra un ejemplo de cómo podría utilizar el tipo XML:

CREAR TABLA CLIENTE (

Nombre del cliente CARACTERÍSTICA (30) NO NULO,
Dirección 1 CARACTERÍSTICA (30),

Dirección 2 CARACTERÍSTICA (30),

Ciudad CARACTERÍSTICA (25),

Estado CARACTER (2),

Código Postal CARACTERÍSTICA (10),

Teléfono CARACTERÍSTICA (13),

Fax CARACTERÍSTICA (13),

Persona de contacto CARACTERÍSTICA (30),

Comentarios XML(SECUENCIA) );

Esta declaración SQL almacenará un documento XML en elComentarioscolumna

de la tabla CLIENTE. El documento resultante podría verse similar al siguiente:

<Comentarios>
<Comentar>
<NºComentario>1</NºComentario>
<MessageText>¿Está VetLab equipado para analizar pingüinos?
¿sangre?</MessageText>
<RespuestaSolicitada>Sí</RespuestaSolicitada> </
Comentar>
362 Parte V: Llevando SQL al mundo real

<Comentar>
<NºComentario>2</NºComentario>
<MessageText>Gracias por la rápida respuesta al
muestra de esputo de foca leopardo.</MessageText>
<RespuestaSolicitada>No</RespuestaSolicitada> </
Comentar>
</Comentarios>

Cuándo no utilizar el tipo XML

El hecho de que el estándar SQL le permita utilizar el tipo XML no significa que siempre deba
hacerlo. De hecho, en muchas ocasiones no tiene sentido utilizar el tipo XML. La mayoría de
los datos de las bases de datos relacionales actuales están mejor en su formato actual que en
el formato XML. A continuación se muestran un par de ejemplos de cuándo no utilizar el tipo
XML:

✓ Cuando los datos se dividen naturalmente en una estructura relacional

con tablas, filas y columnas
✓ Cuándo necesitará actualizar partes del documento en lugar de abordar el
documento en su totalidad

Asignación de SQL a XML y XML a SQL

Para intercambiar datos entre bases de datos SQL y documentos XML, los
distintos elementos de una base de datos SQL deben poder traducirse a
elementos equivalentes de un documento XML, y viceversa. Describo qué
elementos deben traducirse en las siguientes secciones.

Mapeo de conjuntos de caracteres

En SQL, los juegos de caracteres admitidos dependen de la implementación que esté
utilizando. Esto significa que DB2 de IBM puede admitir conjuntos de caracteres que no
son compatibles con SQL Server de Microsoft. SQL Server puede admitir conjuntos de
caracteres que Oracle no admite. Aunque los conjuntos de caracteres más comunes son
casi universalmente compatibles, si utiliza un conjunto de caracteres menos común,
migrar su base de datos y aplicación de una plataforma RDBMS a otra puede resultar
difícil.
 Capítulo 18: Operar con datos XML con SQL 363
XML no tiene problemas de compatibilidad con los juegos de caracteres: sólo admite uno,
Unicode. Esto es algo bueno desde el punto de vista del intercambio de datos entre cualquier
implementación SQL y XML. Todos los proveedores de RDBMS tienen que definir un mapeo
entre cadenas de cada uno de sus conjuntos de caracteres y Unicode, así como un mapeo
inverso de Unicode a cada uno de sus conjuntos de caracteres. Afortunadamente, XML
tampoco admite múltiples conjuntos de caracteres. Si así fuera, los proveedores tendrían un
problema de muchos a muchos que requeriría varias asignaciones más y asignaciones
inversas para resolverse.

Identificadores de mapeo
XML es mucho más estricto que SQL en los caracteres que permite en los identificadores.
Los caracteres que son legales en SQL pero ilegales en XML deben asignarse a algo legal
antes de que puedan formar parte de un documento XML. SQL admite identificadores
delimitados. Esto significa que todo tipo de caracteres impares como %, $ y & son legales,
siempre que estén entre comillas dobles. Estos caracteres no son legales en XML.
Además, los nombres XML que comienzan con los caracteresXMLen cualquier
combinación de casos están reservados y, por tanto, no pueden utilizarse impunemente.
Si tiene identificadores SQL que comienzan con esas letras, debe cambiarlos.

Un mapeo acordado cierra la brecha de identificadores entre SQL y XML. Al pasar de SQL
a XML, todos los identificadores SQL se convierten a Unicode. A partir de ahí, todos los
identificadores SQL que también sean nombres XML legales no se modifican. Caracteres
de identificador SQL que no son legales. Los nombres XML se reemplazan con un código
hexadecimal que toma la forma “_xNNNN_”o "_xNNNNNNNN_”, dóndenorterepresenta
un dígito hexadecimal en mayúscula. Por ejemplo, el guión bajo estará representado por
“_x005F_”.Los dos puntos estarán representados por “_x003A_”.Estas representaciones
son los códigos de los caracteres Unicode para el guión bajo y los dos puntos. El caso en
el que un identificador SQL comienza con los caracteresx, metro,yyose maneja prefijando
todas esas instancias con un código en la forma “_xFFFF_”.

La conversión de XML a SQL es mucho más sencilla. Todo lo que necesita hacer es escanear los
caracteres de un nombre XML en busca de una secuencia de "_xNNNN_”o "_xNNNNNNNN_”.
Siempre que encuentre una secuencia de este tipo, reemplácela con el carácter al que
corresponde el Unicode. Si un nombre XML comienza con los caracteres “_xFFFF_”,ingnóralos.

Siguiendo estas reglas simples, puede asignar un identificador SQL a un nombre XML y luego
volver a un identificador SQL nuevamente. Sin embargo, esta feliz situación no se aplica a una
asignación del nombre XML al identificador SQL y de regreso al nombre XML.
364 Parte V: Llevando SQL al mundo real

Mapeo de tipos de datos

El estándar SQL especifica que un tipo de datos SQL debe asignarse al tipo de datos de
esquema XML más cercano posible. la designaciónlo más cercano posible significa que
todos los valores permitidos por el tipo SQL serán permitidos por el tipo de esquema
XML, y la menor cantidad posible de valores no permitidos por el tipo SQL serán
permitidos por el tipo de esquema XML. Facetas XML, comomaxInclusivo yminInclusivo,
puede restringir los valores permitidos por el tipo de esquema XML a los valores
permitidos por el tipo SQL correspondiente. Por ejemplo, si el tipo de datos SQL restringe
los valores delENTEROescriba al rango
– 2157483648<valor<2157483647,en XML elmaxInclusivoEl valor se puede establecer en
2157483647 y elminInclusivoEl valor se puede establecer en –2157483648. A continuación se
muestra un ejemplo de dicho mapeo:

<xsd:simpleType>
<xsd:base de restricción=”xsd:entero”/>
<xsd:maxInclusive value=”2157483647”/>
<xsd:minInclusive value=”-2157483648”/>
<xsd:anotación>
<sqlxml:sqltype name=”INTEGER”/> </
xsd:anotación>
</xsd:restricción>
</xsd:simpleType>

La sección de anotaciones conserva información de la definición de tipo SQL que no

utiliza XML, pero puede resultarle útil más adelante si el documento se asigna
nuevamente a SQL.

Tablas de mapeo
Puede asignar una tabla a un documento XML. De manera similar, puede asignar todas las
tablas de un esquema o todas las tablas de un catálogo. Los privilegios se mantienen mediante
el mapeo. Una persona que tiene laSELECCIONAREl privilegio en solo algunas columnas de la
tabla podrá asignar solo esas columnas al documento XML. En realidad, la asignación produce
dos documentos, uno que contiene los datos de la tabla y el otro que contiene el esquema XML
que describe el primer documento. A continuación se muestra un ejemplo de la asignación de
una tabla SQL a un documento que contiene datos XML:

<CLIENTE>
<fila>
<Nombre>Abe</Nombre>
<Apellido>Abelson</Apellido>
<Ciudad>Springfield</Ciudad> <Código
de área>714</Código de área>
 Capítulo 18: Operar con datos XML con SQL 365
<Teléfono>555-1111</Teléfono> </fila>

<fila>
<Nombre>Bill</Nombre>
<Apellido>Bailey</Apellido>
<Ciudad>Decatur</Ciudad>
<Código de área>714</Código de área>
<Teléfono>555-2222</Teléfono> </fila>

.
.
.
</CLIENTE>

Al elemento raíz del documento se le ha dado el nombre de tabla. Cada fila de la tabla está contenida
dentro de un archivo <fila>elemento, y cada elemento de fila contiene una secuencia de elementos de
columna, cada uno de los cuales lleva el nombre de la columna correspondiente en la tabla de origen.
Cada elemento de columna contiene un valor de datos.

Manejo de valores nulos

Dado que los datos SQL pueden incluir valores nulos, debe decidir cómo
representarlos en un documento XML. Puede representar un valor nulo como nulo
o ausente. Si elige la opción nula, entonces el atributoxsi:nil=“verdadero” Marca los
elementos de la columna que representan valores nulos. Podría usarse de la
siguiente manera:

<fila>
<Nombre>Bill</Nombre>
<Apellido>Bailey</Apellido>
<Ciudad xsi:nil=”true” /> <Código de
área>714</Código de área>
<Teléfono>555-2222</Teléfono>
</fila>

Si elige la opción ausente, podría implementarla de la siguiente manera:

<fila>
<Nombre>Bill</Nombre>
<Apellido>Bailey</Apellido> <Código de
área>714</Código de área>
<Teléfono>555-2222</Teléfono>
</fila>

En este caso, la fila que contiene el valor nulo está ausente. No hay ninguna referencia al
respecto.
366 Parte V: Llevando SQL al mundo real

Generando el esquema XML

Al mapear de SQL a XML, el primer documento generado es el que contiene los
datos. El segundo contiene la información del esquema. Como ejemplo,
considere el esquema del documento CLIENTE que se muestra en la sección
"Tablas de mapeo", anteriormente en este capítulo:

<xsd:esquema>
<xsd:simpleType nombre=”CHAR_15”>
<xsd:base de restricción=”xsd:cadena”>
<xsd:valor de longitud = “15”/> </
xsd:restricción>
</xsd:simpleType>

<xsd:simpleType nombre=”CHAR_25”>
<xsd:base de restricción=”xsd:cadena”>
<xsd:valor de longitud = “25”/> </
xsd:restricción>
</xsd:simpleType>

<xsd:simpleType nombre=”CHAR_3”>
<xsd:base de restricción=”xsd:cadena”>
<xsd:valor de longitud = “3”/> </
xsd:restricción>
</xsd:simpleType>

<xsd:simpleType nombre=”CHAR_8”>
<xsd:base de restricción=”xsd:cadena”>
<xsd:valor de longitud = “8”/> </
xsd:restricción>
</xsd:simpleType>

<xsd:secuencia>
<xsd:element name=”FirstName” type=”CHAR_15”/>
<xsd:element name=”Apellido” type=”CHAR_25”/>
<xsd:elemento
nombre=”Ciudad” tipo=”CHAR_25 nillable=”true”/>
<xsd:elemento
nombre=”Código de área” tipo=”CHAR_3” nillable=”true”/>
<xsd:elemento
name=”Teléfono” type=”CHAR_8” nillable=”true”/> </
xsd:secuencia>

</xsd:esquema>

Este esquema es apropiado si se utiliza el enfoque nulo para manejar valores nulos. El enfoque
ausente requiere una definición de elemento ligeramente diferente. Por ejemplo:

<xsd:elemento
nombre=”Ciudad” tipo=”CHAR_25” minOccurs=”0”/>
 Capítulo 18: Operar con datos XML con SQL 367

Funciones SQL que operan

con datos XML
El estándar SQL define una serie de operadores, funciones y pseudofunciones que,
cuando se aplican a una base de datos SQL, producen un resultado XML, o cuando se
aplican a datos XML producen un resultado en formato SQL estándar. Las funciones
incluyenXMLELEMENT, XMLFOREST, XMLCONCAT,[Link] las siguientes secciones,
doy breves descripciones de estas funciones, así como de varias otras que se utilizan con
frecuencia al publicar en la web. Algunas de las funciones dependen en gran medida de
XQuery, un lenguaje de consulta estándar diseñado específicamente para consultar datos
XML. XQuery es un tema enorme en sí mismo y está más allá del alcance de este libro.
Para obtener más información sobre XQuery, una buena fuente de información es Jim
Melton y Stephen [Link] XML,Publicado por Morgan Kaufmann.

DOCUMENTO XML
ElDOCUMENTO XMLEl operador toma un valor XML como entrada y devuelve otro
valor XML como salida. El nuevo valor XML es un nodo de documento que se
construye según las reglas del constructor de documentos calculado en XQuery.

ELEMENTO XML
ElELEMENTO XMLEl operador traduce un valor relacional en un elemento XML. Puede
utilizar el operador en unSELECCIONARdeclaración para extraer datos en formato XML
de una base de datos SQL y publicarlos en la web. He aquí un ejemplo:

SELECCIONAR [Link]
XMLELEMENT (NOMBRE”Ciudad”, [Link]) COMO
“Resultado” DEL CLIENTE c
DONDE Apellido=”Abelson”;

Aquí está el resultado devuelto:

Apellido Resultado

abelson <Ciudad>Springfield</Ciudad>
368 Parte V: Llevando SQL al mundo real

XMLFOREST
ElXMLFORESTEl operador produce una lista, obosque,de elementos XML de una lista de valores
relacionales. Cada uno de los valores del operador produce un nuevo elemento. A continuación se
muestra un ejemplo de este operador:

SELECCIONAR [Link]
XMLFOREST ([Link],
c.Código de área,
[Link]éfono) COMO “Resultado”
DEL CLIENTE c
DONDE Apellido=”Abelson” O Apellido=”Bailey”;

Este fragmento produce el siguiente resultado:

Apellido Resultado

abelson <Ciudad>Springfield</Ciudad> <Código de

área>714</Código de área>
<Teléfono>555-1111</Teléfono>
Muralla exterior <Ciudad>Decatur</Ciudad>
<Código de área>714</Código de área>
<Teléfono>555-2222</Teléfono>

XMLCONCAT
XMLCONCATproporciona una forma alternativa de producir un bosque de
elementos concatenando sus argumentos XML. Por ejemplo, el siguiente código:

SELECCIONE [Link],
XMLCONCAT(
XMLELEMENT (NOMBRE”primero”, [Link],
XMLELEMENT (NOMBRE”apellido”, [Link]))
COMO “Resultado”
DEL CLIENTE c ;

produce estos resultados:

Apellido Resultado

abelson <primero>Abe</primero>
<last>Abelson</last>
Muralla exterior <primero>Bill</primero>
<last>Bailey</last>
 Capítulo 18: Operar con datos XML con SQL 369

XMLAGG
XMLAGG,la función agregada, toma documentos XML o fragmentos de documentos XML
como entrada y produce un único documento XML como salida enAGRUPAR POR
consultas. La agregación contiene un bosque de elementos. Aquí hay un ejemplo para
ilustrar el concepto:

SELECCIONAR ELEMENTO XML

( NOMBRE “Ciudad”,
XMLATTRIBUTES ([Link] AS “nombre”),
XMLAGG (XMLELEMENT (NOMBRE”apellido” [Link])
)
) COMO “Lista de ciudades”
DEL CLIENTE c
GRUPO POR Ciudad;

Cuando se ejecuta en la tabla CLIENTE, esta consulta produce los siguientes

resultados:

Lista de ciudades

<Nombre de la ciudad=”Decatur”>
<last>Bailey</last>
</Ciudad>
<Nombre de la ciudad=”Philo”>
<last>Stetson</last>
<last>Stetson</last>
<last>Madera</last>
</Ciudad
<Nombre de la ciudad=”Springfield”>
<last>Abelson</last>
</Ciudad>

COMENTARIO XML
ElCOMENTARIO XMLLa función permite que una aplicación cree un comentario XML. Su
sintaxis es:

XMLCOMMENT ('contenido del comentario'

[Volviendo
{ CONTENIDO | SECUENCIA } ] )

Por ejemplo:

XMLCOMMENT ('Haga una copia de seguridad de la base de datos a las 2 am todas las noches').

crearía un comentario XML similar a este:

<!--Haga una copia de seguridad de la base de datos a las 2 am todas las noches. -->
370 Parte V: Llevando SQL al mundo real

XMLPARSE
ElXMLPARSELa función produce un valor XML al realizar un análisis sin
validación de una cadena. Podrías usarlo así:

XMLPARSE (DOCUMENTO ' ¡GRAN TRABAJO!'

CONSERVAR ESPACIO EN BLANCO)

El código anterior produciría un valor XML que es XML (DOCUMENTO SIN

TIPO)oXML (CUALQUIER DOCUMENTO).Cuál de los dos subtipos se elige
depende de la implementación que esté utilizando.

XMLPI
ElXMLPILa función permite a las aplicaciones crear instrucciones de procesamiento
XML. La sintaxis de esta función es:

Destino NOMBRE XMLPI

[ , expresión-cadena ]
[REGRESO
{ CONTENIDO | SECUENCIA } ] )

ElobjetivoEl marcador de posición representa el identificador del objetivo de la

instrucción de procesamiento. Elexpresión-cadenaEl marcador de posición representa
el contenido del PI. Esta función crea un comentario XML de la forma:

<? expresión-cadena de destino ?>

CONSULTA XML
ElCONSULTA XMLLa función evalúa una expresión XQuery y devuelve el
resultado a la aplicación SQL. La sintaxis deCONSULTA XMLes:

XMLQUERY ( expresión-XQuery
[ PASANDO { Por REF | POR VALOR }
lista de argumentos]
REGRESANDO { CONTENIDO | SECUENCIA }
{ POR REFERENCIA | POR VALOR } )

He aquí un ejemplo del uso deCONSULTA XML:

SELECCIONE max_average,
CONSULTA XML (
'para $batting_average en
/jugador/promedio_bateo
 Capítulo 18: Operar con datos XML con SQL 371
donde /jugador/apellido = $var1 return
$batting_average’
PASANDO POR VALOR
'Manto' AS var1,
SECUENCIA DE DEVOLUCIÓN POR VALOR)
DE estadísticas_ofensivas

XMLCAST
ElXMLCASTLa función es similar a una [Link] SQLfunción, pero tiene
algunas restricciones adicionales. ElXMLCASTLa función permite a una aplicación
convertir un valor de un tipo XML a otro tipo XML o un tipo SQL. De manera similar,
puede usarlo para convertir un valor de un tipo SQL a un tipo XML. Aquí hay algunas
restricciones:

✓ Al menos uno de los tipos involucrados, ya sea el tipo de origen o el tipo de

destino, debe ser un tipo XML.
✓ Ninguno de los tipos involucrados puede ser un tipo de colección SQL, un tipo de fila, un tipo
estructurado o un tipo de referencia.

✓ Sólo se pueden convertir valores de uno de los tipos XML o del tipo nulo SQL a XML
(DOCUMENTO SIN TIPO)o paraXML (CUALQUIER DOCUMENTO).

He aquí un ejemplo:

XMLCAST ([Link] AS XML(CONTENIDO SIN TIPO))

ElXMLCASTla función se transforma en una ordinariaCAST [Link] única razón para utilizar
una palabra clave independiente es hacer cumplir las restricciones que se enumeran aquí.

Predicados
Predicadosdevuelve un valor de Verdadero o Falso. Se han agregado algunos predicados nuevos
que se relacionan específicamente con XML.

DOCUMENTO
El propósito deDOCUMENTOEl predicado es determinar si un valor XML es un documento
XML. Prueba para ver si un valor XML es una instancia de cualquiera de los dosXML
(CUALQUIER DOCUMENTO)oXML (DOCUMENTO SIN TIPO).La sintaxis es:

El valor XML ES [NO]

[CUALQUIER | DOCUMENTO SIN TIPO]
372 Parte V: Llevando SQL al mundo real

Si la expresión se evalúa como Verdadera, el predicado devuelveVERDADERO;de lo contrario,

[Link] el valor XML es nulo, el predicado devuelve unDESCONOCIDO valor. Si no
especificas ninguno de los dosCUALQUIERoSIN TIPO,el supuesto predeterminado esCUALQUIER.

CONTENIDO
tu usas elCONTENIDOpredicado para determinar si un valor XML es una instancia de
XML (CUALQUIER CONTENIDO)oXML (CONTENIDO SIN TIPO).Aquí está la sintaxis:

El valor XML ES [NO]

[CUALQUIER | SIN TIPO] CONTENIDO

Si no especificas ninguno de los dosCUALQUIERoSIN TIPO, CUALQUIERes el valor predeterminado.

XMLEXISTE
Como su nombre lo indica, puede utilizar elXMLEXISTEpredicado para
determinar si existe un valor. Aquí está la sintaxis:

XMLEXISTS ( expresión-XQuery
[ lista de argumentos ])

La expresión XQuery se evalúa utilizando los valores proporcionados en la lista de

argumentos. Si el valor consultado por la expresión XQuery es el SQLNULO valor, se
desconoce el resultado del predicado. Si la evaluación devuelve una secuencia XQuery
vacía, el resultado del predicado esFALSO;de lo contrario, esVERDADERO. Puede utilizar
este predicado para determinar si un documento XML contiene algún contenido
concreto antes de utilizar una parte de ese contenido en una expresión.

VÁLIDO
ElVÁLIDOEl predicado se utiliza para evaluar un valor XML y ver si es válido en el
contexto de un esquema XML registrado. La sintaxis delVÁLIDO El predicado es
más complejo que el caso de la mayoría de los predicados:

El valor xml [NO] ES VÁLIDO

[Opción de restricción de identidad válida XML]
[XML válido según cláusula]
 Capítulo 18: Operar con datos XML con SQL 373
Este predicado comprueba si el valor XML es uno de los cinco subtipos XML:
XML(SECUENCIA), XML(CUALQUIER CONTENIDO), XML(CONTENIDO SIN TIPO),
XML(CUALQUIER DOCUMENTO),oXML (DOCUMENTO SIN TIPO).Además,
opcionalmente podría comprobar si la validez del valor XML depende de las
restricciones de identidad y si es válido con respecto a un esquema XML concreto (el
objetivo de validez).

Hay cuatro posibilidades para elopción-restricción-de-identidadcomponente de

la sintaxis:

✓ SIN RESTRICCIONES DE IDENTIDAD:Si elrestricción-de-identidad- el componente

de sintaxis de opción no está especificado,SIN RESTRICCIONES DE IDENTIDADse
supone. SiDOCUMENTOse especifica, entonces actúa como una combinación de
losDOCUMENTOpredicado y elVÁLIDOpredicadoCON LIMITACIONES DE
IDENTIDAD GLOBAL.

✓ CON LIMITACIONES DE IDENTIDAD GLOBAL:Este componente de la

sintaxis significa que el valor se verifica no sólo con el esquema XML, sino
también con las reglas XML para las relaciones ID/IDREF.
ID e IDREF son tipos de atributos XML que identifican elementos de un documento.

✓ CON RESTRICCIONES DE IDENTIDAD LOCAL:Este componente de la sintaxis significa

que el valor se compara con el esquema XML pero no con las reglas XML para ID/
IDREF o las reglas del esquema XML para restricciones de identidad.

✓ DOCUMENTO:Este componente de la sintaxis significa que la expresión

del valor XML es un documento y es vá[Link] LIMITACIONES DE
IDENTIDAD GLOBALsintaxis con unaXML válido segúncláusula. ElXML
válido segúnLa cláusula identifica el esquema con el que se validará el
valor.

Transformar datos XML en tablas SQL

Hasta hace poco, al pensar en la relación entre SQL y XML, se hacía hincapié
en convertir los datos de una tabla SQL a XML para hacerlos accesibles en
Internet. SQL:2008 abordó el problema complementario de convertir datos
XML en tablas SQL para que puedan consultarse fácilmente utilizando
sentencias SQL estándar. ElTABLA XMLLa pseudofunción realiza esta
operación. La sintaxis paraTABLA XMLes:

XMLTABLE ( [declaración de espacio de nombres,]

expresión-XQuery
[PASANDO lista de argumentos]
COLUMNAS Definiciones-de-columna-XMLtbl
374 Parte V: Llevando SQL al mundo real

donde la lista de argumentos es:

identificador AS de expresión de valor

yDefiniciones de columnas XMLtbles una lista de definiciones de columnas separadas

por comas, que puede contener:

nombre-columna PARA ORDINALIDAD

y/o:

nombre-columna tipo-datos
[POR REFERENCIA | POR
VALOR] [cláusula-por defecto]
[PATH XQuery-expresión]

A continuación se muestra un ejemplo de cómo podría utilizarTABLA XMLpara extraer

datos de un documento XML en una pseudotabla SQL. Una pseudotabla no es
persistente, pero en todos los demás aspectos se comporta como una tabla SQL
normal. Si desea que sea persistente, puede crear una tabla con unCREAR MESA
declaración y luego inserte los datos XML en la tabla recién creada.

SELECCIONE el teléfono del cliente.*

DE
clientes_xml,
TABLA XML(
'por millones de dólares en

$col/cliente
devolver
millones de dólares

PASANDO client_xml.client COMO COLUMNAS

“col”
“NombreCliente” CARÁCTER (30) RUTA ‘NombreCliente’,
“Teléfono” CARÁCTER (13) RUTA ‘teléfono’
) AS teléfono cliente

Cuando ejecuta esta declaración, verá el siguiente resultado:

Nombre del cliente Teléfono

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Abe
Abelson (714)555-1111
Bill Bailey (714)555-2222
mandril de madera (714)555-3333

(3 filas en el teléfono del cliente)

 Capítulo 18: Operar con datos XML con SQL 375

Mapeo no predefinido
Tipos de datos a XML
En el estándar SQL, los tipos de datos no predefinidos incluyen dominio, UDT distinto, fila,
matriz y conjunto múltiple. Puede asignar cada uno de estos a datos con formato XML,
utilizando el código XML adecuado. Las siguientes secciones muestran ejemplos de cómo
mapear estos tipos.

Dominio
Para asignar un dominio SQL a XML, primero debe tener un dominio. Para este
ejemplo, cree uno usando unCREAR DOMINIOdeclaración:

CREAR DOMINIO WestCoast COMO CHAR (2)

VERIFICAR (Estado EN ('CA', 'O', 'WA', 'AK'));

Ahora, crea una tabla que use ese dominio:

CREAR TABLA Región Oeste (

Nombre del cliente Personaje (20) NO NULO,
Estado Costa oeste NO NULO
);

Aquí está el esquema XML para asignar el dominio a XML:

<xsd:simpleType>
Nombre=’[Link] Oeste’>

<xsd:anotación>
<xsd:appinfo>
<sqlxml:sqltype tipo='DOMINIO'
nombreEsquema='Ventas'
typeName = 'Costa Oeste'
mappedType = 'CHAR_2'
final='verdadero'/>
<xsd:appinfo>
</xsd:anotación>

<xsd:base de restricción=’CHAR_2’/>

</xsd:simpleType>
376 Parte V: Llevando SQL al mundo real

Cuando se aplica esta asignación, se obtiene un documento XML que

contiene algo como lo siguiente:

<Región Oeste>
<fila>
.
.
.
<Estado>AK</Estado>
.
.
.
</fila>
.
.
.
</Región Oeste>

UDT distinto
Con un UDT distinto, puede hacer lo mismo que puede hacer con un dominio,
pero con una escritura más fuerte. Así es cómo:

CREAR TIPO WestCoast AS Carácter (2) FINAL;

El esquema XML para asignar este tipo a XML es el siguiente:

<xsd:simpleType>
Nombre=’[Link] Oeste’>

<xsd:anotación>
<xsd:appinfo>
<sqlxml:sqltype tipo=’DISTINTO’
nombreEsquema='Ventas'
typeName = 'Costa Oeste'
mappedType = 'CHAR_2'
final='verdadero'/>
<xsd:appinfo>
</xsd:anotación>

<xsd:base de restricción=’CHAR_2’/>

</xsd:simpleType>

Esto crea un elemento que es el mismo que el creado para el dominio anterior.
 Capítulo 18: Operar con datos XML con SQL 377

Fila
ElFILAtype le permite agrupar varios elementos, o incluso toda una fila de información,
en un solo campo de una fila de la tabla. Puedes crear unFILA escriba como parte de la
definición de la tabla, de la siguiente manera:

CREAR TABLA INFORMACIÓN DE CONTACTO (

Nombre PERSONAJE (30)
Teléfono FILA (Casa CHAR (13), Trabajo CHAR (13))
);

Ahora puede asignar este tipo a XML con el siguiente esquema:

<xsd:complexType Name=’ROW.1’>

<xsd:anotación>
<xsd:appinfo>
<sqlxml:sqltype kind=’FILA’>
<sqlxml:nombre del campo=’Inicio’
mappedType=’CHAR_13’/>
<sqlxml:nombre del campo=’Trabajo’
mappedType=’CHAR_13’/>
</sqlxml:sqltype>
<xsd:appinfo>
</xsd:anotación>

<xsd:secuencia>
<xsd:nombre del elemento=’Inicio’ nillable=’verdadero’
Tipo='CHAR_13'/>
<xsd:nombre del elemento=’Trabajo’ nillable=’verdadero’
Tipo='CHAR_13'/>
</xsd:secuencia>

</xsd:complexType>

Esta asignación podría generar el siguiente XML para una columna:

<Teléfono>
<Inicio>(888)555-1111</Inicio>
<Trabajo>(888)555-1212</Trabajo>
</Teléfono>
378 Parte V: Llevando SQL al mundo real

Formación

Puedes poner más de un elemento en un solo campo usando unFormaciónen lugar

delFILAtipo. Por ejemplo, en elDATOS DE CONTACTOtabla, declararTeléfonocomo
una matriz y luego generar el esquema XML que asignará la matriz a XML.

CREAR TABLA INFORMACIÓN DE CONTACTO (

Nombre PERSONAJE (30),
Teléfono CARÁCTER (13) MATRIZ [4]
);

Ahora puede asignar este tipo a XML con el siguiente esquema:

<xsd:complexType Name=’ARRAY_4.CHAR_13’>

<xsd:anotación>
<xsd:appinfo>
<sqlxml:sqltype tipo=’ARRAY’
elementos máximos = '4'
mappedElementType=’CHAR_13’/>
</xsd:appinfo>
</xsd:anotación>

<xsd:secuencia>
<xsd:element Name=’element’
minOccurs=’0’ maxOccurs=’4’ nillable=’true’
type=’CHAR_13’/> </xsd:secuencia>

</xsd:complexType>

Este esquema generaría algo como esto:

<Teléfono>
<elemento>(888)555-1111</elemento>
<elemento>xsi:nil=’true’/>
<elemento>(888)555-3434</elemento>
</Teléfono>

El elemento de la matriz que contienexsi:nil='verdadero'refleja el hecho de que el

segundo número de teléfono en la tabla de origen contiene un valor nulo.
 Capítulo 18: Operar con datos XML con SQL 379

Conjunto múltiple

Los números de teléfono del ejemplo anterior podrían almacenarse tanto en un conjunto múltiple
como en una matriz. Para mapear un conjunto múltiple, use algo similar a lo siguiente:

CREAR TABLA INFORMACIÓN DE CONTACTO (

Nombre PERSONAJE (30),
Teléfono CARÁCTER (13) MULTICONJUNTO
);

Ahora puede asignar este tipo a XML con el siguiente esquema:

<xsd:complexType Name=’MULTISET.CHAR_13’>

<xsd:anotación>
<xsd:appinfo>
<sqlxml:sqltype tipo=’MULTISET’
mappedElementType=’CHAR_13’/>
</xsd:appinfo>
</xsd:anotación>

<xsd:secuencia>
<xsd:element Name=’element’ minOccurs=’0’
maxOccurs=’ilimitado’ nillable=’true’
type=’CHAR_13’/> </xsd:secuencia>

</xsd:complexType>

Este esquema generaría algo como esto:

<Teléfono>
<elemento>(888)555-1111</elemento>
<elemento>xsi:nil=’true’/>
<elemento>(888)555-3434</elemento>
</Teléfono>

La unión de SQL y XML

SQL proporciona el método estándar mundial para almacenar datos de forma altamente
estructurada. La estructura permite a los usuarios mantener almacenes de datos de una
amplia gama de tamaños y extraer eficientemente de esos almacenes de datos la
información que desean. XML ha pasado de ser un estándar de facto a un oficial
380 Parte V: Llevando SQL al mundo real

Vehículo estándar para transportar datos entre sistemas incompatibles, particularmente

a través de Internet. Al combinar estos dos poderosos métodos, el valor de ambos
aumenta considerablemente. SQL ahora puede manejar datos que no encajan bien en el
estricto paradigma relacional definido originalmente por el Dr. Codd. XML ahora puede
tomar datos de bases de datos SQL de manera eficiente o enviarles datos. El resultado es
una información más disponible y más fácil de compartir. Después de todo, en esencia,
compartir es de lo que se trata el matrimonio.
 Parte VI

Temas avanzados

[Link]/extras/sqlpara obtener excelente contenido para principiantes en línea.

 En esta parte…
✓ Creando cursores

✓ Construyendo declaraciones compuestas

✓ Errores de manejo

✓ Aplicar desencadenantes

✓ [Link]/extras/sqlpara obtener excelente contenido para

principiantes en línea.
 Capítulo 19

Paso a paso por un conjunto de datos

con cursores

En este capítulo
▶ Especificación del alcance del cursor con la declaración DECLARE
▶ Abrir un cursor
▶ Obteniendo datos una fila a la vez
▶ Cerrar un cursor

A La principal incompatibilidad entre SQL y los lenguajes de desarrollo de

aplicaciones más populares es que SQL opera con los datos de un conjunto
completo de filas de la tabla a la vez, mientras que los lenguajes de procedimiento
operan solo con una fila a la vez. Acursorpermite que SQL recupere (o actualice o elimine)
una sola fila a la vez para que pueda usar SQL en combinación con una aplicación escrita
en cualquiera de los lenguajes populares.

Un cursor es como un puntero que localiza una fila de una tabla específica. Cuando un
cursor está activo, puedeSELECCIONAR, ACTUALIZAR,oBORRARla fila a la que apunta el
cursor.

Los cursores son valiosos si desea recuperar filas seleccionadas de una tabla, verificar su
contenido y realizar diferentes operaciones basadas en ese contenido. SQL no puede realizar
esta secuencia de operaciones por sí solo. SQL puede recuperar las filas, pero los lenguajes de
procedimiento son mejores para tomar decisiones basadas en el contenido de los campos. Los
cursores permiten que SQL recupere filas de una tabla una a la vez y luego envíe el resultado al
código de procedimiento para su procesamiento. Al colocar el código SQL en un bucle, puede
procesar toda la tabla fila por fila.

En una representación en pseudocódigo de SQL incorporado, el flujo de ejecución más

común tiene este aspecto:

Sentencia EXEC SQL DECLARE CURSOR

Sentencia EXEC SQL OPEN
Prueba de fin de tabla Código
de procedimiento
384 Parte VI: Temas avanzados

Iniciar bucle
código procesal
BUSCAR SQL EJECUTIVO
código procesal
Prueba de fin de tabla Fin
del bucle
Declaración EXEC SQL CLOSE
código procesal

Las declaraciones SQL en este listado sonDECLARAR, ABRIR, BUSCAR,yCERCA. Cada

una de estas afirmaciones se analiza en detalle en este capítulo.

Si puede realizar la operación que desea con declaraciones SQL normales

(establecidas a la vez), hágalo. Declare un cursor, recupere las filas de la tabla una a
la vez y use el lenguaje host de su sistema solo cuando no pueda hacer lo que desea
hacer solo con SQL.

Declarar un cursor
Para utilizar un cursor, primero debe declarar su existencia al DBMS. Esto lo
haces con unDECLARAR CURSORdeclaración. ElDECLARAR CURSORLa declaración
en realidad no causa que suceda nada; simplemente anuncia el nombre del
cursor al DBMS y especifica en qué consulta operará el cursor. A DECLARAR
CURSORdeclaración tiene la siguiente sintaxis:

DECLARAR nombre-cursor [<sensibilidad del cursor>]

[<desplazamiento del cursor>]
CURSOR [<capacidad de retención del cursor>] [<capacidad de retorno del cursor>]
FOR expresión de consulta
[ORDENAR POR expresión ordenada por]
[PARA expresión de capacidad de actualización] ;

Nota:El nombre del cursor identifica de forma única un cursor, por lo que debe ser diferente al de
cualquier otro nombre de cursor en el módulo o unidad de compilación actual.

Para que su aplicación sea más legible, asigne al cursor un nombre significativo.
Relacionelo con los datos que solicita la expresión de consulta o con la operación que
su código de procedimiento realiza sobre los datos.

A continuación te presentamos algunas características que debes establecer cuando declaras un

cursor:

✓ Sensibilidad del cursor:ElegirSENSIBLE, INSENSIBLE,oASENSITIVO (por

defecto).
✓ Capacidad de desplazamiento del cursor:Elija cualquiera de los dosDESPLAZARSEoSIN DESPLAZAMIENTO (por defecto).
Traducido del inglés al español - [Link]

Capítulo 19: Recorrer un conjunto de datos con cursores 385

✓ Capacidad del cursor:Elija cualquiera de los dosCON RETENCIÓNoSIN RETENCIÓN
(por defecto).

✓ Retornabilidad del cursor:Elija cualquiera de los dosCON DEVOLUCIÓNoSIN DEVOLUCIÓN (por

defecto).

expresión de consulta
Puedes usar cualquier legalSELECCIONARdeclaración como unexpresión de [Link] filas
queSELECCIONARLas recuperaciones de declaraciones son aquellas por las que el cursor pasa
una a la vez. Estas filas son el alcance del cursor.

La consulta no se realiza realmente cuando elDECLARAR CURSORse lee la

declaración. No puede recuperar datos hasta que ejecute elABIERTOdeclaración. El
examen fila por fila de los datos comienza después de ingresar al bucle que encierra
elBUSCARdeclaración.

Cláusula ORDEN POR

Es posible que desee procesar los datos recuperados en un orden particular,
dependiendo de lo que hará su código de procedimiento con los datos. Puede ordenar
las filas recuperadas antes de procesarlas utilizando la opción opcionalORDENAR POR
cláusula. La cláusula tiene la siguiente sintaxis:

ORDENAR POR especificación-clasificación [ , especificación-clasificación]...

Puede tener varias especificaciones de clasificación. Cada uno tiene la siguiente sintaxis:

(nombre de columna) [COLLATE BY nombre de intercalación] [ASC|DESC]

Ordena por nombre de columna y, para hacerlo, la columna debe estar en la lista de selección
de la expresión de consulta. Las columnas que están en la tabla pero no en la lista de selección
de consulta no funcionan como especificaciones de clasificación. Por ejemplo, suponga que
desea realizar una operación que SQL no admite en filas seleccionadas de la tabla CLIENTE.
Puedes usar unDECLARAR CURSORdeclaración como esta:

DECLARAR CURSOR cust1 PARA

SELECCIONE ID de cliente, Nombre, Apellido, Ciudad, Estado, Teléfono
DEL CLIENTE
ORDENAR POR Estado, Apellido, Nombre;

En este ejemplo, elSELECCIONARLa declaración recupera filas ordenadas primero por

estado, luego por apellido y luego por nombre. La declaración recupera a todos los
clientes en Alaska (AK) antes de recuperar al primer cliente de Alabama (AL). Luego, el
extracto clasifica los registros de clientes de Alaska.
386 Parte VI: Temas avanzados

por el apellido del cliente (AarónantesAbbott). Cuando el apellido es el mismo,

la clasificación se realiza por nombre (Jorge Aarónanteshenry aarón).

¿Alguna vez ha hecho 40 copias de un documento de 20 páginas en una

fotocopiadora sin alzadora? ¡Qué lata! Debes hacer 20 pilas sobre mesas y
escritorios, y luego pasar junto a las pilas 40 veces, colocando una hoja en cada
pila. Este proceso de poner las cosas en el orden deseado se llamacolació[Link]
proceso similar juega un papel en SQL.

Una intercalación es un conjunto de reglas que determina cómo se comparan las cadenas de un
juego de caracteres. Un juego de caracteres tiene una secuencia de clasificación predeterminada
que define el orden en el que se ordenan los elementos. Sin embargo, puede aplicar una secuencia
de clasificación distinta a la predeterminada a una columna. Para hacerlo, utilice el opcional
COLABORAR POR cláusula. Su implementación probablemente admita varias intercalaciones
comunes. Elige uno y luego haz la recopilació[Link]ñadiendo unASCoDESC
palabra clave de la cláusula.

en unDECLARAR CURSORdeclaración, puede especificar una columna calculada

que no existe en la tabla subyacente. En este caso, la columna calculada no tiene
un nombre que pueda usar en elORDENAR PORcláusula. Puedes darle un nombre
en elDECLARAR CURSORexpresión de consulta, que le permite identificar la
columna más adelante. Considere el siguiente ejemplo:

DECLARAR ingresos CURSOR PARA

SELECCIONAR Modelo, Unidades, Precio,
Unidades * Precio AS ExtPrice
DESDE TRANSDETAIL
ORDENAR POR Modelo, ExtPrice DESC;

En este ejemplo, noCOLABORAR PORcláusula está en elORDENAR PORcláusula, por lo que se

utiliza la secuencia de clasificación predeterminada. Observe que la cuarta columna de la lista
de selección es el resultado de un cálculo de los datos de la segunda y tercera columnas. La
cuarta columna es un precio extendido llamadoPrecio [Link] mi ejemplo, elORDENAR PORLa
cláusula se ordena primero por nombre de modelo y luego porPrecio Ext. el tipo enPrecio Extes
descendente, como lo especifica elDESCpalabra clave; Las transacciones con el valor en dólares
más alto se procesan primero.

El orden de clasificación predeterminado en unORDENAR PORLa cláusula es ascendente. Si una lista de

especificaciones de clasificación incluye unaDESCordenar y el siguiente ordenamiento también debe ser en
orden descendente, debe especificar explícitamenteDESCpara el siguiente tipo. Por ejemplo:

ORDEN POR A, B DESC, C, D, E, F

es equivalente a

ORDEN POR A ASC, B DESC, C ASC, D ASC, E ASC, F ASC

 Capítulo 19: Recorrer un conjunto de datos con cursores 387

Cláusula de actualizabilidad
A veces, es posible que desee actualizar o eliminar filas de la tabla a las que accede con un
cursor. En otras ocasiones, es posible que desees garantizar que no se puedan realizar
dichas actualizaciones o eliminaciones. SQL le da control sobre este problema con la
cláusula de actualizabilidad delDECLARAR CURSORdeclaración. Si desea evitar
actualizaciones y eliminaciones dentro del alcance del cursor, utilice la cláusula:

SÓLO PARA LEER

Para actualizaciones de columnas específicas únicamente (dejando todas las demás protegidas),
utilice lo siguiente:

PARA ACTUALIZACIÓN DE nombre-columna [, nombre-columna]...

Todas las columnas enumeradas deben aparecer en elDECLARAR CURSORs expresión de consulta. Si
no incluye una cláusula de capacidad de actualización, la suposición predeterminada es que todas las
columnas enumeradas en la expresión de consulta son actualizables. En ese caso, unACTUALIZAR La
declaración puede actualizar todas las columnas de la fila a la que apunta el cursor, y unaBORRARLa
declaración puede eliminar esa fila.

Sensibilidad
La expresión de consulta en elDECLARAR CURSORLa declaración determina las
filas que caen dentro del alcance de un cursor. Considere este posible problema:
¿Qué sucede si una declaración en su programa, ubicada entre elABIERTOy el
CERCA declaraciones, cambia el contenido de algunas de esas filas para que ya no
satisfagan la consulta? ¿El cursor continúa procesando todas las filas que
calificaron originalmente o reconoce la nueva situación e ignora las filas que ya no
califican?

Una declaración SQL normal, comoACTUALIZAR, INSERTAR,oBORRAR,opera en un conjunto de

filas en una tabla de base de datos (o quizás en toda la tabla). Mientras dicha declaración está
activa, el mecanismo de transacción de SQL la protege de la interferencia de otras
declaraciones que actúan simultáneamente sobre los mismos datos. Sin embargo, si utiliza un
cursor, su ventana de vulnerabilidad a interacciones dañinas está abierta de par en par.
Cuando abre un cursor, los datos corren el riesgo de ser víctimas de operaciones simultáneas
y conflictivas hasta que cierra el cursor nuevamente. Si abre un cursor, comienza a procesar
una tabla y luego abre un segundo cursor mientras el primero aún está activo, las acciones
que realice con el segundo cursor pueden afectar lo que ve la declaración controlada por el
primer cursor.

Cambiar los datos en columnas que forman parte de unDECLARAR CURSORLa expresión de
consulta después de que algunas (pero no todas) de las filas de la consulta hayan sido
procesadas resulta en un gran desastre. Es probable que sus resultados sean inconsistentes y
engañosos. Para evitar este problema, asegúrese de que el cursor no cambie como resultado
de cualquiera de las declaraciones dentro de su alcance. Añade elINSENSIBLE
388 Parte VI: Temas avanzados

palabra clave para suDECLARAR CURSORdeclaración. Mientras el cursor esté abierto, no será
sensible a (no se verá afectado por) cambios en la tabla que afecten a las filas calificadas en el
alcance del cursor. Un cursor no puede ser a la vez insensible y actualizable. Un cursor
insensible debe ser de sólo lectura.

Por ejemplo, supongamos que escribe estas consultas:

DECLARAR EL CURSOR C1 PARA SELECCIONAR * DEL EMPLEADO

ORDENAR POR Salario ;
DECLARAR EL CURSOR C2 PARA SELECCIONAR * DEL EMPLEADO
PARA ACTUALIZACIÓN DE Salario;

Ahora, supongamos que abre ambos cursores y busca algunas filas con C1 y luego actualiza
un salario con C2 para aumentar su valor. Este cambio puede hacer que una fila que haya
obtenido con C1 vuelva a aparecer en una recuperación posterior de C1.

Las interacciones peculiares que son posibles con múltiples cursores abiertos, o con cursores abiertos
y operaciones de configuración, son el tipo de problemas de concurrencia que evita el aislamiento de
transacciones. Si opera de esta manera, se está metiendo en problemas. Así que recuerde: no opere
con varios cursores abiertos. Para obtener más información sobre el aislamiento de transacciones,
consulte el Capítulo 15.

La condición predeterminada de sensibilidad del cursor [Link] creas

que sabes lo que esto significa, nada es tan simple como te gustaría que fuera. Cada
implementación tiene su propia definición. Para una implementación ASENSITIVO
podría ser equivalente aSENSIBLE,y para otro podría ser equivalente aINSENSIBLE.
Consulte la documentación de su sistema para conocer su significado en su propio
caso.

Capacidad de desplazamiento

Capacidad de desplazamientole brinda la capacidad de mover el cursor dentro de un conjunto

de resultados. Con elDESPLAZARSEpalabra clave en elDECLARAR CURSORdeclaración, puede
acceder a las filas en el orden que desee. La sintaxis delBUSCARLa declaración controla el
movimiento del cursor. describo elBUSCARdeclaración más adelante en este capítulo.

Abrir un cursor
Aunque elDECLARAR CURSORLa declaración especifica qué filas incluir en el
cursor, en realidad no causa que suceda nada porqueDECLARAR es solo una
declaración y no una declaración ejecutable. ElABIERTOLa declaración da
existencia al cursor. Tiene la siguiente forma:

ABRIR nombre-cursor;
 Capítulo 19: Recorrer un conjunto de datos con cursores 389
Para abrir el cursor que uso en la discusión delORDENAR PORcláusula (anteriormente
en este capítulo), utilice lo siguiente:

DECLARAR ingresos CURSOR PARA

SELECCIONAR Modelo, Unidades, Precio,
Unidades * Precio AS ExtPrice
DESDE TRANSDETAIL
ORDENAR POR Modelo, ExtPrice DESC;
Ingresos ABIERTOS;

No puede recuperar filas de un cursor hasta que abra el cursor. Cuando abre un cursor, los
valores de las variables a las que se hace referencia en elDECLARAR CURSORLa declaración se
vuelve fija, al igual que todas las funciones de fecha y hora actuales. Considere el siguiente
ejemplo de SQL integrado en un programa de lenguaje host:

EXEC SQL DECLARAR EL CURSOR C1 PARA SELECCIONAR * DE PEDIDOS

DONDE [Link] = :NOMBRE
Y fecha de vencimiento < FECHA ACTUAL ;
NOMBRE :='Acme Co'; //Una declaración en el idioma anfitrión
EXEC SQL ABIERTO C1;
NOMBRE :=’Omega Inc.’; //Otra declaración del anfitrión
...
ÓRDENES DE ACTUALIZACIÓN EXEC SQL SET Fecha de vencimiento = CURRENT_DATE;

La solución está disponible (para fechas y horas)

Como describo en la sección "Abrir un cursor", elABIERTOLa utiliza solo un valor de marca de tiempo, sin importar cuánto
declaración corrige el valor de todas las variables a las que se tiempo se ejecute la declaración.
hace referencia en el cursor de declaración. También fija un
Aquí hay un ejemplo interesante de una implicación de
valor para las funciones de fecha y hora. Existe una fijación
esta regla:
similar de valores de fecha y hora en operaciones de
conjuntos. Considere este ejemplo: ACTUALIZAR CLAVE DE CONFIGURACIÓN DE EMPLEADO = ACTUAL_

MARCA DE TIEMPO;
ACTUALIZAR PEDIDOS ESTABLECER RecheckDate =
FECHA_ACTUAL DONDE....; Es posible que espere que esa declaración
establezca un valor único en la columna clave de
Ahora suponga que tiene varios pedidos. Comienza a ejecutar
cada empleado, porque el tiempo se mide en una
esta declaración un minuto antes de la medianoche. A
pequeña fracción de segundo. Estarías
medianoche, la declaración todavía se está ejecutando y no
decepcionado; establece el mismo valor en cada
termina de ejecutarse hasta cinco minutos después de la
fila. Tendrás que encontrar otra forma de generar
medianoche. No importa. Si una declaración hace alguna
una clave única.
referencia aFECHA ACTUAL (oTIEMPOoMARCA DE TIEMPO),el
valor se establece en la fecha y hora en que comienza la Así que cuando elABIERTOLa declaración corrige los valores de
declaración, por lo que todas las filas de PEDIDOS en la fecha y hora para todas las declaraciones que hacen referencia al
declaración obtienen el mismoVuelva a verificar la [Link] cursor, trata todas estas declaraciones como una declaración
manera similar, si una declaración hace referenciaMARCA DE extendida.
TIEMPO,toda la declaración
390 Parte VI: Temas avanzados

ElABIERTOLa declaración fija el valor de todas las variables a las que se hace referencia en el
cursor de declaración y también fija un valor para todas las funciones de fecha y hora actuales.
Como resultado, la segunda asignación a la variable de nombre (NOMBRE := 'Omega Inc.') no
tiene efectoen las filas que busca el cursor. (Ese valor deNOMBREse utiliza elpróximovez que
abres C1.) E incluso si elABIERTOLa declaración se ejecuta un minuto antes de la medianoche y
elACTUALIZARLa declaración se ejecuta un minuto después de la medianoche, el valor de
FECHA ACTUALen elACTUALIZARdeclaración es el valor de esa función en el momento en que
ABIERTOdeclaración ejecutada, incluso siDECLARAR CURSORno hace referencia a la función de
fecha y hora.

Obteniendo datos de una sola fila

El procesamiento de cursores es un proceso de tres pasos:

1. ElDECLARAR CURSORLa declaración especifica el nombre y el alcance del cursor.

2. ElABIERTOLa declaración recopila las filas de la tabla seleccionadas por elDECLARAR

CURSORexpresión de consulta.

3. ElBUSCARLa declaración realmente recupera los datos.

El cursor puede apuntar a una de las filas en el alcance del cursor, o a la ubicación
inmediatamente antes de la primera fila en el alcance, o a la ubicación
inmediatamente después de la última fila en el alcance, o al espacio vacío entre dos
filas. Puede especificar dónde apunta el cursor con la cláusula de orientación en el
BUSCARdeclaración.

Sintaxis
La sintaxis para elBUSCARdeclaración es

FETCH [[orientación] DESDE] nombre-cursor

INTO especificación-objetivo [, especificación-objetivo]...;

Hay siete opciones de orientación disponibles:

✓ PRÓXIMO

✓ PREVIO

✓ PRIMERO

✓ ÚLTIMO

✓ ABSOLUTO
✓ RELATIVO
✓ <especificación de valor simple>
 Capítulo 19: Recorrer un conjunto de datos con cursores 391
La opción predeterminada esPRÓXIMO,que, dicho sea de paso, fue elsoloOrientación
disponible en versiones de SQL anteriores a SQL-92. ElPRÓXIMOLa orientación mueve el cursor
desde donde esté a la siguiente fila en el conjunto especificado por la expresión de consulta.
Eso significa que si el cursor se ubica antes del primer registro, se mueve al primer registro. Si
apunta a grabarnorte,se mueve para grabarnorte+1. Si el cursor apunta al último registro del
conjunto, se mueve más allá de ese registro y se devuelve una notificación de que no hay datos
en el [Link] del sistema. (Capítulo 21 detallesESTADOSQLy el resto de
las funciones de manejo de errores de SQL).

Las especificaciones de destino son variables del lenguaje principal o parámetros,

dependiendo de si SQL incorporado o un lenguaje de módulo, respectivamente, está
utilizando el cursor. El número y los tipos de las especificaciones de destino deben coincidir
con el número y los tipos de las columnas especificadas por la expresión de consulta en el
DECLARAR [Link], en el caso de SQL incorporado, cuando se recupera una lista de
cinco valores de una fila de una tabla, deben estar presentes cinco variables del lenguaje
principal para recibir esos valores, y deben ser del tipo correcto.

Orientación de un cursor desplazable

Debido a que el cursor SQL se puede desplazar, tiene otras opciones además
PRÓXIMO. Si especificaPREVIO,el puntero se mueve a la fila inmediatamente
anterior a su ubicación actual. Si especificaPRIMERO,apunta al primer registro del
conjunto y, si especificaÚLTIMO,apunta al último registro.

Cuando usas elABSOLUTOyRELATIVOorientación, también debe especificar un

valor entero. Por ejemplo,BUSCAR ABSOLUTO 7mueve el cursor a la séptima
fila desde el principio del [Link] PARIENTE 7mueve el cursor siete
filas más allá de su posición [Link] RELATIVA 0 no mueve el cursor.

BUSCAR PARIENTE 1tiene el mismo efecto queBUSCAR SIGUIENTE. BUSCAR PARIENTE

– 1tiene el mismo efecto queBUSCAR ANTES. BUSCAR ABSOLUTO 1te da el primer disco
del set,BUSCAR ABSOLUTO 2le proporciona el segundo registro del conjunto, y así
sucesivamente. Similarmente,BUSCAR ABSOLUTO –1te da el último registro del
conjunto,BUSCAR ABSOLUTO –2le proporciona el penúltimo registro, y así
sucesivamente. especificandoBUSCAR ABSOLUTO 0devuelve el código de condición de
excepción sin datos, al igual queBUSCAR ABSOLUTO 17si solo hay 16 filas en el conjunto.
FETCH <especificación de valor simple>le proporciona el registro especificado por la
especificación de valor simple.

Declaraciones DELETE y UPDATE posicionadas

Puede realizar operaciones de eliminación y actualización en la fila a la que apunta
actualmente el cursor. La sintaxis delBORRARdeclaración se ve así:

BORRAR DEL nombre-tabla DONDE ACTUAL DEL nombre-cursor;

392 Parte VI: Temas avanzados

Si el cursor no apunta a una fila, la declaración devuelve una condición de error y no se

produce ninguna eliminación.

La sintaxis delACTUALIZARdeclaración es la siguiente:

ACTUALIZAR nombre de tabla

SET nombre-columna = valor [,nombre-columna = valor]...
DONDE ACTUAL DEL nombre-cursor;

El valor que coloque en cada columna especificada debe ser una expresión de valor o la
palabra clavePOR [Link] un intento de operación de actualización posicionada devuelve
un error, la actualización no se realiza.

Cerrar un cursor
Después de terminar con un cursor, acostúmbrese a cerrarlo inmediatamente. Dejar un cursor
abierto mientras su aplicación avanza hacia otros problemas puede causar daños. Además, los
cursores abiertos utilizan recursos del sistema.

Si cierra un cursor que no era sensible a los cambios realizados mientras estaba abierto,
cuando lo vuelve a abrir, el cursor reabierto refleja dichos cambios.

Puedes cerrar el cursor que abrí anteriormente en la tabla TRANSDETAIL con una
declaración simple como la siguiente:

CERRAR ingresos ;
 Capítulo 20

Agregar capacidades de procedimiento

con módulos almacenados persistentes

En este capítulo
▶ Equipamiento de declaraciones compuestas con atomicidad, cursores, variables y condiciones
▶ Regular el flujo de declaraciones de control.
▶ Hacer bucles que hacen bucles que hacen bucles
▶ Recuperar y utilizar procedimientos almacenados y funciones almacenadas.
▶ Asignar privilegios, crear módulos almacenados y darles un buen uso a los módulos almacenados

S Algunos de los principales profesionales de la tecnología de bases de datos han estado

trabajando en el proceso de estándares durante años. Incluso después de que un
estándar haya sido emitido y aceptado por la comunidad mundial de bases de datos, el
progreso hacia el siguiente estándar no disminuye. Un lapso de siete años separó la
publicación de SQL-92 y la publicación del primer componente de SQL:1999. Durante los años
intermedios, ANSI e ISO publicaron un apéndice a SQL-92, llamado SQL-92/PSM (Módulos
almacenados persistentes). Este anexo formó la base de una parte de SQL:1999 con el mismo
nombre. SQL/PSM define una serie de declaraciones que brindan a SQL un flujo de estructuras
de control comparable al flujo de estructuras de control disponibles en lenguajes de
programación con todas las funciones. Le permite utilizar SQL para realizar tareas para las que
los programadores anteriormente se veían obligados a utilizar otras herramientas. ¿Te
imaginas cómo habría sido tu vida en los tiempos de las cavernas de 1992, cuando tenías que
cambiar repetidamente entre SQL y su lenguaje host procedimental sólo para hacer tu trabajo?

Declaraciones compuestas
A lo largo de este libro, SQL se representa como un lenguaje no procedimental que trata
con datos un conjunto a la vez en lugar de un registro a la vez. Sin embargo, con la
adición de las instalaciones cubiertas en este capítulo, esta afirmación no es tan cierta
como solía ser. Aunque SQL todavía trata con datos un conjunto a la vez, se está
volviendo más procedimental.
394 Parte VI: Temas avanzados

El SQL arcaico (definido por SQL-92) no sigue el modelo de procedimiento, donde una
instrucción sigue a otra en una secuencia para producir un resultado deseado, por lo que las
primeras declaraciones SQL eran entidades independientes, tal vez integradas en un programa
C++ o Visual Basic. Con estas primeras versiones de SQL, se desaconsejaba plantear una
consulta o realizar otras operaciones mediante la ejecución de una serie de instrucciones SQL
porque estas actividades complicadas daban como resultado una penalización en el
rendimiento en forma de tráfico de red. SQL:1999 y todas las versiones siguientes permiten
declaraciones compuestas, formadas por declaraciones SQL individuales que se ejecutan como
una unidad, aliviando la congestión de la red.

Todas las declaraciones incluidas en una declaración compuesta están encerradas entre
un COMENZARpalabra clave al principio de la declaración y unaFINpalabra clave al final
de la declaración. Por ejemplo, para insertar datos en varias tablas relacionadas, utilice
una sintaxis similar a la siguiente:

vacío principal {
SQL EJECUTIVO
COMENZAR

INSERTAR EN estudiantes (StudentID, Fname, Lname)

VALORES (:sid, :sfname, :slname) ;
INSERTAR EN la lista (ID de clase, Clase, ID de estudiante)
VALORES (:cid, :cname, :sid) ;
INSERTAR EN cuenta por cobrar (ID de estudiante, clase, tarifa)
VALORES (:sid, :cname, :cfee) FIN ;

/* Comprobar SQLSTATE en busca de errores */

}

Este pequeño fragmento de un programa en C incluye una declaración SQL compuesta

incorporada. El comentario sobreESTADOSQLse ocupa del manejo de errores. Si la declaración
compuesta no se ejecuta correctamente, se coloca un código de error en el parámetro de
[Link] supuesto, colocar un comentario después delFIN La palabra clave no
corrige el error. El comentario se coloca allí simplemente para recordarle que en un programa
real, el código de manejo de errores pertenece a ese lugar. (Trato el manejo de errores en
detalle en el Capítulo 21.)

Atomicidad
Las declaraciones compuestas introducen una posibilidad de error que no se
enfrenta cuando se construyen declaraciones SQL simples. Una declaración SQL
simple se completa exitosamente o no, y si no se completa exitosamente, la base de
datos no cambia. Este no es necesariamente el caso cuando una declaración
compuesta crea un error.

Considere el ejemplo de la sección anterior. ¿Qué pasa si elINSERTARa la tabla

ESTUDIANTES y alINSERTARa la mesa ROSTER ambos tuvieron lugar, pero
Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 395

debido a la interferencia de otro usuario, elINSERTAR¿Falló la tabla RECIBIBLE? Un

estudiante sería registrado para una clase pero no se le facturaría. Este tipo de error
puede resultar perjudicial para las finanzas de una universidad.

El concepto que falta en este escenario [Link] declaración atómica es indivisible:

se ejecuta por completo o no se ejecuta en absoluto. Las sentencias SQL simples son
atómicas por naturaleza, pero las sentencias SQL compuestas no lo son. Sin embargo, puede
hacer que una declaración SQL compuesta sea atómica especificándola como tal. En el
siguiente ejemplo, la declaración de SQL compuesto es segura al introducir la atomicidad:

vacío principal {
SQL EJECUTIVO
COMENZAR ATÓMICO
INSERTAR EN estudiantes (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ;
INSERTAR EN la lista (ID de clase, Clase, ID de estudiante)
VALORES (:cid, :cname, :sid) ;
INSERTAR EN cuenta por cobrar (ID de estudiante, clase, tarifa)
VALORES (:sid, :cname, :cfee) FIN ;

/* Comprobar SQLSTATE en busca de errores */

}

Al agregar la palabra claveATÓMICOdespués de la palabra claveCOMENZAR,usted se asegura

de que se ejecute toda la declaración o, si ocurre un error, que toda la declaración se
revierta, dejando la base de datos en el estado en el que se encontraba antes de que la
declaración comenzara a ejecutarse. La atomicidad se analiza en detalle en el capítulo 15 en
el curso del análisis de las transacciones.

Puede averiguar si una declaración se ejecutó correctamente. Lea la sección "Condiciones",

más adelante en este capítulo, para obtener más información.

variables
Los lenguajes informáticos completos como C y BASIC siempre han ofrecidovariables, pero
SQL no los ofreció hasta la introducción de SQL/PSM. Una variable es un símbolo que toma
un valor de cualquier tipo de datos determinado. Dentro de una declaración compuesta,
puede declarar una variable, asignarle un valor y usarla en una declaración compuesta.

Después de salir de una declaración compuesta, todas las variables declaradas en ella se
destruyen. Por lo tanto, las variables en SQL son locales respecto de la declaración
compuesta dentro de la cual se declaran.
396 Parte VI: Temas avanzados

He aquí un ejemplo:

COMENZAR

DECLARAR prezpay NUMÉRICO;

SELECCIONAR salario
EN prezpay
DEL EMPLEADO
DONDE título del trabajo = 'presidente';
FIN;

Cursores
Puedes declarar uncursordentro de una declaración compuesta. Los cursores se utilizan para
procesar los datos de una tabla, una fila a la vez. (Consulte el Capítulo 19 para obtener más detalles).
Dentro de una declaración compuesta, puede declarar un cursor, usarlo y luego olvidarlo porque el
cursor se destruye cuando sale de la declaración compuesta. A continuación se muestra un ejemplo
de este uso:

COMENZAR

DECLARAR ipocandidate CARACTER(30) ;

DECLARAR cursor1 CURSOR PARA
SELECCIONAR empresa
DE biotecnología ;
ABRIR CURSOR1;
FETCH cursor1 INTO ipocandidate; CERRAR
cursor1;
FIN;

Condiciones
Cuando la gente dice que una persona tiene una enfermedad, normalmente quiere decir que
algo anda mal con esa persona: está enferma o lesionada. La gente normalmente no se
molesta en mencionar que una persona está enbiencondición; más bien, hablan de personas
que se encuentran en estado grave o, peor aún, en estado crítico. Esta idea es similar a la
forma en que los programadores hablan sobre la condición de una declaración SQL. La
ejecución de una declaración SQL conduce a un resultado exitoso, a un resultado cuestionable
o a un resultado completamente erróneo. Cada uno de estos posibles resultados corresponde
a uncondición.

Cada vez que se ejecuta una declaración SQL, el servidor de la base de datos coloca
un valor en el parámetro de [Link]. ESTADOSQLes un campo de cinco
caracteres. El valor que se coloca enESTADOSQLindica si la instrucción SQL anterior
se ejecutó correctamente. Si no se ejecutó exitosamente, el valor deESTADOSQL
proporciona alguna información sobre el error.
Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 397

Los primeros dos de los cinco personajes deESTADOSQL (el valor de clase) le brindan las
noticias más importantes sobre si la instrucción SQL anterior se ejecutó exitosamente,
devolvió un resultado que puede haber sido exitoso o no, o produjo un error. La tabla
20-1 muestra los cuatro resultados posibles.

Tabla 20-1 Valores de clase SQLSTATE

Clase Descripción Detalles

00 Exitoso La declaración se ejecutó exitosamente.

terminación

01 Advertencia Algo inusual sucedió durante la ejecución de la declaración,

pero el DBMS no puede decir si hubo un error. Verifique
cuidadosamente la declaración SQL anterior para asegurarse
de que esté funcionando correctamente.

02 Extraviado No se devolvieron datos como resultado de la ejecución de la

declaración. Esto puede ser una buena noticia o no, dependiendo de
lo que intentaste hacer con la declaración. Es posible que esté
esperando una tabla de resultados vacía.

Otro Excepción Los dos caracteres del código de clase, más los tres
caracteres del código de subclase, comprenden los
cinco caracteres [Link]én le dan una
idea de la naturaleza del error.

Condiciones de manejo
Puedes ver tu programaESTADOSQLdespués de la ejecución de cada
declaración SQL. ¿Qué haces con el conocimiento que adquieres?

✓ Si encuentra un código de clase de00,probablemente no quieras hacer nada. Quiere

que la ejecución se lleve a cabo según lo planeado originalmente.

✓ Si encuentra un código de clase de01o02,es posible que desee tomar medidas

[Link] esperaba la indicación "Advertencia" o "No encontrado", entonces
probablemente desee dejar que continúe la ejecución. Si no esperaba ninguno de estos
códigos de clase, entonces probablemente desee que la ejecución se bifurque a un
procedimiento que esté específicamente diseñado para manejar el resultado
inesperado, pero no totalmente inesperado, de advertencia o no encontrado.

✓ Si recibe cualquier otro código de clase, algo anda [Link]ía

pasar a un procedimiento de manejo de excepciones. El procedimiento
al que elijas pasar depende del contenido de las tres subclases.
398 Parte VI: Temas avanzados

personajes, así como los dos personajes de clase [Link] son posibles
múltiples excepciones diferentes, debe haber un procedimiento de manejo de
excepciones para cada una porque excepciones diferentes a menudo requieren
respuestas diferentes. Es posible que pueda corregir algunos errores o encontrar
soluciones. Otros errores pueden ser fatales; nadie morirá, pero es posible que
tengas que cancelar la aplicación.

Declaraciones del controlador

Puedes poner unmanejador de condicionesdentro de una declaración compuesta. Para

crear un controlador de condiciones, primero debe declarar la condición que manejará.
La condición declarada puede ser algún tipo de excepción o simplemente puede ser algo
verdadero. La Tabla 20-2 enumera las posibles condiciones e incluye una breve
descripción de las causas de cada tipo de condición.

Tabla 20-2 Condiciones que pueden especificarse en un

Controlador de condiciones

Condición Descripción

VALOR DE ESTADO SQL 'xxyyy' EspecíficoESTADOSQLvalor

EXCEPCIÓN SQL ESTADOSQLclase distinta a00, 01,o02

ADVERTENCIA SQL ESTADOSQLclase01
EXTRAVIADO ESTADOSQLclase02

El siguiente es un ejemplo de una declaración de condición:

COMENZAR

DECLARAR CONDICIÓN de restricción_violación

PARA EL VALOR DEL ESTADO SQL '23000';
FIN ;

Este ejemplo no es realista, porque normalmente la instrucción SQL que puede provocar
que se produzca la condición (así como el controlador que se invocaría si se produjera la
condición) también estaría incluido dentro delCOMIENZO…FIN estructura.

Acciones del controlador y efectos del controlador.

Si ocurre una condición que invoca un controlador, se ejecuta la acción especificada por el
controlador. Esta acción es una declaración SQL, que puede ser una declaración compuesta.
Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 399

declaración. Si la acción del controlador se completa con éxito, entonces se ejecuta el efecto
del controlador. La siguiente es una lista de los tres posibles efectos del controlador:

✓ CONTINUAR:Continúe la ejecución inmediatamente después de la declaración que

provocó que se invocara el controlador.

✓ SALIDA:Continúe la ejecución después de la declaración compuesta que contiene el

controlador.

✓ DESHACER:Deshaga el trabajo de las declaraciones anteriores en la declaración

compuesta y luego continúe la ejecución después de la declaración que contiene el
controlador.

Si el manejador puede corregir cualquier problema que haya invocado, entonces el

CONTINUAREl efecto puede ser apropiado. ElSALIDAEl efecto puede ser apropiado si el
controlador no solucionó el problema, pero no es necesario deshacer los cambios realizados
en la declaración compuesta. ElDESHACEREl efecto es apropiado si desea devolver la base de
datos al estado en el que se encontraba antes de que la instrucción compuesta comenzara a
ejecutarse. Considere el siguiente ejemplo:

COMENZAR ATÓMICO
DECLARAR CONDICIÓN de restricción_violación
PARA EL VALOR DEL ESTADO SQL '23000';
DECLARAR DESHACER MANEJADOR
PARA violación_restricción
RENUNCIA ;
INSERTAR EN estudiantes (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ; INSERTAR EN la lista (ID
de clase, Clase, ID de estudiante)
VALORES (:cid, :cname, :sid) ;
FIN ;

Si cualquiera de losINSERTARdeclaraciones causan una violación de restricción, como intentar

agregar un registro con una clave principal que duplica una clave principal que ya está en la
tabla,ESTADOSQLasume un valor de '23000',estableciendo así el violación_restriccióncondición
a un valor verdadero. Esta acción hace que el manejadorDESHACERcualquier cambio que se
haya realizado en cualquier tabla por cualquiera de los dos INSERTARdominio. ElRENUNCIALa
declaración transfiere el control nuevamente al procedimiento que llamó al procedimiento que
se está ejecutando actualmente.

Si ambosINSERTARLas declaraciones se ejecutan con éxito, la ejecución continúa con

la declaración que sigue a laFINpalabra clave.

ElATÓMICOLa palabra clave es obligatoria siempre que el efecto de un controlador sea

[Link] no es el caso de los manipuladores cuyo efecto esCONTINUARoSALIDA.
400 Parte VI: Temas avanzados

Condiciones que no se manejan

En el ejemplo de la sección anterior, considere esta posibilidad: ¿Qué sucede si ocurre
una excepción que devuelve unESTADOSQLvalor distinto de '23000'? Definitivamente
algo anda mal, pero el controlador de excepciones que usted codificó no puede
manejarlo. ¿Que pasa ahora?

Debido a que el procedimiento actual no sabe qué hacer, unRENUNCIAocurre. Esto

lleva el problema al siguiente nivel superior de control. Si el problema no se
soluciona allí, continúa elevándose a niveles superiores hasta que se soluciona o
provoca una condición de error en la aplicación principal.

La idea que quiero enfatizar aquí es que si escribe una declaración SQL que puede
causar excepciones, entonces debe escribir controladores de excepciones para todas
esas posibles excepciones. Si no lo hace, tendrá más dificultades para aislar el origen
de un problema cuando inevitablemente ocurra.

Asignación
Con SQL/PSM, SQL obtuvo una función que incluso los lenguajes procedimentales más
humildes han tenido desde sus inicios: la capacidad de asignar un valor a una variable.
Básicamente, una declaración de asignación toma la siguiente forma:

ESTABLECER destino = fuente;

En este uso,objetivoes un nombre de variable, yfuentees una expresion.

Varios ejemplos incluyen los siguientes:

SET vfname = 'Joss';

SET varea = 3.1416 * :radio * :radio ;

SET vWIMPmass = NULL;

Flujo de declaraciones de control

Desde su formulación original en el estándar SQL-86, uno de los principales
inconvenientes que ha impedido que la gente use SQL de manera procedimental ha
sido su falta de flujo de declaraciones de control. Hasta que SQL/PSM se incluyó en
el estándar SQL, no se podía salir de un orden secuencial estricto de ejecución sin
volver a un lenguaje anfitrión como C o BASIC. SQL/PSM introduce el flujo
tradicional de estructuras de control que proporcionan otros lenguajes, permitiendo
así que los programas SQL realicen las funciones necesarias sin tener que alternar
entre lenguajes.
Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 401

SI... ENTONCES... DE LO CONTRARIO... TERMINAR SI

La declaración de flujo de control más básica es laSI... ENTONCES... DE LO CONTRARIO... TERMINAR SI

declaración. Esta afirmación, traducida aproximadamente del lenguaje informático, significaSI una
condición es verdadera, luego ejecute las declaraciones que siguen a laENTONCESpalabra clave. De lo
contrario, ejecute las instrucciones que siguen a laDEMÁSpalabra clave. Por ejemplo:

SI
vfname = 'Joss'
ENTONCES

ACTUALIZAR estudiantes
SET Fname = 'Joss' WHERE
StudentID = 314159;
DEMÁS
ELIMINAR DE estudiantes
DONDE StudentID = 314159;
TERMINARA SI

En este ejemplo, si la variablenombrevfcontiene el valor 'Jos',luego el registro del

estudiante 314159 se actualiza con 'joss'en elNombrecampo. Si la variable
nombrevfcontiene cualquier valor distinto de 'Jos',luego, el registro del estudiante
314159 se elimina de la tabla ESTUDIANTES.

ElSI... ENTONCES... DE LO CONTRARIO... TERMINAR SILa declaración es excelente si desea

elegir una de dos acciones según el valor de una condición. Sin embargo, a menudo querrás
hacer una selección entre más de dos opciones. En esos momentos, probablemente debería
utilizar unCASOdeclaración.

CASO... CASO FINAL

CASOLas declaraciones vienen en dos formas: la [Link]ón y el buscado
CASOdeclaración. Ambos tipos le permiten tomar diferentes rutas de ejecución según
los valores de las condiciones.

Declaración CASO simple

Un simpleCASOLa declaración evalúa una sola condición. Según el valor de esa
condición, la ejecución puede tomar una de varias ramas. Por ejemplo:

CASO vmayor
CUÁNDO 'Ciencias de la Computación'
LUEGO INSERTAR EN geeks (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ;
CUÁNDO 'Medicina deportiva'
LUEGO INSERTAR EN deportistas (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ; CUANDO
'Filosofía'
LUEGO INSERTAR EN los escépticos (StudentID, Fname, Lname)
402 Parte VI: Temas avanzados

VALORES (:sid, :sfname, :slname) ;

ELSE INSERT INTO no declarado (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ;
CASO FINAL

ElDEMÁSLa cláusula maneja todo lo que no cae en las categorías nombradas

explícitamente en elENTONCEScláusulas.

No es necesario utilizar elDEMÁScláusula: es opcional. Sin embargo, si no lo incluye, y el

CASOLa condición de la declaración no es manejada por ninguno de los ENTONCES
cláusulas, SQL devuelve una excepción.

Declaración CASE buscada

un buscadoCASOdeclaración es similar a una simpleCASOdeclaración, pero evalúa
múltiples condiciones en lugar de solo una. Por ejemplo:

CASO
CUANDO es mayor
IN ('Ciencias de la Computación', 'Ingeniería eléctrica') LUEGO
INSERTAR EN geeks (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ; CUANDO
vclub
IN ('Radio amateur', 'Rocket', 'Computadora') LUEGO INSERTAR
EN geeks (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ; CUANDO
es mayor
IN ('Medicina deportiva', 'Educación física') LUEGO INSERTAR en
deportistas (StudentID, Fname, Lname)
VALORES (:sid, :sfname, :slname) ; DEMÁS

INSERTAR EN escépticos (StudentID, Fname, Lname)

VALORES (:sid, :sfname, :slname) ;
CASO FINAL

Se evita una excepción poniendo a todos los estudiantes que no sean geeks ni deportistas en la tabla
SKEPTICS. Debido a que no todos los no geeks y no deportistas son escépticos, esto puede no ser
estrictamente exacto en todos los casos. Si no es así, siempre puedes agregar algunos má[Link]
cláusulas.

BUCLE... BUCLE FINAL

ElBUCLELa declaración le permite ejecutar una secuencia de declaraciones SQL varias veces.
Después de la última declaración SQL incluida dentro delBUCLE… BUCLE FINALLa declaración
se ejecuta, el control vuelve a la primera declaración de este tipo.
Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 403

y hace otra pasada por las declaraciones adjuntas. La sintaxis es la siguiente:

ESTABLECER vcount = 0;
BUCLE
SET vcount = vcount + 1; INSERTAR EN
asteroide (AsteroidID)
VALORES (vcount);
FINALIZAR BUCLE

Este fragmento de código precarga su tabla ASTEROID con identificadores únicos.

Puedes completar otros detalles sobre los asteroides a medida que los encuentres,
según lo que veas a través de tu telescopio cuando los descubras.

Observe el pequeño problema con el fragmento de código del ejemplo anterior: es un

bucle infinito. No se toman medidas para salir del bucle, por lo que continuará
insertando filas en la tabla ASTEROID hasta que el DBMS llene todo el almacenamiento
disponible con registros de la tabla ASTEROID. Si tiene suerte, el DBMS generará una
excepción en ese momento. Si no tiene suerte, el sistema simplemente fallará.

Para elBUCLEPara que la declaración sea útil, necesita una forma de salir de los bucles antes de
generar una excepción. De esa manera es laDEJARdeclaración.

DEJAR
ElDEJARLa declaración funciona tal como se podría esperar que funcione. Cuando la ejecución
encuentra unDEJARdeclaración incrustada dentro de una declaración etiquetada, pasa a la
siguiente declaración más allá de la declaración etiquetada. Por ejemplo:

Precarga de asteroide:
ESTABLECER vcount = 0;
BUCLE
SET vcount = vcount + 1; SI
vcount> 10000
ENTONCES

DEJE la precarga de asteroides;

TERMINARA SI ;
INSERTAR EN asteroide (AsteroidID)
VALORES (vcount);
END LOOP Precarga de asteroides

El código anterior inserta 10.000 registros numerados secuencialmente en la

tabla ASTEROID y luego sale del bucle.
404 Parte VI: Temas avanzados

MIENTRAS... HACER... TERMINAR MIENTRAS

ElMIENTRASLa declaración proporciona otro método para ejecutar una serie de declaraciones
SQL varias veces. Si bien una condición designada es verdadera, laMIENTRAS El bucle continúa
ejecutándose. Cuando la condición se vuelve falsa, el bucle se detiene. Por ejemplo:

Precarga de asteroide2:
ESTABLECER vcount = 0;
MIENTRAS
vcount< 10000 hacer
SET vcount = vcount + 1; INSERTAR EN
asteroide (AsteroidID)
VALORES (vcount);
FINALIZAR MIENTRAS AsteroidPreload2

Este código hace exactamente lo mismo quePrecarga de asteroidehizo en el apartado

anterior. Este es sólo otro ejemplo del hecho frecuentemente citado de que con SQL,
normalmente hay múltiples formas de realizar una tarea determinada. Utilice el método
con el que se sienta más cómodo, suponiendo que su implementación permita ambos.

REPETIR…HASTA…TERMINAR REPETIR
ElREPETIREl bucle es muy parecido alMIENTRASbucle, excepto que la condición se verifica
después de que se ejecuten las declaraciones incrustadas en lugar de antes. Por ejemplo:

Precarga de asteroide3:
ESTABLECER vcount = 0;
REPETIR
SET vcount = vcount + 1; INSERTAR EN
asteroide (AsteroidID)
VALORES (vcount);
HASTA X = 10000
FINALIZAR REPETIR AsteroidPreload3

Aunque puedes realizar la misma operación de tres maneras diferentes (con

BUCLE, MIENTRAS,yREPETIR),Encontrará algunos casos en los que una de estas
estructuras es claramente mejor que las otras dos. Tenga los tres métodos en su
bolsa de trucos para que cuando surja una situación como esta pueda decidir cuál
es la mejor herramienta disponible para la situación.
Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 405

PARA... HACER... FIN PARA

El SQLPARAEl bucle declara y abre un cursor, busca las filas del cursor, ejecuta el cuerpo
del [Link]ón una vez para cada fila y luego cierra el cursor. Este bucle
hace posible el procesamiento completamente dentro de SQL, en lugar de cambiar a un
lenguaje anfitrión. Si su implementación es compatible con SQLPARAbucles, puede
usarlos como una alternativa simple al procesamiento del cursor descrito en el Capítulo
19. Aquí hay un ejemplo:

FOR vcount AS Curs1 CURSOR PARA

SELECCIONE AsteroidID DEL asteroide
HACER

ACTUALIZAR asteroide SET Descripción = ‘hierro pedregoso’

DONDE ACTUAL DE Curs1;
FIN PARA

En este ejemplo, actualiza cada fila de la tabla ASTEROID poniendo 'hierro de

piedra'en elDescripcióncampo. Esta es una forma rápida de identificar las
composiciones de los asteroides, pero la tabla puede sufrir algunas fallas en el
departamento de precisión. Quizás sería mejor comprobar las firmas espectrales
de los asteroides y luego introducir sus tipos individualmente.

ITERAR
ElITERARLa declaración proporciona una manera de cambiar el flujo de ejecución dentro
de una declaración SQL iterada. Las sentencias SQL iteradas sonBUCLE, MIENTRAS,
REPETIR,[Link] la condición de iteración de la sentencia SQL iterada es verdadera o no
se especifica, entonces la siguiente iteración del bucle comienza inmediatamente
después de laITERARse ejecuta la declaración. Si la condición de iteración de la sentencia
SQL iterada es falsa o desconocida, la iteración cesa después de laITERARse ejecuta la
declaración. Por ejemplo:

Precarga de asteroide4:
ESTABLECER vcount = 0;
MIENTRAS
vcount< 10000 hacer
SET vcount = vcount + 1; INSERTAR EN
asteroide (AsteroidID)
VALORES (vcount);
ITERAR AsteroidPreload4;
ESTABLECER vpreload = 'HECHO';
FINALIZAR MIENTRAS AsteroidPreload4

La ejecución vuelve a la parte superior delMIENTRASdeclaración inmediatamente después de

ITERARdeclaración cada vez a través del bucle hastacuentaves igual a 9999.
406 Parte VI: Temas avanzados

En esa iteración,cuentavincrementa a 10000, elINSERTARrealiza, el ITERARla

declaración cesa la iteración,precargase establece en 'HECHO',y la ejecución
continúa con la siguiente declaración después del ciclo.

Procedimientos almacenados
Los procedimientos almacenados residen en la base de datos del servidor en lugar de
ejecutarse en el cliente, donde se ubicaban todos los procedimientos antes de SQL/PSM.
Después de definir un procedimiento almacenado, puede invocarlo con unLLAMAR
declaración. Mantener el procedimiento ubicado en el servidor en lugar de en el cliente
reduce el tráfico de la red, acelerando así el rendimiento. El único tráfico que necesita
pasar del cliente al servidor es elLLAMARdeclaración. Puede crear este procedimiento de
la siguiente manera:

SQL EJECUTIVO
CREAR PROCEDIMIENTO ChessMatchScore
(Puntuación ENTRADA CHAR (3),
resultado FUERA CHAR (10))
COMENZAR ATÓMICO
Puntuación del CASO
CUANDO '1-0' ENTONCES
Resultado SET = 'ganancias blancas';
CUANDO '0-1' ENTONCES
Resultado SET = 'blackwins';
DEMÁS
Resultado SET = 'empate';
CASO FINAL
FIN ;

Después de haber creado un procedimiento almacenado como el de este ejemplo,

puede invocarlo con unLLAMARdeclaración similar a la siguiente declaración:

LLAMAR ChessMatchScore ('1-0', :Resultado);

El primer argumento es un parámetro de entrada que se envía alPuntuación del partido de

ajedrez procedimiento. El segundo argumento es una variable incrustada que acepta el valor
asignado al parámetro de salida que elPuntuación del partido de ajedrezprocedimiento utiliza
para devolver su resultado a la rutina de llamada. En este caso regresa "Las blancas ganan".

SQL:2011 ha agregado un par de mejoras a los procedimientos almacenados. El primero de

ellos es la introducción de argumentos con nombre. Aquí está el equivalente de la llamada
anterior, con argumentos con nombre:

LLAMAR ChessMatchScore (resultado => :Resultado,puntuación =>’1-0’);

 Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 407

Como los argumentos tienen nombre, se pueden escribir en cualquier orden

sin peligro de confusión.

La segunda mejora agregada en SQL:2011 es la adición de argumentos de entrada

predeterminados. Puede especificar un argumento predeterminado para el parámetro de
entrada. Después de hacer eso, no necesita especificar un valor de entrada en elLLAMAR
declaración; Se supone el valor predeterminado. (Por supuesto, querrá hacer esto sólo si el
valor predeterminado fuera en realidad el valor que desea enviar al procedimiento).

Aquí hay un ejemplo de ese uso:

SQL EJECUTIVO
CREAR PROCEDIMIENTO ChessMatchScore
(Puntuación ENTRADA CHAR (3) PREDETERMINADO
'1-0', resultado FUERA CHAR (10))
COMENZAR ATÓMICO
Puntuación del CASO
CUANDO '1-0' ENTONCES
Resultado SET = 'ganancias blancas';
CUANDO '0-1' ENTONCES
Resultado SET = 'blackwins';
DEMÁS
Resultado SET = 'empate';
CASO FINAL
FIN ;

Ahora puedes llamar a este procedimiento de esta manera con el valor predeterminado:

LLAMAR ChessMatchScore (:Resultado);

Por supuesto, sólo querrá hacer esto si el valor predeterminado fuera en realidad
el valor que desea enviar al procedimiento.

Funciones almacenadas
Una función almacenada es similar en muchos aspectos a un procedimiento almacenado. En
conjunto, los dos se conocen comorutinas [Link] diferencian en varios aspectos,
incluida la forma en que se invocan. Un procedimiento almacenado se invoca con unLLAMAR
declaración, y se invoca una función almacenada con unaLlamada de función, que puede
reemplazar un argumento de una declaración SQL. El siguiente es un ejemplo de definición de
función, seguido de un ejemplo de llamada a esa función:

CREAR FUNCIÓN Historial de compras (CustID)

DEVOLUCIONES CHAR VARIAN (200)

COMENZAR

DECLARAR compra CHAR VARYING (200)

408 Parte VI: Temas avanzados

POR DEFECTO '' ;

PARA x COMO SELECCIONAR *
DE transacciones t
DONDE [Link] = ClienteID
HACER

SI un <>''
ENTONCES ESTABLECER compra = compra || ', ';
TERMINARA SI ;
SET compra = compra || [Link]ón; FIN PARA

DEVOLUCIÓN compra;
FIN ;

Esta definición de función crea una lista delimitada por comas de compras realizadas
por un cliente que tiene un número de cliente específico, tomado de la tabla
TRANSACCIONES. La siguienteACTUALIZARLa declaración contiene una llamada de
función aHistorial de comprasque inserta el último historial de compras del cliente
número 314259 en su registro en la tabla CLIENTE:

ESTABLECER ID de cliente = 314259;

ACTUALIZAR cliente
Historial SET = Historial de compras (ID de cliente)
DONDE ID de cliente = 314259;

Privilegios
Analizo los diversos privilegios que puede otorgar a los usuarios en el Capítulo 14. El propietario de la
base de datos puede otorgar los siguientes privilegios a otros usuarios:

✓ El derecho aBORRARfilas de una tabla

✓ El derecho aINSERTARfilas en una tabla
✓ El derecho aACTUALIZARfilas en una tabla

✓ El derecho a crear una tabla queREFERENCIASotra mesa

✓ el derecho deUSOen un dominio

SQL/PSM agrega un privilegio más que se puede otorgar a un usuario: el

EJECUTARprivilegio. Aquí hay dos ejemplos:

OTORGAR EJECUCIÓN en ChessMatchScore a TournamentDirector;

GRANT EJECUTAR en PurchaseHistory a SalesManager;

 Capítulo 20: Agregar capacidades de procedimiento con módulos almacenados persistentes 409

Estas declaraciones permiten al director del torneo de ajedrez ejecutar la

Puntuación del partido de ajedrezprocedimiento, y el gerente de ventas de la
empresa para ejecutar elHistorial de comprasfunción. personas que carecen de
EJECUTAREl privilegio de una rutina no puede usarlo.

Módulos almacenados
Un módulo almacenado puede contener múltiples rutinas (procedimientos y/o funciones) que
pueden ser invocadas por SQL. Cualquiera que tenga laEJECUTAREl privilegio de un módulo
tiene acceso a todas las rutinas del módulo. Los privilegios sobre rutinas dentro de un módulo
no se pueden otorgar individualmente. El siguiente es un ejemplo de un módulo almacenado:

CREAR MÓDULO mod1

PROCEDIMIENTO MatchScore
( EN puntuación CHAR (3),
Resultado OUT CHAR (10) )
COMENZAR ATÓMICO
resultado del CASO
CUANDO '1-0' ENTONCES
Resultado SET = 'ganancias blancas';
CUANDO '0-1' ENTONCES
Resultado SET = 'blackwins';
DEMÁS
Resultado SET = 'empate';
CASO FINAL
FIN ;
FUNCIÓN Historial de compras (ID de cliente)
DEVOLUCIONES CHAR VARIADO (200)
COMIENZO
DECLARAR compra CHAR VARYING (200)
POR DEFECTO '' ;
PARA x COMO SELECCIONAR *
DE transacciones t
DONDE [Link] = ClienteID
HACER

SI un <>''
ENTONCES ESTABLECER compra = compra || ', ';
TERMINARA SI ;
SET compra = compra || [Link]ón; FIN PARA

DEVOLUCIÓN compra;
FIN ;
MÓDULO FINAL ;
410 Parte VI: Temas avanzados

Las dos rutinas de este módulo (un procedimiento y una función) no tienen mucho
en común, pero no es necesario. Puede reunir rutinas relacionadas en un solo
módulo, o puede incluir todas las rutinas que probablemente utilizará en un solo
módulo, independientemente de si tienen algo en común.
 Capítulo 21

Manejo de errores

En este capítulo
▶ Condiciones de error de señalización

▶ Bifurcación al código de manejo de errores

▶ Determinar la naturaleza exacta de un error
▶ Averiguar qué DBMS generó una condición de error

W. ¿No sería fantástico si cada aplicación que escribieras funcionara perfectamente en

todo momento? Sí, y también sería genial ganar 314,9 millones de dólares.
león jugando Powerball. Desafortunadamente, ambas posibilidades son igualmente
improbables. Las condiciones de error de un tipo u otro son inevitables, por lo que es útil
saber qué las causa. El mecanismo de SQL para devolverle información de error es el
parámetro de estado(ovariable del lenguaje principal)[Link] en el
contenido deESTADOSQL,puede tomar diferentes acciones para remediar la condición de
error.

Por ejemplo, elCUANDO SEALa directiva le permite tomar una acción predeterminada
siempre que se cumpla una condición específica (siESTADOSQLtiene un valor distinto de
cero, por ejemplo). También puede encontrar información de estado detallada sobre la
declaración SQL que acaba de ejecutar en el área de diagnóstico. En este capítulo,
explico estas útiles funciones de manejo de errores y cómo usarlas.

ESTADOSQL
ESTADOSQLespecifica un gran número de condiciones anó[Link] una
cadena de cinco caracteres en la que sólo las letras mayúsculasAa través dezy los
números del 0 al 9 son caracteres válidos. La cadena de cinco caracteres se divide en dos
grupos: un código de clase de dos caracteres y un código de subclase de tres caracteres.
El código de clase mantiene un estado después de completar una declaración SQL. Ese
estado podría indicar la finalización exitosa de la declaración o uno de varios tipos
principales de condiciones de error. El código de la subclase proporciona detalles
adicionales sobre esta ejecución particular de la declaración. La figura 21-1 ilustra la
ESTADOSQLdisposición.
412 Parte VI: Temas avanzados

El estándar SQL define cualquier código de clase que comience con las letrasA a través deho los
números del 0 al 4; por lo tanto, estos códigos de clase significan lo mismo en cualquier
implementación. Códigos de clase que comienzan con las letras. Ia través dezo los números del
5 al 9 se dejan abiertos para que los implementadores (las personas que crean sistemas de
administración de bases de datos) los definan porque la especificación SQL no puede anticipar
todas las condiciones que pueden surgir en cada implementación. Sin embargo, los
implementadores deberían utilizar estos códigos de clases no estándar lo menos posible para
evitar problemas de migración de un DBMS a otro. Idealmente, los implementadores deberían
utilizar los códigos estándar la mayor parte del tiempo y los códigos no estándar sólo en las
circunstancias más inusuales.

Figura 21-1:
ESTADOSQL
de 00000
indica
exitoso
terminación
de un SQL:
declaración.

IntroduzcoESTADOSQLen el Capítulo 20, pero aquí hay un resumen. Un código de clase

de00 indica finalización exitosa. Código de clase01significa que la declaración se ejecutó
correctamente pero produjo una advertencia. Código de clase02indica una condición
sin datos. CualquierESTADOSQLcódigo de clase distinto de00, 01,o02indica que la
declaración no se ejecutó correctamente.

PorqueESTADOSQLse actualiza después de cada operación SQL, puede verificarlo

después de que se ejecute cada declaración. SiESTADOSQLcontiene00000 (finalización
exitosa), puede continuar con la siguiente operación. Si contiene algo más, es posible
que desees salir de la línea principal de tu código para manejar la situación. El código de
clase específico y el código de subclase que unESTADOSQLcontiene, determine cuál de
varias acciones posibles debe realizar.

UsarESTADOSQLen un programa de lenguaje de módulo (que describo en el Capítulo 16),

incluya una referencia a él en las definiciones de sus procedimientos, como muestra el
siguiente ejemplo:

PROCEDIMIENTO NUTRIENTE
(SQLSTATE, :foodname CHAR (20), :calorías SMALLINT,
:proteína DECIMAL (5,1), :grasa DECIMAL (5,1),
:carbo DECIMAL (5,1))
INSERTAR EN LOS ALIMENTOS
(Nombre del alimento, Calorías, Proteínas, Grasas, Carbohidratos)
VALORES
(:nombre del alimento, :calorías, :proteína, :grasa, :carbo) ;
 Capítulo 21: Manejo de errores 413
En el lugar apropiado de su programa de lenguaje de procedimientos, puede
hacer que los valores estén disponibles para los parámetros (tal vez
solicitándolos al usuario) y luego llamar el procedimiento. La sintaxis de esta
operación varía de un idioma a otro, pero se parece a esto:

nombre del alimento = “Okra,

hervida”; calorías = 29;
proteína = 2,0;
grasa = 0,3;
carbohidratos = 6,0;
NUTRIENTE(estado, nombre del alimento, calorías, proteínas, grasas, carbohidratos);

El estado deESTADOSQLse devuelve en la [Link] programa puede

examinar esta variable y luego tomar la acción adecuada según el contenido de
la variable.

Cláusula CUANDO SIEMPRE

¿De qué sirve saber que una operación SQL no se ejecutó correctamente si no
se puede hacer nada al respecto? Si ocurre un error, no querrás que tu
aplicación continúe ejecutándose como si todo estuviera bien. Debe poder
reconocer el error y hacer algo para corregirlo. Si no puede corregir el error, al
menos desea informar al usuario del problema y llevar la aplicación a una
finalización elegante. ElCUANDO SEALa directiva es el mecanismo SQL para
tratar excepciones de ejecución.

ElCUANDO SEALa directiva es en realidad una declaración y, por lo tanto, se encuentra

en la sección de declaración SQL de su aplicación, antes del código SQL ejecutable. La
sintaxis es la siguiente:

SIEMPRE condición acción;

La condición puede ser cualquieraERROR [Link] acción puede ser

CONTINUARoIR ADIRECCIÓ[Link] SQLes cierto siESTADOSQLtiene un código de clase
distinto de00, 01,o02. NO ENCONTRADOes cierto siESTADOSQLes02000.

Si la acción esCONTINUAR,No sucede nada especial y la ejecución continúa normalmente. Si la

acción esIR ADIRECCIÓN(oIR ADIRECCIÓN), la ejecución se ramifica a la dirección designada
en el programa. En la dirección de la sucursal, puede colocar una declaración condicional que
examineESTADOSQLy toma diferentes acciones en función de lo que encuentra. A
continuación se muestran algunos ejemplos de este escenario:

SIEMPRE QUE SQLERROR VAYA A error_trap;

CUANDO NO SE ENCUENTRE CONTINUAR ;

414 Parte VI: Temas avanzados

ElIR Aopción es simplemente una macro: Laimplementación(es decir, el precompilador del

lenguaje incorporado) inserta la siguiente prueba después de cadaSQL EJECUTIVO declaración:

SI SQLSTATE <>'00000'
Y SQLSTATE <>'00001'
Y SQLSTATE <>'00002'
ENTONCES GOTOerror_trap;

ElCONTINUARLa opción es esencialmente unaNO OPERATIVOque dice "ignora esto".

Áreas de Diagnóstico
A pesar deESTADOSQLpuede brindarle información sobre por qué falló una declaración
en particular, la información es bastante breve. Por tanto, SQL proporciona la captura y
retención de información de estado adicional en áreas de diagnóstico.

Se mantienen múltiples áreas de diagnóstico en forma deúltimo en entrar primero en salir

(LIFO) pila. Es decir, la información sobre el error más reciente se puede encontrar en la parte
superior de la pila, con información sobre errores más antiguos más abajo en la lista. La
información de estado adicional en un área de diagnóstico puede resultar particularmente útil
en los casos en que la ejecución de una única instrucción SQL genera múltiples advertencias
seguidas de un [Link] la aparición de un solo error, pero el área de
diagnóstico tiene la capacidad de informar sobre múltiples errores (con suerte, todos).

El área de diagnóstico es una estructura de datos administrada por DBMS que tiene dos
componentes:

✓ Encabezamiento:El encabezado contiene información general sobre la declaración

SQL más reciente que se ejecutó.

✓ Área de detalle:El área de detalles contiene información sobre cada

código (error, advertencia o éxito) que generó la declaración.

Área de encabezado de diagnóstico

En elESTABLECER TRANSACCIÓNdeclaración (descrita en el Capítulo 15), puede especificar
TAMAÑO DEL DIAGNÓ[Link]ÑOque especifique es el número de áreas de detalle
asignadas para la información de estado. Si no incluyes unTAMAÑO DEL DIAGNÓSTICO
cláusula en suESTABLECER TRANSACCIÓNdeclaración, su DBMS asigna su número
predeterminado de áreas de detalle, sea lo que sea.
 Capítulo 21: Manejo de errores 415
El área del encabezado contiene varios elementos, como se enumeran en la Tabla 21-1.

Tabla 21-1 Área de encabezado de diagnóstico

Campos Tipo de datos

NÚMERO Numérico exacto sin parte fraccionaria

NÚMERO DE FILAS Numérico exacto sin parte fraccionaria

COMMAND_FUNCTION VARCHAR (implementación de longitud máxima

definida)

COMMAND_FUNCTION_CODE Numérico exacto sin parte fraccionaria

FUNCIÓN_DINÁMICA VARCHAR (implementación de longitud máxima

definida)

CÓDIGO_FUNCTION_DYNAMIC Numérico exacto sin parte fraccionaria

MÁS Numérico exacto sin parte fraccionaria

TRANSACCIONES_COMMITTED Numérico exacto sin parte fraccionaria

TRANSACTIONS_ROLLED_BACK Numérico exacto sin parte fraccionaria

TRANSACTION_ACTIVE Numérico exacto sin parte fraccionaria

La siguiente lista describe estos elementos con más detalle:

✓ ElNÚMEROEl campo es el número de áreas de detalle que se han completado con

información de diagnóstico sobre la excepción actual.

✓ ElNÚMERO DE FILASEl campo contiene el número de filas afectadas si la declaración

SQL anterior era unaINSERTAR, ACTUALIZAR,oBORRAR.

✓ ElCOMMAND_FUNCTIONEl campo describe la declaración SQL que se acaba de

ejecutar.

✓ ElCOMMAND_FUNCTION_CODEEl campo proporciona el número de código de la

instrucción SQL que se acaba de ejecutar. Cada función de comando tiene un
código numérico asociado.

✓ ElFUNCIÓN_DINÁMICAEl campo contiene la instrucción SQL dinámica.

✓ ElCÓDIGO_FUNCTION_DYNAMICEl campo contiene un código numérico
correspondiente a la instrucción SQL dinámica.

✓ ElMÁSEl campo puede ser un 'Túo un 'NORTE'. 'Y'indica que hay más registros de
estado de los que puede contener el área de detalles. 'NORTE'indica que todos los
registros de estado generados están presentes en el área de detalles. Dependiendo de
su implementación, es posible que pueda ampliar la cantidad de registros que puede
manejar utilizando elESTABLECER TRANSACCIÓN declaración.
416 Parte VI: Temas avanzados

✓ ElTRANSACCIONES_COMMITTEDEl campo contiene el número de

transacciones que se han confirmado.
✓ ElTRANSACTIONS_ROLLED_BACKEl campo contiene el número de
transacciones que se han revertido.
✓ ElTRANSACTION_ACTIVEEl campo contiene un '1'si una transacción está
actualmente activa y un '0’de lo contrario. Una transacción se considera activa si
hay un cursor abierto o si el DBMS está esperando un parámetro diferido.

Área de detalle de diagnóstico

Las áreas de detalles contienen datos sobre cada error, advertencia o condición de éxito
individual. Cada área de detalle contiene 28 elementos, como muestra la Tabla 21-2.

Tabla 21-2 Área de detalles de diagnóstico

Campos Tipo de datos

CONDICIÓN_NÚMERO Numérico exacto sin parte fraccionaria

RETURNED_SQLSTATE CARACTER (6)

MENSAJE DE TEXTO VARCHAR (implementación de longitud máxima definida)

MENSAJE_LENGTH Numérico exacto sin parte fraccionaria

MESSAGE_OCTET_LENGTH Numérico exacto sin parte fraccionaria

CLASE_ORIGIN VARCHAR (implementación de longitud máxima definida)

SUBCLASS_ORIGIN VARCHAR (implementación de longitud máxima definida)

NOMBRE DE LA CONEXIÓN VARCHAR (implementación de longitud máxima definida)

NOMBRE DEL SERVIDOR VARCHAR (implementación de longitud máxima definida)

RESTRICCIÓN_CATALOGO VARCHAR (implementación de longitud máxima definida)

RESTRICCIÓN_ESQUEMA VARCHAR (implementación de longitud máxima definida)

RESTRICCIÓN_NOMBRE VARCHAR (implementación de longitud máxima definida)

CATÁLOGO_NOMBRE VARCHAR (implementación de longitud máxima definida)

ESQUEMA_NOMBRE VARCHAR (implementación de longitud máxima definida)

NOMBRE DE LA TABLA VARCHAR (implementación de longitud máxima definida)

COLUMNA_NOMBRE VARCHAR (implementación de longitud máxima definida)

CURSOR_NOMBRE VARCHAR (implementación de longitud máxima definida)

CONDICIÓN_IDENTIFICADOR VARCHAR (implementación de longitud máxima definida)

PARÁMETRO_NOMBRE VARCHAR (implementación de longitud máxima definida)

PARAMETRO_ORDINAL_ Numérico exacto sin parte fraccionaria

POSICIÓN
 Capítulo 21: Manejo de errores 417

Campos Tipo de datos

PARAMETER_MODE Numérico exacto sin parte fraccionaria

CATÁLOGO_RUTINA VARCHAR (implementación de longitud máxima definida)

RUTINA_ESQUEMA VARCHAR (implementación de longitud máxima definida)

RUTINA_NOMBRE VARCHAR (implementación de longitud máxima definida)

ESPECÍFICO_NOMBRE VARCHAR (implementación de longitud máxima definida)

TRIGGER_CATALOG VARCHAR (implementación de longitud máxima definida)

TRIGGER_SCHEMA VARCHAR (implementación de longitud máxima definida)

TRIGGER_NAME VARCHAR (implementación de longitud máxima definida)

CONDICIÓN_NÚMEROcontiene el número de secuencia del área de detalle. Si un estado de

cuenta genera cinco elementos de estado que llenan cinco áreas de detalle, el
CONDICIÓN_NÚMEROpara la quinta área de detalle es 5. Para recuperar un área de detalle
específica para su examen, utilice unOBTENER DIAGNÓSTICOdeclaración (descrita más
adelante en este capítulo en la sección “Interpretación de la información devuelta por
SQLSTATE”) con el valor deseadoCONDICIÓN_NÚMERO. RETURNED_SQLSTATEsostiene el
ESTADOSQLvalor que provocó que se llenara esta área de detalle.

CLASE_ORIGINle indica la fuente del valor del código de clase devuelto en

[Link] el estándar SQL define el valor, elCLASE_ORIGINes 'ISO 9075’.Si
su implementación DBMS define el valor,CLASE_ORIGINcontiene una cadena
que identifica la fuente de su DBMS.SUBCLASS_ORIGINle indica la fuente del
valor del código de subclase devuelto enESTADOSQL.

CLASE_ORIGINes importante. Si obtienes unESTADOSQLde '22012’,por ejemplo, los

valores indican que está en el rango de estándarESTADOSQLs, para que sepas que
significa lo mismo en todas las implementaciones de SQL. Sin embargo, si el ESTADOSQL
es '22500',los dos primeros caracteres están en el rango estándar e indican una
excepción de datos, pero los últimos tres caracteres están en el rango definido por la
implementación. Y siESTADOSQLes '90001',está completamente en el rango definido por
la implementació[Link] valores en el rango definido por la implementación
pueden significar diferentes cosas en diferentes implementaciones, aunque el código en
sí pueda ser el mismo.

Entonces, ¿cómo se puede saber el significado detallado de "22500’o el significado de '

90001'?Debe buscar en la documentación del implementador. ¿Qué implementador? Si
estas usandoCONECTAR,es posible que se esté conectando a varios productos. Para
determinar cuál produjo la condición de error, mire CLASE_ORIGINySUBCLASS_ORIGIN:
Tienen valores que identifican cada implementación. Puedes probar elCLASE_ORIGINy
SUBCLASS_ORIGINpara ver si identifican implementadores para los cuales usted tiene la
ESTADOSQL listados. Los valores reales colocados enCLASE_ORIGINySUBCLASS_ORIGIN
están definidos por el implementador, pero también se espera que sean nombres de
empresas que se explican por sí mismos.
418 Parte VI: Temas avanzados

Si el error reportado es una violación de restricción, elCONSTRAINT_CATALOG,

CONSTRAINT_SCHEMA,yRESTRICCIÓN_NOMBREidentificar la restricción que se está
violando.

Ejemplo de violación de restricciones

La información de violación de restricciones es probablemente la información más importante que
OBTENER DIAGNÓSTICOproporciona. Considere la siguiente tabla de EMPLEADOS:

CREAR TABLA EMPLEADO

(ID CHAR(5) RESTRICCIÓN CLAVE PRIMARIA EmpPK,
Salario DEC(8,2) RESTRICCIÓN EmpSal CHECK Salario > 0,
Departamento CHAR(5) RESTRICCIÓN EmpDept,
DEPARTAMENTO DE REFERENCIAS) ;

Y esta tabla DEPARTAMENTO:

CREAR DEPARTAMENTO DE MESA

(Nº de departamento CHAR(5),
Presupuesto DEC(12,2) RESTRICCIÓN DepartamentoPresupuesto
VERIFICAR(Presupuesto >= SELECCIONAR SUMA(Salario)
DEL EMPLEADO
DÓNDE
[Link]=[Link]),
...);

Ahora considere unINSERTARcomo sigue:

INSERTAR EN VALORES DE EMPLEADO(:ID_VAR, :SAL_VAR, :DEPT_VAR)

;

Supongamos que obtienes unESTADOSQLde '23000’.Lo busca en su documentación de

SQL y descubre que esto significa que la declaración está cometiendo una "violación
de la restricción de integridad". ¿Ahora que? EsoESTADOSQLvalor significa que una de
las siguientes situaciones es verdadera:

✓ El valor enID_VARes un duplicado de un existenteIDENTIFICACIÓNvalor:Has

violado elCLAVE PRIMARIArestricción.

✓ El valor enSAL_VARes negativo:Has violado elCONTROLARrestricción

enSalario.
✓ El valor enDEPTO_VARno es un valor clave válido para ninguna fila existente
de DEPARTAMENTO:Has violado elREFERENCIASrestricción enDepartamento

✓ El valor enSAL_VARes lo suficientemente grande como para que la suma de los

salarios de los empleados en este departamento exceda elPRESUPUESTO:Has
violado elCONTROLARrestricción en elPRESUPUESTOcolumna de DEPARTAMENTO.
(Recuerde que si cambia la base de datos, se verifican todas las restricciones que
puedan verse afectadas, no solo las definidas en la tabla inmediata).
 Capítulo 21: Manejo de errores 419
En circunstancias normales, sería necesario realizar muchas pruebas para
descubrir qué hay de malo en [Link] puedes descubrir lo que
necesitas saber usandoOBTENER DIAGNÓSTICOcomo sigue:

DECLARAR ConstNameVarCHAR(18) ;
OBTENER DIAGNÓSTICOS EXCEPCIÓN 1
ConstNameVar = CONSTRAINT_NAME;

Asumiendo queESTADOSQLes '23000',esteOBTENER DIAGNÓSTICOconjuntos

ConstNameVara 'EmpPK’, ‘EmpSal’, ‘EmpDept’,o 'DepartamentoPresupuesto’. Observe
que, en la práctica, también desea obtener laRESTRICCIÓN_ESQUEMA y
RESTRICCIÓN_CATALOGOpara identificar de forma única la restricción dada por
RESTRICCIÓN_NOMBRE.

Agregar restricciones a una tabla existente

Este uso deOBTENER DIAGNÓSTICOS —determinar cuál de varias restricciones ha sido
violada, es particularmente importante en el caso en queALTERAR TABLA se usa para
agregar restricciones que no existían cuando escribiste el programa:

ALTERAR EMPLEADO DE MESA

AÑADIR RESTRICCIÓN SalLimitCHECK(Salario < 200000);

Ahora, si inserta datos en EMPLEADO o actualiza elSalariocolumna de

EMPLEADO, obtienes unESTADOSQLde '23000'siSalariosupera los $200.000.
Puedes programar tuINSERTARdeclaración para que, si obtiene una
ESTADOSQLde '23000'y no reconoce el nombre de restricción particular que
OBTENER DIAGNÓSTICOdevuelve, puede mostrar un mensaje útil, como
INSERT no válido: restricción SalLimit violada.

Interpretando la información
devuelta por SQLSTATE
NOMBRE DE LA CONEXIÓNyENTORNO_NOMBREidentifique la conexión y el
entorno al que está conectado en el momento en que se ejecuta la instrucción
SQL.

Si el informe trata de una operación de tabla,NOMBRE_CATALOGO, NOMBRE_ESQUEMA, y

NOMBRE DE LA TABLAidentificar la mesa.COLUMNA_NOMBREidentifica la columna dentro de
la tabla que provocó que se realizara el informe. Si la situación involucra un cursor,
CURSOR_NOMBREda su nombre.

A veces, un DBMS produce una cadena de texto en lenguaje natural para explicar una
condición. ElMENSAJE DE TEXTOEl artículo es para este tipo de información. El
contenido de este elemento depende de la implementación; el estándar SQL no
420 Parte VI: Temas avanzados

definirlos explícitamente. Si tienes algo enMENSAJE DE TEXTO,su longitud en

caracteres se registra enMENSAJE_LENGTH,y su longitud en octetos se registra
enMESSAGE_OCTET_LENGTH.Si el mensaje está en caracteres ASCII normales,
MENSAJE_LENGTHes igualMESSAGE_OCTET_LENGTH.Si, por el contrario, el
mensaje está en kanji o en algún otro idioma cuyos caracteres requieren más
de un octeto para expresarse,MENSAJE_LENGTHdifiere de
MESSAGE_OCTET_LENGTH.

Para recuperar información de diagnóstico de un encabezado de área de diagnóstico, utilice lo

siguiente:

OBTENER DIAGNÓSTICO estado1 = elemento1 [, estado2 = elemento2]... ;

estadonortees una variable del lenguaje principal o un parámetro;artículonortepuede ser cualquiera de las
palabras clave NÚMERO, MÁS, COMMAND_FUNCTION, DYNAMIC_FUNCTION,oNÚMERO DE FILAS.

Para recuperar información de diagnóstico de un área de detalles de diagnóstico, utilice la

siguiente sintaxis:

OBTENER DIAGNÓSTICO EXCEPCIÓN número-condición

estado1 = elemento1 [, estado2 = elemento2]... ;

De nuevoestadonortees una variable del lenguaje principal o un parámetro, yartículonortees cualquiera

de las 28 palabras clave para los elementos de detalle enumerados en la Tabla 21-2. El número de
condición es (¡sorpresa!) el del área de [Link]ÓN_NÚMEROartículo.

Manejo de excepciones
CuandoESTADOSQLindica una condición de excepción al mantener un valor distinto de
00000, 00001,o00002,Es posible que desee manejar la situación de una de las siguientes
maneras:

✓ Devuelve el control al procedimiento principal que llamó al subprocedimiento

que generó la excepción.

✓ Usar unaCUANDO SEAcláusula (como se describió anteriormente en este capítulo) para pasar
a una rutina de manejo de excepciones o realizar alguna otra acción.

✓ Manejar la excepción en el acto con uncompuestoDeclaración SQL (como se

describe en el Capítulo 20). Una sentencia SQL compuesta consta de una o
más sentencias SQL simples, intercaladas entreCOMENZARyFIN palabras
clave.
 Capítulo 21: Manejo de errores 421
El siguiente es un ejemplo de un controlador de excepciones de sentencia compuesta:

COMENZAR

DECLARAR LA EXCEPCIÓN ValueOutOfRange PARA SQLSTATE'73003';

INSERTAR EN LOS ALIMENTOS
(calorías)
VALORES
(: cal);
SEÑAL ValorOutOfRange;
MENSAJE 'Procesar un nuevo valor calórico'.
EXCEPCIÓN
CUANDO ValueOutOfRange ENTONCES
MENSAJE 'Manejo del error de rango de calorías'; CUANDO
OTROS ENTONCES
RENUNCIA ;
FIN

Con uno o másDECLARARdeclaraciones, puede dar nombres a específicos ESTADOSQL

valores que sospecha que pueden surgir. ElINSERTARLa declaración es la que podría
provocar que se produzca una excepción. Si el valor de:Californiaexcede el valor máximo
para unPEQUEÑOelemento de datos,ESTADOSQLse establece en "73003”.El SEÑALLa
declaración señala una condición de excepción. Borra el área de diagnóstico superior.
Establece elRETURNED_SQLSTATEcampo del área de diagnóstico al ESTADOSQLpara la
excepción nombrada. Si no ha ocurrido ninguna excepción, la serie de declaraciones
representadas por elMENSAJE 'Procesar un nuevo valor calórico'se ejecuta la declaración.
Sin embargo, si ha ocurrido una excepción, esa serie de declaraciones se omite y el
EXCEPCIÓNse ejecuta la declaración.

Si la excepción fuera unaValor fuera de rangoexcepción, luego una serie de

declaraciones representadas por elMENSAJE 'Manejo del error de rango de
calorías'se ejecuta la declaración. ElRENUNCIALa declaración se ejecuta si la
excepción no es unaValor fuera de rangoexcepción.

RENUNCIAsimplemente pasa el control de la ejecución al procedimiento padre que llama. Ese

procedimiento puede tener código adicional de manejo de errores para tratar excepciones
distintas al error de valor esperado fuera de rango.
422 Parte VI: Temas avanzados
 Capítulo 22

Desencadenantes

En este capítulo
▶ Creando desencadenantes

▶ Consideraciones al disparar un gatillo

▶ Ejecutando un disparador
▶ Disparar múltiples disparadores

I En el curso de la ejecución de una aplicación de base de datos, pueden surgir ocasiones

en las que, si se produce alguna acción específica, se desea que esa acción provoque otra
acción, o quizás una sucesión de acciones. En cierto sentido, esa primera acción
desencadenantesla ejecución de las siguientes acciones. SQL proporciona la DESENCADENAR
mecanismo para proporcionar esta capacidad.

Los gatillos, por supuesto, son más conocidos como aquellas partes de un arma de fuego que hacen
que se dispare. De manera más general, un desencadenante es una acción o evento que provoca que
ocurra otro evento. En SQL, la palabradesencadenarse utiliza en este sentido más general. Una
sentencia SQL desencadenante provoca otra sentencia SQL (lamotivadodeclaración) a ejecutar.

Examinando algunas aplicaciones de los desencadenantes

El disparo de un gatillo es útil en varias situaciones. Un ejemplo es realizar una función de
registro. Ciertas acciones que son críticas para la integridad de una base de datos (como
insertar, editar o eliminar una fila de una tabla) podrían desencadenar la creación de una
entrada en un registro que documente esa acción. Las entradas del registro pueden registrar
no sólo qué acción se tomó, sino también cuándo se tomó y quién la realizó.

Los desencadenadores también se pueden utilizar para mantener la coherencia de una base de
datos. En una aplicación de ingreso de pedidos, un pedido de un producto específico puede
generar una declaración que cambia el estado de ese producto en la tabla de inventario de
disponible a reservado. De manera similar, la eliminación de una fila en la tabla de pedidos puede
desencadenar una declaración que cambie el estado del producto en cuestión de reservado a
disponible.
424 Parte VI: Temas avanzados

Los disparadores ofrecen una flexibilidad aún mayor que la que se ilustra en los ejemplos
anteriores. El elemento activado no tiene por qué ser una declaración SQL. Puede ser un
procedimiento en el lenguaje anfitrión que realiza alguna operación en el mundo exterior,
como cerrar una línea de producción o hacer que un robot vaya a buscar una cerveza fría del
refrigerador.

Creando un disparador
Creas un disparador, lógicamente, con unCREAR DISPARADORdeclaración. Una vez creado el
desencadenante, permanece al acecho, esperando a que se produzca el evento
desencadenante. Cuando ocurra el evento desencadenante, ¡bang! El gatillo se dispara.

La sintaxis para elCREAR DISPARADORLa declaración es bastante complicada, pero

puedes dividirla en partes comprensibles. Primero eche un vistazo al panorama general:

CREAR DISPARADOR nombre_disparador

trigger_action_timetrigger_event
EN nombre_tabla
[REFERENCIA lista_alias_valores_antiguos_o_nuevos]
acción_activada

El nombre del activador es el identificador único de este activador. El tiempo de la acción

desencadenante es el momento en que desea que se produzca la acción desencadenante: ya sea
ANTESo DESPUÉSel evento desencadenante. El hecho de que pueda ocurrir una acción
[Link] El evento que supuestamente está causando que esto suceda puede parecer
un poco extraño, pero en algunos casos, esta habilidad puede ser muy útil (y puede lograrse sin
invocar el viaje en el tiempo). Debido a que el motor de base de datos sabe que está a punto de
ejecutar un evento desencadenante antes de ejecutarlo realmente, tiene la capacidad de intercalar
el evento desencadenante antes de la ejecución del evento desencadenante, si un tiempo de acción
desencadenante deANTESha sido especificado.

Tres posibles eventos desencadenantes pueden provocar que se active un desencadenador: la

ejecución de unINSERTARdeclaración, unBORRARdeclaración, o unaACTUALIZARdeclaración. Estas tres
declaraciones tienen el poder de cambiar el contenido de una tabla de base de datos. Por lo tanto,
cualquier inserción de una o más filas en la tabla de asunto, cualquier eliminación de una o más filas
de la tabla de asunto, o cualquier actualización de una o más columnas en una o más filas de la tabla
de asunto puede provocar que se active un [Link] nombre_tabla,por supuesto, se refiere a la
tabla para la cualINSERTAR, ELIMINAR,o ACTUALIZARha sido especificado.
 Capítulo 22: Desencadenantes 425

Activadores de declaraciones y filas

Elacción_activadaen el ejemplo anterior tiene la siguiente sintaxis:

[PARA CADA { FILA | DECLARACIÓN }]

CUANDO <pariente izquierdo><condición de búsqueda><pariente derecho>
<sentencia SQL activada>

Puede especificar cómo actuará el disparador:

✓ Activador de fila:El gatillo se disparará una vez al encontrar elINSERTAR,

ELIMINAR,oACTUALIZARdeclaración que constituye el hecho desencadenante.

✓ Activador de declaración:El disparador se activará varias veces, una por cada fila
de la tabla de asuntos que se vea afectada por el evento desencadenante.

Como lo indican los corchetes, elPARA CADALa cláusula es opcional. A pesar de ello, el
desencadenante debe actuar de una forma u otra. Si noPARA CADA Si se especifica la
cláusula, el comportamiento predeterminado esPARA CADA DECLARACIÓN.

Cuando se dispara un gatillo

La condición de búsqueda en elCUANDOLa cláusula le permite especificar las circunstancias bajo las
cuales se activará un disparador. Especifique un predicado y, si el predicado es verdadero, se
activará el disparador; si es falso, no lo será. Esta capacidad aumenta en gran medida la utilidad de
los desencadenantes. Puede especificar que un disparador se active solo después de que se haya
excedido un determinado valor de umbral o cuando se pueda determinar que cualquier otra
condición es Verdadera o Falsa.

La declaración SQL desencadenada

La declaración SQL activada puede ser una única declaración SQL o una secuencia de
declaraciones SQL ejecutadas una tras otra. En el caso de una única sentencia SQL, la
sentencia SQL activada es simplemente una sentencia SQL normal. Sin embargo, para
una secuencia de declaraciones SQL, debe garantizar la atomicidad para garantizar que
la operación no se cancele a mitad de camino, dejando la base de datos en un estado no
deseado. Puedes hacer esto con unCOMIENZO-FINbloque que incluye elATÓMICO
palabra clave:

COMENZAR ATÓMICO
{ sentencia SQL 1 }
{ sentencia SQL 2 } . . .

{ sentencia SQLnorte}
FIN
426 Parte VI: Temas avanzados

Un ejemplo de definición de activador

Supongamos que el director de recursos humanos de la empresa quiere ser informado cada vez que
uno de los directores regionales contrata a un nuevo empleado. El siguiente disparador puede
manejar esta situación muy bien:

CREAR DISPARADOR nueva contratación

ANTES DE INSERTAR EN EL EMPLEADO
PARA CADA DECLARACIÓN
COMENZAR ATÓMICO
LLAMAR a sendmail ('HRDirector')
INSERTAR EN la tabla de registro
VALORES ('NEWHIRE', CURRENT_USER, CURRENT_TIMESTAMP);
FIN;

Cada vez que se inserta una nueva fila en la tabla NEWHIRE, se envía un correo electrónico al gerente
de recursos humanos con los detalles, y el nombre de inicio de sesión de la persona que realiza la
inserción y la hora de la inserción se registran en una tabla de registro, lo que proporciona una pista
de auditoría.

Activar una sucesión de desencadenantes

Probablemente pueda ver una complicación en la forma en que funcionan los desencadenantes.
Supongamos que crea un disparador que hace que una instrucción SQL se ejecute en una tabla tras la
ejecución de alguna instrucción SQL anterior. ¿Qué pasa si esa declaración desencadenada en sí
misma provoca que se active un segundo desencadenante? Ese segundo disparador hace que se
ejecute una tercera instrucción SQL en una segunda tabla, lo que a su vez puede provocar que se
active otro disparador, afectando a otra tabla más. ¿Cómo es posible mantener todo en orden? SQL
maneja este disparo de gatillo estilo ametralladora con algo llamadodesencadenar contextos de
ejecución.

una sucesión deINSERTAR, ELIMINAR,yACTUALIZARLas operaciones se pueden realizar

anidando los contextos en los que ocurren. Cuando se activa un disparador, se crea un
contexto de ejecución. Sólo puede haber un contexto de ejecución activo a la vez. Dentro
de ese contexto, se puede ejecutar una declaración SQL que active un segundo
disparador. En ese punto, el contexto de ejecución existente se suspende en una
operación análoga a insertar un valor en una pila. Se crea un nuevo contexto de
ejecución, correspondiente al segundo disparador, y se realiza su operación. No existe un
límite arbitrario para la profundidad posible de anidación. Cuando se completa una
operación, su contexto de ejecución se destruye y el siguiente contexto de ejecución
superior se "saca de la pila" y se reactiva. Este proceso continúa hasta que se completan
todas las acciones y se destruyen todos los contextos de ejecución.
 Capítulo 22: Desencadenantes 427

Hacer referencia a valores antiguos y valores nuevos

La una parte delCREAR DISPARADORLa sintaxis de la que aún no he hablado es la opcional.
REFERENCIA lista_alias_valor_antiguo_o_nuevofrase. Le permite crear un alias o nombre de
correlación que haga referencia a valores en la tabla de asuntos del activador. Después de
crear un nombre de correlación para nuevos valores o un alias para nuevos contenidos de
tabla, puede hacer referencia a los valores que existirán después de unaINSERTARo
ACTUALIZARoperación. De manera similar, después de crear un nombre de correlación para
valores antiguos o un alias para contenidos de tablas antiguas, puede hacer referencia a los
valores que existían en la tabla temática antes de unaACTUALIZAR oBORRARoperación.

Ellista_alias_valores_antiguos_o_nuevosen elCREAR DISPARADORLa sintaxis

puede ser una o más de las siguientes frases:

ANTIGUO [ FILA ] [ COMO ] <nombre de correlación de valores antiguos>

NUEVO [ FILA ] [ COMO ] <nombre de correlación de nuevos valores>

TABLA ANTIGUA [AS] <alias de la tabla de valores antiguos>

NUEVA TABLA [ AS ] <alias de la nueva tabla de valores>

Los alias de tabla son identificadores de tablas de transición, que no son persistentes, pero que
existen sólo para facilitar la operación de referencia. Como era de esperar,NUEVA FILAyNUEVA
MESAno se puede especificar para unBORRARdesencadenante, yVIEJA FILAasí comoMESA
ANTIGUAno se puede especificar para unINSERTARdesencadenar. Después de eliminar una fila
o tabla, no hay ningún valor nuevo. Similarmente,VIEJA FILA yMESA ANTIGUAno se puede
especificar para unINSERTARdesencadenar. No hay valores antiguos a los que hacer referencia.

En un desencadenador a nivel de fila, puede utilizar un nombre de correlación de valor antiguo para
hacer referencia a los valores de la fila que la instrucción SQL desencadenante modifica o elimina, ya
que esa fila existía antes de que la instrucción la modificara o eliminara. De manera similar, un alias
de tabla de valores antiguo es lo que se utiliza para acceder a los valores de toda la tabla tal como
existían antes de que la acción de la instrucción SQL desencadenante entrara en vigor.
428 Parte VI: Temas avanzados

No puedes especificar tampocoMESA ANTIGUAoNUEVA MESAcon unANTESdesencadenar.

Las tablas de transición creadas por elMESA ANTIGUAoNUEVA MESAEs muy probable que
la palabra clave se vea afectada por las acciones causadas por la declaración SQL
activada. Para eliminar este problema potencial, utiliceMESA ANTIGUAyNUEVA MESA con
unANTESEl gatillo está prohibido.

Activar múltiples disparadores

en una sola mesa
Un último tema que quiero cubrir en este capítulo es el caso en el que se crean múltiples
desencadenadores, todos provocando la ejecución de una instrucción SQL que opera en la
misma tabla. Todos esos disparadores están preparados y listos para disparar. Cuando ocurre
el evento desencadenante, ¿cuál ocurre primero? Este enigma se resuelve mediante una
decisión ejecutiva. Cualquier disparador que se haya creado primero es el primero en
dispararse. El desencadenante creó segundos incendios a continuación, y así sucesivamente.
De este modo se evita la posible ambigüedad y la ejecución se desarrolla de forma ordenada.
 Parte VII

La parte de decenas

[Link] obtener excelente contenido para principiantes en línea.

 En esta parte…
✓ Faltas frecuentes
✓ Recuperación rápida

✓ [Link] obtener excelente contenido para principiantes en

línea.
 Capítulo 23

Diez errores comunes

En este capítulo
▶ Asumir que sus clientes saben lo que necesitan
▶ No preocuparse por el alcance del proyecto
▶ Considerando sólo factores técnicos
▶ Nunca pedir comentarios de los usuarios
▶ Usando solo su entorno de desarrollo o arquitectura de sistema favorito
▶ Diseñar tablas de bases de datos de forma aislada
▶ Saltarse revisiones de diseño, pruebas beta y documentación

I Si está leyendo este libro, debe estar interesado en construir sistemas de bases de datos
relacionales. Acéptalo: nadie estudia SQL por diversión. Utiliza SQL para crear aplicaciones
de bases de datos, pero antes de poder crear una, necesita una base de datos.
Desafortunadamente, muchos proyectos fracasan antes de codificar la primera línea de la
aplicación. Si no obtiene la definición correcta de la base de datos, su aplicación está
condenada al fracaso, sin importar qué tan bien la escriba. Aquí hay diez errores comunes en la
creación de bases de datos a los que debe estar atento.

Suponiendo que sus clientes

saben lo que necesitan
Generalmente, los clientes lo llaman para diseñar un sistema de base de datos cuando
tienen problemas para obtener la información que necesitan porque sus métodos actuales
no funcionan. Los clientes suelen creer que han identificado el problema y su solución. Se
dan cuenta de que todo lo que necesitan hacer es decirtúqué hacer.

Dar a los clientes exactamente lo que piden suele ser una receta segura para el desastre. La
mayoría de los usuarios (y sus gerentes) no poseen el conocimiento o las habilidades
necesarias para identificar con precisión el problema, por lo que tienen pocas posibilidades de
determinar la mejor solución.
432 Parte VII: La parte de decenas

Su trabajo es convencer con tacto a su cliente de que es un experto en análisis y diseño

de sistemas y que debe realizar un análisis adecuado para descubrir la causa real del
problema. Normalmente, la verdadera causa del problema se esconde detrás de los
síntomas más evidentes.

Ignorar el alcance del proyecto

Su cliente le dice lo que espera de la nueva aplicación al comienzo del proyecto de
desarrollo. Desafortunadamente, el cliente casi siempre se olvida de decirle algo,
generalmente varias cosas. A lo largo del trabajo, estos nuevos requisitos surgen y
se incorporan al proyecto. Si le pagan por proyecto en lugar de por horas, este
crecimiento en el alcance puede convertir lo que alguna vez fue un proyecto
rentable en un perdedor. Asegúrate de que todo lo que estás obligado a entregar
esté especificado por escrito antes de comenzar el proyecto.

Considerando sólo factores técnicos

Los desarrolladores de aplicaciones a menudo consideran proyectos potenciales en
términos de su viabilidad técnica y basan sus estimaciones de tiempo y esfuerzo en esa
determinación. Sin embargo, las cuestiones de costos máximos, disponibilidad de
recursos, requisitos de cronograma y políticas de la organización pueden tener un efecto
importante en el proyecto. Estos problemas pueden convertir un proyecto técnicamente
viable en una pesadilla. Asegúrese de comprender todos los factores no técnicos
relevantes antes de comenzar cualquier proyecto de desarrollo. Puede decidir que no
tiene sentido continuar; es mejor llegar a esa conclusión al comienzo del proyecto que
después de haber realizado un esfuerzo considerable.

No pedir comentarios al cliente

Su primera inclinación podría ser escuchar a los gerentes que lo contratan. Después de
todo, los propios usuarios no tienen ninguna influencia y seguro que no pagan su tarifa.
Por otro lado, también puede haber buenas razones para ignorar a los directivos. Por lo
general, no tienen ni idea de lo que realmente necesitan los usuarios. ¡Espera un
minuto! No ignore a todos ni asuma que sabe más que un administrador o usuario
sobre lo que debe hacer una base de datos y cómo debe funcionar. Los ingresadores de
datos no suelen tener mucha influencia organizacional, y muchos gerentes tienen sólo
una comprensión vaga de algunos aspectos del trabajo que realizan. Pero aislarse de
cualquiera de los grupos es casi seguro que dará como resultado un sistema que
resuelve un problema que nadie tiene. Puede aprender mucho de los administradores y
de los usuarios haciendo las preguntas adecuadas.
 Capítulo 23: Diez errores comunes 433

Utilizando siempre su entorno

de desarrollo favorito
Probablemente haya pasado meses o incluso años adquiriendo competencia en el uso
de un DBMS o entorno de desarrollo de aplicaciones en particular. Pero su entorno
favorito, sin importar cuál sea, tiene fortalezas y debilidades. De vez en cuando, se
encuentra con una tarea de desarrollo que exige mucho en un área donde su entorno de
desarrollo preferido es débil. Entonces, en lugar de llegar a un acuerdo que no sea
realmente la mejor solución, haga el esfuerzo de hacerlo. Tiene dos opciones: ascender
en la curva de aprendizaje de una herramienta más adecuada y luego usarla, o decirles
con franqueza a sus clientes que su trabajo se haría mejor con una herramienta en la
que usted no es un experto. Luego sugiera que el cliente contrate a alguien que pueda
ser productivo con esa herramienta de inmediato. Una conducta profesional de este tipo
se gana el respeto de sus clientes. (Desafortunadamente, si trabaja para una empresa en
lugar de hacerlo usted mismo, esa conducta también puede provocar que lo despidan o
lo despidan. Es mejor optar por la opción uno: sumergirse en un nuevo entorno de
desarrollo).

Uso exclusivo de su arquitectura

de sistema favorita
Nadie puede ser un experto en todo. Los sistemas de gestión de bases de datos que funcionan
en un entorno de teleprocesamiento son diferentes a los sistemas que funcionan en entornos
de cliente/servidor, de recursos compartidos, basados en web o de bases de datos
distribuidas. Es posible que uno o dos sistemas en los que sea experto no sean los mejores
para el trabajo en cuestión. Elija la mejor arquitectura de todos modos, incluso si eso significa
dejar el trabajo. No conseguir el trabajo es mejor que conseguirlo y producir un sistema que no
satisface las necesidades del cliente.

Diseño de tablas de bases de datos de forma aislada

Si identifica incorrectamente los objetos de datos y sus relaciones entre sí, es probable
que las tablas de su base de datos introduzcan errores en los datos y destruyan la validez
de los resultados. Para diseñar una base de datos sólida, se debe considerar la
organización general de los objetos de datos y determinar cuidadosamente cómo se
relacionan entre sí. Por lo general, ningúnbienel diseño existe. Debe determinar qué es
apropiado, considerando las necesidades presentes y proyectadas de su cliente.
434 Parte VII: La parte de decenas

Descuidar las revisiones de diseño

Nadie es perfecto. Incluso el mejor diseñador y desarrollador puede pasar por alto
puntos importantes que son evidentes para alguien que mira la situación desde una
perspectiva diferente. Presentar su trabajo antes de una revisión formal del diseño
puede hacerlo más disciplinado en su trabajo, lo que probablemente le ayudará a evitar
numerosos problemas que de otro modo habría experimentado. Haga que un
profesional competente revise su diseño propuesto antes de comenzar el desarrollo.
Debería pedirle a un diseñador de base de datos que lo revise, pero es posible que
también desee mostrárselo al cliente.

Saltarse las pruebas beta

Cualquier aplicación de base de datos lo suficientemente compleja como para ser
verdaderamente útil también lo es como para contener errores. Incluso si la prueba de todas
las formas que se le ocurran, la aplicación seguramente contendrá modos de falla que no
descubrirá. La prueba beta significa entregar la aplicación a personas que no saben cómo fue
diseñada. Es probable que tengan problemas que usted nunca encontró porque sabe
demasiado sobre la aplicación. Si están familiarizados con los datos, pero no con la base de
datos, también es más probable que utilicen la aplicación como lo harían a diario, de modo
que puedan identificar consultas que tardan mucho en generar resultados. Luego puede
corregir los errores o las deficiencias de rendimiento que otros encuentren antes de que el
producto entre en uso oficialmente.

No documentar su proceso
Si cree que su aplicación es tan perfecta que nunca es necesario revisarla, ni siquiera
una vez más, piénselo de nuevo. De lo único que puedes estar absolutamente seguro en
este mundo es del cambio. Cuenta con eso. Dentro de seis meses, no recordará por qué
diseñó las cosas de la forma en que lo hizo, a menos que documente cuidadosamente lo
que hizo y por qué lo hizo de esa manera. Si se transfiere a un departamento diferente o
gana la lotería y se jubila, su reemplazo casi no tiene posibilidades de modificar su
trabajo para cumplir con nuevos requisitos si no documentó su diseño. Sin
documentación, es posible que su reemplazo deba desechar todo y comenzar desde
cero.

No se limite a documentar su trabajo adecuadamente: documente demasiado su

trabajo. Incluya más detalles de los que crea razonables. Si regresa a este proyecto
después de seis u ocho meses de ausencia, se alegrará de haberlo documentado en
detalle.
 Capítulo 24

Diez consejos de recuperación

En este capítulo
▶ Verificando la estructura de su base de datos
▶ Usando bases de datos de prueba

▶ Examinar cualquier consulta que contenga combinaciones

▶ Examinar consultas que contienen subselecciones

▶ Uso de GROUP BY con las funciones SET
▶ Estar al tanto de las restricciones de la cláusula GROUP BY
▶ Usar paréntesis en expresiones
▶ Protegiendo su base de datos controlando privilegios
▶ Hacer una copia de seguridad de su base de datos periódicamente

▶ Anticipar y manejar errores

A La base de datos puede ser un tesoro virtual de información, pero al igual que el
tesoro de los piratas del Caribe de antaño, lo que realmente desea
probablemente esté enterrado y oculto a la vista. ElSELECCIONAR SQLLa declaración es
su herramienta para desenterrar esta información oculta. Incluso si tiene una idea clara
de lo que desea recuperar, traducir esa idea a SQL puede ser un desafío. Si su
formulación está un poco equivocada, puede terminar con resultados equivocados, pero
resultados que se acercan tanto a lo que esperaba que lo engañan. Para reducir sus
posibilidades de ser engañado, utilice los siguientes diez principios.

Verificar la estructura de la base de datos

Si recupera datos de una base de datos y sus resultados no parecen razonables, verifique el
diseño de la base de datos. Se utilizan muchas bases de datos mal diseñadas y, si está
trabajando con una, corrija el diseño antes de probar cualquier otra solución. Recuerde: un
buen diseño es un requisito previo para la integridad de los datos.
436 Parte VII: La parte de decenas

Pruebe consultas en una base de datos de prueba

Cree una base de datos de prueba que tenga la misma estructura que su base de datos de
producción, pero con solo unas pocas filas representativas en las tablas. Elige los datos para
que sepas de antemano cuáles deben ser los resultados de tus consultas. Ejecute cada
consulta de prueba sobre los datos de la prueba y vea si los resultados coinciden con sus
expectativas. Si no es así, es posible que deba reformular sus consultas. Si una consulta se
formula correctamente pero de todos modos obtiene malos resultados, es posible que deba
reestructurar su base de datos.

Cree varios conjuntos de datos de prueba y asegúrese de incluir casos impares, como tablas
vacías y valores extremos en el límite de los rangos permitidos. Trate de pensar en escenarios
poco probables y verifique el comportamiento adecuado cuando ocurran. Al comprobar casos
poco probables, podrá obtener información sobre los problemas que tienen más
probabilidades de ocurrir.

Verifique las consultas que incluyen uniones

Las uniones son notoriamente contraintuitivas. Si su consulta contiene uno, asegúrese de que
esté haciendo lo que espera antes de agregarDÓNDEcláusulas u otros factores que complican
la situación.

Consultas de triple verificación con subselecciones

Las consultas con subselecciones toman datos de una tabla y, según lo que se recupera,
toman algunos datos de otra tabla. Por lo tanto, por definición, estas consultas pueden ser
realmente difíciles de responder correctamente. Asegúrese de que los datos que el interior
SELECCIONARrecupera son los datos que el exteriorSELECCIONARnecesita producir el
resultado deseado. Si tiene dos o más niveles de subselección, debe tener aún más cuidado.

Resumir datos con GROUP BY

Digamos que tienes una tabla (NACIONAL) que contiene el nombre (Jugador), equipo (
Equipo),y número de jonrones conectados (Homeros)por cada jugador de béisbol de la Liga
Nacional. Puedes recuperar el total de jonrones del equipo para todos los equipos con una
consulta como esta:

SELECCIONAR Equipo, SUM (Jonrones)

DE NACIONAL
GRUPO POR Equipo;
 Capítulo 24: Diez consejos de recuperación 437

Esta consulta enumera cada equipo, seguido del número total de jonrones de todos los
jugadores de ese equipo.

Ver restricciones de cláusula GROUP BY

Supongamos que desea una lista de bateadores poderosos de la Liga Nacional. Considere la
siguiente consulta:

SELECCIONAR Jugador, Equipo, Jonrones

DE NACIONAL
DONDE Homeros >= 20
GRUPO POR Equipo;

En la mayoría de las implementaciones, esta consulta devuelve un error. Generalmente, solo las columnas
utilizadas para agrupar o las columnas utilizadas en una función establecida pueden aparecer en la lista de
selección. Sin embargo, si desea ver estos datos, la siguiente formulación funciona:

SELECCIONAR Jugador, Equipo, Jonrones

DE NACIONAL
DONDE Homeros >= 20
GRUPO POR Equipo, Jugador, Jonrones;

Debido a que todas las columnas que desea mostrar aparecen en elAGRUPAR PORcláusula, la
consulta tiene éxito y entrega los resultados deseados. Esta formulación ordena la lista
resultante primero porEquipo,entonces porJugador,y finalmente porHomeros.

Utilice paréntesis con AND, OR y NOT

A veces cuando mezclasYyO,SQL no procesa la expresión en el orden esperado. Utilice
paréntesis en expresiones complejas para asegurarse de obtener los resultados
deseados. Escribir algunas pulsaciones de teclas adicionales es un pequeño precio a
pagar para obtener mejores resultados.

Los paréntesis también ayudan a garantizar que elNOLa palabra clave se aplica al
término o expresión al que desea aplicarla.

Controlar los privilegios de recuperación

Mucha gente no utiliza las funciones de seguridad disponibles en su DBMS. No quieren
molestarse con ellos porque piensan que el mal uso y la apropiación indebida de datos
son cosas que sólo les suceden a otras personas. No esperes a quemarte. Establecer y
mantener la seguridad de todas las bases de datos que tengan algún valor.
438 Parte VII: La parte de decenas

Haga una copia de seguridad de sus bases de datos con regularidad

Alerta de subestimación: los datos son difíciles de recuperar después de que una subida de tensión, un
incendio, un terremoto o algún otro desastre destruya su disco duro. (Recuerde, a veces las computadoras
simplemente fallan sin una buena razón). Haga copias de seguridad frecuentes y guarde los medios de
copia de seguridad en un lugar seguro.

Lo que constituye un lugar seguro depende de cuán críticos sean sus datos. Podría ser una
caja fuerte a prueba de fuego en la misma habitación que su computadora. Puede que esté
en otro edificio. Puede que esté en la nube. Podría estar en un búnker de hormigón bajo una
montaña endurecida para resistir un ataque nuclear. Decida qué nivel de seguridad es
apropiado para sus datos.

Maneje las condiciones de error con gracia

Ya sea que esté realizando consultas ad hoc desde una estación de trabajo o incrustando
consultas en una aplicación, ocasionalmente SQL devuelve un mensaje de error en lugar de los
resultados deseados. En una estación de trabajo, puede decidir qué hacer a continuación,
según el mensaje devuelto. En una aplicación, la situación es diferente. El usuario de la
aplicación probablemente no sepa qué acción es apropiada. Implemente un amplio manejo de
errores en sus aplicaciones para cubrir todos los errores imaginables que puedan ocurrir.
Crear código de manejo de errores requiere un gran esfuerzo, pero es mejor que tener al
usuario mirando con curiosidad una pantalla congelada.
 Apéndice

SQL: 2011 palabras reservadas

abdominales EMPEZANDO CONTROLAR CRUZ

TODO BINARIO CLOB CUBO

ASIGNAR GOTA CERCA CUME_DIST

ALTERAR BOOLEANO JUNTARSE ACTUAL

Y AMBOS COTEJAR ACTUAL_

CATALOGAR
CUALQUIER POR RECOLECTAR
FECHA ACTUAL
SON LLAMAR COLUMNA
ACTUAL_
FORMACIÓN LLAMADO COMPROMETERSE POR DEFECTO_
TRANSFORMAR_
ARRAY_AGG CARDINALIDAD CONDICIÓN GRUPO

COMO EN CASCADA CONECTAR TRAYECTORIA DE CORRIENTE

ASENSITIVO CASO RESTRICCIÓN ROL ACTUAL

ASIMÉTRICO ELENCO CONVERTIR ESQUEMA_ACTUAL

EN FORTIFICAR TECHO CORR TIEMPO ACTUAL

ATÓMICO TECHO CORRESPONDIENTE ACTUAL_

MARCA DE TIEMPO
AUTORIZACIÓN CARBONIZARSE CONTAR
ACTUAL_
AVG CHAR_LENGTH COVAR_POP TRANSFORMAR_
GROUP_FOR_TYPE
COMENZAR PERSONAJE COVAR_SAMP
USUARIO ACTUAL
ENTRE PERSONAJE_ CREAR
LONGITUD CURSOR
440 SQL para principiantes, octava edición

CICLO ESCAPAR GLOBAL RETRASO

FECHA CADA CONCEDER IDIOMA

DÍA EXCEPTO GRUPO GRANDE

DÍAS EJECUTIVO AGRUPAMIENTO LAST_VALUE

DESASIGNAR EJECUTAR TENIENDO LATERAL

DIC EXISTE SOSTENER DIRIGIR

DECIMAL Exp HORA PRINCIPAL

DECLARAR EXTERNO HORAS IZQUIERDA

POR DEFECTO EXTRACTO IDENTIDAD COMO

BORRAR FALSO EN ME GUSTA_REGEX

DENSE_RANK BUSCAR INDICADOR LN

DEREF FILTRAR INTERNO LOCAL

DESCRIBIR FIRST_VALUE EN FUERA HORA LOCAL

DETERMINISTA FLOTAR INSENSIBLE MARCA DE TIEMPO LOCAL

DESCONECTAR PISO INSERTAR MÁS BAJO

DISTINTO PARA EN T FÓSFORO

DOBLE PARA SIEMPRE ENTERO MÁXIMO

GOTA EXTRANJERO INTERSECARSE MAX_

CARDINALIDAD
DINÁMICA GRATIS INTERSECCIÓN
MIEMBRO
CADA DE INTERVALO
UNIR
ELEMENTO LLENO EN
MÉTODO
DEMÁS FUNCIÓN ES
MÍNIMO

FIN FUSIÓN UNIRSE

MINUTO
EJECUCIÓN FINAL CONSEGUIR MANTENER
 Apéndice: SQL: 2008 palabras reservadas 441
MINUTOS DE PRIMARIO BIEN

MODIFICACIÓN COMPENSAR PROCEDIMIENTO RETROCEDER

MODIFICA VIEJO RANGO ENROLLAR

MÓDULO EN RANGO FILA

MES SOLO LECTURAS NUMERO DE FILA

MULTICONJUNTO ABIERTO REAL FILAS

NACIONAL O RECURSIVO PUNTO DE GUARDADO

NATURAL ORDEN ÁRBITRO ALCANCE

NCHAR AFUERA REFERENCIAS DESPLAZARSE

NCLOB EXTERIOR REFERENCIA BUSCAR

NUEVO ENCIMA REGR_AVGX SEGUNDO

NULO SUPERPOSICIONES REGR_AVGY SEGUNDOS

NO CUBRIR REGR_COUNT SELECCIONAR

NINGUNO PARÁMETRO REGR_INTERCEPT SENSIBLE

NORMALIZAR DIVIDIR REGR_R2 USUARIO_SESIÓN

NO PERCENT_RANK REGR_SLOPE COLOCAR

NTH_VALUE PERCENTIL_ REGR_SXX SIMILAR

CONTINUAR

NTILE REGR_SXY PEQUEÑO

PERCENTIL_
NULO DESCT REGR_SYY ALGUNO

NULLIF POSICIÓN LIBERAR ESPECÍFICO

NUMÉRICO RESULTADO POSITION_REGEX TIPO ESPECÍFICO

OCURRENCIAS_ FUERZA DEVOLVER SQL

REGEXACIONES

PRECISIÓN DEVOLUCIONES EXCEPCIÓN SQL

OCTET_LENGTH
PREPARAR REVOCAR ESTADOSQL
442 SQL para principiantes, octava edición

ADVERTENCIA SQL ENTONCES VERDADERO VARIAR

CUADRADO TIEMPO UESCAPE VERSIÓN

COMENZAR MARCA DE TIEMPO UNIÓN VERSIONAMIENTO

ESTÁTICO ZONA_HORARIA_HORA ÚNICO VERSIONES

STDDEV_POP ZONA HORARIA_ DESCONOCIDO CUANDO

MINUTO
STDDEV_SAMP UNNEST CUANDO SEA
A
SUBMULTISET ACTUALIZAR DÓNDE
SEGUIMIENTO
SUBCADE SUPERIOR WIDTH_BUCKET
TRADUCIR
SUBSTRING_ USUARIO VENTANA
REGEXACIONES TRADUCIR_
REGEXACIONES USANDO CON
SUMA
TRADUCCIÓN VALOR DENTRO
SIMÉTRICO
TRATAR VALORES SIN
SISTEMA
DESENCADENAR VAR_POP AÑO
USUARIO_SISTEMA
TRUNCAR VAR_SAMP AÑOS
MESA
RECORTAR VARBINARIO
MUESTRA DE TABLA
TRIM_ARRAY VARCHAR
 Índice

• Símbolos y limitadoBUSCARcapacidad, 236–238

conectivos lógicos, 230–232 cláusulas

Numéricos • modificadoras, 211–213 ORDENAR POR

cláusula, 235–236 descripción general, 211
% (signo de porcentaje) comodín, 218–220
* (asterisco), 140, 245, 334 ventanas, 238–242
_ (guión bajo) comodín, 218–220 || Bases de datos ACID, 326
(operador de concatenación), 65–66, 178 = Controles ActiveX, Microsoft, 355 consultas ad
(operador igual), 274 hoc, desde el teclado, 22 funciones agregadas,
1NF (primera forma normal), 132 2NF 181–184, [Link] también
(segunda forma normal), 132–134 3NF establecer funciones
(tercera forma normal), 53 alias, 252, 427
4GL (lenguajes de cuarta generación), 81 TODOpredicado, 221–224
TODOcuantificador, consultas anidadas, 275–276

•A• ALTERARdeclaración, 62, 63

ALTERAR TABLAdeclaración, 53, 102, 123,
forma anormal, 135-136 124, 419
abdominalesfunción, 194 alterar la estructura de la mesa, 90–92, 102 Y
abdominalesfunciones de valor de conectivos lógicos, 69, 230–231, 437 CUALQUIER
intervalo, 196 ABSOLUTOorientación, 391 predicado, 221–224
Access, Microsoft CUALQUIERcuantificador, consultas anidadas, 275–276 API
alterar la estructura de la tabla, 90–92 consultas de (interfaz de programación de aplicaciones), 352
definición de datos, 98–100 vista de hoja de datos, crear subprogramas, Java, 356–357
tablas de bases de datos aplicación, interfaz ODBC, 351 entornos de
en, 83–84 desarrollo de aplicaciones, 433 interfaz de
eliminar tablas, 94–95 programación de aplicaciones
Vista de diseño, creación de tablas de bases de datos, (API), 352
84–86 aplicaciones, 318, 423–424
Vista de diseño, configuración de propiedades de campo en, aplicaciones, SQL en
86–90 * comodín, 334
índices, creación, 92–94 SQL incorporado, 336–339
seguridad, 100–101 Microsoft Access, 343–345
SQL en, privilegios de acceso 95–97, 342, 343– lenguaje del módulo, 339–342
[Link] de acceso a los [Link] descripción general, 333–334
tambiénDÓNDEclausulas lenguajes procedimentales y SQL, 335–336
DEcláusula, 213 herramientas RAD, 342–343
AGRUPAR PORcláusula, 232–234 fortalezas y debilidades de SQL,
TENIENDOcláusula, 234 334–335
444 SQL para principiantes, octava edición

tablas de períodos de tiempo de aplicación ENTREpredicado, 215–217

descripción general, 159–162 EMPEZANDOtipo de datos, 27
claves primarias, designación en, 162–163 BINARIOtipo de datos, 33
consulta, 164–165 OBJETO BINARIO GRANDE (BLOB)datos
restricciones referenciales, aplicables a, tipo, 33
163–164 BINARIOcuerdas, 32–33
tipos de datos numéricos aproximados, 29– VARIACIÓN BINARIAtipo de datos, 33 tablas
30 arquitectura, sistema, 433 bitemporales, 169–170 BLOB (OBJETO
FORMACIÓNtipo de datos, 39–40, 378 BINARIO GRANDE)datos
ARRAY_MAX_CARDINALIDADfunción, 40, tipo, 33
193–194 GOTAlocalizadores, 33
matrices, 193 BOOLEANOtipo de datos, 33 expresiones de
ASENSITIVOpalabra clave, 388 valor booleano, 67 depósitos, partición de
aserciones, 126, 128–129 ventanas en, 239 errores, corrección, 434
asignación, en SQL/PSM, 400
asterisco (*), 140, 245, 334 EN construir la estructura de la base de [Link] tambiénrápido
LOCALpalabras clave, 66 ATÓMICO herramientas de desarrollo de aplicaciones
palabra clave, 395, 399 que alteran la estructura de la tabla, 102
transacciones atómicas, 326 creación de tablas, 97–101
valores atómicos, 172 eliminar índices, 103
atomicidad, declaraciones compuestas, 394–395 borrar tablas, 102
atributos índices, creación, 101
dominios, 17 descripción general, 81

dependencia funcional, 132–133 modificado, consideraciones de portabilidad, 103 usando

creación de vistas con, 144–145 descripción SQL con Microsoft Access, 95–97 bytes, 192–
general, 7, 13 193
dependencia transitiva, 134
UDT, 41
registros auditables de las entradas de la base de datos.
•C•
Vertablas versionadas por el sistema Lenguaje C, 337–338
AUTORIZACIÓNcláusula, 341 identificador de LLAMARdeclaraciones, 406
autorización, 341 entrada automática de datos, 148 CARDINALIDADfunción, 40, 193
tipo de datos AutoNumber, Microsoft Access, 85 AVG cardinalidad de matrices, 40
función, 70–71, 183, 232 Producto cartesiano, 213, 250, 253
CASCADApalabra clave, 310
eliminaciones en cascada, 121–122,
•B• 284 CASOexpresiones
JUNTARSE,204-205
hacer una copia de seguridad de los datos, 314, 325, 438 discusión general, 197–198
datos de entrada incorrectos, 124 NULLIF,202–204
mesas bajas, 141 con condiciones de búsqueda, 198–200
uniones básicas, 249–250 con valores, 200–202
ANTESdesencadenantes, 428 CASOdeclaración, 198
COMENZARpalabra clave, 394 CASO... CASO FINALdeclaraciones, 401–402
pruebas beta, 434 ELENCOexpresiones, 205–207, 336, 339
 Índice 445
CATÁLOGO_NOMBREcampo, 419 columnas
catálogos, 52, 61–62 agregar datos a, 148 agregar a tablas
FORTIFICAR TECHOfunción, 195 existentes, 123 procesar DBMS de, 12–
TECHOfunción, 195 13 eliminar de tablas existentes, 124
cadena de dependencia, 310 identificar, en relaciones de múltiples
CARBONIZARSEvalor, 172 tablas
PERSONAJEtipo de datos, 31 PERSONAJE bases de datos, 106–107
OBJETO GRANDE (CLOB)datos transferir entre tablas, 149–150 valores
tipo, 31–32, 361 delimitados por comas, 146
conjuntos de caracteres COMMAND_FUNCTIONcampo, diagnóstico
privilegios de acceso, asignación, 74 área de encabezado, 415
intercalación, 386 COMMAND_FUNCTION_CODEcampo,
CONVERTIRfunción de valor, área de encabezado de diagnóstico,
mapeo 189, 362–363 415 comentarios, XML, 369
bases de datos relacionales de tablas múltiples, 111– COMPROMETERSEdeclaración, 72, 318, 324
112 TRADUCIRfunción de valor, 189 cadenas de operadores de comparación
caracteres, 30–32 subconsultas correlacionadas introducidas con,
CARÁCTER VARIABLEtipo de datos, 279–281
31 CHARACTER_LENGTHfunción, 192 uso con subconsultas, 272–274
caracteres, idioma, 32 predicados de comparación, 68, 214, 215
CONTROLARrestricción, 127 vista lógica completa, 17
CLASE_ORIGINcampo, detalle de diagnóstico complejidad de las bases de datos, 7–
área, 417 8 claves compuestas, 113, 133
extensiones de cliente, 354–355 declaraciones compuestas
clientes, 48–49 asignación, 400
sistemas cliente/servidor atomicidad, 394–395
Entradas ODBC, 352 condiciones, 396–400
SQL en, 47–49 cursores, declaración interna, 396
CLOB (PERSONAJE OBJETO GRANDE)datos controladores de excepciones, 420–421
tipo, 31–32, 361 descripción general, 393–394
CLOBlocalizador, 32 variables, 395–396
nube, 8, 354 concatenación, 65–66, 368 operador de
racimos, 52, 62 concatenación (||), 65–66, 178 vista
JUNTARSEexpresiones conceptual, 17
discusión general, 204–205 uniones acceso simultáneo, 315–317
sindicales, usando con, 260, 263–265 manejadores de condiciones, 398–
COLABORAR PORcláusula, 386 cotejo, 386 399 uniones de condiciones, 254
CONDICIÓN_NÚMEROcampo, 417, 420
secuencias de clasificación, 63, 74, 111–112 expresiones de valor condicional, 180
tipos de datos de colección, 39–40, 44 condiciones, en declaraciones compuestas,
expresiones de valor de colección, 67 396–400
restricciones de columna, 126–127 NOMBRE DE LA CONEXIÓNcampo,
referencias de columnas, 176-177 419 conectivos, 207
COLUMNA_NOMBREcampo, 419 consistencia, 326, 423
uniones de nombre de columna, 254–255 constantes, 172
446 SQL para principiantes, octava edición

restricciones obteniendo datos de filas individuales, 390–392

agregar a tablas existentes, 419 abriendo, 388–390
discusión general, 17–18, 46–47 descripción general, 383–384
descripción general, 16
clave primaria, en el período de tiempo de la aplicación
mesas, 162 •D•
especificando, 63 Daño a las bases de datos, evitando, 71–72
dentro de transacciones, 327–331 Lenguaje de control de datos (DCL)
tipos de, 126–129 privilegios de acceso, asignación a usuarios,
información de violación, función 73–75
constructora 418–419, para estructura delegar responsabilidades en materia de seguridad,
UDT, 43 77–78
jerarquía de contención, 52 descripción general, 51, 71, 298
CONTENIDOpredicado, 372 integridad referencial, 75–77
contención, 315 transacciones, 71–72
CONTINUARefecto, 399 corrupción de datos, vulnerabilidad a, 317–318
CONVERTIRfunción de valor, 189 copia de Lenguaje de definición de datos (DDL)
archivos de datos externos, 149 subconsultas catálogos, 61–62
correlacionadas, 277–281, 282–283 nombres de recopilar tablas en esquemas, 61
correlación, 252, 427 crear tablas, 109
CORRESPONDIENTEpalabra clave, 245–246, vistas de varias tablas, 56–60
247 CONTARfunción, 69, 182–183 CREAR descripción general, 51, 52, 298
ASERCIÓNdeclaración, 63 CREAR UN JUEGO DE bases de datos de planificación, 52–
CARACTERESdeclaración, 63 CREAR 53 vistas de una sola tabla, 55–56
COLABORACIÓNdeclaración, 63 CREAR declaraciones, 62–64
DOMINIOdeclaración, 63, 305, 306 CREAR tablas, creación, 53–55
ESQUEMAdeclaración, 63 CREARdeclaraciones, diccionario de datos, 7
53, 62, 63, 166 CREAR MESAdeclaración, 53, 54, integridad de los datos
63, 98 CREAR TRADUCCIÓNdeclaración, 63 columnas, agregar a tablas existentes, 123
CREAR DISPARADORdeclaración, 424 CREAR columnas, eliminar de tablas existentes
TIPOdeclaración, 308 CREAR VISTA mesas, 124
declaraciones, 59–60, 63 UNIÓN CRUZADA,253 restricciones, 126–129, 147 integridad
del dominio, 119–120 integridad de la
entidad, 118–119 Internet, base de
producto cruzado, 253 datos de ejecución
sesiones actuales, 176 manipulaciones terminadas, 49–50
FECHA ACTUALfunción, 196 TIEMPO descripción general, 118
ACTUALfunción, 196 FECHA Y HORA amenazas potenciales, 124–126
ACTUALfunción, 196 USUARIO ACTUAL integridad referencial, 120–123
variable especial, 176 pérdida de datos, 6
CURSOR_NOMBREcampo, 419 Lenguaje de manipulación de datos (DML)
cursores conectivos lógicos, 69 en
cierre, 392 Microsoft Access, 343
declaraciones compuestas, declarando descripción general, 51, 64,
dentro, 396 298 predicados, 68
declarando, 341, 384–388 establecer funciones, 69–71
 Índice 447
subconsultas, 71 modelo relacional, 11-13
expresiones de valor, 64–68 esquemas, 16, 17
redundancia de datos, 125 vistas, 14-16
fuente de datos, interfaz ODBC, 351 propietarios de objetos de base de datos, 298–299
almacenamiento de datos, 6 objetos de base de datos, 299, 324
tipos de datos estructura de base de datos, verificación, 435
números aproximados, 29–30 funciones de gestión de bases de datos, 298 consultas
BINARIOcuerdas, 32–33 de definición de datos, Microsoft Access,
BOOLEANO,33 98–100
cadenas de caracteres, 30–32 Vista de hoja de datos, Microsoft Access, construcción
colección, 39–40 tablas en, 83–84
convirtiendo conELENCOexpresiones, FECHAtipo de datos, 34
205–207, 339 FECHAvalor, 172
fechas y horas, 33–35 tipo de datos de fecha y hora, 33–35
números exactos, 27–28 expresiones de valor de fecha y hora, 66–67, 179–180
intervalos, 35 funciones de valor de fecha y hora, 196
mapeo, 364, 375–379 valores de fecha y hora, fijación, 389
descripción general, 26
intervalos de día, 35, 66, 180
lenguajes procedimentales versus SQL, 336
DBA (administrador de bases de datos), 298–299
ÁRBITRO,41
[Link] de gestión de bases de datos
FILA,38–39 [Link] de control de datos [Link]
tabla de, 45
Lenguaje de definición de datos DECIMALtipo de
UDT, 41–44 datos, 28
privilegios de usuario, 298
segmentos de declaración para variables del lenguaje
XML,35–38, 360–362 principal, 339 declaraciones en módulos, 340
XMLCASTfunción, 371 DECLARAR CURSORdeclaración, 384, 386,
administrador de base de datos (DBA), 298–299
387–388
sistema de gestión de bases de datos (DBMS)
transacciones SQL predeterminadas, 319–320
exceder la capacidad de, 126
valores predeterminados, 208
discusión general, 8–9
APLAZABLErestricción, 327
mantenimiento del índice, 117
BORRARdeclaraciones
modelo relacional de objetos, preferido
tablas bitemporales, 170
18-19, uso en proyectos, 433
consultas anidadas, 282–284
manipulación de base de datos
datos obsoletos, eliminación, 156
agregar datos, 146-151
DML canalizado, 284
creando vistas, 141–145
restringir, 73
eliminar datos obsoletos, 156
tablas versionadas por el sistema, 166, 167 eventos
descripción general, 139
desencadenantes, 424, 426
recuperar datos, 139-141
acceso de usuario, 298
transferir datos, 154-156
actualizar datos existentes, 151–154 usar con cursores, 391–392
actualizar vistas, 145 eliminar datos
modelos de bases de datos
en tablas de períodos de tiempo de aplicación,
restricciones, 16, 17-18 161 índices, 103
dominios, 16, 17 datos obsoletos, 156, 304
modelo de objeto, 18 filas, en operaciones de cursor, 387, 391–392
modelo relacional de objetos, 18-19 tablas, 94–95, 102
448 SQL para principiantes, octava edición

anomalía de eliminación, 130 GOTAdeclaración, 53, 62, 64

eliminaciones, en cascada, 121–122 MESA PLEGABLEcomando, 102
identificadores delimitados, 363 hardware duplicado, 314
tablas delta, 284 durabilidad, 326
bases de datos departamentales, 8 diseño biblioteca de enlaces dinámicos (DLL), 351
de bases de datos, 20, 105–106 revisiones CÓDIGO_FUNCTION_DYNAMICcampo, 415
de diseño, 434
Vista de diseño, Microsoft Access
tablas de base de datos, incorporación, 84–86
• mi •
propiedades de campo, configuración, 86–90 SQL incorporado, 175, 336–339 FIN
área de detalle, diagnóstico, 414, 416–418 áreas palabra clave, 394
de diagnóstico bases de datos empresariales, 8
información de violación de restricciones, 418–419 integridad de la entidad, 118–119
restricciones, agregar a tablas existentes, 419 área ENTORNO_NOMBREcampo, 419
de detalles, 416–418 operador igual (=), 274
área de encabezado, 414–416 IGUALpredicados, 164
información devuelta porESTADOSQL, uniones equi, 251–253
interpretación, 419–420 falla del equipo, partición de
descripción general, 414 ancho equivalente 314–315,
TAMAÑO DEL DIAGNÓSTICOcláusula, 414 manejo de errores 195
lectura sucia, 320 agregar a aplicaciones, 438 condiciones
DISTINTOpalabra clave, 272 que causan errores, 200 áreas de
DISTINTOpredicado, 225 diagnóstico, 414–420 manejo de
DK/NF (forma normal de clave de dominio), 134–135 excepciones, 420–421 descripción
DLL (biblioteca de enlaces dinámicos), 351 general, 411
[Link] de manipulación de datos ESTADOSQLparámetro de estado, 411–413
DOCUMENTOcomponente deVÁLIDO CUANDO SEAcláusula, 413–414 caracteres de
predicado, 373 escape, 186, 193 tipos de datos numéricos
DOCUMENTOpredicado, 371–372 que documenta el exactos, 27–28 EXCEPTOoperador, 248
progreso, 434 forma normal de clave de dominio
(DK/NF), 134–135 dominios evitación de excepciones, 200
controladores de excepciones, 420–
privilegios de acceso, asignación a usuarios, 74 421 EJECUTIVOdirectiva SQL, 339
creación, 63 EJECUTARpalabra clave, 298
discusión general, 17, 305–306 EJECUTARprivilegio, 408–409 contextos de
integridad, 119–120 ejecución, disparador, 426 pruebas de existencia,
mapeo a XML, 375–376 bases de datos relacionales de consultas anidadas, 277–278 EXISTEpredicado,
múltiples tablas, 111–112 descripción general, 16 224–225, 277–278 SALIDAefecto, 399

sesiones inactivas, 176 Expfunción, 194

PRECISIÓN DOBLEtipo de datos, 29–30 DLL de expresiones, definidas, 171 lenguaje de
controlador, interfaz ODBC, 351 administrador de marcado [Link] EXTRACTO
controladores, interfaz ODBC, 351 controladores, función, 192
ODBC, 350, 352
GOTAdominios, 306
 Índice 449
•F• [Link] también funciones específicas de
nombre

falla del equipo, 314–315 viabilidad de los

definido, 171
descripción general, 181
proyectos, 432 retroalimentación sobre los
recursividad, 285
proyectos, escucha, 432 BUSCARdeclaración, 236–
conjunto, 181–184
238, 390–391 Panel Propiedades de campo,
almacenado, 407–408
Microsoft Access,
para datos XML, 367–371
85, 86
campos, definidos, 172
archivos, copia de datos extranjeros, 149
primera forma normal (1NF), 132
•G•
PRIMEROorientación, 391 GENERADO SIEMPREpalabra clave, 166 CONCEDER
FIRST_VALUEfunción, 241 archivos ELIMINARdeclaración, 74 INSERCIÓN DE SUBVENCIÓN
planos, 9–11 declaración, 74 OPCIÓN DE SUBVENCIÓN PARAcláusula,
FLOTARtipo de datos, 30 310–311 REFERENCIAS DE SUBVENCIÓNdeclaración, 74
FLOTARvalor, 172 CONCEDER SELECCIONARdeclaración, 74 CONCEDER
número de punto flotante, declaración, 73, 300–301, 311–312 ACTUALIZACIÓN DE LA
29 PISOfunción, 195 SUBVENCIÓNdeclaración, 74 otorgando privilegios a los
declaración de flujo de control [Link] AGRUPAR PORcláusula
CASO... CASO FINALdeclaraciones, 401–402 PARA...
HACER... FIN PARAdeclaraciones, 405 SI... ENTONCES...
DE LO CONTRARIO... TERMINAR SIdeclaraciones, 401 discusión general, 232–234 TENIENDOcláusula,
ITERARdeclaración, 405–406 DEJARdeclaración, 403 subconsultas con, 281 descripción general, 212

BUCLE... BUCLE FINALdeclaraciones, 402–403 restricciones, 437

descripción general, 400 resumir datos con, 436–437
REPETIR…HASTA…TERMINAR REPETIR
declaraciones, 404
MIENTRAS... HACER... TERMINAR MIENTRAS
•H•
declaraciones, 404 PARA CADAcláusula, 425 PARA... controladores, condición, 398–399
HACER... FIN PARAdeclaraciones, 405 archivos de datos manejo de excepciones, 420–421 fallas
externos, copiando desde, 149 claves externas, 73–74, 114, de hardware, 314–315 TENIENDO
121 cláusula, 212, 234, 281 área de
bosques de valores XML, producción, utilidad encabezado, diagnóstico, 414–416
de conversión de formato 368, 149 jerarquías, 307
entrada de datos basada en formularios, 146– filas históricas, 165, 166–167
148 FORTRAN, 207 capacidad de retención, cursor, 385
lenguajes de cuarta generación (4GL), 81 idiomas anfitriones, utilizandoELENCOexpresiones
DEcláusula, 212 con, 206–207
LLENOpalabra clave, 229–230 variables del lenguaje principal, 175, 205–207, 339, 411 código
uniones externas completas, 259 llamadas HTML para acceso a la base de datos, 354–355
a funciones, 285, 350, 407–408
dependencia funcional, 132–133
450 SQL para principiantes, octava edición

•I• Internet, SQL terminado, 49–50 Sistemas de bases de datos

basados en Internet, 352–353 INTERSECARSEoperador,
246–248 tipo de datos de intervalo, 35
iconos, usados en libro, 2
identificadores, mapeo, 363 opción-
superposición de intervalos, determinación, 226
restricción-de-identidad
expresiones de valores de intervalo, 66–67, 180
componente deVÁLIDOpredicado,
funciones de valores de intervalo, 196
373 IDE (desarrollo integrado
ambientes), 81 intranets, 49–50, 355
SI... ENTONCES... DE LO CONTRARIO... TERMINAR SI
ISAM (acceso secuencial indexado
declaraciones, 401 IGNORAR NULLSpalabras clave,
método), 351
240 INMEDIATAMENTE PRECEDEpredicados, 165
Estándar ISO/IEC SQL, 19
ÉXITO INMEDIATOpredicados, 165 desajuste de
aislamiento, 326
niveles de aislamiento, 320–322,
impedancia, eliminando, 41 implementaciones, 23
323 ITERARdeclaración, 405–406
ENpredicado, 217–218, 270–271, 277–278
Propiedad indexada, Microsoft Access, 88
método de acceso secuencial indexado
•J•
(ISAM), 351 Subprogramas de Java, 356–357

índices JDBC (Conectividad de base de datos Java),

beneficios de, 116–117 355–357
creando, 92–94, 101 unirse a los operadores

eliminando, 103 uniones básicas, 249–250

discusión general, 114-116 Producto cartesiano, 213
mantenimiento, 117 ENcláusulas, 266
esquema de información, 62 uniones de nombre de columna, 254–255

uniones internas, 255–256 uniones de condición, 254

argumentos de entrada, predeterminado, UNIÓN CRUZADA,253

407 INSENSIBLEpalabra clave, 387–388 consultas de doble verificación que incluyen, 436
INSERTARdeclaraciones equi-uniones, 251–253
copiar datos entre tablas, 150–151 uniones internas, 255–256
consultas anidadas, 282–284 uniones naturales, 253–254
DML canalizado, 284 uniones exteriores, 256–259

privilegios, 298, 302 descripción general, 249

restringir, 73 se une al sindicato, 259–265

expresiones de valor de fila, usando con, 208 en vistas, 56
filas, agregando datos por, 147–148 DÓNDEcláusulas, 266
eventos desencadenantes, 424,
426 anomalía de inserción, 130
inestabilidad, plataforma, 314 ENTEROtipo
•k•
de datos, 27 bases de datos integradas, 7 claves, 112-114
entornos de desarrollo integrados

(IDE), 81 •L•
SQL interactivo, 333 RETRASOfunción, 239–240
interfaz, ODBC, 350 caracteres del idioma, 32
 Índice 451
IDIOMAcláusula, 341 metadatos, 7, 359
ÚLTIMOorientación, 391 métodos, UDT, 41
LAST_VALUEfunción, 241 pila de último en Acceso [Link], controles
entrar, primero en salir (LIFO), 414 Microsoft Microsoft ActiveX, 355
DIRIGIRfunción, 240 MÍNIMOfunción, 70, 183
subtipos de hojas de UDT estructurados, 43 MODIFICACIÓNfunción, 194
tipos de hojas, 307 anomalías de modificación, 129–130, 283–284
DEJARdeclaración, 403 atributos modificados, creación de vistas con,
uniones exteriores izquierdas, 256–258 Pila 144–145
LIFO (último en entrar, primero en salir), 414 cláusulas [Link] tambiénDÓNDEclausulas
COMOpredicado, 218–220 valores literales, DEcláusula, 213
172–174 LNfunción, 194 discusión general, 211–213
AGRUPAR PORcláusula, 232–234
bloquear objetos de base de datos, TENIENDOcláusula, 234
324 funciones de registro, 423 ORDENAR PORcláusula, 235–236 modificar datos de la
conectivos lógicos, 230–232 tabla, otorgar acceso al usuario
esquemas lógicos, 61 a, 303
iniciar sesión, 299 lenguaje del módulo, 339–342
BUCLE... BUCLE FINALdeclaraciones, 402–403 módulos, 339
MÁS BAJOfunción de valor, 189 caracteres en módulos, almacenados,
minúscula, conversión módulo 409–410, 194
cadenas de caracteres a, 189 MÁScampo, área de encabezado de diagnóstico, 415
MULTICONJUNTOtipo de datos, 40 conjuntos múltiples, 193,

•M• 379
Bases de datos relacionales [Link] también

entidades importantes, 106 integridad de los datos; conjuntos de

corrupción maliciosa, 125 gerentes, caracteres de normalización, 111–112

escuchar opiniones de, 432 mantisa, intercalaciones, 111–112

29–30 definir objetos, 106

cartografía diseñar, 105–106
conjuntos de caracteres, 362–363 dominios, 111–112
tipos de datos, 364 índices, 114-117
identificadores, 363 claves, 112-114
tipos de datos no predefinidos a XML, descripción general, 105

375–379 tablas, definición, 107–111

tablas, 364–365 tablas y columnas, identificación, 106–107
FÓSFOROpredicado, 226–230 traducciones, 111–112
procesamiento de materiales, 293 vistas de varias tablas, creación, 56–60 función
MÁXIMOfunción, 70, 183 mutadora, para UDT estructurados, 43
supertipos máximos de UDT estructurados,
43 falla mecánica, 124
• norte •
UNIRdeclaraciones, 154-156, 284
MENSAJE_LENGTHcampo, 420 argumentos con nombre, 406–407
MESSAGE_OCTET_LENGTHcampo, 420 restricciones con nombre, 127
MENSAJE DE TEXTOcampo, 419–420 LOS NOMBRES SONcláusula, 341
452 SQL para principiantes, octava edición

CARACTER NACIONALtipo de datos, 32 NTILEfunción de ventana, particionando en

GRAN OBJETO DE CARÁCTER NACIONAL cubos con, 239
tipo de datos, 32 NULOpredicado, 220–221
CARÁCTER NACIONAL VARIABLEdatos valores nulos
tipo, 32 cambiando valores a, conCASO
conductores nativos, 352 expresiones, 202–204
uniones naturales, 253–254 encontrar filas con, 220–221
consultas anidadas discusión general, 46
TODOcuantificador, 275–276 CUALQUIER FÓSFOROpredicado, 229–230
cuantificador, 275–276 subconsultas razones para usar, 182
correlacionadas, 278–281 BORRAR en XML, manejo, 365 NULLIFexpresiones, 202–204
declaraciones, 282–284 pruebas de NÚMEROcampo, área de encabezado de
existencia, 277–278 INSERTARdeclaraciones, diagnóstico, 415 NUMÉRICOtipo de datos, 27–28
282–284 descripción general, 71, 267–268 literales numéricos, 65

DML canalizado, 284 expresiones de valores numéricos, 65, 179

devolver conjuntos de filas con, 269–272 funciones de valores numéricos, 190–196
devolver valores únicos con, 272–275
ALGUNOcuantificador, 275–276 ACTUALIZAR
declaraciones, 282–284 funciones de ventana
•O•
anidadas, 241–242 NUEVA MESApalabras clave, modelo de objeto, 5, 18
284 PRÓXIMOorientación, 391 Lenguajes de programación orientados a objetos, 18
aplicaciones rápidas orientadas a objetos.
tipos de datos no predefinidos, mapeo a herramientas de desarrollo (RAD), 334, 342–343
XML, 375–379 bases de datos relacionales de objetos, 5, 18–19 objetos,
lectura no repetible, 321 definición, 106
formas normales, 38 función de observador, para UDT estructurados, 43
normalización datos obsoletos, eliminación, 156
forma anormal, 135-136 OCURRENCIAS_REGEXfunción, 191
NS/NF, 134–135 OCTET_LENGTHfunción, 192–193 ODBC
primera forma normal, 132 anomalías (Conectividad de base de datos abierta)
de modificación, 129–131 formas extensiones de cliente, 354–355
normales, 131–132 en entorno cliente/servidor, 352
descripción general, 54, 129, 267 componentes de, 351
reducir la complejidad de las relaciones, 270 e Internet, 352–353
segunda forma normal, 132-134 intranets, 355
tercera forma normal, 134 Interfaz ODBC, 350
bases de datos NoSQL, 11 descripción general, 349–350
NO APLAZABLErestricción, 327 NO extensiones de servidor, 353
EXISTEpredicado, 277, 278 NO EN Interfaz ODBC, 350
palabras clave, 271–272 NO EN COMPENSARpalabra clave, 237
predicado, 217–218 DIFERENTE A OLAP (tramitación de solicitudes en línea), 195
predicado, 218–220 NOconectivos ENcláusulas, 266
lógicos, 69, 232, 437 NO NULO relaciones uno a muchos, 58, 110 procesamiento
restricciones, 163, 327 NTH_VALUE de solicitudes en línea (OLAP), 195
función, 240–241
 Índice 453
Abra Conectividad de base de [Link] período de tiempo de la aplicación de consulta
ABIERTOdeclaración, 388–390 cursores de mesas, 164
apertura, 388–390 error del operador, 124 para XML, 371–373
preprocesador, 337, 338
Oconectivos lógicos, 69, 230–231, 437 sesiones anteriores, 176
ORDENAR PORcláusula CLAVE PRIMARIArestricción, 127
discusión general, 235–236 claves primarias
descripción general, 212–213 en tablas de períodos de tiempo de aplicación,
usar con cursores, 385–386 designando, 162–163
orientación de los cursores, 391 cambios a, 122
UNIÓN EXTERNAoperación, 205 nombres de campos descriptivos
uniones exteriores, 256–259 para, 86 discusión general, 112–114
SUPERPOSICIONESpredicado, 226 en índices, 93
CUBRIRfunción de valor, 188 descripción general, 53

en tablas versionadas por el sistema, designando, 167

PREVIOorientación, 391
• PAG • jerarquía de privilegios, 300
parámetros, 175 privilegios
relación padre-hijo, 120–121 en todos los niveles, concesión, 307–309
paréntesis, usando conY, O,y asignación a usuarios, 73–75, 77–78
NO,437 propietarios de objetos de base de datos, 298–
análisis de cadenas, 370 PARCIALpalabra 299 DBA, 298–299
clave, 229–230 coincidencias parciales, de delegar acceso, 309
comparación, 218–220 dividir ventanas en eliminar filas obsoletas, 304
depósitos, 239 Pascal, 207 insertar datos, 302
mantener al asignar tablas a
contraseñas, 299 XML, 364
signo de porcentaje (%) comodín, 218–220 modificar datos de tablas, 303 hacer
definiciones de período, 158–159 referencia a tablas relacionadas, 304–305
Módulos almacenados [Link] de recuperar datos, 437
datos personales SQL/PSM, 7 revocar, 310–311
lectura fantasma, 321–322 SQL/PSM, 408–409
esquemas físicos, 61 DESENCADENAR,306–307
DML canalizado, 284 para usar dominios, 306
bases de datos de planificación, 52–53 usandoCONCEDERyREVOCARjuntos,
inestabilidad de la plataforma, 314 311–312
consideraciones de portabilidad, 103 visualización de datos, 302–303

POSICIÓNfunción, 190–191 lenguajes procesales

POSICIÓN_REGEXfunción, 191–192 FUERZA combinando SQL y, 335–336 descripción
función, 195 general, 21, 22, 333–334 fortalezas y
PRECEDEpredicados, 164 precisión de debilidades de, 335 procedimientos, 339
números, 27 [Link] también
predicados específicos procedimientos, almacenados, 406–407 revisiones
por nombre de diseño profesionales, 434 programas,
definido, 32 incorporación de código SQL, 23 subtipos
discusión general, 68 adecuados de UDT estructurados, 43
454 SQL para principiantes, octava edición

API propietarias, 352 descripción general, 82

herramientas propietarias, 141 información de seguimiento, 82–83 usando SQL con,

protegiendo los [Link] tambiénTransacciones SQL 95–97, 342–343 LEER COMPROMETIDOnivel de
acceso simultáneo, 315–317 aislamiento, 321, 322 LEER SIN COMPROMISOnivel de
restricciones, 327–331 aislamiento,
falla del equipo, 314–315 320–321, 322
descripción general, 313 LEER ESCRIBIRmodo, 320
inestabilidad de la plataforma, REALtipo de datos, 29
314 nivel de acceso público, 300 REALvalor, 172
registros, 7, 13

•Q• recursión, 285–288

consultas recursivas
Cuadrícula QBE (Consulta por ejemplo), 95 discusión general, 288
filas de calificación, 199 descripción general, 285
operador de comparación cuantificado, 272 consultas. recursión, 285–288
Ver tambiénconsultas anidadas; recursivo ahorrando tiempo con, 289–293
consultas usos para, 293–294
tablas de períodos de tiempo de aplicación, 164– redundancia, 125, 314
165 tablas bitemporales, 170 ÁRBITROtipos de datos, 41 REFERENCIA ES
incluyendo uniones, doble verificación, 436 cláusula, 309 expresiones de valor de
desde el teclado, 22 referencia, 68 REFERENCIASprivilegio, 74, 77,
descripción general, 22 298 REFERENCIA valor_antiguo_o_nuevo_
orden de clasificación para la salida, 235

con subselecciones, doble verificación, 436 tablas lista_aliasfrase, 427–428 que hace referencia a
versionadas por el sistema, 168–169 en bases de tablas relacionadas y otorga acceso
datos de prueba, 436 para, 304–305
en documentos XML, 361 cuadrícula de integridad referencial, 75–77, 120–123
consulta por ejemplo (QBE), 95 expresiones restricciones de integridad referencial, 102,
de consulta, 385 163–164, 168
reglas de integridad referencial, yFÓSFORO

•R• predicado, 228–230

tamaños de registro, 29
bases de datos relacionales
Herramientas [Link]ón rápida
herramientas de desarrollo
complejidad de, 7–8
verificación de rango, 124
componentes de, 12
Herramientas de desarrollo rápido de aplicaciones (RAD)
restricciones, 16, 17-18
almacenamiento de datos, 6
alterar la estructura de la tabla, 90–92 Vista de hoja de
base de datos, definida, 7
datos, crear tablas de bases de datos
en, 83–84 SGBD, 8–9
eliminar tablas, 94–95 diseño de, 20
Vista de diseño, creación de tablas de bases de datos,
dominios, 16, 17
limas planas, 9-11
84–86
versus modelo de objetos, 18 modelo
Vista de diseño, configuración de propiedades de campo en,
relacional de objetos, 18–19 descripción
86–90
general, 5
índices, creación, 92–94
modelo relacional, 11-12
 Índice 455
relaciones, 12-13 revocar privilegios, 310–311
esquemas, 16, 17 uniones externas derechas, 258–
tamaños de, 7–8 259 roles, 301–302
vistas, 14-16 RETROCEDERfunción, 317
modelo relacional, 5, 11-13 operadores RETROCEDERdeclaración, 72, 318, 324
[Link] tambiénunirse rutinas, almacenadas, 407
operadores FILAtipo de datos, 38–39, 377
EXCEPTO,248 activadores de fila, 425
INTERSECARSE,246–248 expresiones de valor de fila, 67, 207–209
descripción general, 243 valores de fila, 172
UNIÓN,243–246 NÚMERO DE FILAScampo, encabezado de diagnóstico
valores relacionales, traduciendo a XML área, 415
elementos, 367 [Link] tambiéncursores
relaciones, 12-13 bloques de, agregando a tablas, 148–151
RELATIVOorientación, 391 datos, agregando a, 146–148
Icono recordar, 2 Procesamiento de DBMS de, 12–13
REPETIR…HASTA…TERMINAR REPETIR eliminación, 156
declaraciones, 404 grupos de, evaluando en Windows, 242
LECTURA REPETIBLEnivel de aislamiento, 321–322 insertando en tablas de base de datos, 91
grupos repetidos, 39 conjuntos de, regresando con consultas anidadas,
palabras reservadas, 26, 439–442 269-272
RENUNCIAdeclaración, 399, 400, 421 transferir entre mesas, 149–150
RESTRINGIRpalabra clave, 310–311
recuperar datos
hacer una copia de seguridad de los datos, 438
•S•
manejo de errores en aplicaciones, 438 discusión caja de arena, 356
general, 139–141 AGRUPAR PORcláusula, PUNTO DE GUARDADOdeclaración, 325, 326–327
restricciones sobre, 437 descripción general, 435 puntos de guardado, 325, 326–327
sistemas de gestión de bases de datos escalables, 8
paréntesis, usando conY, O,y valores escalares, 172
NO,437 escala de números, 28
privilegios, control, 437 consultas ESQUEMAcláusula, 341
que incluyen uniones, doble ESQUEMA_NOMBREcampo, 419
comprobando, 436 esquemas, 16, 17, 52, 61–63
consultas en bases de datos de prueba, esquemas, XML, 359, 366
436 consultas con subselecciones, doble scripts, 355
comprobando, 436 DESPLAZARSEpalabra clave, 388
resumir datos conAGRUPAR POR,436–437 verificando capacidad de desplazamiento, cursor, 384, 388, 391
la estructura de la base de datos, 435 condiciones de búsqueda,CASOexpresiones con,
retornabilidad, cursor, 385 REVOCAR 198-200
ELIMINARdeclaración, 74 REVOCAR segunda forma normal (2NF), seguridad
INSERTARdeclaración, 74 REVOCAR [Link] tambiénprivilegios
REFERENCIASdeclaración, 74 REVOCAR Declaraciones DCL, 298
SELECCIÓNdeclaración, 74 REVOCAR delegar responsabilidad para, 77–78
declaración, 73, 310–312 REVOCAR dominios, 305–306
ACTUALIZACIÓNdeclaración, 74 Microsoft Access, 100–101
456 SQL para principiantes, octava edición

descripción general, 297 tipos de fuentes, 42

realizar manipulaciones de bases de datos sobre variables especiales, 176
Internet, 49–50 SQL
integridad referencial, 75–77 en sistemas cliente/servidor, 47–49
roles, 301–302 discusión general, 21–23 historia
niveles de acceso de usuario, 298– de, 23–24
300 vistas, creación, 145 en Internet, 49–50
SELECCIONARdeclaraciones en intranets, 49–50
DML canalizado, 284 descripción general, 21

como expresiones de consulta, palabras reservadas, 26, 439–442

385 restrictivas, 73 declaraciones, 24–25
recuperar datos con, 140 transferir Transacciones SQL
datos entre tablas, 150 acceso de Bases de datos ACID, 326
usuario, 298 hacer una copia de seguridad de los datos, 325

condiciones de selección, creación de vistas con, COMPROMETERSEdeclaración, 324

143-144 restricciones en, 327–331

sensibilidad, cursor, 384, 387–388 SEQUEL predeterminado, 319–320
(CONSULTA en inglés estructurado niveles de aislamiento, 320–322 bloqueo
Idioma), 23 de objetos de base de datos, 324
SERIALIZABLEnivel de aislamiento, 320, 322, 323 RETROCEDERdeclaración, 324 puntos de
serialización de transacciones simultáneas, 317 guardado, 325, 326–327
extensiones de servidor, 353 ESTABLECER TRANSACCIÓNdeclaración, 323
servidores, 47–48 subtransacciones, 325, 326–327 declaraciones de
USUARIO_SESIÓNvariable especial, 176 inicio de transacción, 322–323 Vista SQL,
sesiones, 176 Microsoft Access, 96–97, 344 Pestaña Objeto de
ESTABLECER RESTRICCIONES APLAZADASdeclaración, Vista SQL, Microsoft Access,
329–330 96–97, 98
establecer funciones SQL:2008 palabras reservadas, 439–442
promedio,183 SQL:2011, [Link] tambiéndatos temporales
CONTAR,182–183 SQL/PSM (Módulos almacenados persistentes).
discusión general, 69–71 Ver tambiéndeclaraciones compuestas
AGRUPAR PORcláusula, combinando con, 232 declaración de flujo de control, 400–406
MÁXIMO,183 descripción general, 393
MÍNIMO,183 privilegios, 408–409
descripción general, 181–183 funciones almacenadas, 407–408
SUMA,184 módulos almacenados, 409–410
ESTABLECER TRANSACCIÓNdeclaración, 319, 323, 414 procedimientos almacenados, 406–407
SIMILARpredicado, 220 ESTADOSQLparámetro de estado
SIMPLEpalabra clave, 229–230 discusión general, 396–398, 411–413
vistas de una sola tabla, 55–56 interpretación de la información devuelta por,
PEQUEÑOtipo de datos, 27 419–420
ingeniería social, 76 CUADRADOfunción, 195
software, estabilidad de, 314 activadores de declaraciones, 425
ALGUNOpredicado, 221–224 declaraciones
ALGUNOcuantificador, consultas anidadas, 275–276 DDL, 62–64
orden de clasificación para la salida, 235, 386 SQL, 24-25
 Índice 457
parámetro de [Link] SUBCADEfunción de valor, 185–186
parámetro SUBSTRING_REGEXfunción de valor, 186–187
funciones almacenadas, 407–408 subcadenas, 185, 188
módulos almacenados, 409–410 subtransacciones, 325, 326–327
procedimientos almacenados, 406–407 subtipos de UDT estructurados, 43
rutinas almacenadas, 407 ÉXITOSpredicados, 165 SUMA
concatenación de cadenas, 65–66 función, 70, 184
expresiones de valores de cadena resumir datos conAGRUPAR POR,436–437
CONVERTIR,189 superusuario, 299
discusión general, 65–66, 178 MÁS sintaxis de SQL, 23 administrador del
BAJO,189 sistema, 299 arquitectura del sistema, 433
CUBRIR,188 SISTEMA_TIME A PARTIRsintaxis, 168 HORA
descripción general, 184 DEL SISTEMApalabra clave, 159
SUSTENCIÓN,185–186 USUARIO_SISTEMAvariable especial, 176
SUBCADE SIMILAR,186 tablas versionadas por el sistema, 166–169
SUBSTRING_REGEX,186–187
TRADUCIR,189
TRADUCIR_REGEX,187–188
RECORTAR,189 •T•
SUPERIOR,188 restricciones de tabla, 126, 127–128
estructura de la base de datos, 9, 435 Lenguaje NOMBRE DE LA TABLAcampo, 419
de consulta en inglés estructurado [Link] tambiénperíodo de tiempo de solicitud
(SECUELA), 23 mesas; puntos de vista
tipos estructurados definidos por el usuario, 43–44, privilegios de acceso, asignación, 74
307–308 alteración, 63, 102
hojas de estilo, 359 bitemporal, 169-170
SUBCLASS_ORIGINcampo, detalle de diagnóstico bloques de filas, agregando, 148–151
área, 417 cambiando datos en, 12
sublenguaje, 22 recopilar en esquemas, 61 columnas,
subconsultas agregar a las existentes, 123 columnas,
TODOcuantificador, 275–276 CUALQUIER eliminar de las existentes, 124
cuantificador, 275–276 subconsultas restricciones, agregar a las existentes,
correlacionadas, 278–281 BORRAR 419 crear, 53–55, 63, 97–101
declaraciones, 282–284 pruebas de definiendo, en relacional multitabla
existencia, 277–278 bases de datos, 107-111
EXISTEpredicado, usando con, 224–225 eliminando, 94–95, 102
INSERTARdeclaraciones, 282–284 descripción eliminar filas, otorgar privilegios
general, 71, 267–268 para, 304
DML canalizado, 284 disparando múltiples disparadores, 428
devolver conjuntos de filas con, 269–272 identificando, en relación de múltiples tablas
devolver valores únicos con, 272–275 ALGUNO bases de datos, 106–107
cuantificador, 275–276 ÚNICOpredicado, mapeo a documentos XML, 364–365
usando con, 225 ACTUALIZARdeclaraciones, eliminación, 64
282–284 subselecciones, 150, 153, 436 versionado por el sistema, 165–169
SUBCADE SIMILARfunción de valor, 186 transfiriendo datos entre, 149–150
458 SQL para principiantes, octava edición

mesas(continuado) desencadenantes

mecanografiado, 307–308 aplicaciones de, 423–424

actualización de datos existentes, 151– creación, 424–426
154 vistas, 14–16, 142–143 cocción múltiple, en mesas individuales, 428
Datos XML, transformándose en, 373–374 descripción general, 423
Icono de material técnico, 2 haciendo referencia a valores antiguos y nuevos, 427–
datos [Link] tambiéntiempo de aplicación 428 en tablas versionadas por el sistema, 167
tablas de periodo desencadenar contextos de ejecución,
tablas bitemporales, 169–170 426 RECORTARfunción de valor, 189
descripción general, 157 TRIM_ARRAYfunción, 40, 194 matrices
períodos, 158-159 bidimensionales, 12 tablas escritas,
tablas versionadas por el sistema, 165–169 307–308
veces, 158–159
condición de terminación, 287 bases de datos de
prueba, consultas, 436 tercera forma normal (3NF),
•U•
53 lenguajes de tercera generación, 81 HORA CON UDT (tipos definidos por el usuario), 41–44, 67, 376
ZONA HORARIAtipo de datos, 35 TIEMPO SIN ZONA BAJOpalabra clave, 298
HORARIAtipo de datos, 34 zonas horarias, 179–180 guión bajo (_) comodín, 218–220
DESHACERefecto, 399
Unicódigo, 363
veces, 158–159, 179–180, 226 UNIÓN TODOSoperación, 245 UNIÓN
MARCA DE TIEMPOvalor, 172 CORRESPONDIENTEoperación,
MARCA DE TIEMPO CON ZONA HORARIAdatos 245–246
tipo, 35 se une al sindicato, 259–265
MARCA DE TIEMPO SIN ZONA HORARIAdatos UNIÓNoperador, 150, 243–246 tablas
tipo, 34 compatibles con uniones, 243–245
marcas de tiempo, 168–169 ÚNICOpalabra clave, 229–230 ÚNICO
Icono de propina, 2 predicado, 225
procesamiento de transacciones, 315 cláusula de actualizabilidad deDECLARAR CURSOR
tiempo de transacción, 158 declaración, 387
TRANSACTION_ACTIVEcampo, 416 actualizar anomalías, 120–123
transacciones, 71–72 ACTUALIZARdeclaraciones
TRANSACCIONES_COMMITTEDcampo, 416 tablas bitemporales, 170
TRANSACTIONS_ROLLED_BACKcampo, 416 CASOexpresiones, usando con, 199–200
declaraciones de inicio de transacción, 322–323 discusión general, 151–154
transferencia de datos, 149–150, 154–156 consultas anidadas, 282–284
dependencia transitiva, 134 DML canalizado, 284
TRADUCIRfunción de valor, 189 restringir, 73
TRADUCIR_REGEXfunción de valor, tablas versionadas por el sistema, 166, 167 eventos
187–188 desencadenantes, 424, 426
tablas de traducción, 63, 74 acceso de usuario, 298
traducciones, 111–112 usando con cursores, 391–392
desencadenar contextos de ejecución, 426 actualizando
DESENCADENARpalabra clave, 298 tablas de períodos de tiempo de aplicación, 160–161
DESENCADENARprivilegios, concesión, 306– tablas de bases de datos, 90–91
307 sentencias SQL activadas, 425 datos existentes, 151–154
 Índice 459
filas en operaciones de cursor, 391–392 tablas actualización basada en condiciones, 199–200
versionadas por el sistema, 165 filas de tabla a las expresiones de valor, 177–180
que se accede con cursores, 387 valores, basados variables, 174-175
en condiciones, 199–200 vistas, 145 VARBINARIOtipo de datos, 33 variables, 172,
174–175, 395–396 verificar la estructura de la
SUPERIORfunción de valor, 188 base de datos, 435 ver datos, otorgar acceso
caracteres en mayúsculas, conversión al usuario a,
cadenas de caracteres a, 188 302–303
USOpalabra clave, 298 puntos de vista

niveles de acceso de usuario, 298–300 creando, 141-145

privilegios de acceso de los [Link] de discusión general, 14–16 mesas
usuario de privilegios, 335 múltiples, 56–60
nombres de usuario, 301–302 descripción general, 55

tipos definidos por el usuario (UDT), 41–44, 67, 376 mesa única, 55–56
actualización, 145

•V• mesas virtuales, 14–16, 141

VÁLIDOpredicado, 372–373
tiempo válido, 158
•W•
controles de validación, 355 Icono de advertencia, 2
expresiones de [Link] tambiénCASO sistemas de bases de datos basados en web, 352–354
expresiones CUANDOcláusula, 425
ELENCO,205–207 CUANDO SEAcláusula, 413–414 DÓNDEcláusulas.
condicional, 180 Ver tambiénconsultas anidadas
fecha y hora, 179–180 TODOpredicado, 221–224
discusión general, intervalo CUALQUIERpredicado, 221–224
64–68, 180 predicados de comparación,
numérico, 179 215 DISTINTOpredicado, 225
descripción general, 177–178 uniones equi, 251–253
fila, 207–209 EXISTEpredicado, 224–225
cuerda, 178 discusión general, 213–215
funciones de [Link] tambiénvalor de cadena operadores de unión, 266
expresiones COMOpredicado, 218–220 FÓSFORO
fecha y hora, 196 predicado, 226–228 NO EN
intervalo, 196 predicado, 217–218 DIFERENTE A
numérico, 190–196 predicado, 218–220 NULOpredicado,
descripción general, 184 220–221 SUPERPOSICIONES
[Link] tambiénfunciones; funciones de valor predicado, 226 descripción general,
CASOexpresiones con, 200–202 140, 212
JUNTARSEexpresiones, 204–205 ENTREpredicado, 215–217 EN
referencias de columnas, 176–177 predicado, 217–218
literal, 172–174 consultas recursivas, 292
descripción general, 171 reglas de integridad referencial yFÓSFORO
fila, 172 predicado, 228–230
variables especiales, 176 SIMILARpredicado, 220
tipos de, 171–172 ALGUNOpredicado, 221–224
460 SQL para principiantes, octava edición

DÓNDEclausulas(continuado) XMLtipo de datos, 35–38, 360–362

ÚNICOpredicado, 225 Nombres XML, 363
conACTUALIZARdeclaraciones, 153 MIENTRAS... Esquemas XML, 359, 366
HACER... TERMINAR MIENTRASdeclaraciones, 404 XMLAGGfunción, 369
WIDTH_BUCKETfunción, 195–196 ventanas, 238–242 XMLCASTfunción, 371
COMENTARIO XMLfunción, 369 XMLCONCAT
CON OPCIÓN DE SUBVENCIÓNcláusula, 77–78, 309 función, 368 XML(CONTENIDO(CUALQUIER))tipo,
CON LIMITACIONES DE IDENTIDAD GLOBAL 36–37 XML(CONTENIDO(SIN TIPO))tipo, 37
componente deVÁLIDOpredicado, 373 XML(CONTENIDO(XMLSCHEMA))subtipo, 37
CON LIMITACIONES DE IDENTIDAD LOCAL DOCUMENTO XMLfunción, 367
componente deVÁLIDOpredicado, 373 CON XML(DOCUMENTO(CUALQUIER))subtipo, 37
VERSIONAMIENTO DEL SISTEMApalabra clave, XML(DOCUMENTO(SIN TIPO))tipo, 37–38
166 CON LAZOSsintaxis, 237–238 SIN ELEMENTO XMLfunción, 367 XMLEXISTE
RESTRICCIONES DE IDENTIDAD predicado, 372 XMLFORESTfunción, 368
componente deVÁLIDOpredicado, 373 XMLPARSEfunción, 370
TRABAJARpalabra clave, 324
bases de datos de grupos de trabajo, 8

acuerdos escritos sobre proyectos, 432 XMLPIfunción, 370

CONSULTA XMLfunción, 370–371

•X• XML(SECUENCIA)tipo, 36
TABLA XMLpseudofunción, 373–374
XML (lenguaje de marcado extensible) XQuery
conjuntos de caracteres, mapeo, 362– descripción general, 36, 367

363 tipos de datos, mapeo, 364 patrones de expresión regulares, reemplazando

generar esquemas XML, 366 con cadenas de reemplazo, 187–188
identificadores, mapeo, 363 tipos de datos patrones de expresión regular, búsqueda
no predefinidos, mapeo a, cuerdas para, 186–187
375–379 CONSULTA XMLfunción, 370–371
valores nulos, manejo, descripción
general de 365, 359
predicados, 371–373
• Sí •
y SQL, 359–360, 379–380 intervalos año-mes, 35, 66, 180
Funciones SQL para datos XML, tablas
367–371, mapeo, 364–365
transformar en tablas SQL, 373–374 tipo
de datos XML, 360–362
Sobre el Autor
Allen [Link] un veterano con 30 años de experiencia en la industria informática y autor de
más de 30 libros, entre ellosCrystal Reports 2008 para principiantes, desarrollo de bases de
datos para principiantes, acceso a programación eléctrica con VBA,ySQL todo en uno para
[Link] conferencias a nivel internacional sobre bases de datos, redes, innovación,
astronomía y emprendimiento. También enseña desarrollo de bases de datos a través de un
programa educativo líder en línea. Para conocer las últimas noticias sobre las actividades de
Allen, [Link] contactar a Allen [Link]@[Link].

Dedicación
Este libro está dedicado a Walker Taylor, quien hará cosas increíbles cuando sea
mayor.

Agradecimientos del autor

En primer lugar, me gustaría agradecer la ayuda de Jim Melton, editor de la
especificación ISO/ANSI para SQL. Sin sus incansables esfuerzos, este libro, y de hecho el
propio SQL como estándar internacional, tendrían mucho menos valor. Andrew
Eisenberg también ha contribuido a mi conocimiento de SQL a través de sus escritos. Me
gustaría agradecer a Michael Durthaler por sus útiles sugerencias sobre la cobertura de
los cursores. También me gustaría agradecer a mi editor de proyectos, Pat O’Brien, a mi
editor técnico, Mike Chapple, y a mi editor de adquisiciones, Kyle Looper, por sus
contribuciones clave a la producción de este libro. Gracias también a mi agente, Carole
McClendon de Waterside Productions, por su apoyo a mi carrera.
Agradecimientos del editor
Editor senior de adquisiciones:Kyle Looper Coordinador del proyecto:Sheree Montgomery Imagen

Editor de proyectos:Pat O'Brien Editor de de portada:©[Link]/pagadesign

copia:Virginia Sanders Editor técnico:Mike

Chapple Asistente editorial:Anne Sullivan
Asistente editorial senior:caso cherie