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

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

¿Qué es RDB y RDBMS?

13

Instalación local de un RDBMS (Windows)

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

FROM

31

Utilizando la sentencia FROM

32

WHERE

33

Utilizando la sentencia WHERE nulo y no nulo

34

GROUP BY

35

ORDER BY y HAVING

36

El interminable agujero de conejo (Nested queries)

37

¿Cómo convertir una pregunta en un query SQL?

38

Preguntándole a la base de datos

39

Consultando PlatziBlog

Introducción a la bases de datos NO relacionales

40

¿Qué son y cuáles son los tipos de bases de datos no relacionales?

41

Servicios administrados y jerarquía de datos

Manejo de modelos de datos en bases de datos no relacionales

42

Top level collection con Firebase

43

Creando y borrando documentos en Firestore

44

Colecciones vs subcolecciones

45

Recreando Platziblog

46

Construyendo Platziblog en Firestore

47

Proyecto final: transformando tu proyecto en una db no relacional

Bases de datos en la vida real

48

Bases de datos en la vida real

49

Big Data

50

Data warehouse

51

Data mining

52

ETL

53

Business intelligence

54

Machine Learning

55

Data Science

56

¿Por qué aprender bases de datos hoy?

Bonus

57

Bases de datos relacionales vs no relacionales

58

Elegir una base de datos

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Creando Platziblog: tablas independientes

24/58
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 141

Preguntas 65

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta 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.

/*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)
)

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.

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

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
);

Este es mi proyecto de una tienda online

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

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
);

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 “cascade” 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.

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.

El nickname, tambien deberia ser UNIQUE

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)
);

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

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
);

++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…

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

En este caso el uso del UQ (unique) tambien se aplicarìa a “Nickname” ya que 2 usuarios no pueden tener el mismo nickname, estoy en lo correcto?

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

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

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!!

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)
);

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

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.
–Si 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 ‘APELLIDO_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 ‘VENDEDOR_CLIENTE’, ‘VENDEDOR_CLIENTE_PRODUCTO’.
–Todas 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.
–El 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

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

¿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

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!

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.

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.

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

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

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 “categorias” 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 “Etiquetas”:
CREATE TABLE `Platziblog` . `etiquetas` (
`id` INT NOT NULL AUTO_INCREMENT,
`nombre_etiqueta` VARCHAR(30) NOT NULL,
PRIMARY KEY (`id`));

  1. Ahora la tabla “Usuarios” 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 “MUSEO” CASCADE;
– Creando usuario SQL
CREATE USER museo IDENTIFIED BY "museo"
DEFAULT TABLESPACE "USERS"
TEMPORARY TABLESPACE “TEMP”;
– Asignando quota en tablespace
ALTER USER museo QUOTA UNLIMITED ON USERS;

– Asignando roles
GRANT “CONNECT” 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.“personas” (
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.“personas” 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 “rel_tipoPersona_Pers _FK” FOREIGN KEY ( id_persona )
REFERENCES museo.“personas” ( 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 “Secciones_Personas _FK” FOREIGN KEY ( id_personaarquitecto )
REFERENCES museo.“personas” ( 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 😃

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.

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)

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.

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

me convertido en una experta utilizando DROP de tantas veces que he tenido que elimininar mis esquemas porque al ingresar la información los errores no me permiten avanzar 😦

Una llave foránea es una referencia a una llave en otra tabla y determina una relación existente entre 2 tablas.

Me pueden decir si esta bien el diagrama o me toca corregir algo ?.
Acepto opiniones.

Se empieza por los que NO tienen ninguna Clave Foranea

Llaves Foraneas, son aquellas que unen las tablas entre ellas.

no pasa nada si no se le pone el set de caracteres en la base de datos y en las tablas???

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.

también debería de ser único el nickname

Para la clave foránea se hace de la siguiente manera:

FOREIGN KEY(usuarios_id) REFERENCES usuarios(id);

Y así con cualquiera que necesiten

Lo visto en clase:

Adapté mi proyecto de la universidad que había hecho con SQL Management Studio al MySQL. Me encanto la funcionalidad de Reverse Engineer.

genail

Es recomendable iniciar con la creacion de tablas, por las tabals que no tienen llave foranea

Gran clase

Porque etiquetas no tiene FK

Creadas las tablas

	CREATE TABLE usuarios (
	  id int(11) 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 KEY email_UNIQUE (email)
	) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

CREATE TABLE categorias (
  id int(11) NOT NULL AUTO_INCREMENT,
  nombre_categoria varchar(30) NOT NULL,
  PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

CREATE TABLE etiquetas (
  id int(11) NOT NULL AUTO_INCREMENT,
  nombre_etiqueta varchar(30) NOT NULL,
  PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=21 DEFAULT CHARSET=utf8;```

Estas son las tablas creadas desde HeidiSQL

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

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

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

Este curso es brutal

Este curso es muy interesante, además el profesor explica muy bien!