Metodología de Diseño (Paso 9): Pasar al estándar de la base de datos (SQL)

Clase 24 de 63 • Fundamentos de Bases de Datos 2017

Ivan Robles

student•

Paso 9: Pasar al estándar de la base de datos (SQL)

create table, crea una tabla.
alter table, modifica una tabla existente.

Tabla Pasajero

create table Pasajero (
Pasajero_ID int not null auto_increment,
Nombre_P varchar(30) not null,
Pasaporte varchar(15),
ContactoEmergencia varchar(40) not null,
primary key (Pasajero_ID)
);

Tabla Aerolinea_Pasajero

create table Aerolinea_Pasajero (
Pasajero_ID int not null,
Aerolinea_ID int not null,
ViajeroFrecuente numeric(12,0),
primary key (Pasajero_ID, Aerolínea_ID)
);

Generalmente cuando creamos las tablas se hacen con un orden especifico, si creamos primero Aerolinea_Pasajero, se va a referir a una tabla que no existe. Esto nos da un error de consistencia.
Se recomienda hacer alter table, para cambiar los esquemas al final.

Editando la tabla Aerolinea_Pasajero

alter table Aerolinea_Pasajero ADD
constraint FK_Aerolinea_Pasajero
foreign key (Pasajero_ID) 
references Pasajero (Pasajero_ID);

Andric Alejandro Vargas Alarcón

student•

Excelente aporte, solo te falto indicar que era basado en MySQL, y uno que otro espacio en " Not null"

Camilo Acevedo Escalante

student•

Hola, muy buen aporte, tambien recuerda que se requiere especificar como buena práctica el mecanismo de almacenamiento que va a utilizar la tabla al momento de crearla, ya sea InnoDB o MyISAM.

Saludos!

Camilo Caquimbo Tabares

student•

Una herramienta clave en este paso es utilizar programas como MySQL Workbench (https://www.mysql.com/products/workbench/) que generan el código SQL a partir de los diagramas

Cesar David Ramírez Dimaté

student•

Así es.

Juan Camilo Álvarez Muñoz

student•

Muchas gracias por el aporte

Camilo Acevedo Escalante

student•

Hola

Se debe tener en cuenta que primaria la creación de las entidades fuertes para que las entidades debiles al momento de ser creadas y “referencian” las llaves de las primeras, no se llegue al error de que las segundas no encuentran a quien hacen referencia. Logicamente que en el momento que se realiza el alter se esta evitando dicho inconveniente.

A modo de concepto personal, se podrian realizar la creación inicialmente de las entidades fuertes y despues las entidades debiles para asi evitar esos casos que se pueden presentar.

Y también podemos crear las entidades y en el momento de crearlas definir las llaves foraneas dentro del bloque del create table.

EJM

//CREAMOS LA ENTIDAD FUERTE "CLIENTE"
CREATE TABLE CLIENTE
(
//ATRIBUTOS DE LA ENTIDAD
id_cliente int not null,
nombre_cliente varchar(30) not null,
PRIMARY KEY (id_cliente)
)engine=innodb; //AQUI ESTAMOS DECLARANDO EL MECANISMO DE ALMACENAMIENTO

CREATE TABLE VENTA
(
//ATRIBUTOS DE LA ENTIDAD, FIJARSE QUE SE CREO UN id_cliente
id_factura int not null,
id_cliente int not null,
cantidad int,
PRIMARY KEY (id_factura),
FOREIGN KEY(id_cliente) REFERENCES CLIENTE(id_cliente)
)engine=innodb;

La linea del FOREIGN KEY lo que indica es que el primer id_cliente pertenece o se creo en la tabla VENTA y es una llave foranea que a hacer referencia (REFERENCES), en la tabla o entidad CLIENTE a la llave primaria id_cliente.

Ya para finalizar en ambas tablas se declara el mecanismo de almacenamiento que en su defecto si no se declara lo toma con InnoDB, aunque existe otro el cual es MyISAM. Se recomienda una vez establecido uno, mantener este para las demás entidades.

Saludos!

José Samuel Aguilar Morales

student•

Ojo, te faltan espacios en las consultas, como Create table o id_cliente int not null

Camilo Acevedo Escalante

student•

Gracias! eso veo, pero no es consulta, es DDL

Saludos!

Cesar David Ramírez Dimaté

student•

Hago las siguientes observaciones:

El campo numeric(12, 0) NO EXISTE en MySQL. El que existe es el tipo de dato decimal(12, 0).
El orden de ejecución en SQL es secuencial, así que sí podrias definir las entidades fuertes primero y luego la entidad débil sin tener que utilizar ALTER TABLE después para las FK.
Es una buena práctica definir el esquema de almacenamiento de la tabla. Ya sea InnoDB ó MyISAM.
Es una buena práctica definir un INDEX para las llaves foráneas.
Para que no queden registros huérfanos, es bueno definir el ON DELETE NO ACTION y ON DELETE NO ACTION. Lo que hará es que si la tabla hace referencia a un campo de otra tabla creará una restricción para que no se pueda ni eliminar ni actualizar este campo específico.

-- -----------------------------------------------------
-- Table `basics_bd`.`Aerolina`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `basics_bd`.`Aerolina` (
  `idAerolinea` INT NOT NULL AUTO_INCREMENT,
  `nombre` VARCHAR(20) NOT NULL,
  `fechaInicio` TIMESTAMP NULL,
  PRIMARY KEY (`idAerolinea`))
ENGINE = InnoDB;


-- -----------------------------------------------------
-- Table `basics_bd`.`Pasajero`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `basics_bd`.`Pasajero` (
  `idPasajero` INT NOT NULL AUTO_INCREMENT,
  `nombre` VARCHAR(30) NOT NULL,
  `pasaporte` VARCHAR(15) NULL,
  `contactoEmergencia` VARCHAR(40) NOT NULL,
  PRIMARY KEY (`idPasajero`))
ENGINE = InnoDB;


-- -----------------------------------------------------
-- Table `basics_bd`.`Aerolina_Pasajero`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `basics_bd`.`Aerolina_Pasajero` (
  `idAerolinea` INT NOT NULL,
  `idPasajero` INT NOT NULL,
  `viajeroFrecuente` DECIMAL(12,0) NULL,
  PRIMARY KEY (`idAerolinea`, `idPasajero`),
  INDEX `fk_Aerolina_Pasajero_Pasajero_idx` (`idPasajero` ASC),
  INDEX `fk_Aerolina_Pasajero_Aerolina_idx` (`idAerolinea` ASC),
  CONSTRAINT `fk_Aerolina_Pasajero_Aerolina`
    FOREIGN KEY (`idAerolinea`)
    REFERENCES `basics_bd`.`Aerolina` (`idAerolinea`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION,
  CONSTRAINT `fk_Aerolina_Pasajero_Pasajero`
    FOREIGN KEY (`idPasajero`)
    REFERENCES `basics_bd`.`Pasajero` (`idPasajero`)
    ON DELETE NO ACTION
    ON UPDATE NO ACTION)
ENGINE = InnoDB;

Rafael Jair Sanchez Alviso

student•

Los 9 paso para diseñar nuestra base de datos son:
Paso 1
Identificar cuales entidades resuelven nuestro problema.

Paso 2 Cardinalidad
Identificar las relaciones de las Entidades. Recuerda que la relación es en ambos sentidos.

Paso 3
En este paso vamos a plasmar las entidades y relaciones en un diagrama conceptual.

Paso 4
Asignamos atributos a nuestras entidades.
Debemos decidir cuales son llaves, obligatorios o no obligatorios. También es preciso que no repitamos los nombre, podemos usar algún tipo dd nomenclatura para evitar eso (AV_nom).

Paso 5
En este paso ya generamos nuestro diagrama conceptual con nuestras entidades, relaciones y atributos.

Paso 6
Pasamos nuestro diagrama conceptual al diagrama lógico.

Paso 7
Identificar nuevos atributos en mis entidades débiles que se generaron en el paso 6.

Paso 8
Pasar nuestro diagrama lógico al diagrama físico.

Paso 9
Pasar al estándar de la base de datos (SQL).

Jorge Heli Rueda Uribe

student•

Excelente compilación de los 9 pasos. Ya los apunté en mi cuaderno. Muchas gracias.

Carlos Rebeiz Quiceno Becerra

student•

Mis entidades del proyecto:

CREATE TABLE tab_paises(
    pa_id SERIAL NOT NULL,
    pa_code VARCHAR(10) NOT NULL,
    pa_name VARCHAR(50) NOT NULL,
  PRIMARY KEY(pa_id)
);

CREATE TABLE tab_ciudades(
    pa_id BIGINT NOT NULL,
    ci_id SERIAL NOT NULL,
    ci_code VARCHAR(10) NOT NULL,
    ci_name VARCHAR(50) NOT NULL,
  PRIMARY KEY(pa_id, ci_id),
  FOREIGN KEY(pa_id) REFERENCES tab_paises(pa_id)
);

CREATE TABLE tab_aeropuertos(
    pa_id BIGINT NOT NULL,
    ci_id BIGINT NOT NULL,
    ae_id SERIAL NOT NULL,
    ae_code VARCHAR(10) NOT NULL,
    ae_name VARCHAR(50) NOT NULL,
    ae_address VARCHAR(255) NOT NULL,
    ae_phone VARCHAR(15),
    ae_foundation_date TIMESTAMP,
  PRIMARY KEY(pa_id, ci_id, ae_id),
  FOREIGN KEY(pa_id) REFERENCES tab_paises(pa_id),
  FOREIGN KEY(ci_id) REFERENCES tab_ciudades(ci_id)
);

CREATE TABLE tab_aerolineas(
    aer_id SERIAL NOT NULL,
    aer_name VARCHAR(50) NOT NULL,
    aer_phone VARCHAR(15) NOT NULL,
    aer_foundation_date TIMESTAMP,
  PRIMARY KEY(aer_id)
);

CREATE TABLE tab_aviones(
    ae_id BIGINT NOT NULL,
    aer_id BIGINT NOT NULL,
    av_id SERIAL NOT NULL,
    av_matricula VARCHAR(20) NOT NULL,
    av_placa VARCHAR(20) NOT NULL,
    av_number_seats INTEGER NOT NULL,
  PRIMARY KEY(ae_id, aer__id, av_id),
  FOREIGN KEY(ae_id) REFERENCES tab_aeropuertos(ae_id),
  FOREIGN KEY(aer_id) REFERENCES tab_aerolineas(aer_id)
);

CREATE TABLE tab_pilotos(
    pa_id BIGINT NOT NULL,
    pi_id SERIAL NOT NULL,
    pi_identificacion VARCHAR(15) NOT NULL,
    pi_firtsname VARCHAR(50) NOT NULL,
    pi_lastname VARCHAR(50) NOT NULL,
    pi_license VARCHAR(25) NOT NULL,
    pi_fly_hours DECIMAL(10,2),
    pi_birth_date DATE NOT NULL,
  PRIMARY KEY(pi_id),
  FOREIGN KEY(pa_id) REFERENCES tab_paises(pa_id)
);

CREATE TABLE tab_tripulantes(
    pa_id BIGINT NOT NULL,
    tri_id SERIAL NOT NULL,
    tri_identificacion VARCHAR(15) NOT NULL,
    tri_firtsname VARCHAR(50) NOT NULL,
    tri_lastname VARCHAR(50) NOT NULL,
    tri_license VARCHAR(25) NOT NULL,
    tri_fly_hours DECIMAL(10,2),
    tri_birth_date DATE NOT NULL,
  PRIMARY KEY(tri_id),
  FOREIGN KEY(pa_id) REFERENCES tab_paises(pa_id)
);

CREATE TABLE tab_pasajeros(
    pa_id BIGINT NOT NULL,
    pas_id SERIAL NOT NULL,
    pas_card_number VARCHAR(15) NOT NULL,
    pas_firtsname VARCHAR(50) NOT NULL,
    pas_lastname VARCHAR(50) NOT NULL,
    pas_passport VARCHAR(25),
    pas_emergency_contact VARCHAR(50),
    pas_emergency_number VARCHAR(15),
    pas_birth_date DATE NOT NULL,
  PRIMARY KEY(tri_id),
  FOREIGN KEY(pa_id) REFERENCES tab_paises(pa_id)
);

CREATE TABLE tab_rutas(
    ru_id SERIAL NOT NULL,
    ru_pa_id_begin BIGINT NOT NULL,
    ru_ci_id_begin BIGINT NOT NULL,
    ru_pa_id_end BIGINT NOT NULL,
    ru_ci_id_end BIGINT NOT NULL,
    ru_day_hour_begin TIMESTAMP NOT NULL,
    ru_day_hour_end TIMESTAMP NOT NULL,
    ru_range DECIMAL(5,2) NOT NULL,
  PRIMARY KEY(ru_id),
  FOREIGN KEY(ru_pa_id_begin, ru_ci_id_begin) REFERENCES tab_ciudades(pa_id, ci_id),
  FOREIGN KEY(ru_pa_id_end, ru_ci_id_end) REFERENCES tab_ciudades(pa_id, ci_id),
  FOREIGN KEY(ru_pa_id_begin) REFERENCES tab_paises(pa_id),
  FOREIGN KEY(ru_pa_id_end) REFERENCES tab_paises(pa_id)
);

Cesar David Ramírez Dimaté

student•

Realmente NO recomiendo colocar un alias de la tabla en cada atributo, ya que eso lo puedes manejar en las consultas SQL.

De igual manera que utilices el prefijo tab_ ya sobra, porque en sí ya te refieres a una tabla.

SELECT a.nombre, a.fechaInicio, p,nombre, p.pasaporte FROM Aerolina AS a, Pasajero AS p;

Hans Piña

student•

Se lee HORRIBLE con esos prefijos 😦 Usa alias mejor.

Saúl Báez Terrez

student•

Mal video! Me molesta mucho que aunque el instructor se equivoque, no se hayan tomado la molestia al menos de poner algún mensaje flotante para indicarlo y así no confundirte. Además, los archivos del proyecto no coinciden con lo que se ha ido viendo en el transcurso del curso. Este curso pide a gritos 1 estrella, no se porque tiene tan buena valoración si realmente no lo merece

orlando morales andrade

student•

Estoy de acuerdo, hay varias cosas por mejorar.... parece que la cadena publicitaria efecto platzi se riega sin sentido critico. Igual el curso me ha servido, pero nuevamente faltan varias cosas por mejorar. Saludos comunidad.

Joaquin Araujo

student•

Hay paises que tienen acuerdos para no exigirle pasaportes a ciertas nacionalidades, antes los Venezolanos podíamos visitar Colombia<3 solo con la cédula de indentidad Venezolana, ya no:ccc

Daniel Hernandez

student•

Alguien me puede explicar para que sirve alter table, por favor

Ricardo Celis

teacher•

hola! claro que sí, este comando sirve y se utiliza para agregar, borrar o modificar columnas en una tabla existente =)

Daniel Hernandez

student•

¿Y cuando quiera modificar una tabla debo utilizar este comando o esto depende?

Erick Neftalí Sarmiento Cortes

student•

¿Perdón en que editor esta escribiendo?, ¿es necesario uno especial o en cualquiera escribo?

Diego Forero

Team Platzi•

Cualquier editor te sirve, el usa notepad++ porque esta en windows, pero puedes usar cualquiera.

Erick Neftalí Sarmiento Cortes

student•

ok gracias

Claudio Jesus Vázquez Villanueva

student•

Díganme si estoy mal pero los DDL van en mayúsculas no?

David Toca

student•

No es necesario, de hecho en SQL no hay diferencia entre mayusculas y minusculas.

Alexander Román

student•

pueden ir en minuscula o mayuscula

edwar enrique vilchez serrano

student•

create table aerolinea(
aerolinea_id int(5) not null auto_increment,
nombre_aerolinea varchar(50) not null,
tipo varchar(15),
modelo varchar(40) not null,
primary key(aerolinea_id)
);

Daniel Blasco Marcos

student•

¿Que Notepad está usando el profesor?

Laszlo Caputo Adam

student•

Notepad++

Diego Forero

Team Platzi•

El usa este editor https://notepad-plus-plus.org/

Daniel Cadavid

student•

 Vamos a usar el sql de mysql
 Las tablas se deben crear en un orden especifico, primero se deben crear las entidades fuertes y luego las débiles para no generar errores de consistencia
 Vamos a crear la tabla pasajero asi
Créate table PASAJERO
(
PASAJERO_ID int not null auto_increment,
NOMBRE_P varchar (30) not null,
PASAPORTE varchar (30),
CONTACTO_EMERGENCIA varchar (40) not null,
Primary key (PASAJERO_ID)
);
 En el punto anterior los atributos se colocaron dentro del paréntesis, cada uno es separado por coma, además está conformado por NOMBRE_ATRIBUTO tipo de campo (varchar), especificación de si es obligatorio y no (Not null es obligatorio, cuando no es obligatorio no se escribe not null); Una vez declaramos todos los atributos en la sintaxis especificada pasamos a definir la llave primaria para finalmente cerrar la tabla creada con cierre de paréntesis y un punto y coma
 Vamos a crear la entidad débil AEROLINEA_PASAJERO asi:
Créate table AEROLINEA_PASAJERO
(
PASAJERO_ID int not null,
AEROLINEA_ID int not null,
VIAJEROFRECUENTE numeric (12,0),
Primary key (PASAJERO_ID, AEROLINEA_ID)
);

Alter table AEROLINEA_PASAJERO add constraint FK_AEROLINEA_PASAJERO foreign key (PASAJERO_ID) referencies PASAJERO (PASAJERO_ID);

 El alter table sirve para modificar las tablas agregando campos o cambiando la definición de los campos (creación de llaves foráneas) También sirve para especificar sus respectivas relaciones con las llaves primarias que corresponde. El anterior alter table se traduciría así: en la tabla AEROLINEA_PASAJERO agregar como llave foránea en la tabla FK_AEROLINEA_PASAJERO el atributo (PASAJERO_ID) y establecer una relación con la llave principal (PASAJERO_ID) de la tabla PASAJERO
 El alter table no funcionaría si las tablas que se usan no se han creado previamente
 Con Mysql workbench se puede codificar un diagrama de base de datos, se puede descargar en https://www.mysql.com/products/workbench/
 Es una buena práctica definir el esquema de almacenamiento de la tabla ya sea InnoDB o MyISAM con el comando “engine = InnoDB”
 Es una buena práctica definir Index para las llaves foráneas
 Para que sublime text reconozca la sintaxis de SQL debemos ir a tolls / command Palette / escribir sql / dar clic en set sintax SQL
 Para realizar operaciones en una base de datos relacionales es importante tener claros los siguientes conceptos:

DDL (Data Definition Language): Permite crear y modificar la estructura de una base de datos.
CREATE: Utilizado para crear nuevas tablas, campos e índices.
ALTER: Utilizado para modificar las tablas agregando campos o cambiando la definición de los campos.
DROP: Empleado para eliminar tablas e índices.
TRUNCATE: Empleado para eliminar todos los registros de una tabla.
COMMENT: Utilizado para agregar comentarios al diccionario de datos.
RENAME: Tal como su nombre lo indica es utilizado para renombrar objetos.

DML (Data Manipulation Language): Permite recuperar, almacenar, modificar, eliminar, insertar y actualizar datos de una base de datos.
SELECT: Utilizado para consultar registros de la base de datos que satisfagan un criterio determinado.
INSERT: Utilizado para cargar de datos en la base de datos en una única operación.
UPDATE: Utilizado para modificar los valores de los campos y registros especificados
DELETE: Utilizado para eliminar registros de una tabla de una base de datos.

DCL (Data Control Language): Permite crear roles, permisos e integridad referencial, así como el control al acceso a la base de datos.
GRANT: Usado para otorgar privilegios de acceso de usuario a la base de datos.
REVOKE: Utilizado para retirar privilegios de acceso otorgados con el comando GRANT.

TCL (Transactional Control Language): Permite administrar diferentes transacciones que ocurren dentro de una base de datos.

COMMIT: Empleado para guardar el trabajo hecho.
ROLLBACK: Utilizado para deshacer la modificación que hice desde el último COMMIT.

Diego Omar Sandoval Velazco

student•

La verdad uno tiene que tener previo conocimiento del lenguaje y no es como pensaba que era desde cero que lastima

Victor Sánchez Jáuregui

student•

No te desanimes! Si sigues el curso desde el principio con calma todas las dudas se van aclarando! Pausa los videos cuantas veces lo necesites y has las consultas! entre todos vamos aprendiendo!

José Gálvez

student•

No hubiese sido mejor iniciar con un CREATE DATABASE ContAereo;

Julio Cesar Rico Suarez

student•

Mis scripts
-Falto la tabla aerolínea y el otro constraint

Noe Mikhael Huaccharaque Ruiz

student•

Como instalo SQL en ubuntu?

Diego Forero

Team Platzi•

SQL es Structured Query Language o lenguaje estructurado de consultas, quieres instalar un motor de base de datos como mysql?

Si es instalar mysql en ubuntu, este tutorial te puede servir https://www.digitalocean.com/community/tutorials/how-to-install-mysql-on-ubuntu-16-04

Cesar David Ramírez Dimaté

student•

Actualizar sistema
sudo apt-get update
Instalar MySQL y definir clave de root (root)
sudo apt-get install mysql-server mysql-client
Version de MySQL
mysql --version
Definir parámetros de seguridad
sudo mysql_secure_installation
- NO cambiar contraseña de root.
- SI Remover usuarios anónimos.
- NO deshabilitar login de manera remota.
- SI Remover la BD de prueba.
- SI Recargar los privilegios de las tablas.
Instalar MySQL Workbench
sudo apt-get install mysql-workbench
Configurar conexión
Name: Localhost
Hostname: 127.0.0.1
Port: 3306
Username: root
Password: contraseña_definida_instalacion.

Jose Luis Campos Bautista

student•

Pregunta.
¿Alguna otra forma de resolver las siguiente relación entre las tablas de partidos y equipos?

Diego Forero

Team Platzi•

Me parece la solución correcta ya que un equipo puede ser tanto local como visitante, y el manejo de la tabla horarios permite tener dos o mas partidos en el mismo horario, yo incluiría en la tabla partidos un campo que almacene la cancha donde se jugará el partido.

Jose Luis Campos Bautista

student•

Muchas gracias por tu ayuda @GOLLUM23.

Ricardo Celis

teacher•

https://github.com/peadiazmo/PlatziStore

Cesar David Ramírez Dimaté

student•

Y los archivos del proyecto actual del aeropuerto?

Usuario anónimo

user•

Si es una buena.

Metodología de Diseño (Paso 9): Pasar al estándar de la base de datos (SQL)

Introducción al Curso Fundamentos de Bases de Datos

¡Vamos a renovar este curso!

Introducción al Curso de Bases de Datos

Teoría general de Bases de Datos

Propósito general de las Bases de Datos

Tipos de Bases de Datos y sus aplicaciones en la industria

Visión general de los datos

Tipos de Datos

Diferentes tipos de Bases de Datos

Reto ¿Hadoop y Blockchain podrían cambiar una Base de Datos tradicional?

Bases de Datos Relacionales

¿Qué es una Entidad?

¿Qué es una Relación?

Características o datos de una Entidad

¿Ya aparecieron las llaves?

Índices e Indexación

Constraints o Restricciones

Capas de abstracción del modelo Entidad-Relación

Metodología básica de 9 pasos con Barker (Paso 1) Identificar Cuáles son las Entidades Resuelven Nuestro Problema

Metodología básica de 9 pasos con Barker (Paso 2): Identificación de las Relaciones de las Entidades.

Metodología básica de 9 pasos con Barker (Paso 3): Entidades y Relaciones

Metodología de Diseño (Correcciónes del paso 2 y 3)

Metodología de Diseño (Paso 4): Asignar Atributos a las Entidades.

Metodología de Diseño (Solución del paso 4): Terminando de Asignar Atributos a las Entidades

Metodología de Diseño (Pasos 5, 6 y 7) 5. Generar un diagrama conceptual, 6. Modelo lógico, 7. Identificar nuevos atributos que generan nuestras entidades débiles.

Metodología de Diseño (Paso 8): Construir el Diagrama del Modelo Físico

Metodología de Diseño (Paso 9): Pasar al estándar de la base de datos (SQL)

Reto con el paso 4 de la Metodología de Diseño

Bases de Datos NO Relacionales y Otros tipos de Bases de Datos

Atomicidad y consistencia

Aislamiento y durabilidad

Bases de Datos In-Memory (Cambio de árboles a columnar)

Otros tipos de Bases de Datos en la industria

Bases de Datos In-Memory con indexación de columnar

Definiendo el Proyecto y Generando Entidades de PlatziStore: Pasos 1 y 2

Definir la Estructura de la Tabla Cliente del Proyecto: Pasos 3 y 4

Terminando de Estructurar Nuestras Tablas (Continuación del paso 4)

Metodología de Diseño (Paso 5): Diagrama Conceptual

Metodología de Diseño (Paso 6 y 7): Modelo Lógico y Entidades Débiles

Solución de atributos de entidad del proyecto - Atributos adicionales a entidad débil creada

Metodología de Diseño (Paso 8)

Llevando nuestro proyecto a SQL (Paso 9)

Terminando la Implementación del Proyecto (Paso 9)

Dependencias funcionales

Normalización, llevando el proyecto hasta tercera forma normal (primera forma normal)

Normalización, llevando mi proyecto hasta tercera forma normal (segunda forma normal)

Normalización, llevando mi proyecto hasta tercera forma normal (Cuarta y quinta forma normal)

Comenzando con SQL

DDL: Data Definition Language y DML: Data Manipulation Language

ACID desde lo no relacional

CAP

Scale Out y Scale Up

¿Scale out o Scale up?

DBMS en nube para poder iniciar una aplicación propia

IMPORTANTE: Preparación del entorno de trabajo

Estructura básica de un Query

Aprendiendo a Hacer más Querys

Estructura básica del Query con más de una tabla

Estructura básica del Query con más de una tabla 2

Tuplas y más tuplas

Insertar registros

Joins

Noo SQL Aplicado, Planteando el Problema

Aplicando NoSQL: Colecciones y Shards

Aplicando noSQL: Integración de Comunicaciones y Hardware en una Base de Datos Scale OUT

Aplicando noSQL: Integrando JSON a Bases de Datos No Relacionales

Conclusiones del curso