Bienvenida conceptos b谩sicos y contexto hist贸rico de las Bases de Datos

1

Bienvenida conceptos b谩sicos y contexto hist贸rico de las Bases de Datos

Introducci贸n a las bases de datos relacionales

2

Historia de las bases de datos relacionales

3

Qu茅 son entidades y atributos

4

Entidades de Platzi Blog

5

Relaciones

6

M煤ltiples muchos

7

Diagrama ER

8

Diagrama F铆sico: tipos de datos y constraints

9

Diagrama F铆sico: normalizaci贸n

10

Formas normales en Bases de Datos relacionales

11

Diagrama F铆sico: normalizando Platziblog

RDBMS (MySQL) o c贸mo hacer lo anterior de manera pr谩ctica

12

Instalaci贸n local de un RDBMS (Windows)

13

驴Qu茅 es RDB y RDBMS?

14

Instalaci贸n local de un RDBMS (Mac)

15

Instalaci贸n local de un RDBMS (Ubuntu)

16

Clientes gr谩ficos

17

Servicios administrados

SQL hasta en la sopa

18

Historia de SQL

19

DDL create

20

CREATE VIEW y DDL ALTER

21

DDL drop

22

DML

23

驴Qu茅 tan standard es SQL?

24

Creando Platziblog: tablas independientes

25

Creando Platziblog: tablas dependientes

26

Creando Platziblog: tablas transitivas

Consultas a una base de datos

27

驴Por qu茅 las consultas son tan importantes?

28

Estructura b谩sica de un Query

29

SELECT

30

Playground: SELECT en SQL

31

FROM y SQL JOINs

32

Utilizando la sentencia FROM

33

WHERE

34

Utilizando la sentencia WHERE nulo y no nulo

35

GROUP BY

36

ORDER BY y HAVING

37

El interminable agujero de conejo (Nested queries)

38

驴C贸mo convertir una pregunta en un query SQL?

39

Pregunt谩ndole a la base de datos

40

Consultando PlatziBlog

Introducci贸n a la bases de datos NO relacionales

41

驴Qu茅 son y cu谩les son los tipos de bases de datos no relacionales?

42

Servicios administrados y jerarqu铆a de datos

Manejo de modelos de datos en bases de datos no relacionales

43

Top level collection con Firebase

44

Creando y borrando documentos en Firestore

45

Colecciones vs subcolecciones

46

Recreando Platziblog

47

Construyendo Platziblog en Firestore

48

Proyecto final: transformando tu proyecto en una db no relacional

Bases de datos en la vida real

49

Bases de datos en la vida real

50

Big Data

51

Data warehouse

52

Data mining

53

ETL

54

Business intelligence

55

Machine Learning

56

Data Science

57

驴Por qu茅 aprender bases de datos hoy?

Bonus

58

Bases de datos relacionales vs no relacionales

59

Elegir una base de datos

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

5D
16H
22M
17S

Creando Platziblog: tablas independientes

24/59
Recursos
  • Una buena pr谩ctica es comenzar creando las entidades que no tienen una llave for谩nea.
  • Generalmente en los nombres de bases de datos se evita usar e帽es o acentos para evitar problemas en los manejadores de las bases de datos.

Aportes 158

Preguntas 88

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

debimos haber establecido Unique tambien para el nickname

Por razones de buenas pr谩cticas de seguridad, el campo de password deber铆a permitir muchos m谩s caracteres para guardar una contrase帽a hasheada o cifrada de n bits.

Creaci贸n de la DB
Tablas independientes
Una buena practica a la hora de empezar a crear las entidades en una base de datos es comenzar con aquellas tablas independientes. Una tabla independiente es aquella que no posee atributos con llave for谩nea.
Nota: Recuerda que a la hora de crear una entidad, est谩 por convenci贸n se escribe en plural, puesto que denota un grupo de datos. Tambi茅n debe evitarse el uso de acentos a la hora de asignar nombres a la base de datos, entidades o atributos (帽, tildes, etc.), ya que pueden ocurrir algunos problemas.

/*creacion de base de datos PlatziBlog*/
create database PlatziBlog default character set utf8 ;

/*linia para utilizar PlatziBlog*/
use PlatziBlog;

/*construccion de tablas independientes*/
create table categorias
(
id int not null auto_increment,
nom_categoria varchar(30) not null,
constraint primary key (id)
);

create table etiquetas
(
id int not null auto_increment,
nom_etiquetas varchar(30) not null,
constraint primary key (id)
);

create table usuarios 
(
  id int not null auto_increment,
  login varchar(30) not null,
  pasword varchar(32) not null,
  nickname varchar(40) not null,
  email varchar(40) not null,
  primary key (id),
  unique key email_unique (email)
)

Lo hice en PostgreSQL:

CREATE TABLE categorias (
	id SERIAL PRIMARY KEY NOT NULL,
	name Varchar(30) NOT NULL
);

CREATE TABLE etiquetas (
	id SERIAL PRIMARY KEY NOT NULL,
	name VARCHAR(30) NOT NULL
);

CREATE TABLE usuarios (
	id SERIAL PRIMARY KEY NOT NULL,
	login VARCHAR(30) NOT NULL,
	password VARCHAR(32) NOT NULL,
	nickname VARCHAR(40) NOT NULL,
	email VARCHAR(255) NOT NULL UNIQUE
);

Para comenzar a pasar del diagrama f铆sico a la base de datos, seguir los siguientes pasos:
.

  1. Identificar las tablas que no tienen llave for谩nea (Tablas independientes), pues est谩n ser谩n las primeras en crearse.
  • Importante no colocar los ttulo de las tablas o nombre de la base de datos con e帽es, Mayusculas o Acentos.
    .
  1. Crear las tablas depesndientes, estas se conforman por las que si poseen llaves foraneas.
  • El comando 鈥渃ascade鈥 sirve para que cada que se haga un update en la tabla principal, se refleje tambi茅n en la tabla en la que estamos creando la relaci贸n.
    .
  1. Crear las tablas transitivas; Estas sirven como puente para unir dos tablas. No tienen contenido sem谩ntico.
  • Reverse Engineer nos reproduce el esquema del cual nos basamos para crear nuestras tablas. Es 煤til cuando llegas a un nuevo trabajo y quieres entender cu谩l fue la mentalidad que tuvieron al momento de crear las bases de datos.

A menos que se vayan a loguear con el email, login debe ser unique, no pueden haber dos usuarios con la misma informacion de login

Ejercicio

CREATE TABLE usuarios (
  id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
  login VARCHAR(30) NOT NULL,
  password VARCHAR(32) NOT NULL,
  nickname VARCHAR(40) NOT NULL,
  email VARCHAR(40) NOT NULL UNIQUE
);

CREATE TABLE categorias (
  id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
  nombre_categoria VARCHAR(30) NOT NULL
);

CREATE TABLE etiquetas (
  id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
  nombre_etiqueta VARCHAR(30) NOT NULL
);

Este es mi proyecto de una tienda online

Buen tip que da el profesor. Siempre empezar a crear las tablals que no tienen llaves for谩neas.

El campo login deber铆a ser 煤nico ya que, si usan autenticaci贸n v铆a username y password puede generar conflictos en caso de que dos usuarios tengan el mismo login.

phpMyAdmin es muy utilizado para administrar tablas en servidores remotos. Funciona parecido al MySQL Workbench.

El nickname, tambien deberia ser UNIQUE

Tan rapido se crea un proyecto y nosotros lo hicimos con puro codigo, nuestro profe nos ayudo mucho pero nos hizo sufrir sin editor grafico :c

++TUPLA: ++ Una tupla es una secuencia de valores agrupados que se separan por comas o parentesis.
Ejemplo

CREATE TABLE alumnos (
	nombre varchar(255),
	apellido varchar(255)
);

nombre y apellido son tuplas ya que estan separadas por comas.

Dejo aqu铆 nuevamente mi diagrama f铆sico, pero ahora con tipos y restricciones鈥

Otra forma de generar el ejercicio:

CREATE TABLE IF NOT EXISTS categorias (
	id INT NOT NULL AUTO_INCREMENT,
	nombre VARCHAR(30) NOT NULL,

	PRIMARY KEY (id)
);

CREATE TABLE IF NOT EXISTS etiquetas (
	id INT NOT NULL AUTO_INCREMENT,
	nombre VARCHAR(30) NOT NULL,

	PRIMARY KEY (id)
);

CREATE TABLE IF NOT EXISTS usuarios (
	id INT NOT NULL AUTO_INCREMENT,
	login VARCHAR(30) NOT NULL,
	password VARCHAR(32) NOT NULL,
	nickname VARCHAR(40) NOT NULL,
	email VARCHAR(40) NOT NULL UNIQUE,

	PRIMARY KEY (id)
);

En este caso el uso del UQ (unique) tambien se aplicar矛a a 鈥淣ickname鈥 ya que 2 usuarios no pueden tener el mismo nickname, estoy en lo correcto?

La columna password deber铆a ser un VARCHAR (255) y por seguridad ese campo debe guardarse en forma NEWID() como m茅todo de encriptaci贸n. Ya que la persona que maneje o tenga acceso a la BD no debe saber el password del usuario.

Quien mas ve los videos a 1.5x?? xd

驴Por convencion el nombre de la tabla(entidad) deberia estar en singular o en plural?. Habia escuchado que debia estar en plural pero no estoy seguro

Generalmente en los nombres de bases de datos se evita usar e帽es o acentos para evitar problemas en los manejadores de las bases de datos.

DUDA

En email ponemos NOT NULL y UNIQUE, 驴por qu茅 no poner simplemente PRIMARY KEY? se supone que esta es la combinaci贸n de ambas o estoy equivocado?

Muchas gracias!!

Les comparto mi ejemplo de otra manera de crear las tablas desde una Query.
Espero mi ejemplo les sea 煤til.
Trabajando en mi proyecto!!

CREATE TABLE kernels (
	id_kernels int NOT NULL AUTO_INCREMENT,
	kernel_name varchar(255) NOT NULL UNIQUE,
	PRIMARY KEY (id_kernels)
);

CREATE DATABASE IF NOT EXIST platziblog;

USE platziblog;

CREATE TABLE categories(
categories_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
categories_name VARCHAR(30) NOT NULL
);

CREATE TABLE labels(
label_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
label_name VARCHAR(30) NOT NULL
);

CREATE TABLE users(
user_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
user_login VARCHAR(30) NOT NULL,
user_password VARCHAR(32) NOT NULL,
user_nickname VARCHAR(40) NOT NULL,
user_email VARCHAR(40) NOT NULL UNIQUE
);

IMPORTANTE
Buenas practicas:
Siempre que guardemos informaci贸n sensible en una tabla (INSERT) hay que utilizar algoritmos de cifrado!

Insertar una contrase帽a con AES:
mysql> INSERT INTO usuarios VALUES('usuario',AES_ENCRYPT('contrase帽a','llave'));
Para desencriptar:
mysql> INSERT INTO usuarios VALUES('usuario',AES_DECRYPT('contrase帽a','llave'));```
 
Fuente: https://www.solingest.com/almacenar-contrasenas-en-mysql

Creo que al igual que email, tambi茅n el nickname deberia ser unique

siento que no soy el 煤nico que acelera la velocidad de reproducci贸n a 1.5x.

les recomiendo intentar hacerlo en SQL directamente, me sirvi贸 para practicar y reforzar.

BUENAS PRACTICAS PARA EL DISE脩O DE BASE DE DATOS
-El nombre de las tablas debe ser en may煤sculas o CamelCase.
-El nombre de las tablas debe ser en singular.
-El nombre de las tablas deben ser descriptivos, no importa que tan largos sean siempre y cuando sean soportados por la base de datos.
鈥揝i la tabla tiene m谩s de 2 palabras estas se deben poner juntas o con un gui贸n bajo, nunca se debe de usar espacios, ej 鈥楢PELLIDO_PATERNO鈥 .
-Si la tabla es una tabla muchos a muchos (multivaluada), se deben de utilizar los nombres de las tablas que generan la relaci贸n, deber谩n de ir con guiones bajos, ej 鈥榁ENDEDOR_CLIENTE鈥, 鈥榁ENDEDOR_CLIENTE_PRODUCTO鈥.
鈥揟odas las tablas deben de tener un Primary Key (PK) y debe de ser el primer campo de la tabla y debe de ser 煤nico e irrepetible.
鈥揈l nombre de los campos/columnas deben ser en singular.
-PK o llave primaria de todas las tablas debe de ser un entero (INT o BIGINT), es 煤nico, autoincremental, indexado y dependiendo del uso de la tabla, ser谩 ascendente o descendente, si es una tabla que genera muchos registros lo mejor ser铆a descendente.
https://videlcloud.wordpress.com

En heidi seria

CREATE TABLE `categoria` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`nombre_categoria` VARCHAR(30) NOT NULL DEFAULT '0' COLLATE 'utf8_spanish_ci',
	PRIMARY KEY (`id`)
)
COLLATE='utf8_spanish_ci'
ENGINE=InnoDB
;

CREATE TABLE `etiquetas` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`nombre_etiqueta` VARCHAR(30) NULL DEFAULT '0' COLLATE 'utf8_spanish_ci',
	PRIMARY KEY (`id`)
)
COLLATE='utf8_spanish_ci'
ENGINE=InnoDB
;

CREATE TABLE `usuario` (
	`id` INT(11) NOT NULL AUTO_INCREMENT,
	`login` VARCHAR(30) NULL DEFAULT NULL COLLATE 'utf8_spanish_ci',
	`password` VARCHAR(30) NULL DEFAULT NULL COLLATE 'utf8_spanish_ci',
	`nickname` VARCHAR(40) NULL DEFAULT NULL COLLATE 'utf8_spanish_ci',
	`email` VARCHAR(40) NULL DEFAULT NULL COLLATE 'utf8_spanish_ci',
	PRIMARY KEY (`id`),
	UNIQUE INDEX `email` (`email`)
)
COLLATE='utf8_spanish_ci'
ENGINE=InnoDB
;


para crear una tabla con m谩s de una columna unique:

CREATE TABLE usuarios(
	id INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
    	login VARCHAR(30) NOT NULL,
    	password VARCHAR(32) NOT NULL,
    	nickname VARCHAR(40) NOT NULL,
    	email VARCHAR(40) NOT NULL,
    	CONSTRAINT UC_usuarios UNIQUE(email, nickname)
);

categor铆a

CREATE TABLE categoria(
	id INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
    nombre_categoria VARCHAR(30) NOT NULL
);

etiquetas

CREATE TABLE etiquetas(
	id INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
    nombre_etiqueta VARCHAR(30) NOT NULL
);

usuarios

CREATE TABLE usuarios(
	id INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
    login VARCHAR(30) NOT NULL,
    password VARCHAR(32) NOT NULL,
    nickname VARCHAR(40) NOT NULL,
    email VARCHAR(40) NOT NULL,
    UNIQUE(email)
);

Estupenda clase instructor Israel, es cierto que es m谩s c贸modo crear primero las tablas que no tienen las llaves for谩neas, sin embargo tambi茅n se puede hacer la creaci贸n de todas las tablas de una vez, solo se debe tener en cuenta usar Alter posteriormente para colocar las llaves for谩neas.

Usando **ALTER ** pude modifica la propiedad **UNIQUE **que hab铆a olvidado asignar.

ALTER TABLE platzi_blog.usuarios ADD UNIQUE KEY (nickname);

2 CONSEJOS

  1. NICKNAME tambi茅n deber铆a ser unique porque no podemos ni debemos tener dos usuarios con el mismo nombre
  2. Para CERRAR tabs que se abren con Ctrl + W

驴es correcto tener como practica nombrar a los atributos con los nombres de la tabla?
Me explico, tenes muchos campos que se llaman ID, o similar entre tablas, entonces hacer lo siguiente:
categorias_id
etiquetas_id
etc

![](

mi proyecto personal

Creo que los nombres de las categorias y etiquetas tambi茅n deber铆an ser UNIQUE, pues debemos evitar datos repetidos en estos campos.
Gran curso 聽馃挌.

Me parece muy conveniente utilizar una convenci贸n de denominaci贸n de objetos con prefijos en la bases de datos. con el fin de que un desarrollador externo entienda el prop贸sito de cada objeto dentro de un proyecto, un ejemplo seria el siguiente:

interesante!

create database platziblog;

use platziblog; 

create table categorias(
id int not null auto_increment primary key,
categoria varchar(30) not null
);

create table etiquetas(
id int not null auto_increment primary key,
etiqueta varchar(30) not null
);

create table usuarios(
id int not null auto_increment primary key,
login varchar(30) not null,
password varchar(32) not null,
nickname varchar(40) not null,
email varchar(40) not null unique
);

驴Qu茅 siginifica?

(`email` ASC));

Pensando en la raz贸n del tip de creaci贸n de entidades que no tienen llaves for谩neas es para que cuando se vayan a crear las que s铆 tienen llaves for谩neas entonces el sistema ya pueda obtener esa llave de una entidad existente.

En WorkBench, con el diagrama podemos utilizar el concepto de ingenieria inversa, y generamos el archivo SQL

Para hacerlo en terminal

<CREATE TABLE categorias(id_categoria INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL, nombre_categoria VARCHAR(30) NOT NULL); 

CREATE TABLE etiquetas(id_etiquetas INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL, nombre_etiqueta VARCHAR(30) NOT NULL);


CREATE TABLE usuarios(id_usuario INTEGER PRIMARY KEY AUTO_INCREMENT NOT NULL, login VARCHAR(30) NOT NULL, password VARCHAR(32) NOT NULL, nickname VARCHAR(40) NOT NULL UNIQUE, email VARCHAR(40) NOT NULL UNIQUE);

> 

No s茅 a ustede spero en mi workbench al momento de crear la tabla me aparece la opci贸n de 鈥淓ngine鈥 (motor de almacenamiento) pero veo que en el cliente del profesor no le aparece esta opci贸n o al menos no est谩 visible. Si quieres conocer un poco m谩s de esto les dejo el siguiente enlace: Elige tu motor de almacenamiento MySQL.

Les dejo mi diagrama:

Veo muy innecesario el crear el campo login, ya que realmente el usuario realizara login cuando ingrese su nickname o email y la contrase帽a.

Yo lo probe en SQL SERVER y lo 煤nico que varia para esas sentencias es que no acpeta el caracter " ` " para los campos de los nombres.

Inicamos en el diagrama fisico

Creamos 5 entidades relacionales, cuando las tablas no tienen llaves foraneas ejemplo usuarios, categorias y etiquetas, empezamos por las que tienen menos datos,

  1. creamos un esquema: name: platzi blog
  2. Tomamos primero a 鈥渃ategorias鈥 con dos campos,
  3. Creamos la tabla
CREATE TABLE `Platziblog` .`categorias` (
`id` INT NOT NULL AUTO_INCREMENT,
`nombre_categoria` VARCHAR(30) NOT NULL,
PRIMARY KEY (`id`));
  1. Luego creamos la tabla 鈥淓tiquetas鈥:
CREATE TABLE `Platziblog` . `etiquetas` (
`id` INT NOT NULL AUTO_INCREMENT,
`nombre_etiqueta` VARCHAR(30) NOT NULL,
PRIMARY KEY (`id`));

  1. Ahora la tabla 鈥淯suarios鈥 no tiene una llave foranea, creamos esta llave para esta tabla,
CREATE TABLE `Platziblog` . `usaurios` (
`id` INT NOT NULL AUTO_INCREMENT,
`login` VARCHAR(30) NOT NULL,
`password` VARCHAR(32) NOT NULL,
`nickname` VARCHAR(40) NOT NULL,
`email` VARCHAR(40) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE INDEX `email_UNIQUE` (`email` ASC));
  1. Conviene siempre estar seguros de lo que se realizo revisando cada linea de codigo, constatando que lo realizado en el entorno grafico se trazable a las lineas de codigo.

  2. revisamos las tablas creadas en el entorno grafico.

Va mi aporte con mi ejercicio del museo.
y el script de creaci贸n: 鈥 borrando usuario
drop user 鈥淢USEO鈥 CASCADE;
鈥 Creando usuario SQL
CREATE USER museo IDENTIFIED BY "museo"
DEFAULT TABLESPACE "USERS"
TEMPORARY TABLESPACE 鈥淭EMP鈥;
鈥 Asignando quota en tablespace
ALTER USER museo QUOTA UNLIMITED ON USERS;

鈥 Asignando roles
GRANT 鈥淐ONNECT鈥 TO museo ;
GRANT CREATE TRIGGER TO museo ;
GRANT CREATE SESSION TO museo ;
GRANT CREATE TABLE TO museo ;
GRANT CREATE TABLESPACE TO museo ;

鈥 Creando tablas
CREATE TABLE museo.c_estadomunicipio (
id_entidad INTEGER NOT NULL,
d_entidad VARCHAR2(30),
id_entidadpadre INTEGER NOT NULL
);

ALTER TABLE museo.c_estadomunicipio ADD CONSTRAINT c_estadomunicipio_pk PRIMARY KEY ( id_entidad );

CREATE TABLE museo.c_estilocontruccion (
id_estilocontruccion INTEGER NOT NULL,
d_estiloconstruccion VARCHAR2(30 CHAR)
);

ALTER TABLE museo.c_estilocontruccion ADD CONSTRAINT id_estilocontruccion_pk PRIMARY KEY ( id_estilocontruccion );

CREATE TABLE museo.c_institucion (
id_institucion INTEGER NOT NULL,
d_institucion VARCHAR2(50 CHAR),
d_abreviadoinstitucion VARCHAR2(15 CHAR)
);

ALTER TABLE museo.c_institucion ADD CONSTRAINT c_institucion_pk PRIMARY KEY ( id_institucion );

CREATE TABLE museo.c_pais (
id_pais INTEGER NOT NULL,
d_pais VARCHAR2(20 CHAR)
);

ALTER TABLE museo.c_pais ADD CONSTRAINT c_pais_pk PRIMARY KEY ( id_pais );

CREATE TABLE museo.c_periodoartistico (
id_periodoartistico INTEGER NOT NULL,
anioinicio INTEGER,
aniofin INTEGER,
era CHAR(1)
);

ALTER TABLE museo.c_periodoartistico ADD CONSTRAINT c_periodoartistico_pk PRIMARY KEY ( id_periodoartistico );

CREATE TABLE museo.c_rolempleado (
id_rolempleado INTEGER NOT NULL,
d_rolempleado VARCHAR2(30)
);

ALTER TABLE museo.c_rolempleado ADD CONSTRAINT c_rolempleado_pk PRIMARY KEY ( id_rolempleado );

CREATE TABLE museo.c_tecnicas (
id_tecnica INTEGER NOT NULL,
d_tecnica VARCHAR2(150 CHAR)
);

ALTER TABLE museo.c_tecnicas ADD CONSTRAINT c_tecnicas_pk PRIMARY KEY ( id_tecnica );

CREATE TABLE museo.c_tipoasentamiento (
id_tipoasentamiento INTEGER NOT NULL,
d_tipoasentamiento VARCHAR2(25 CHAR)
);

ALTER TABLE museo.c_tipoasentamiento ADD CONSTRAINT id_tipoasentamiento_pk PRIMARY KEY ( id_tipoasentamiento );

CREATE TABLE museo.c_tipocoleccion (
id_tipocoleccion INTEGER NOT NULL,
d_tipocoleccion VARCHAR2(30)
);

ALTER TABLE museo.c_tipocoleccion ADD CONSTRAINT c_tipocoleccion_pk PRIMARY KEY ( id_tipocoleccion );

CREATE TABLE museo.c_tipoelementos (
id_tipoelemento INTEGER NOT NULL,
d_tipoelemento VARCHAR2(60 CHAR)
);

ALTER TABLE museo.c_tipoelementos ADD CONSTRAINT c_tipoelementos_pk PRIMARY KEY ( id_tipoelemento );

CREATE TABLE museo.c_tipoexpo (
id_tipoexpo INTEGER NOT NULL,
d_tipoexpo VARCHAR2(30 CHAR)
);

ALTER TABLE museo.c_tipoexpo ADD CONSTRAINT c_tipoexpo_pk PRIMARY KEY ( id_tipoexpo );

CREATE TABLE museo.c_tipomaterial (
id_tipomaterial INTEGER NOT NULL,
d_tipomaterial VARCHAR2(60 CHAR)
);

ALTER TABLE museo.c_tipomaterial ADD CONSTRAINT c_tipomaterial_pk PRIMARY KEY ( id_tipomaterial );

CREATE TABLE museo.c_tipopersona (
id_tipopersona INTEGER NOT NULL,
d_tipopersona VARCHAR2(60 CHAR),
b_tipoempleado CHAR(1),
id_rolempleado INTEGER NOT NULL,
id_jefeempleado INTEGER NOT NULL
);

ALTER TABLE museo.c_tipopersona ADD CONSTRAINT c_tipopersona_pk PRIMARY KEY ( id_tipopersona );

CREATE TABLE museo.c_usoactual (
id_usoactual INTEGER NOT NULL,
usoactual VARCHAR2(20),
observaciones VARCHAR2(255)
);

ALTER TABLE museo.c_usoactual ADD CONSTRAINT c_usoactual_pk PRIMARY KEY ( id_usoactual );

CREATE TABLE museo.coleccion (
id_coleccion INTEGER NOT NULL,
d_coleccion VARCHAR2(60 CHAR),
id_sede INTEGER NOT NULL
);

ALTER TABLE museo.coleccion ADD CONSTRAINT coleccion_pk PRIMARY KEY ( id_coleccion );

CREATE TABLE museo.elementos (
id_elementos INTEGER NOT NULL,
d_elemento VARCHAR2(30 CHAR),
d_descripcion LONG,
f_aquisicion DATE,
ancho FLOAT,
largo FLOAT,
peso FLOAT,
id_periodoartistico INTEGER NOT NULL,
id_pais INTEGER NOT NULL
);

ALTER TABLE museo.elementos ADD CONSTRAINT elementos_pk PRIMARY KEY ( id_elementos );

CREATE TABLE museo.exposicion (
id_exposicion INTEGER NOT NULL,
id_tipoexposicion INTEGER NOT NULL,
f_inicioexposicion DATE,
f_finexposicion DATE,
id_paisnacionalidad INTEGER NOT NULL
);

ALTER TABLE museo.exposicion ADD CONSTRAINT exposicion_pk PRIMARY KEY ( id_exposicion );

CREATE TABLE museo.localidad (
id_localidad INTEGER NOT NULL,
d_asentamiento VARCHAR2(20 CHAR),
codigopostal VARCHAR2(5 CHAR),
id_entidad INTEGER NOT NULL,
id_tipoasentamiento INTEGER NOT NULL
);

ALTER TABLE museo.localidad ADD CONSTRAINT localidad_pkv1 PRIMARY KEY ( id_localidad );

CREATE TABLE museo.鈥減ersonas鈥 (
id_persona INTEGER NOT NULL,
"Nombre " VARCHAR2(20 CHAR) NOT NULL,
apepater VARCHAR2(20 CHAR),
apemater VARCHAR2(20 CHAR),
id_paisnacionalidad INTEGER,
anionace INTEGER,
aniomuerte INTEGER,
mesnace INTEGER,
mesmuerte INTEGER,
dianace INTEGER,
diamuerte INTEGER,
id_tipopersona INTEGER
);

ALTER TABLE museo.鈥減ersonas鈥 ADD CONSTRAINT personas_pk PRIMARY KEY ( id_persona );

CREATE TABLE museo.rel_sedesecciones (
id_sede INTEGER NOT NULL,
id_seccion INTEGER NOT NULL
);

ALTER TABLE museo.rel_sedesecciones ADD CONSTRAINT rel_sedesecciones_pk PRIMARY KEY ( id_sede,
id_seccion );

CREATE TABLE museo.rel_tecnicas_elemento (
id_tecnica INTEGER NOT NULL,
id_elementos INTEGER NOT NULL
);

ALTER TABLE museo.rel_tecnicas_elemento ADD CONSTRAINT rel_tecnicas_elemento_pk PRIMARY KEY ( id_tecnica,
id_elementos );

CREATE TABLE museo.rel_tipocoleccioncoleccion (
id_coleccion INTEGER NOT NULL,
id_tipocoleccion INTEGER NOT NULL
);

ALTER TABLE museo.rel_tipocoleccioncoleccion ADD CONSTRAINT rel_tipocoleccioncoleccion_pk PRIMARY KEY ( id_coleccion,
id_tipocoleccion );

CREATE TABLE museo.rel_tipoelementoelementos (
id_tipoelemento INTEGER NOT NULL,
id_elementos INTEGER NOT NULL
);

ALTER TABLE museo.rel_tipoelementoelementos ADD CONSTRAINT rel_tipoelementoelementos_pk PRIMARY KEY ( id_tipoelemento,
id_elementos );

CREATE TABLE museo.rel_tipomaterialelemento (
id_tipomaterial INTEGER NOT NULL,
id_elementos INTEGER NOT NULL
);

ALTER TABLE museo.rel_tipomaterialelemento ADD CONSTRAINT rel_tipomaterialelemento_pk PRIMARY KEY ( id_tipomaterial,
id_elementos );

CREATE TABLE museo.rel_tipopersonapersonas (
id_persona INTEGER NOT NULL,
id_tipopersona INTEGER NOT NULL
);

ALTER TABLE museo.rel_tipopersonapersonas ADD CONSTRAINT rel_tipopersonapersonas_pk PRIMARY KEY ( id_persona,
id_tipopersona );

CREATE TABLE museo.secciones (
id_seccion INTEGER NOT NULL,
nombreseccion VARCHAR2(60),
id_seccionpadre INTEGER NOT NULL,
altura FLOAT,
largo FLOAT,
ancho FLOAT,
pesomaximo FLOAT,
anioconstruccion INTEGER,
mesconstruccion INTEGER,
id_personaarquitecto INTEGER NOT NULL,
id_estiloconstruccion INTEGER NOT NULL,
id_usoactual INTEGER NOT NULL,
id_personaresponsable INTEGER
);

ALTER TABLE museo.secciones ADD CONSTRAINT secciones_pk PRIMARY KEY ( id_seccion );

CREATE TABLE museo.sede (
id_sede INTEGER NOT NULL,
d_sede VARCHAR2(60 CHAR),
d_abreviadosede VARCHAR2(12 CHAR),
id_localidad INTEGER NOT NULL,
id_institucion INTEGER NOT NULL
);

ALTER TABLE museo.sede ADD CONSTRAINT sede_pk PRIMARY KEY ( id_sede );

ALTER TABLE museo.c_estadomunicipio
ADD CONSTRAINT c_estadomuni_c_estado_fk FOREIGN KEY ( id_entidadpadre )
REFERENCES museo.c_estadomunicipio ( id_entidad );

ALTER TABLE museo.c_tipopersona
ADD CONSTRAINT c_tipopersona_c_rolempleado_fk FOREIGN KEY ( id_rolempleado )
REFERENCES museo.c_rolempleado ( id_rolempleado );

ALTER TABLE museo.c_tipopersona
ADD CONSTRAINT c_tipopersona_c_tipopersona_fk FOREIGN KEY ( id_jefeempleado )
REFERENCES museo.c_tipopersona ( id_tipopersona );

ALTER TABLE museo.coleccion
ADD CONSTRAINT coleccion_sede_fk FOREIGN KEY ( id_sede )
REFERENCES museo.sede ( id_sede );

ALTER TABLE museo.elementos
ADD CONSTRAINT elementos_c_pais_fk FOREIGN KEY ( id_pais )
REFERENCES museo.c_pais ( id_pais );

ALTER TABLE museo.elementos
ADD CONSTRAINT elementos_c_periodoarti_fk FOREIGN KEY ( id_periodoartistico )
REFERENCES museo.c_periodoartistico ( id_periodoartistico );

ALTER TABLE museo.exposicion
ADD CONSTRAINT exposicion_c_pais_fk FOREIGN KEY ( id_paisnacionalidad )
REFERENCES museo.c_pais ( id_pais );

ALTER TABLE museo.exposicion
ADD CONSTRAINT exposicion_c_tipoexpo_fk FOREIGN KEY ( id_tipoexposicion )
REFERENCES museo.c_tipoexpo ( id_tipoexpo );

ALTER TABLE museo.localidad
ADD CONSTRAINT localidad_c_estadomun_fk FOREIGN KEY ( id_entidad )
REFERENCES museo.c_estadomunicipio ( id_entidad );

ALTER TABLE museo.localidad
ADD CONSTRAINT localidad_c_tipoasent_fk FOREIGN KEY ( id_tipoasentamiento )
REFERENCES museo.c_tipoasentamiento ( id_tipoasentamiento );

ALTER TABLE museo.rel_sedesecciones
ADD CONSTRAINT rel_sedesecciones_fk FOREIGN KEY ( id_seccion )
REFERENCES museo.secciones ( id_seccion );

ALTER TABLE museo.rel_sedesecciones
ADD CONSTRAINT rel_sedesecciones_sede_fk FOREIGN KEY ( id_sede )
REFERENCES museo.sede ( id_sede );

ALTER TABLE museo.rel_tecnicas_elemento
ADD CONSTRAINT rel_tecni_c_tecni_fk FOREIGN KEY ( id_tecnica )
REFERENCES museo.c_tecnicas ( id_tecnica );

ALTER TABLE museo.rel_tecnicas_elemento
ADD CONSTRAINT rel_tecnicas_elemento_fk FOREIGN KEY ( id_elementos )
REFERENCES museo.elementos ( id_elementos );

ALTER TABLE museo.rel_tipocoleccioncoleccion
ADD CONSTRAINT rel_tipocol_c_tipocol_fk FOREIGN KEY ( id_tipocoleccion )
REFERENCES museo.c_tipocoleccion ( id_tipocoleccion );

ALTER TABLE museo.rel_tipocoleccioncoleccion
ADD CONSTRAINT rel_tipocol_coleccion_fk FOREIGN KEY ( id_coleccion )
REFERENCES museo.coleccion ( id_coleccion );

ALTER TABLE museo.rel_tipoelementoelementos
ADD CONSTRAINT rel_tipoelem_c_tipoelem_fk FOREIGN KEY ( id_tipoelemento )
REFERENCES museo.c_tipoelementos ( id_tipoelemento );

ALTER TABLE museo.rel_tipoelementoelementos
ADD CONSTRAINT rel_tipoelemento_eleme_fk FOREIGN KEY ( id_elementos )
REFERENCES museo.elementos ( id_elementos );

ALTER TABLE museo.rel_tipomaterialelemento
ADD CONSTRAINT rel_tipomatelem_ctipomat_fk FOREIGN KEY ( id_tipomaterial )
REFERENCES museo.c_tipomaterial ( id_tipomaterial );

ALTER TABLE museo.rel_tipomaterialelemento
ADD CONSTRAINT rel_tipomaterialelemento_fk FOREIGN KEY ( id_elementos )
REFERENCES museo.elementos ( id_elementos );

ALTER TABLE museo.rel_tipopersonapersonas
ADD CONSTRAINT rel_tipopersona_c_tipopers_fk FOREIGN KEY ( id_tipopersona )
REFERENCES museo.c_tipopersona ( id_tipopersona );

ALTER TABLE museo.rel_tipopersonapersonas
ADD CONSTRAINT 鈥渞el_tipoPersona_Pers _FK鈥 FOREIGN KEY ( id_persona )
REFERENCES museo.鈥減ersonas鈥 ( id_persona );

ALTER TABLE museo.secciones
ADD CONSTRAINT secciones_c_estilocontruc_fk FOREIGN KEY ( id_estiloconstruccion )
REFERENCES museo.c_estilocontruccion ( id_estilocontruccion );

ALTER TABLE museo.secciones
ADD CONSTRAINT secciones_c_usoactual_fk FOREIGN KEY ( id_usoactual )
REFERENCES museo.c_usoactual ( id_usoactual );

ALTER TABLE museo.secciones
ADD CONSTRAINT 鈥淪ecciones_Personas _FK鈥 FOREIGN KEY ( id_personaarquitecto )
REFERENCES museo.鈥減ersonas鈥 ( id_persona );

ALTER TABLE museo.secciones
ADD CONSTRAINT secciones_secciones_fk FOREIGN KEY ( id_seccionpadre )
REFERENCES museo.secciones ( id_seccion );

ALTER TABLE museo.sede
ADD CONSTRAINT sede_c_institucion_fk FOREIGN KEY ( id_institucion )
REFERENCES museo.c_institucion ( id_institucion );

ALTER TABLE museo.sede
ADD CONSTRAINT sede_localidad_fk FOREIGN KEY ( id_localidad )
REFERENCES museo.localidad ( id_localidad );

CREATE SEQUENCE museo.c_estadomunicipio_id_entidad START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_estadomunicipio_id_entidad BEFORE
INSERT ON museo.c_estadomunicipio
FOR EACH ROW
WHEN ( new.id_entidad IS NULL )
BEGIN
:new.id_entidad := museo.c_estadomunicipio_id_entidad.nextval;
END;
/

CREATE SEQUENCE museo.c_estilocontruccion_id_estiloc START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_estilocontruccion_id_estiloc BEFORE
INSERT ON museo.c_estilocontruccion
FOR EACH ROW
WHEN ( new.id_estilocontruccion IS NULL )
BEGIN
:new.id_estilocontruccion := museo.c_estilocontruccion_id_estiloc.nextval;
END;
/

CREATE SEQUENCE museo.c_institucion_id_institucion START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_institucion_id_institucion BEFORE
INSERT ON museo.c_institucion
FOR EACH ROW
WHEN ( new.id_institucion IS NULL )
BEGIN
:new.id_institucion := museo.c_institucion_id_institucion.nextval;
END;
/

CREATE SEQUENCE museo.c_pais_id_pais_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_pais_id_pais_trg BEFORE
INSERT ON museo.c_pais
FOR EACH ROW
WHEN ( new.id_pais IS NULL )
BEGIN
:new.id_pais := museo.c_pais_id_pais_seq.nextval;
END;
/

CREATE SEQUENCE museo.c_periodoartistico_id_periodoa START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_periodoartistico_id_periodoa BEFORE
INSERT ON museo.c_periodoartistico
FOR EACH ROW
WHEN ( new.id_periodoartistico IS NULL )
BEGIN
:new.id_periodoartistico := museo.c_periodoartistico_id_periodoa.nextval;
END;
/

CREATE SEQUENCE museo.c_rolempleado_id_rolempleado START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_rolempleado_id_rolempleado BEFORE
INSERT ON museo.c_rolempleado
FOR EACH ROW
WHEN ( new.id_rolempleado IS NULL )
BEGIN
:new.id_rolempleado := museo.c_rolempleado_id_rolempleado.nextval;
END;
/

CREATE SEQUENCE museo.c_tecnicas_id_tecnica_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_tecnicas_id_tecnica_trg BEFORE
INSERT ON museo.c_tecnicas
FOR EACH ROW
WHEN ( new.id_tecnica IS NULL )
BEGIN
:new.id_tecnica := museo.c_tecnicas_id_tecnica_seq.nextval;
END;
/

CREATE SEQUENCE museo.c_tipocoleccion_id_tipocolecci START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_tipocoleccion_id_tipocolecci BEFORE
INSERT ON museo.c_tipocoleccion
FOR EACH ROW
WHEN ( new.id_tipocoleccion IS NULL )
BEGIN
:new.id_tipocoleccion := museo.c_tipocoleccion_id_tipocolecci.nextval;
END;
/

CREATE SEQUENCE museo.c_tipoelementos_id_tipoelement START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_tipoelementos_id_tipoelement BEFORE
INSERT ON museo.c_tipoelementos
FOR EACH ROW
WHEN ( new.id_tipoelemento IS NULL )
BEGIN
:new.id_tipoelemento := museo.c_tipoelementos_id_tipoelement.nextval;
END;
/

CREATE SEQUENCE museo.c_tipoexpo_id_tipoexpo_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_tipoexpo_id_tipoexpo_trg BEFORE
INSERT ON museo.c_tipoexpo
FOR EACH ROW
WHEN ( new.id_tipoexpo IS NULL )
BEGIN
:new.id_tipoexpo := museo.c_tipoexpo_id_tipoexpo_seq.nextval;
END;
/

CREATE SEQUENCE museo.c_tipomaterial_id_tipomaterial START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_tipomaterial_id_tipomaterial BEFORE
INSERT ON museo.c_tipomaterial
FOR EACH ROW
WHEN ( new.id_tipomaterial IS NULL )
BEGIN
:new.id_tipomaterial := museo.c_tipomaterial_id_tipomaterial.nextval;
END;
/

CREATE SEQUENCE museo.c_tipopersona_id_tipopersona START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_tipopersona_id_tipopersona BEFORE
INSERT ON museo.c_tipopersona
FOR EACH ROW
WHEN ( new.id_tipopersona IS NULL )
BEGIN
:new.id_tipopersona := museo.c_tipopersona_id_tipopersona.nextval;
END;
/

CREATE SEQUENCE museo.c_usoactual_id_usoactual_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.c_usoactual_id_usoactual_trg BEFORE
INSERT ON museo.c_usoactual
FOR EACH ROW
WHEN ( new.id_usoactual IS NULL )
BEGIN
:new.id_usoactual := museo.c_usoactual_id_usoactual_seq.nextval;
END;
/

CREATE SEQUENCE museo.coleccion_id_coleccion_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.coleccion_id_coleccion_trg BEFORE
INSERT ON museo.coleccion
FOR EACH ROW
WHEN ( new.id_coleccion IS NULL )
BEGIN
:new.id_coleccion := museo.coleccion_id_coleccion_seq.nextval;
END;
/

CREATE SEQUENCE museo.elementos_id_elementos_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.elementos_id_elementos_trg BEFORE
INSERT ON museo.elementos
FOR EACH ROW
WHEN ( new.id_elementos IS NULL )
BEGIN
:new.id_elementos := museo.elementos_id_elementos_seq.nextval;
END;
/

CREATE SEQUENCE museo.exposicion_id_exposicion_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.exposicion_id_exposicion_trg BEFORE
INSERT ON museo.exposicion
FOR EACH ROW
WHEN ( new.id_exposicion IS NULL )
BEGIN
:new.id_exposicion := museo.exposicion_id_exposicion_seq.nextval;
END;
/

CREATE SEQUENCE museo.secciones_id_seccion_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.secciones_id_seccion_trg BEFORE
INSERT ON museo.secciones
FOR EACH ROW
WHEN ( new.id_seccion IS NULL )
BEGIN
:new.id_seccion := museo.secciones_id_seccion_seq.nextval;
END;
/

CREATE SEQUENCE museo.sede_id_sede_seq START WITH 1 NOCACHE ORDER;

CREATE OR REPLACE TRIGGER museo.sede_id_sede_trg BEFORE
INSERT ON museo.sede
FOR EACH ROW
WHEN ( new.id_sede IS NULL )
BEGIN
:new.id_sede := museo.sede_id_sede_seq.nextval;
END;
/

Hola,
Quisiera saber la ruta en la que queda almacenada la BD en mi equipo local, como se puede hacer Backup de ella y asegurarme que los datos no se van a perder o una vez creada debo realizar alguna acci贸n de guardado?

El AUTO_INCREMENT al final de las sentencias CREATE que funci贸n tiene?

Alquien me puede ense帽ar comoa gregar una iamgen

Mejor que en mi universidad

Que genial, me emociono de solo dar peque帽os pasos. Gracias #Platzi

Lo ideal es tener la base de datos, nombre de tablas y campos in English

Todo este proceso se hizo para las entidades independientes aquellas que no tienen conexion devuelta con otra entidad sino que solamente se conectan a otras.

En el caso de que alg煤n guerrero lo haga en terminal:

-- CREAR DB
DROP DATABASE IF EXISTS `platziblog`;
;
CREATE DATABASE `platziblog`
DEFAULT CHARACTER SET utf8;
;
USE `platziblog`;
-- PRIMERO CREAMOS LAS TABLAS INDEPENDIENTES
--
-- CATEGORIAS
CREATE TABLE `platziblog`.`categorias` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
  `nombre_categoria` VARCHAR(30) NOT NULL,
  PRIMARY KEY (`id`));
-- ETIQUETAS
CREATE TABLE `platziblog`.`etiquetas` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
  `nombre_etiqueta` VARCHAR(30) NOT NULL,
  PRIMARY KEY (`id`));
-- USUARIOS
CREATE TABLE `platziblog`.`usuarios` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
  `login` VARCHAR(30) NOT NULL,
  `password` VARCHAR(32) NOT NULL,
  `nickname` VARCHAR(40) NOT NULL,
  `email` VARCHAR(40) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `email_UNIQUE` (`email` ASC));
-- LUEGO LAS TABLAS CON FOREIGN KEYS
--
-- POSTS
CREATE TABLE `platziblog`.`posts` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
  `titulo` VARCHAR(150) NOT NULL,
  `fecha_publicacion` TIMESTAMP NULL,
  `contenido` TEXT NOT NULL,
  `estatus` CHAR(8) NULL DEFAULT 'activo',
  `usuario_id` INT UNSIGNED NOT NULL,
  `categoria_id` INT UNSIGNED NOT NULL,
  PRIMARY KEY (`id`));
;
ALTER TABLE `platziblog`.`posts`
ADD INDEX `posts_usuarios_idx` (`usuario_id` ASC);
;
ALTER TABLE `platziblog`.`posts`
ADD CONSTRAINT `posts_usuarios`
  FOREIGN KEY (`usuario_id`)
  REFERENCES `platziblog`.`usuarios` (`id`)
  ON DELETE NO ACTION
  ON UPDATE CASCADE;
;
ALTER TABLE `platziblog`.`posts`
ADD INDEX `posts_categorias_idx` (`categoria_id` ASC);
;
ALTER TABLE `platziblog`.`posts`
ADD CONSTRAINT `posts_categorias`
  FOREIGN KEY (`categoria_id`)
  REFERENCES `platziblog`.`categorias` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;
-- COMENTARIOS
CREATE TABLE `platziblog`.`comentarios` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
  `cuerpo_comentario` TEXT NOT NULL,
  `usuario_id` INT UNSIGNED NOT NULL,
  `post_id` INT UNSIGNED NOT NULL,
  PRIMARY KEY (`id`));
;
ALTER TABLE `platziblog`.`comentarios`
ADD INDEX `comentarios_usuario_idx` (`usuario_id` ASC);
;
ALTER TABLE `platziblog`.`comentarios`
ADD CONSTRAINT `comentarios_usuario`
  FOREIGN KEY (`usuario_id`)
  REFERENCES `platziblog`.`usuarios` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;
;
ALTER TABLE `platziblog`.`comentarios`
ADD INDEX `comentarios_post_idx` (`post_id` ASC);
;
ALTER TABLE `platziblog`.`comentarios`
ADD CONSTRAINT `comentarios_post`
  FOREIGN KEY (`post_id`)
  REFERENCES `platziblog`.`posts` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;
-- TABLA TANSITIVA POSTS ->---<- ETIQUETAS
CREATE TABLE `platziblog`.`posts_etiquetas` (
  `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
  `post_id` INT UNSIGNED NOT NULL,
  `etiqueta_id` INT UNSIGNED NOT NULL,
  PRIMARY KEY (`id`));
;
ALTER TABLE `platziblog`.`posts_etiquetas`
ADD INDEX `postsetiquetas_post_idx` (`post_id` ASC)
;
ALTER TABLE `platziblog`.`posts_etiquetas`
ADD CONSTRAINT `postsetiquetas_post`
  FOREIGN KEY (`post_id`)
  REFERENCES `platziblog`.`posts` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;
;
ALTER TABLE `platziblog`.`posts_etiquetas`
ADD INDEX `postsetiquetas_etiquetas_idx` (`etiqueta_id` ASC)
;
ALTER TABLE `platziblog`.`posts_etiquetas`
ADD CONSTRAINT `postsetiquetas_etiquetas`
  FOREIGN KEY (`etiqueta_id`)
  REFERENCES `platziblog`.`etiquetas` (`id`)
  ON DELETE NO ACTION
  ON UPDATE NO ACTION;
/*
reverse engineer es util pero solo en algun cliente graficos cmo workbnch o phpadmin
*/

Para las relaciones 1:1 la llave foranea se pasa a cualquiera de las dos entidades, o a la que m谩s convenga

supeeeeer

Si utilizan en un futuro postgres, el tipo de dato que deben colocar para que el id se auto incremente, es: serial, aunque lo que realmente hace esto es poner un valor por defecto y el tipo integer a la columna que est茅n creando, en este caso el id. Les dejo el enlace donde encontr茅 esto: https://www.postgresqltutorial.com/postgresql-serial/

Tengo entendido que dependiendo Del gestor de base de datos existen diferentes muy sutiles

Genial Hasta ahora!

Excelente Curso 馃槂

excelente curso, excelente profesor, he reforzado y aprendido cosas que no sabia

Ya cre茅 todas las tablas pero no he asignado la llave foranea.

creo que el login deberia de ser Unique

Para SQL Server el AUTO INCREMENT se llama IDENTITY y en Oracle se debe crear una secuencia con CREATE y utilizar esa secuencia con NEXTVAL en el insert.

Me aparece un error de sintaxis en la l铆nea 8, en mi caso cuando en Workbench ejecuto el apply al final de la l铆nea me aparece VISIBLE. Si borr贸 VISIBLE el query funciona bien. 驴Saben por qu茅 pasa esto o qu茅 indica VISIBLE?

UNIQUE INDEX `email_UNIQUE` (`email` ASC) VISIBLE)

Poco a poco voy aprendiendo, ya que el diagrama f铆sico que realic茅 inicialmente tuve que modificarlo ya que me daba cuenta de mis errores cuando creaba las tablas, ya me va quedando mas claro.

create table categorias (
id_categoria int not null primary key auto_increment,
categoria varchar(300)
);

create table usuarios (
id_usuario int not null primary key auto_increment,
login varchar(30) not null,
clave varchar(300) not null,
nickname varchar(40) not null unique,
email varchar(40) not null unique

);

create table etiquetas(
id_etiqueta int not null primary key auto_increment,
nombre_etiqueta varchar(30) not null unique

);

create table posts(
id_post int not null primary key auto_increment,
titulo varchar(150),
fecha_plubicacion timestamp,
contenido text,
status boolean,
id_usuario int,
id_categoria int,
foreign key (id_usuario) REFERENCES usuarios (id_usuario),
foreign key (id_categoria) references categorias (id_categoria)

);

create table comentarios(
id_comentario int not null auto_increment primary key,
comentario text,
id_usuario int,
id_post int,
foreign key (id_usuario) references usuarios (id_usuario),
foreign key (id_post) references posts (id_post)

);

Ac谩 les dejo algunos tips sobre las tablas indpendientes:

  • Las tablas independientes son 煤tiles para almacenar informaci贸n que no est谩 directamente relacionada con otras tablas en la base de datos.

  • Las tablas independientes pueden tener cualquier n煤mero de campos y pueden ser consultadas por separado o en conjunto con otras tablas en la base de datos.

  • Es importante nombrar adecuadamente las tablas independientes para que su uso sea f谩cilmente identificable en el futuro.

  • Aseg煤rate de definir correctamente las relaciones de las tablas independientes con otras tablas, ya sea mediante claves for谩neas o tablas intermedias, para mantener la integridad de la base de datos.

Que genial que podemos aplicar lo aprendido, no entend铆a nada del diagrama f铆sico, pero verlo aplicado es hermoso.

  • Llave for谩nea. Recordemos que etas llaves son aquellas que unen las tablas entre ellas y en este caso siempre van a la tabla que tiene el final el que tiene la linea muchos

create table categorias(
id int not null auto_increment,
categoria varchar(30),
primary key(id)
)

excelente profesor he aprendido bastante GRACIAS

Yo tambi茅n habr铆a agregado unique en el nombre de la etiqueta. No tiene caso poder tener etiquetas con el mismo nombre.

Porque etiquetas no tiene FK

c贸digo de la clase

/* base de datos que vamos a usar */
USE platziblog;

/*tabla categor铆as */
CREATE TABLE categories(
	categorie_id INT PRIMARY KEY NOT NULL,
    categorie_name VARCHAR(30) NOT NULL
);

/* tabla etiquetas*/
CREATE TABLE tags(
	tag_id INT PRIMARY KEY NOT NULL,
    tag_name VARCHAR(30) NOT NULL
);

/* tabla usuarios */
CREATE TABLE users(
	user_id INT PRIMARY KEY NOT NULL,
    login VARCHAR(30) NOT NULL,
    password VARCHAR(30) NOT NULL,
    nickname VARCHAR(40) NOT NULL UNIQUE,
    email VARCHAR(40) NOT NULL UNIQUE
);

Listo arme todo馃槃

Siguiendo el paso a paso, para el Platziblog:

Si estan escribiendo todos los comandos a mano, solo para practicar, se puede aplicar el PRIMARY KEY de esta forma tambien

CREATE TABLE categories(
  category_id SMALLINT NOT NULL AUTO_INCREMENT PRIMARY_KEY,
  category_name VARCHAR(30) NOT NULL
);

practicar en sql

Excelente profesor !

Creo que en lo que respecta tanto al nickname como al login tambi茅n deber铆an ser UNIQUE, ya que cada usuario tiene su propio identificador que no se puede repetir.

adicional le agregaria los campos created_ad y updated_ad el promero almacenando la fecha de creacion definiendo el default como getdate() y el segundo como null llenandose cada que la tabla de actualize

Para el campo password, deber铆a tener una cantidad de caracteres mayor, considerando que se pueda cifrar.

Minuto 10:14 creo que la valor de nickname y email deberian ambos de tener el UQ ya que el nickname tambien sea unico, es mi forma de ver ya que sucede en muchos lados que no te dejan ingresar tu nickname por que ya existe.

#Creando la base de datos
CREATE DATABASE platziblog DEFAULT CHARACTER SET utf8;

# Seleccionando la base de datos platziblog
USE platziblog;

# Creando tabla categorias
CREATE TABLE platziblog.categorias
(
idcategoria INT NOT NULL AUTO_INCREMENT COMMENT "C贸digo de la categor铆a", 
des_categoria VARCHAR(30) NOT NULL COMMENT "Nombre o descripci贸n de la categor铆a",
PRIMARY KEY(idcategoria)
) COMMENT "Tabla de categorias de los blogs";

#Creando la tabla etiquetas
CREATE TABLE etiquetas
(
idetiqueta INT NOT NULL AUTO_INCREMENT COMMENT "ID de cetiqueta",
nom_etiqueta VARCHAR(30) NOT NULL COMMENT "Nombre o descripci贸n de la etiqueta",
PRIMARY KEY (idetiqueta)
) COMMENT "Tabla de etiquetas de los blogs";

#Creando la tabla usuarios
CREATE TABLE usuarios 
(
  idusuario INT NOT NULL AUTO_INCREMENT COMMENT "ID de usuario",
  login VARCHAR(30) NOT NULL COMMENT "login del usuarios",
  pasword VARCHAR(32) NOT NULL COMMENT "password del usuario",
  nickname VARCHAR(40) NOT NULL COMMENT "apodo del usuario",
  email VARCHAR(40) NOT NULL COMMENT "correo del usuario",
  PRIMARY KEY (idusuario),
  UNIQUE INDEX usuarios_email_UNIQUE (email ASC) VISIBLE)
COMMENT = 'Tabla de usuarios del sistema';

Creando tablas en Platzi Blog

Aqui el codigo SQL de la clase

CREATE DATABASE platziblog;
USE platziblog;
CREATE TABLE categories(
id INT PRIMARY KEY AUTO_INCREMENT NOT NULL,
name VARCHAR(30) NOT NULL);

CREATE TABLE tags(
id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(30) NOT NULL);

CREATE TABLE users(
id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
login VARCHAR(30) NOT NULL,
password VARCHAR(100) NOT NULL,
nickname VARCHAR(40) NOT NULL,
email VARCHAR(40) NOT NULL UNIQUE);

Primero tienes que crear la base de datos, luego elegir esa DB como default y despu茅s si puedes pegar la creaci贸n de las tablas todas juntas.

Les comparto el Script DDL:

use platziBlog;
create table categorias (
id int,
categoria varchar(30),
constraint categorias_pk primary key (id)
);
create table etiquetas (
id int,
etiqueta varchar(30),
constraint etiquetas_pk primary key (id)
);
create table usuarios (
id int,
login varchar(30) not null,
password varchar(32) not null,
nickname varchar(40) not null,
email varchar(40) not null unique,
constraint usuarios_pk primary key (id)
);
create table posts (
id int,
titulo varchar(150),
fecha_publica timestamp,
contenido text,
estatus char(1),
usuario_id int,
categoria_id int,
check (estatus in ('A','I')),
constraint posts_pk primary key (id),
constraint posts_usuarios_fk foreign key (usuario_id) references usuarios (id),
constraint posts_categorias_fk foreign key (categoria_id) references categorias (id)
);
create table comentarios (
id int,
comentario text,
usuario_id int,
post_id int,
constraint comentarios_pk primary key (id),
constraint comentarios_usuarios_fk foreign key (usuario_id) references usuarios (id),
constraint comentarios_posts_fk foreign key (post_id) references posts (id)
);

Base de datos para un colegio.