MCOM2 U3 Contenido

Matemáticas
Computación II
6º Semestre
Unidad 3: Síntesis y
Almacenamiento de datos
Clave
05142423/06142423
Universidad Abierta y a Distancia de México

Computación II
Unidad 3. Síntesis y almacenamiento de datos
Índice
Presentación .................................................................................................................................... 3
Competencia específica ................................................................................................................... 3
Logros .............................................................................................................................................. 3
Validación ........................................................................................................................................ 3
Validación cruzada .......................................................................................................................... 4
Leave one-out .................................................................................................................................. 5
Bootstrap .......................................................................................................................................... 5
Base de datos ................................................................................................................................... 6
Panorama en los modelos de datos ................................................................................................. 7
Modelo relacional ............................................................................................................................ 8
Elementos entidad-relación ............................................................................................................ 8
Limitaciones..................................................................................................................................... 9
SQL ................................................................................................................................................ 10
Álgebra relacional ......................................................................................................................... 10
Estructura ...................................................................................................................................... 18
Consultas y subconsultas .............................................................................................................. 22
Actualizaciones y borrado ............................................................................................................. 25
Cierre de la unidad ........................................................................................................................ 29
Fuentes de consulta ....................................................................................................................... 29
UnADM | DCEIT | MT | MCOM2 2

Computación II
Presentación
En la unidad pasada revisamos la introducción y funcionamiento de algunos algoritmos para poder

extraer información y correlaciones útiles en los datos que queremos analizar. Revisamos tres de
ellos, uno para detectar grupos de datos, otro usado generalmente para determinar la cantidad de
variables efectivas usadas y el último para hacer predicciones a partir del conjunto de
entrenamiento.
En esta unidad redondearemos el tema de la minería de datos con un par de aspectos sobre el
entrenamiento como lo es la validación del modelo, así como la regularización.
Otro aspecto muy importante y paralelo a la predicción de datos es el almacenamiento de

información en una base de datos. Diseñar y manejar una base de datos tiene la intención de
almacenar grandes cantidades de información para recuperarla de forma eficiente. En esta unidad
daremos un vistazo rápido al paradigma SQL y el álgebra relacional usada como trasfondo teórico
en el diseño de dicho lenguaje.
Competencia específica
Usar el modelo construido para presentar y almacenar la información para su futuro uso.
Logros
• Presentar una síntesis de los datos
• Conocer el concepto de bases de datos
• Almacenar la información en una base de datos
Validación
El desempeño de estos algoritmos depende enteramente de su entrenamiento, es decir, puede
estar determinado por la cantidad de iteraciones o que tan bien escogimos el conjunto de
entrenamiento. Esto induce una pregunta de forma directa. ¿Qué tan bueno fue el entrenamiento
del algoritmo? ¿Cómo se debe escoger un conjunto de entrenamiento para que el entrenamiento
sea bueno?

Computación II
Es una práctica común que los algoritmos presentados en la unidad que para obtener un buen
desempeño su entrenamiento se conforme de dos fases: la de entrenamiento y la de prueba. En
algunos casos incluso hay una fase intermedia de optimización pero no es nuestro caso.
Para entrenar y probar los algoritmos requerimos dividir el conjunto en dos partes. La práctica
común dicta que 2/3 partes del conjunto se use para entrenar y el 1/3 restante para validar.
Si lo que se está haciendo es entrenar una red neuronal para abstraer una función cuyo dominio e
imagen es de los reales en los reales entonces se tiene un conjunto infinito de puntos que
proveerle para su entrenamiento y posterior validación. Pero como comúnmente lo que se va
hacer es estar usando conjuntos acotados es importante tomar en cuenta el siguiente aspecto del
entrenamiento: Los conjuntos de entrenamiento y prueba deben ser siempre ajenos.
Si usas el conjunto de entrenamiento como validación lo que estamos haciendo es provocar que
nuestro algoritmo se sobreentrene, es decir, estás incorporando el ruido que contenga este
conjunto dentro del modelo.
Para determinar numéricamente el error en que se está incurriendo una forma muy sencilla y
común de medir esto es midiendo la cantidad de ejemplos bien clasificados (o mal clasificados,
ya que estamos hablando de dos tipos de eventos independientes, los casos exitosos y los fallidos
tal cual sucede en un proceso de Bernoulli). La tasa de éxitos la definimos como
𝐶𝑎𝑠𝑜𝑠 𝑒𝑥𝑖𝑡𝑜𝑠
𝑓=
𝑁ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑐𝑎𝑠𝑜𝑠
y esta razón nos provee el porcentaje de éxito que podemos esperar de nuestros algoritmos una
vez entrenados.
A continuación presentaremos una serie de esquemas comunes
Validación cruzada
A simple vista es fácil suponer que dividir al azar el conjunto de entrenamiento en dos
subconjuntos una solase podría ser víctimas de la mala suerte y dejar fuera todo un conjunto de
ejemplos que representen toda una categoría (tal vez una categoría que se represente por pocos
casos).
La forma en que atenuamos este error de muestreo es generar n subconjuntos muestreando sin
repetición el conjunto de entrenamiento. Esta n variedades son usadas después como conjunto de
entrenamiento y validación tomando n-1 conjuntos para entrenar y el último para validar.
De esta forma se garantiza que al recorrer todo el conjunto en la fase de entrenamiento no

estamos dejando fuera ninguna categoría o ejemplo importante para entrenar nuestro algoritmo.

Computación II
La práctica usual dicta que n=10, es decir, que se parte el conjunto en 10 subconjuntos
muestreados aleatoriamente para usar 9 de ellos para entrenar y 1 para validar y que todo el
proceso de entrenamiento se haga por lo menos 10 veces.
Leave one-out
Este método para medir el error de nuestro algoritmo de entrenamiento, que se traduce como
Dejar Uno Fuera (DUF), presenta una variación respecto de la validación cruzada y la presenta al
ser un caso extremo de la misma. DUF es simplemente lo mismo que validación cruzada
únicamente que no hay ningún muestreo aleatorio para conformar los conjuntos de validación y
prueba.
Lo que hacemos con DUF es generar n variedades a partir del conjunto de entrenamiento, de la
misma forma que validación cruzada, usamos n-1 instancias para entrenar y la restante para
validar. La diferencia es que n es también la cardinalidad del conjunto de entrenamiento, es decir,
se ocupa n-1 ejemplos del conjunto de entrenamiento para entrenar y 1 para validar. Se repite el
proceso n veces, es decir, sobre cada una de las instancias del conjunto de entrenamiento.
La ventaja de este esquema es que no hay azar incluido en el muestreo, al ser determinístico
presente la ventaja del determinismo y del a optimalidad computacional. El problema que
presenta es que no se le puede estratificar el conjunto de entrenamiento de forma representativa.
Puedes usar este método para determinar el error en el que incurre tu algoritmo si confías en que
es suficientemente grande para atenuar errores de muestreo.
Bootstrap
El método de Bootstrap es el mismo que se usa en estadística usualmente. Lo que se hace es

generar un conjunto con n instancias pero con reemplazo, es decir, algunas instancias van a estar
sobrerrepresentadas.
Si no se está escogiendo una instancia con probabilidad 1/n entonces la probabilidad con la que
no estas escogiendo una instancia para conformar el nuevo conjunto de entrenamiento con
reemplazo es:
1 𝑛
(1 − ) = 𝑒 −1 = 0.368
𝑛
Esta es la probabilidad de que un ejemplo no sea escogido lo cual es bastante alto, lo que hace
que en un conjunto grande el error inducido al dejar fuera toda una categoría de ejemplos sea
bastante alta, es decir, el error presentado puede ser muy optimista.

Computación II
Entonces ahora sabes que el conjunto de entrenamiento conformado con reemplazo contiene sólo
el 63% de los ejemplos del conjunto de entrenamiento original y por lo tanto la taza de error
cometida va a ser optimista, pero usas el factor de restitución conformada por el conjunto de
prueba de la siguiente forma
𝐸𝑡𝑜𝑡𝑎𝑙 = 0.632 ∗ 𝐸𝑝𝑟𝑢𝑒𝑏𝑎 + 0.368 ∗ 𝐸𝑒𝑛𝑡𝑟𝑛𝑎𝑚𝑖𝑒𝑛𝑡𝑜
Y repites este procedimiento varias veces muestreando diferentes veces con reemplazo. Este es el
mejor método que puedes usar en un conjunto pequeño.
Base de datos
El desarrollo tecnológico conlleva dos aspectos, la cantidad de datos que se generan son, hoy en
día, inmensamente grandes, también porque los dispositivos de almacenamiento se abaratan año
con año lo que facilita la posibilidad de adquirir medios de almacenamiento masivo y por lo tanto
llenarlos de datos. Sin embargo, lo que queremos con estos datos no es únicamente guardarlos,
también queremos recuperarlos y como viste en la unidad pasada por rápidas que puedan ser las
computadoras existe siempre una forma extremadamente ineficiente de buscar en los datos.
Lo primero que tienes que definir es, que es lo que vas a guardar. Al modelar, cualquier tipo de
datos, tienes que distinguir una estructura discreta abstraída de la realidad. Entonces es por esto
que vas a distinguir entre entidades y relaciones entre ellas.
Una entidad u objeto puede ser cualquier cosa que puedas describir con un conjunto de
atributos. Por ejemplo una persona tiene un nombre, RFC, altura, preferencia política, u otra
característica que lo hace única y lo identifica con los demás, o bien pueden ser una anotación en
un partido de futbol mismo que consta de minuto en el que fue realizado, jugador que lo logró y
un jugador descrito por nombre, número, equipo, u otras. Las diferentes entidades se agrupan por
las relaciones existentes entre ellas, por ejemplo los goles son realizados por jugadores.
Cada elemento que pueda ser agrupado dentro del conjunto descrito por estas entidades y sus
correspondientes atributos la denominaremos registro. Si cada registro está representado
únicamente por un elemento se dice que la propiedad o conjunto de propiedades que lo
distinguen como único es una llave para esa entidad.
Denomina pues, como primera aproximación que una base de datos al sistema para agrupar una
o más de estas relaciones en algún dispositivo de almacenamiento. Y es que la definición de base
de datos concierne a estos diversos archivos así como a los diferentes tipos de usuarios que hacen
uso de ella.
Computación II
Se distinguen tres tipos de usuarios de una base de datos: los administradores, los
programadores de sistemas, y los usuarios finales. Los usuarios finales son el tipo de usuario
menos sofisticado ya que usualmente el uso de la base de datos es transparente para él debido a
que interactúa con la misma a través de algún sistema programado por los programadores de
sistemas quienes pueden calificar como un nivel de sofisticación mayor al del usuario final, ya
que estos se encargan de definir las entidades donde se va a escribir en la base de datos. Un tanto
ajeno a estos dos tipos de usuarios que guardan una relación directa entre ellos está el
administrador de la base, quien es él que se encarga de administrar las transacciones y usuarios de
toda la base, los dos tipos de usuario anteriores dependen de las políticas de este último.
De hecho al sistema de base de datos que se define en el párrafo anterior se denomina más
precisamente como Sistema Manejador de Base de Datos (SMBD, o bien, las siglas en inglés
son DBMS que es como se referencia en todos los textos técnicos) y este es el que mantiene la
consistencia de los datos confiados a la base de datos a través de un sistema de archivos y un
lenguaje para tal efecto. Los SMDB constan de:
- Una estructura de datos

- Un lenguaje para la definición y manipulación de la estructura de datos
- Políticas para determinar restricciones que garanticen la integridad, seguridad y control de
concurrencia
La determinación de las propiedades, llaves, relaciones e incluso la base de datos entera son
aspectos abstractos que puedes determinar en buena medida de forma empírica. Es decir, basándote
en tu experiencia vas a determinar que atributos necesitamos plasmar en nuestras relaciones.
Otro aspecto importante que caracteriza a los SMBD es la independencia de los datos, un
concepto que determina el nivel de cohesión que tienen los programas que hacen uso de la base de
datos y la base datos específicamente. A modo de ejemplo puedes pensar en un sistema de nómina
y la base de datos donde se guarden los datos de dicho sistema. Si el sistema tiene un grado de
independencia muy bajo (dependencia alta) entonces cualquier modificación al sistema se va a ver
reflejada en el rediseño de la base, o cualquier falta de consistencia en la base se reflejará en el
funcionamiento del sistema de nómina. En el otro extremo, un nivel de independencia (datos muy
independientes) muy bajo requiere una gran cantidad de búsquedas y verificaciones lo que haría
un sistema muy lento. Entonces podemos inferir que el nivel de independencia tiene un nivel
óptimo que requiere ser buscado y determinado caso a caso.
Panorama en los modelos de datos

Durante las últimas tres décadas han aparecido diferentes paradigmas para almacenar y recuperar
grandes cantidades de datos, y aunque en esta unidad no te vas a concentrar en el esquema
relacional harás una revisión de otros esquemas para la creación de bases de datos, como el
jerárquico, el de gráficas e incluso el paradigma NoSQL.

Computación II
Considerando los diferentes elementos que conforman una base de datos puedes destacar tres
modelos relevantes. El modelo jerárquico, que conceptualiza la información como una
estructura arbórea con un esquema de tal forma que las relaciones entre los datos se establecen
con un paradigma padre/hijo. Un nodo padre puede tener varios hijos pero un hijo sólo un padre.
El esquema de red en cambio, permite que cada nodo hijo tenga varios padres (y también varios
hijos) permitiendo así una representación más natural de las entidades modeladas.
Sin embargo, estos esquemas consideran que los datos tienen una relación jerárquica intrínseca,
relación que requiere tiempo de cómputo determinar y separar pero cuando consideramos una
gran cantidad de datos como los que pueden manejar empresas como Google, Facebook,
Microsoft, eBay, etcétera, así como las operaciones necesarias para realizar búsquedas cruzadas
en esta masa de datos y también las necesidades de escalabilidad en un entorno cambiante es
cuando la hipótesis de la estructura en los datos parece quedarse corta. Es en este contexto es que
aparece el paradigma NoSQL que tiene por objetivo responder a estas necesidades de acceso a
la información de forma eficiente dejando de lado algunas necesidades como puede ser la
ausencia del esquema intrínseco de los datos.
Modelo relacional
El modelado de datos, se mencionó con anterioridad, es una tarea que requiere un proceso de
abstracción en el que observarás un conjunto de entidades relacionadas entre sí y descritas por un
conjunto de atributos con un dominio específico. El paradigma de modelación de datos que
usaremos es el modelo relacional o entidad-relación.
Este se caracteriza por describir una relación en términos de relaciones entre diferentes dominios,
como por ejemplo, un número complejo está definido por dos enteros, cada uno de estos serían
pues atributos distintos y cada número un registro distinto. O también puedes pensar en términos
del ejemplo de sistema de nómina mencionado previamente, donde con facilidad se pueden
distinguir un conjunto variado de entidades distintas como pueden ser el empleado, el pago
quincenal, entre otros, y cada una de estas entidades tiene una descripción heterogénea de
dominios que van desde los números flotantes hasta las cadenas de texto.
Como dijimos, los Sistemas Manejadores de Bases de Datos constan de
- Una estructura de datos: En este caso es una relación o tabla.
- Un lenguaje para la definición de la estructura de datos.
- Un lenguaje para la manipulación de datos: Para este caso usaremos álgebra relacional
- Restricciones de seguridad e integridad.
Elementos entidad-relación

Computación II
Una relación corresponde de forma informal a una tabla cuya definición está especificada por un
esquema de datos. Este consta de:
- Nombre de la relación o tabla.
- Conjunto de atributos nombrados específicamente.
- Un dominio 𝐷 al cual pertenece cada atributo.
Los dominios pueden ser atómicos, que corresponden a los tipos de datos usuales como enteros,
flotantes o booleanos. O bien pueden ser compuestos como puede ser un número telefónico (que
consta de números, paréntesis y guiones).
Una relación consta de dos partes principales. El encabezado o esquema (schema por su
traducción al inglés) que describe el conjunto de atributos que definen la relación, y el cuerpo de
la misma, que no es otra cosa que un conjunto de n-tuplas, se define como grado de la relación a
la cardinalidad del conjunto de atributos, en este caso n, y como cardinalidad de la relación a la
cantidad de tuplas agrupadas en esa relación. En el siguiente ejemplo se presentan estos conceptos.
La llave de una relación es el atributo (o conjunto de atributos) que hacen única a cada una de las
tuplas en la relación.
Ejemplo.
La relación empleado consta de los atributos (rfc, nombre, paterno, materno, puesto, sueldo)El
esquema de dicha relación es:
empleado(rfc, nombre, paterno, materno, puesto, sueldo)
La relación con tres registros es

rfc nombre paterno materno puesto sueldo
besm- Mariana Benítez Suárez Investigadora $30,000
770216-
fx5
esmr- Rodrigo Estévez Milán Programador/Analista $25,000
821021-
gh7
mafh- Horacio Martínez Fernández Becario $5,000
920226-
j24
En este ejemplo anterior la relación es de grado 6, su cardinalidad es de 3 y la llave es el atributo

rfc.
Limitaciones
Todo modelo tiene una serie de limitantes que se derivan de su propia conceptualización. En este
caso te concentrarás en una estructura subyacente en los datos de tal forma y ahí es donde el

Computación II
modelo relacional encuentra sus principales limitaciones ya que no toda la información está bien
estructurada.
Considerar que todos los datos se ajustan a una estructura bien definida es un requerimiento
suficientemente fuerte y de hecho no todos los tipos de datos lo cumplen, por ejemplo, los
siguientes tipos de datos
- Datos temporales y georreferenciados
- Datos multimedia
- Datos no estructurados / estructura débil
Algunas de las limitaciones relacionadas con el lenguaje que usa el modelo relacional para
manejar los datos, SQL, son:
- Incapacidad para hacer consultas recursivos. Todas las consultas que se hacen en SQL son
de tipo lineal en el sentido de que todos los valores que queramos presentar deben
recuperarse con anterioridad con otra consulta.
- Construir una consulta muy complicada (con muchas restricciones y llamando a varias
tablas) puede ser prohibitivo y complicado de construir
- Pero el modelo relacional tiene otros aspectos que se derivan del modelo mismo.
- Una entidad sobrevive únicamente si la definimos como una relación. Por ejemplo, si
tuviéramos una tabla Cliente que tuviera los campos calle, número, colonia, estado, esto
no conforma la dirección a menos de que la definamos como tal en una Relación.
- La atomicidad pensada en los tipos de datos que conforman las distintas relaciones
contribuye a que la conformación de consultas más complejas sea muy difícil de
computar.
SQL
Como se especifica en la sección anterior toda base de datos requiere de un lenguaje para
manejar los datos guardados. Para las bases de datos relacionales usarás el SQL. MySQL es una
implementación específica de este lenguaje (otras implementaciones son Sqlite y PostgresQL).
Examinarás los fundamentos del SQL en el Álgebra Relacional para después mostrar la estructura
general del lenguaje lo que nos va a permitir generar consultas.
Álgebra relacional
El Álgebra Relacional es la estructura que te va a permitir operar y manipular las diferentes
relaciones. Las operaciones que realicemos con las relaciones deberán resultar en una relación
también. Esta propiedad de cerradura la tiene el Álgebra Relacional.

Computación II
A todas las expresiones del Álgebra relacional la denominarás query o consulta. Las operaciones
del Álgebra Relacional caen en cuatro diferentes conjuntos:
1. Operaciones Estándar: Unión, Intersección y Diferencia
2. Operaciones de Filtrado: Selección y Proyección
3. Operaciones para Combinar: Producto y Join
4. Operaciones Neutras: Renombrado de tablas
Estas operaciones, aunque limitadas, serán la base y las que más pueden usarse para extraer datos
de una base de datos.
Si 𝑅 y 𝑆 son un par de relaciones que cumplen con tener el mismo esquema, es decir, el mismo
conjunto de atributos. Las operaciones de unión, intersección y diferencia se definen de la forma
que sigue:
- Unión 𝑅 ∪ 𝑆: Es el conjunto de todas las tuplas 𝑞 tal que 𝑞 ∈ 𝑅 o 𝑞 ∈ 𝑆. La unión presenta

al elemento 𝑞 únicamente una vez.
- Intersección 𝑅 ∩ 𝑆: Es el conjunto de todas las tuplas 𝑞 tal que 𝑞 ∈ 𝑅 y 𝑞 ∈ 𝑆.
- Diferencia 𝑅 − 𝑆: Es el conjunto de todas las tuplas 𝑞 tal que 𝑞 ∈ 𝑅 pero 𝑞 ∉ 𝑆. Esta
operación no es conmutativa ya que la diferencia 𝑆 − 𝑅 puede diferir completamente la
original.
Considera el siguiente ejemplo. Si tuviéramos dos relaciones 𝑃 y 𝑄 con el siguiente esquema:

pasajeros( #pasajero, nombre, edad, sexo )
#pasajero nombre edad sexo #pasajero nombre edad sexo
2343 Ernesto 35 H 7638 Elena 45 m
3241 Juan 16 H 5372 Andrés 21 h
8723 Alicia 78 M 8323 Ofelia 34 m
8323 Ofelia 34 M 2343 Ernesto 35 h
𝑃 𝑄
Entonces la Union, Intersección y Diferencia de estas tablas son

#pasajero Nombre Edad sexo #pasajero nombre edad sexo
2343 Ernesto 35 h 2343 Ernesto 35 h
3241 Juan 16 h 8323 Ofelia 34 m
8723 Alicia 78 m 𝑃∩𝑄

Computación II
7638 Elena 45 m
5372 Andrés 21 h
8323 Ofelia 34 m
𝑃∪𝑄
#pasajero nombre edad sexo
3241 Juan 16 h
87 3 Alicia 78 m
𝑃−𝑄
Las operaciones de proyección y selección ayudan a filtrar relaciones imponiendo alguna condición
- Proyección: Se 𝑃 es una relación entonces la proyección de 𝑃, denotada como
𝜋𝑎1 ,𝑎2 ,…,𝑎𝑛 (𝑅), forma una nueva relación pero con una selección de los atributos que la
componen, a saber únicamente los atributos {𝑎1 , 𝑎2 , … , 𝑎𝑛 }. En otras palabras,
seleccionamos únicamente algunos de los atributos que constituyen 𝑃.
- Selección: Si 𝑄 es una relación válida entonces el operador de selección produce una nueva
relación pero seleccionando algunas tuplas (o registros) de 𝑃. La denominamos 𝜎𝐶 (𝑄)
donde 𝐶 es una condición lógica válida aplicable a 𝑄.
Ejemplo
Si 𝑃 es la misma relación antes definida, la proyección que toma únicamente los atributos si haces
la proyección de los atributos #empleado y sexo tendrías que hacerlo de la siguiente manera:
𝜋#𝑒𝑚𝑝𝑙𝑒𝑎𝑑𝑜,𝑒𝑑𝑎𝑑 (𝑃)
y el resultado sería
#empleado Edad
2343 35
3241 16
8723 78
8323 34

Computación II
Y si haces la selección sobre la tabla 𝑅 = 𝑃 ∪ 𝑄 de todos los pasajeros que sean mayores de edad
la selección se especifica cómo.
𝜎𝑒𝑑𝑎𝑑≥18 (𝑅)
y lo que obtienes se expresa en la siguiente tabla
#pasajero nombre edad sexo
2343 Ernesto 35 h
8723 Alicia 78 m
7638 Elena 45 m
5372 Andrés 21 h
8323 Ofelia 34 m
𝜎𝑒𝑑𝑎𝑑≥18 (𝑅)
Un refinamiento más podría ser la proyección sobre la selección anterior para obtener únicamente
la edad y el sexo. Es decir, obtener la edad y el sexo de los pasajeros que sean mayores de edad
sobre la unión de 𝑃 ∪ 𝑄.
𝜋#𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜,𝑠𝑒𝑥𝑜,𝑒𝑑𝑎𝑑 (𝜎𝑒𝑑𝑎𝑑≥18 (𝑃 ∪ 𝑄))
con lo que obtienes
#pasajero edad sexo
2343 35 h
8723 78 m
7638 45 m
5372 21 h
8323 34 m
Un refinamiento más sobre esa última relación sería seleccionar aquellos pasajeros que sean
mujeres. La expresión quedaría como
𝜋#𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜,𝑠𝑒𝑥𝑜,𝑒𝑑𝑎𝑑 (𝜎𝑒𝑑𝑎𝑑≥18∧𝑠𝑒𝑥𝑜=′𝑚′ (𝑃 ∪ 𝑄))

Computación II
Y los datos seleccionados quedan como:
#pasajero edad sexo
8723 78 m
7638 45 m
8323 34 m
Las operaciones con las que hemos trabajado hasta ahora nos permiten refinar los datos en alguna
relación, pero usualmente estarás trabajando con dos o más relaciones heterogéneas, entonces
requieres alguna operación que te permita conformar tablas donde no necesariamente ambas
contienen los mismos atributos, es decir vas a necesitar extender las relaciones con atributos
contenidos en otra relación., por ejemplo, nosotros tenemos una tabla pasajeros y otra destinos,
podríamos requerir conocer a que destino viajaron todos los pasajeros mayores de 60 años.
Esto lo lleva a cabo la operación de producto, si 𝑃 y 𝑄 son tablas cuyos esquemas no

necesariamente comparten atributos, entonces denotamos al producto como 𝑃 × 𝑄 de tal forma
que se forme la tupla (𝑝, 𝑞) donde 𝑝 ∈ 𝑃 y 𝑞 ∈ 𝑄. Suponiendo que estas tablas tengan atributos
en común y quisieras referirte a ellos sin temor a equivocarte, necesitas entonces alguna forma
de referenciarlos, para tal efecto usarás el operador (punto), por ejemplo 𝑃. #𝑒𝑚𝑝𝑙𝑒𝑎𝑑𝑜 se refiere
a la columna #𝑒𝑚𝑝𝑙𝑒𝑎𝑑𝑜 de la relación 𝑃.
En el siguiente ejemplo podemos ver el producto de las relaciones presentadas 𝑋 e 𝑌 y la tabla

resultado 𝑋 × 𝑌. Los esquemas para ambas relaciones es el mismo, solo cuentan con un atributo
denominado coordenada.
coord coord. 𝑿. 𝒄𝒐𝒐𝒓𝒅 𝒀. 𝒄𝒐𝒐𝒓𝒅

1 -1 1 -1
2 -2 1 -2
4 -3 1 -3
𝑋 𝑌 2 -1
2 -2
2 -3
3 -1
3 -2
3 -3
𝑋×𝑌

Computación II
Cuando al extender tablas suele ser muy común que ambas compartan atributos y al hacer el
producto requieras que el resultado se restrinja a aquellos valores que son iguales en las
columnas compartidas. A esta operación lo llamamos join (más específicamente natural join
pero como no verás otro tipo puedes identificarlo únicamente como join).
Si 𝑅, 𝑆 son relaciones cuyos esquemas son
𝑅(𝑎1 , … , 𝑎𝑛 , 𝑟1 , … , 𝑟𝑚 )
𝑆(𝑎1 , … , 𝑎𝑛 , 𝑠1 , … , 𝑠𝑡 )
entonces el join de 𝑆, 𝑅 lo denotas por 𝑅 ⋈ 𝑆 y la relación cuyo esquema es
𝑅 ⋈ 𝑆(𝑎1, … , 𝑎𝑛 , 𝑟1 , … , 𝑟𝑚 , 𝑠1 , … , 𝑠𝑡 )
y las tuplas que lo conforman son el subconjunto de tuplas de 𝑅 × 𝑆 que cumplen con 𝑅. 𝑎1 =
𝑆. 𝑎1 , … , 𝑅. 𝑎𝑛 = 𝑆. 𝑎𝑛
Ejemplo.
Si tienes un par de relaciones 𝑃, 𝑄 definidas como se presenta a continuación, entonces su join sería
como se presenta en la última tabla, donde el atributo por el cuál se unen es V.
K V V A B K P.V Q.V A B
1 5 5 6 8 1 5 5 6 8
2 6 8 2 9 3 8 8 2 9
3 8
𝑃 𝑄 𝑃⋈𝑄
Otro ejemplo más práctico es el de una hipotética aerolínea. Si tenemos las tablas pasajeros, vuelos
y destinos cuyos esquemas son y tuplas son:
pasajeros(#pasajero, #vuelo, nombre, edad, sexo)
destinos(#destino, país, estado, nombre)
vuelos(#vuelo, origen, destino, salida, arribo)

#pasajero #vuelo nombre edad sexo #destino país estado nombre
2343 334 Ernesto 35 h 1 México Oaxaca Puerto

Escondido
3241 432 Juan 16 h
2 Brasil Sao Paulo Sao Paulo

Computación II
8723 432 Alicia 78 m 3 China Pekín Muralla
7638 113 Elena 45 m 4 México Nuevo Monterrey

León
5372 435 Andrés 21 h
destinos
8323 113 Ofelia 34 m
Pasajeros
#vuelo origen destino salida arribo
113 3 2 7:00 21:00
421 1 3 10:00 04:00
435 1 2 16:00 10:00
442 1 4 20:00 21:00
443 4 1 14:00 15:00
334 2 1 13:00 23:00
321 4 2 15:00 01:00
450 2 4 20:00 10:00
116 3 1 11:00 05:00
Vuelos
El join que resulta de unir las relaciones pasajeros (P) y vuelos (V) a través del atributo (#vuelo)
queda como sigue
#pasajero P.#vuelo nombre edad sexo V.#vuelo origen destino salida arribo
2343 334 Ernesto 35 h 334 2 1 13:00 23:00
3241 432 Juan 16 h 435 1 2 16:00 10:00
5372 435 Andrés 21 h 334 2 1 13:00 23:00
5372 435 Andrés 21 h 435 1 2 16:00 10:00
7638 113 Elena 45 m 443 4 1 14:00 15:00
8323 113 Ofelia 34 m 113 3 2 7:00 21:00
8323 113 Ofelia 34 m 116 3 1 11:00 05:00
8723 432 Alicia 78 m 442 1 4 20:00 21:00

Computación II
En este punto puedes pensar en combinar los operadores de proyección para simplificar la
presentación del join recién hecho, por ejemplo, puedes quedarte únicamente con #pasajero,
P.#vuelo, nombre, edad, origen, destino, salida y arribo. La formulación de la proyección anterior
es:
𝑆𝑒𝑎 𝐶 = {#𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜, 𝑃. #𝑣𝑢𝑒𝑙𝑜, 𝑛𝑜𝑚𝑏𝑟𝑒, 𝑒𝑑𝑎𝑑, 𝑜𝑟𝑖𝑔𝑒𝑛, 𝑑𝑒𝑠𝑡𝑖𝑛𝑜, 𝑠𝑎𝑙𝑖𝑑𝑎, 𝑎𝑟𝑟𝑖𝑏𝑜}

𝑅 ← 𝜋𝐶 (𝑃 ⋈ 𝑉)
Con lo que obtienes
#pasajero P.#vuelo nombre edad origen destino salida arribo

2343 334 Ernesto 35 2 1 13:00 23:00
3241 432 Juan 16 1 2 16:00 10:00
5372 435 Andrés 21 2 1 13:00 23:00
5372 435 Andrés 21 1 2 16:00 10:00
7638 113 Elena 45 4 1 14:00 15:00
8323 113 Ofelia 34 3 2 7:00 21:00
8323 113 Ofelia 34 3 1 11:00 05:00
8723 432 Alicia 78 1 4 20:00 21:00
Y si quisieras seleccionar a los mayores de 21 años sobre la relación 𝑅 entonces la formulación

es:
𝜎𝑒𝑑𝑎𝑑>21 (𝑅)
Los datos no se muestran porque solo basta con contar a los 5 elementos que cumplen con esta
condición en el conjunto de tuplas recién presentado.
Nota: Los joins pueden ser por cualquier atributo, de hecho el Natural Join es un caso particular
de un Theta-Join que une tablas bajo cualquier restricción arbitraria. Para el ejemplo que acabas
de ver el Theta-Join fue sobre el atributo #vuelo y su expresión es con el símbolo ⋈𝐴 donde A es
el atributo por el que estamos uniendo. Para el ejemplo visto 𝜋𝐶 (𝑃 ⋈#𝑣𝑢𝑒𝑙𝑜 𝑉) obtiene
exactamente la misma relación.
Las operaciones de renombrado de tablas tienen como fin facilitar la manipulación de los
resultados obtenidos, de hecho las hemos estado usando, por ejemplo al renombrar la tabla vuelos
por V. No requieren mayor explicación por su trivialidad.

Computación II
Estructura
Las implementaciones de SQL se basan en la especificación del mismo lenguaje. Este lenguaje se
va a encargar de todas las necesidades previstas en la especificación de las bases de datos para
sus lenguajes, esto es, el SQL se encargará de:
- Definición de datos: Creación de tablas, bases de datos y vistas.

- Manejo de datos: Inserción y actualización de datos así como de las restricciones
impuestas a cada uno de ellos.
- Consultas: Selección de datos con diferentes restricciones
A partir de este momento estaremos hablando indistintamente de SQL o de la implementación

que revisaremos que es MySQL.
Definición de datos
Para definir una base de datos en SQL la forma general es la siguiente.
Dentro de la especificación de sintaxis siguiente observarás que el nombre de las instrucciones o

palabras reservadas se encuentra en negritas mientras que los metasímbolos se encuentran
<encerrados en llaves>, es decir, estos son las representaciones símbolos que luego tomarán un
valor específico, en otras palabras son variables por definir. Los valores opcionales los
definiremos entre corchetes, i.e. [opción].
𝒄𝒓𝒆𝒂𝒕𝒆 𝒅𝒂𝒕𝒂𝒃𝒂𝒔𝒆 < 𝑛𝑜𝑚𝑏𝑟𝑒_𝑏𝑎𝑠𝑒 >
Por ejemplo para nuestra base de datos que se llamará aerolínea la instrucción es
createdatabase aerolínea
Para crear las tablas o relaciones que la integran, cuyos nombres son vuelos, pasajeros y destinos
utilizarás la instrucción
𝒄𝒓𝒆𝒂𝒕𝒆 𝒕𝒂𝒃𝒍𝒆 < 𝑛𝑜𝑚𝑏𝑟𝑒_𝑡𝑎𝑏𝑙𝑎 > ( < 𝑙𝑖𝑠𝑡𝑎_𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜𝑠 > )
Como puedes observar la lista de atributos va encerrada entre paréntesis y cada uno de estos se
define
< 𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜 >∶= < 𝑛𝑜𝑚𝑏𝑟𝑒_𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜 >< 𝑡𝑖𝑝𝑜_𝑑𝑒_𝑑𝑎𝑡𝑜 > [𝒏𝒐𝒕 𝒏𝒖𝒍𝒍]
Alguno de los tipos de datos más usados por MySQL son:
Numéricos: SMALLINT, INTEGER, INT, BIGINT, BOOLEAN, DECIMAL, FLOAT,

DOUBLE

Computación II
Fecha y Hora: DATE, DATETIME, TIME, TIMESTAMP, YEAR

Cadenas: CHAR, VARCHAR, BLOB
En el caso de la tabla destinos
CREATE TABLE destinos (
id_destinoCHAR(1) NOT NULL,
paisVARCHAR(10) NOT NULL,
estadoVARCHAR(10) NOT NULL,
nombreVARCHAR(20) NOT NULL,
PRIMARY KEY (id_destino)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Puedes ver que en la tabla anterior hay una instrucción que comienza con las palabras reservadas
“PRIMARY KEY” (al cual nos referiremos para abreviar como PK). Esta instrucción recibe el
nombre de un campo para el cual vas a identificar unívocamente a todos los registros de la tabla,
es decir, el nombre del campo asociado a PK debe ser único, por lo tanto id_destino no
puede repetirse en la tabla.
Para la tabla vuelos la definición queda como
CREATE TABLE vuelos (

id_vueloVARCHAR(4) NOT NULL,
origenCHAR(1) NOT NULL,
destinoCHAR(1) NOT NULL,
salidaTIME NOT NULL,
arriboTIME NOT NULL,
PRIMARY KEY (id_vuelo),
CONSTRAINT `fk_destino` FOREIGN KEY (origen) REFERENCES
destinos (id_destino) ON DELETE RESTRICT ON UPDATE CASCADE,
CONSTRAINT `fk_origen` FOREIGN KEY (destino) REFERENCES
destinos (id_destino) ON DELETE RESTRICT ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Los archivos que contienen estas instrucciones y las que insertan una serie de datos para probar las
puedes descargar el sitio, se llaman aerolínea.sql y aerolínea_datos.sql. La forma
de ejecutar estos archivos .sql desde el símbolo del sistema es la siguiente
C:\> mysql –u checo –p < aerolinea.sql

Computación II
Esto crea la base de datos
C:\> mysql –u checo –p < aerolinea_datos.sql
Esta última instrucción agrega los datos
Los archivos .sql son scripts que contienen instrucciones válidas de MySQL y se ejecutan línea
por línea.
Ambos archivos los puedes bajar de la carpeta Material de Apoyo correspondiente a la unidad 2.
En este caso puedes observar que después de la definición de PK hay dos instrucciones que
comienzan con CONSTRAINT. Estas líneas especifican una restricción sobre la base de datos,
cada una tiene un nombre (fk_destino y fk_origen) y después la restricción específica.
En ambos casos esa restricción es la aplicación de una llave foránea y lo que va a hacer es checar
la consistencia del campo especificado y en que tabla está ese valor, el último modificador dice
en qué casos va a checar la consistencia.
Específicamente la restricción fk_destino se define por
FOREIGN KEY (origen) REFERENCES destinos (id_destino) ON DELETE

RESTRICT ON UPDATE CASCADE
Es decir, el campo “origen” hace referencia a la tabla “destinos” en el campo de esta tabla
llamada “id_destino” y el chequeo se va a hacer cuando se hagan borrados o actualizaciones.
Automáticamente se hacen cuando se insertan datos.
Ahora, las tablas están compuestas por atributos con cierto dominio, para especificar cada uno de
estos
No olvides poner especial atención en que partes de código expuesto hay comas (,), puntos y
comas (;) o ningún carácter al final de la instrucción.
Manejo de datos
Dentro de las instrucciones para hacer el correcto manejo de datos se encuentran las instrucciones
INSERT, UPDATE y DELETE. Adicionalmente también están las instrucciones para alterar la
estructura de una tabla y esto lo puede lograr la instrucción ALTER.
Consultas
La consulta de los datos es la tarea más frecuente cuando se usa una base de datos. La instrucción
que puede hacer esto es la instrucción SELECT detallada en las siguientes secciones

Computación II
Condiciones
Una parte importante de cualquier lenguaje es la implementación de operadores condicionales y

una instrucción particular para computar estas restricciones.
Los operadores de comparación de SQL se definen en la siguiente tabla, podrás ver que incluimos
un operador denominado IS, este verifica que su argumento sea efectivamente un valor booleano,
por ejemplo IS TRUE regresa 1.
Función Operador
Igualdad =
Mayor, Mayor Igual >, >=
Menor, Menor Igual <, <=
Distinto <>
Valor de verdad de operador booleano IS <booleano | nulo>, IS NOT <booleano | nulo>
Dentro de los operadores lógicos tenemos

Función Operador
AND, && Conjunción
OR, || Disyunción
NOT, !
La instrucción es WHERE cuya definición es

𝑾𝑯𝑬𝑹𝑬 < 𝑝𝑟𝑒𝑑𝑖𝑐𝑎𝑑𝑜 >
Donde <condición> se expresa como
< 𝑝𝑟𝑒𝑑𝑖𝑐𝑎𝑑𝑜 >≔ < 𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜 > 𝑂𝑃𝑐𝑜𝑚𝑝 < 𝑣𝑎𝑙𝑜𝑟

> {𝐴𝑁𝐷|𝑂𝑅|𝑁𝑂𝑇 < 𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜 > 𝑂𝑃𝑐𝑜𝑚𝑝 < 𝑣𝑎𝑙𝑜𝑟 > }
En donde 𝑂𝑃𝑐𝑜𝑚𝑝 es alguno de los operadores de comparación. Entonces la cláusula WHERE es

la combinación de átomos que constan de un valor, un operador de comparación y un valor para
comparar. Los siguientes son ejemplos de cómo puede usarse la instrucción WHERE

Computación II
WHERE fecha_salida > WHERE destino = ’1’ WHERE país <> ‘Mèxico’
’2013-02-23’
(2) (3)
(1)
La razón por la que se está describiendo un apartado para WHERE es porque permite seleccionar
tuplas con el criterio especificado y esta selección de tuplas le sirve tanto a la instrucción
SELECT, como a UPDATE o DELETE.
Consultas y subconsultas
La instrucción más importante para SQL es la instrucción SELECT. Esta se encarga de mostrar los
datos requeridos en pantalla en forma de tablas.
Su sintaxis es
SELECT [DISTINCT | UNIQUE] < atributos >
FROM <tablas>
[WHERE <condición>]
Donde la especificación de <atributos> es como sigue
<atributos> := * | [<relación>.]<atributo> [[<relación],]

<atributo>]
Es decir, el valor de <atributos> puede ser o bien un asterisco, o bien una lista de atributos
separados por comas, o bien una cada una de estas relaciones puede estar precedida por el nombre
de la relación terminada por un punto.
Por ejemplo, si quisieras listar todos los vuelos la instrucción sería
SELECT * FROM vuelos;
O bien podríamos querer únicamente la columna id_vuelo de la misma relación
SELECT id_vuelo FROM vuelos;
Si quieres la proyección sobre la tabla de pasajeros que recupera los atributos id_pasajero y sexo,
entonces las siguientes tres relaciones son equivalentes para la consulta
𝜋𝑖𝑑_𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜,𝑠𝑒𝑥𝑜 (𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜𝑠)

Computación II
SELECT id_pasajero, sexo FROM pasajeros
SELECT pasajeros.id_pasajero,pasajeros.sexo FROM pasajeros
SELECT p.id_pasajero, p.sexo FROM pasajeros P
En la última instrucción utilizamos un alias para la tabla pasajeros en la que la renombramos como
P y así es como la referenciamos dentro de la consulta.
Si lo que queremos es hacer una selección sobre esa proyección en la que escojamos a todos los
hombres tenemos que hacer uso de la cláusula WHERE y fijar el valor sexo=’h’. La selección en
álgebra relacional queda como
𝜎𝑠𝑒𝑥𝑜=′ ℎ′ (𝜋𝑖𝑑_𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜,𝑠𝑒𝑥𝑜 (𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜𝑠))
Y traducida a SQL queda como
SELECT P.id_pasajero, P.sexo FROM pasajeros P WHERE p.sexo=’h’
Si lo que queremos es la proyección sobre los atributos id_vuelo, origen y destino de la tabla
vuelos pero siempre y cuando los vuelos salgan en el medio día su fórmula en el álgebra
relacional es
𝜎𝑠𝑎𝑙𝑖𝑑𝑎>00:00∧ 𝑠𝑎𝑙𝑖𝑑𝑎<12:00 (𝜋𝑖𝑑_𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜,𝑜𝑟𝑖𝑔𝑒𝑛,𝑑𝑒𝑠𝑡𝑖𝑛𝑜 (𝑣𝑢𝑒𝑙𝑜𝑠))
SELECT id_vuelo, origen, destino, salida

FROM vuelos
WHERE salida > '00:00:00' AND salida <='12:00:00';
Puedes usar el operador UNION cuya sintaxis es
< 𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛1 > 𝑼𝑵𝑰𝑶𝑵 < 𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛2 >
Cuya restricción es que el número de columnas en cada relación sea el mismo. Por ejemplo
SELECT id_vuelo AS c1, destino AS c2 FROM vuelos

UNION
SELECT id_pasajero AS c1, nombre AS c2 FROM pasajeros
Pero todas estas consultas están completamente limitadas a la selección y proyección sobre una
sola tabla. Si quisieras hacer el producto de dos relaciones entonces el átomo FROM debe
contener todas las relaciones de dónde vas a hacer nuestro producto. En un ejemplo anterior

Computación II
seleccionas algunos valores sobre las relaciones pasajeros y vuelos. Si quisieras todo el producto
entre ambas relaciones, su fórmula en álgebra relacional queda como
𝑣𝑢𝑒𝑙𝑜𝑠 × 𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜𝑠
Y en SQL lo tenemos que expresar de la forma
SELECT * FROM vuelos, pasajeros;
Pero esto no sería de gran utilidad ya que estarías formando tuplas que no guardan relación
alguna entre ellas, recuerda que el producto de dos relaciones es el producto cruz entre ellas.
Algo de más utilizad es formar un WHERE en el que ligas un par de atributos entre ambas tablas,
por ejemplo
SELECT * FROM vuelos, pasajeros WHERE nombre=’Ernesto’ AND

destino=’3’;
Así al restringir la consulta a restricciones en atributos de cada una de las tablas consultadas el
subconjunto de tuplas en la consulta será un poco más interesante que simplemente listarlas
todas. Pero como viste en la sección anterior, una forma de hacer un producto es hacer un natural
join.
Natural Joins
Si hacemos la consulta
SELECT * FROM vuelos, pasajeros;
Pero ligando los datos que son comunes entre ambas relaciones de la siguiente forma
SELECT * FROM vuelos, pasajeros WHERE vuelos.id_vuelo =

pasajeros.id_vuelo;
Entonces restringirás nuestra consulta a todos aquellos pasajeros que realmente volaron en una
fecha dada. Esto es en esencia un natural join, pero MySQL se encarga de hacerlo con una
instrucción predestinada para tal efecto, y es la cláusula JOIN. Su uso se ilustra haciendo el join
anterior.
SELECT * FROM vuelos V JOIN pasajeros P ON (V.id_vuelo =

P.id_vuelo);
La sintaxis queda clara a partir de este ejemplo, en la cláusula FROM seleccionas la primera tabla
JOIN la segunda tabla con quien queramos relacionarla para después especificar la llave de cada
tabla por la que se hace el join. Si quieres extender ese resultado obtenido para cruzarla con los

Computación II
detalles que nos puede ofrecer la tabla destinos entonces tenemos que hacer otro join, pero como
la tabla obtenida
SELECT * FROM vuelos V JOIN pasajeros P ON (V.id_vuelo = P.id_vuelo)

JOIN destinos D ON (D.id_destino = V.origen);
Con esta consulta obtendrías todos los atributos comunes a las tuplas que tengan en común el
número de vuelo en las tablas vuelos y pasajeros y a su vez en común el id_destino en la tabla
destinos con el valor de origen en la tabla vuelos.
Actualizaciones y borrado
Las principales instrucciones para hacer la actualización de datos de datos en una tabla son las
instrucciones INSERT y UPDATE. Estas instrucciones tienen por finalidad el insertar y
actualizar datos en alguna tabla cuidando la integridad de los datos.
El caso particular del INSERT tiene la siguiente sintaxis
𝑰𝑵𝑺𝑬𝑹𝑻 < 𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛 > 𝑽𝑨𝑳𝑼𝑬𝑺 (< 𝑙𝑖𝑠𝑡𝑎_𝑑𝑒_ 𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜𝑠 >)
En este caso la lista de atributos debe ir en el mismo orden en el que están definidos la secuencia
de datos en la relación, por ejemplo, las tres sentencias que siguen insertan datos en las tablas
especificadas de forma correcta
INSERT INTO destinos VALUES ('2', 'Brasil', 'Sao Paulo', 'Sao

Paulo');
INSERT INTO vuelos VALUES ('435', '1', '2', '16:00', '10:00');
INSERT INTO pasajeros VALUES ('3241', '435', 'Juan', '16', 'h');
Si los datos no existen entonces la secuencia de ejecución de estas tres instrucciones no lanzará
ningún error ya que en la tabla destinos el campo id_destino está marcado como llave
primaria, esto quiere decir que no puede existir otro destino que tome el valor 2 en el campo
id_destino. Como en la tabla vuelos el campo destino está marcado como llave foránea
(FOREIGN KEY) entonces la inserción del vuelo 435 (cuyo valor debe ser único por la misma
razón que en la tabla vuelos) será posible de llevarse a cabo. Para finalizar con la última
instrucción que también agrega una tupla que debe ser única según su llave id_pasajero pero
que también checa que el vuelo con id_vuelo = 435 exista ya que de otra manera se lanzará
un error de consistencia de datos.
Otra forma alternativa para usar la instrucción INSERT es como sigue:

Computación II
𝑰𝑵𝑺𝑬𝑹𝑻 < 𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛

> (< 𝑙𝑖𝑠𝑡𝑎_𝑑𝑒_𝑛𝑜𝑚𝑏𝑟𝑒_𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜𝑠 >) 𝑽𝑨𝑳𝑼𝑬𝑺(< 𝑙𝑖𝑠𝑡𝑎_𝑑𝑒_ 𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜𝑠 >)
Esta forma permite variar el orden en el que se pasan los datos a meter a la tabla. Por ejemplo
INSERT INTO destinos (pais, estado, nombre, id_destino) VALUES ('La

Habana', 'Cuba', 'La Habana', '5');
En el siguiente ejemplo puedes ver la tabla antes y después de este INSERT.

SELECT * FROM destinos;
+------------+-----------+-----------+------------------+
| id_destino | pais | estado | nombre |
+------------+-----------+-----------+------------------+
| 1 | México | Oaxaca | Puerto Escondido |
| 2 | Brasil | Sao Paulo | Sao Paulo |
| 3 | China | Pekín | Muralla |
| 4 | México | Nvo León | Monterrey |
+------------+-----------+-----------+------------------+
4 rows in set (0.00 sec)
(a)
SELECT * FROM destinos;
+------------+-----------+-----------+------------------+
| id_destino | pais | estado | nombre |
+------------+-----------+-----------+------------------+
| 1 | México | Oaxaca | Puerto Escondido |
| 2 | Brasil | Sao Paulo | Sao Paulo |
| 3 | China | Pekín | Muralla |
| 4 | México | Nvo León | Monterrey |
| 5 | La Habana | Cuba | La Habana |
+------------+-----------+-----------+------------------+
(b)
Como puedes ver el INSERT es esencialmente el mismo excepto que esta vez los datos a insertar
pasan ordenados como se especifica después de la tabla.
La otra instrucción dedicada a hacer actualizaciones en la base de datos es precisamente la

instrucción UPDATE. Su sintaxis es
𝑼𝑷𝑫𝑨𝑻𝑬 < 𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛 > 𝑺𝑬𝑻 < 𝑙𝑖𝑠𝑡𝑎_𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜𝑠 > 𝑊𝐻𝐸𝑅𝐸 < 𝑝𝑟𝑒𝑑𝑖𝑐𝑎𝑑𝑜 >
donde la lista de atributos debe contener el atributo a cambiar y el nuevo valor.

Computación II
< 𝑙𝑖𝑠𝑡𝑎_𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜𝑠 >≔ < 𝑛𝑜𝑚𝑏𝑟𝑒_𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜 >=< 𝑣𝑎𝑙𝑜𝑟

> {, < 𝑛𝑜𝑚𝑏𝑟𝑒_𝑎𝑡𝑟𝑖𝑏𝑢𝑡𝑜 >=< 𝑣𝑎𝑙𝑜𝑟 >}
Por ejemplo la lista de pasajeros actual es
mysql> select * from pasajeros;
+-------------+----------+-----------+------+------+
| id_pasajero | id_vuelo | nombre | edad | sexo |
+-------------+----------+-----------+------+------+
| 2343 | 334 | Ernesto | 35 | h |
| 3241 | 435 | Juan | 16 | h |
| 5372 | 334 | Andrés | 21 | h |
| 5372 | 435 | Andrés | 21 | h |
| 7638 | 443 | Elena | 45 | m |
| 8323 | 113 | Ofelia | 34 | m |
| 8323 | 116 | Ofelia | 21 | h |
| 8723 | 442 | Alicia | 78 | m |
+-------------+----------+-----------+------+------+
Si quisieras actualizar a todos los pasajeros cuyo nombre es Ernesto por Ernestina y su sexo de
‘h’ a ‘m’ entonces la instrucción debería ser
UPDATE pasajeros SET nombre='Ernestina', sexo='m' WHERE

nombre='Ernesto';
SELECT * FROM pasajeros;

+-------------+----------+-----------+------+------+
+-------------+----------+-----------+------+------+
| 2343 | 334 | Ernestina | 35 | m |
| 3241 | 435 | Juan | 16 | h |
| 5372 | 334 | Andrés | 21 | h |
| 5372 | 435 | Andrés | 21 | h |
| 7638 | 443 | Elena | 45 | m |
| 8323 | 113 | Ofelia | 34 | m |
| 8323 | 116 | Ofelia | 21 | h |
| 8723 | 442 | Alicia | 78 | m |
+-------------+----------+-----------+------+------+
O bien si quieres actualizar todos aquellas edades de 21 a 31 lo que tienes que hacer es

Computación II
UPDATE pasajeros SET edad='31' WHERE edad='21';
Lo que transforma nuestra tabla en el siguiente conjunto de datos
SELECT * FROM pasajeros;
+-------------+----------+-----------+------+------+
+-------------+----------+-----------+------+------+
| 2343 | 334 | Ernestina | 35 | m |
| 3241 | 435 | Juan | 16 | h |
| 5372 | 334 | Andrés | 31 | h |
| 5372 | 435 | Andrés | 31 | h |
| 7638 | 443 | Elena | 45 | m |
| 8323 | 113 | Ofelia | 34 | m |
| 8323 | 116 | Ofelia | 31 | h |
| 8723 | 442 | Alicia | 78 | m |
+-------------+----------+-----------+------+------+
Nota: UPDATE es una instrucción que puede alterar uno o todos los datos y que no
necesariamente requiere de un predicado WHERE para poder ser usado, esto quiere decir que la
instrucción
UPDATE t1 SET c=valor_nuevo;
Va a cambiar todos los valores anteriores por valor_nuevo en el atributo c de la tabla t1. Si esto
no era lo que querías hacer es posible que pierdas información, tiempo, recursos y todo lo que
esto conlleva. Como consejo, cuando vayas a hacer una actualización en una tabla escribe
UPDATE WHERE
y después completa la información requerida. Si tu actualización no requiere del predicado

WHERE, es decir, aplica a toda la tabla (aspecto más bien raro) puedes usar el predicado
WHERE ‘1’ o simplemente borrar la palabra WHERE. Pero si tu actualización no aplicaba a toda
la tabla y presionas enter entonces fallará y no perderás nada.
Este consejo aplica idéntico para DELETE.
La última instrucción para actualizar la información en una tabla es la de borrado de tuplas, esta
instrucción es DELETE y su sintaxis es muy parecida a la de UPDATE.
𝑫𝑬𝑳𝑬𝑻𝑬 𝑭𝑹𝑶𝑴 < 𝑟𝑒𝑙𝑎𝑐𝑖ó𝑛 > 𝑾𝑯𝑬𝑹𝑬 < 𝑝𝑟𝑒𝑑𝑖𝑐𝑎𝑑𝑜 >

Computación II
Si la tabla de donde estás borrando la tupla tiene definida una llave foránea en otra tabla entonces
obtendrás un error de integridad en los datos, por ejemplo
mysql> DELETE FROM destinos WHERE id_destino='1';

ERROR 1451 (23000): Cannot delete or update a parent row: a foreign
key constraint fails (àerolinea`.`vuelos`, CONSTRAINT
`fk_destino` FOREIGN KEY (òrigen`) REFERENCES `destinos`
(ìd_destino`) ON UPDATE CASCADE)
Este error aparece principalmente porque el destino con id_destino=’1’ está referenciado en otra
tabla, particularmente la de vuelos, es por esto que no se nos permite borrarlo. Si en cambio no
existe ninguna referencia a la tupla que estás borrando en otra tabla entonces no hay problema
para hacerlo. Como el destino con id_destino=’5’ no está referenciado en ninguna otra tabla
entonces su borrado es directo.
mysql> DELETE FROM destinos WHERE id_destino='5';

Query OK, 1 row affected (0.16 sec)
Cierre de la unidad
Con esta unidad has terminado la asignatura de Computación II. Toda esta asignatura giró alrededor
de lo que son los datos, la información y como se manipulan y almacenan.
Este tipo de algoritmos puede ayudarte a indagar un poco más sobre conceptos como información,
aprendizaje computacional, teoría de la información, inteligencia computacional y minería de
datos. En general esta unidad acabas de ver un panorama más o menos ilustrativo de cómo es la
síntesis y almacenamiento de datos.
Fuentes de consulta
MacKay, D. J. (2003). Information theory, inference and learning algorithms. . Cambridge

university press.

Computación II
Witten, I. H. (2005). Data Mining: Practical machine learning tools and techniques. Morgan
Kaufmann.
Grassmann, W. K., &Tremblay, J. P. (1996). Logic and discrete mathematics(Vol. 1). Upper
Saddle River, New Jersey: Prentice Hall.
Garcia-Molina, H., Ullman, J. D., &Widom, J. (2000). Database system implementation (Vol.
654). Upper Saddle River, NJ:: Prentice Hall.

MCOM2 U3 Contenido

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

MCOM2 U3 Contenido

Cargado por

Copyright:

Formatos disponibles

Matemáticas

Universidad Abierta y a Distancia de México

UnADM | DCEIT | MT | MCOM2 2

En la unidad pasada revisamos la introducción y funcionamiento de algunos algoritmos para poder

Otro aspecto muy importante y paralelo a la predicción de datos es el almacenamiento de

• Presentar una síntesis de los datos

• Conocer el concepto de bases de datos

• Almacenar la información en una base de datos

UnADM | DCEIT | MT | MCOM2 3

A continuación presentaremos una serie de esquemas comunes

De esta forma se garantiza que al recorrer todo el conjunto en la fase de entrenamiento no

UnADM | DCEIT | MT | MCOM2 4

El método de Bootstrap es el mismo que se usa en estadística usualmente. Lo que se hace es

UnADM | DCEIT | MT | MCOM2 5

𝐸𝑡𝑜𝑡𝑎𝑙 = 0.632 ∗ 𝐸𝑝𝑟𝑢𝑒𝑏𝑎 + 0.368 ∗ 𝐸𝑒𝑛𝑡𝑟𝑛𝑎𝑚𝑖𝑒𝑛𝑡𝑜

- Una estructura de datos

Panorama en los modelos de datos

UnADM | DCEIT | MT | MCOM2 7

UnADM | DCEIT | MT | MCOM2 8

La relación con tres registros es

En este ejemplo anterior la relación es de grado 6, su cardinalidad es de 3 y la llave es el atributo

UnADM | DCEIT | MT | MCOM2 9

UnADM | DCEIT | MT | MCOM2 10

- Unión 𝑅 ∪ 𝑆: Es el conjunto de todas las tuplas 𝑞 tal que 𝑞 ∈ 𝑅 o 𝑞 ∈ 𝑆. La unión presenta

Considera el siguiente ejemplo. Si tuviéramos dos relaciones 𝑃 y 𝑄 con el siguiente esquema:

#pasajero nombre edad sexo #pasajero nombre edad sexo

2343 Ernesto 35 H 7638 Elena 45 m

3241 Juan 16 H 5372 Andrés 21 h

8723 Alicia 78 M 8323 Ofelia 34 m

8323 Ofelia 34 M 2343 Ernesto 35 h

Entonces la Union, Intersección y Diferencia de estas tablas son

2343 Ernesto 35 h 2343 Ernesto 35 h

3241 Juan 16 h 8323 Ofelia 34 m

8723 Alicia 78 m 𝑃∩𝑄

UnADM | DCEIT | MT | MCOM2 11

#pasajero nombre edad sexo

UnADM | DCEIT | MT | MCOM2 12

y lo que obtienes se expresa en la siguiente tabla

#pasajero nombre edad sexo

𝜋#𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜,𝑠𝑒𝑥𝑜,𝑒𝑑𝑎𝑑 (𝜎𝑒𝑑𝑎𝑑≥18 (𝑃 ∪ 𝑄))

con lo que obtienes

#pasajero edad sexo

𝜋#𝑝𝑎𝑠𝑎𝑗𝑒𝑟𝑜,𝑠𝑒𝑥𝑜,𝑒𝑑𝑎𝑑 (𝜎𝑒𝑑𝑎𝑑≥18∧𝑠𝑒𝑥𝑜=′𝑚′ (𝑃 ∪ 𝑄))

UnADM | DCEIT | MT | MCOM2 13

Y los datos seleccionados quedan como:

#pasajero edad sexo

Esto lo lleva a cabo la operación de producto, si 𝑃 y 𝑄 son tablas cuyos esquemas no

En el siguiente ejemplo podemos ver el producto de las relaciones presentadas 𝑋 e 𝑌 y la tabla

coord coord. 𝑿. 𝒄𝒐𝒐𝒓𝒅 𝒀. 𝒄𝒐𝒐𝒓𝒅

UnADM | DCEIT | MT | MCOM2 14

entonces el join de 𝑆, 𝑅 lo denotas por 𝑅 ⋈ 𝑆 y la relación cuyo esquema es

pasajeros(#pasajero, #vuelo, nombre, edad, sexo)

destinos(#destino, país, estado, nombre)

vuelos(#vuelo, origen, destino, salida, arribo)

2343 334 Ernesto 35 h 1 México Oaxaca Puerto

UnADM | DCEIT | MT | MCOM2 15

7638 113 Elena 45 m 4 México Nuevo Monterrey

#vuelo origen destino salida arribo

113 3 2 7:00 21:00

421 1 3 10:00 04:00

435 1 2 16:00 10:00

442 1 4 20:00 21:00

443 4 1 14:00 15:00