Creando Platziblog: tablas independientes

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

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.

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

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

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

Este es mi proyecto de una tienda online

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

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

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.

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

El nickname, tambien deberia ser UNIQUE

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?

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

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

Quien mas ve los videos a 1.5x?? xd

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.

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

¿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.

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

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

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.

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

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  💚.

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.

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

¿Qué siginifica?

(`email` ASC));

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.

28. Creando Platziblog: tablas independientes

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

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

CREATE TABLE `platzi_test`.`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,
  PRIMARY KEY (`id`),
  UNIQUE INDEX `email_UNIQUE` (`email` ASC) VISIBLE);

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

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

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

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

• 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

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

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.

yo estoy tratando de hacerlo con la sintaxis para tener mas memoria de como utilizar las sentencias…
me ayuda a reforzar más que utilizando haciendo paso a paso los “clic”

Se esta poniendo masiso el curso 😈😈😈👌👌👌☕☕👀💻🏋️

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 “Engine” (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 “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.

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?

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

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/

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)

Estas tablas independientes suelen tener una estructura simple y pueden ser utilizadas para almacenar datos que no encajan en ninguna otra entidad o que sean relevantes en un contexto global de la aplicación o sistema. Es importante señalar que, aunque estas tablas no tengan relaciones directas con otras tablas, aún pueden estar relacionadas con otras entidades o datos a través de lógica de aplicación o consultas SQL específicas. Sin embargo, desde el punto de vista del diseño de la base de datos, se consideran

Cuando se refiere a “tablas independientes” en el contexto de bases de datos relacionales, generalmente se hace referencia a tablas que no tienen una relación directa o dependencia con otras tablas en la base de datos. Estas tablas suelen contener información que no necesita estar vinculada a otras tablas a través de claves foráneas o relaciones complejas.

• Las tablas independientes se utilizan para almacenar datos que no necesariamente tienen que ver con otras entidades o datos en la base de datos.

https://www.youtube.com/watch?v=uUdKAYl-F7g

Les comparto a todos el siguiente video para ampliar sus conocimientos en BD.

DB Mangement System

https://www.youtube.com/watch?v=cMUQznvYZ6w&list=RDCMUCxcOPU5S9MiVkvbb_5jlS4g&start_radio=1&rv=cMUQznvYZ6w&t=5&ab_channel=DatabasesA2Z

programa Workbench que es el usamos para graficar

En este caso el email es UNIQUE pero que tal si un usuario por ejemplo en un clínica brinda el correo equivocado y este pertenece a otro paciente se complica la cosa. Yo lo dejaría sin UNIQUE,

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)

);

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

excelente profesor he aprendido bastante GRACIAS

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