¿Cómo crear una base de datos en SQL?

Hola chicos ! , les paso parte del código para que vayan aprendiendo. \-- Tabla para almacenar información de productos CREATE TABLE productos ( id INT PRIMARY KEY, nombre VARCHAR(100) NOT NULL, descripcion TEXT, precio DECIMAL(10, 2) NOT NULL, cantidad\_disponible INT NOT NULL ); \-- Tabla para almacenar información de clientes CREATE TABLE clientes ( id INT PRIMARY KEY, nombre VARCHAR(100) NOT NULL, email VARCHAR(100) NOT NULL, telefono VARCHAR(20) ); \-- Tabla para almacenar información de colores CREATE TABLE colores ( id INT PRIMARY KEY, nombre VARCHAR(50) NOT NULL ); \-- Tabla para almacenar información de marcas CREATE TABLE marcas ( id INT PRIMARY KEY, nombre VARCHAR(50) NOT NULL ); \-- Tabla para almacenar información de inventario CREATE TABLE inventario ( id INT PRIMARY KEY, id\_producto INT NOT NULL, id\_color INT NOT NULL, id\_marca INT NOT NULL, FOREIGN KEY (id\_producto) REFERENCES productos(id), FOREIGN KEY (id\_color) REFERENCES colores(id), FOREIGN KEY (id\_marca) REFERENCES marcas(id) );

CHICOS VENGO DEL FUTURO, ESTO ES SUPER IMPORTANTE AL CREAR LAS TABLAS POR PRIMERA VEZ  después van a batallar como yo en la clase de delete y la de update, porque al decir NOTNULL y no contar con un número de ID, no me dejaba borrar o hacer update en un registro, no supe como modificar la table de STUDENTS, si alguien sabe se lo agradecería que lo dejara en este comentario, saludos.

El tipo de dato que nos permite almacenar acentos y tildes es ***NVARCHAR.*** Sintaxis: NVARCHAR(n) -n: longitud de cadena de 1 a 4000.

me parece excelnte que sin mas llegamos a la practica,me parece genial,que no se pierda el tiempo en tanta teoria,que se puede explicar durante el proceso de construccion de la ba se de datos.

A esta altura del curso, siento que está estructurado de forma muy superficial. Para una persona que apenas está aprendiendo se le hace muy complejo y todo queda en que se debe investigar. Tampoco lo consideraría de un nivel más avanzado porque los ejercicios son ejecuciones de tablas simples. No se manejan conceptos a través de representaciones gráficas usando herramientas como UML. Considero que dentro del aprendizaje de Bases de datos es importante la visualización de las relaciones la respectiva simbologia. Para las personas que apenas se están empezando en el mundo del sql y las bases de datos podrían tener problemas en la captación de los conceptos. Básicamente sirve como un curso de repaso simple para las personas que ya tenemos algunas nociones y conceptos previos. Siento que está pasando con los últimos cursos que se están creando en Platzi, se preocupan más por la estética de los videos y presentaciones que por la calidad del contenido. Es una opinión con ánimo de mejorar y que Platzi no pierda su oferta de valor. La profesor se nota que tiene bastante conocimiento y tiene una forma de explicar. Pero creo que el contenido del curso no está bien estructurado.

No me quedaba claro qué es realmente SQLite, MySQL y SQL, así que busqué. SQL no es más que una sintaxis estandar para el manejo de bases de datos mediante código, por lo que no existe un programa que ejecute código SQL como tal. SQLite y MySQL son, por otra parte, sistemas ya completos de gestion de bases de datos con sus propios programas y peculiaridades, pero usando el como sintaxis base el estandar SQL. Entre los 2 mencionados el más minimalista es SQLite, pero MySQL es más potente. Así, en estricto rigor, puedo instalar un programa para ejecutar instrucciones SQLite, pero no uno para SQL, pero entre panas digamos que en fondo sí se ejecuta código SQL.

Así quedaron mis tablas del ejercicio planteado

Creo que sería necesario tambien agregar clases de diagrams UML que representen la BD, y ahí explicar los tipos de datos y despues traducirlos a la creación, para que los estudiantes sepan como se relacionan y las conexiones. Siempre es importante definir antes de ir al código y es algo que a Platzi se le ha pasado en muchos cursos van directo al código sin antes aterrizar de manera gráfica, con diagramas UML

**<u>Clave primaria (Primary Key):</u>** -Una clave primaria es un campo en una tabla de una base de datos que identifica de manera única cada fila en esa tabla. * Debe ser única para cada registro y no puede contener valores nulos. * Una tabla solo puede tener una clave primaria. * Su principal propósito es asegurar que cada registro en la tabla pueda ser identificado de manera única y, por lo tanto, puede ser referenciado de manera precisa. **<u>Clave foránea (Foreign Key)</u>** Una clave foránea es un campo en una tabla que crea un vínculo entre esa tabla y la clave primaria de otra tabla. * Se utiliza para asegurar la integridad referencial en la base de datos, lo que significa que los valores en la clave foránea deben coincidir con los valores en la clave primaria de la otra tabla o ser nulos. * Permite establecer y reforzar las relaciones entre las tablas, asegurando que las dependencias entre ellas sean consistentes. * Una tabla puede tener múltiples claves foráneas, dependiendo de cuántas relaciones necesite establecer con otras tablas. **<u>Ejemplo:</u>** Considera dos tablas en una base de datos: `Clientes` y `Pedidos`. * En la tabla `Clientes`, la columna `ClienteID` puede ser la clave primaria, ya que identifica de manera única a cada cliente. * En la tabla `Pedidos`, la columna `PedidoID` puede ser la clave primaria para identificar cada pedido, y `ClienteID` puede ser una clave foránea que referencia la `ClienteID` en la tabla `Clientes`, estableciendo así una relación entre pedidos y clientes. Esto garantiza que cada pedido está asociado a un cliente existente y ayuda a mantener la integridad de los datos en la base de datos.

UTF-8 Es un sistema de codificación de caracteres flexible y ampliamente compatible. Además, es el más utilizado desde el 2008. UTF-8 soporta todos los idiomas y alfabetos. La codificación de caracteres es el proceso de asignar números a caracteres gráficos, especialmente los caracteres escritos del lenguaje humano (como las tildes), lo que permite almacenarlos, transmitirlos y transformarlos mediante computadoras.

Creo que sería necesario tambien agregar clases de diagrams UML que representen la BD, y ahí explicar los tipos de datos y despues traducirlos a la creación, para que los estudiantes sepan como se relacionan y las conexiones. Siempre es importante definir antes de ir al código y es algo que ha Platzi se le ha pasado en muchos cursos van directo al código sin antes aterrizar de manera gráfica, con diagramas UML

De momento mis tablas van quedando así, falta poner CONSTRAINTS por ejemplo. ```js CREATE DATABASE school_db; --creando la tabla de estudiantes CREATE TABLE students( id INT PRIMARY KEY AUTO_INCREMENT UNSIGNED, firts_name VARCHAR(50) NOT NULL, last_name VARCHAR(50) NOT NULL, age INT NOT NULL, email VARCHAR(50) NOT NULL, load_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); --creando la tabla cursos CREATE TABLE courses( id INT PRIMARY KEY AUTO_INCREMENT UNSIGNED, course_name VARCHAR(50) NOT NULL, `description` TEXT NOT NULL, duration_hours INT NOT NULL, instructor_id INT, load_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP FOREING KEY(instructor_id) REFERENCES instructors(id) ); -- creando la tabla de instructores CREATE TABLE instructors( id INT PRIMARY KEY AUTO_INCREMENT UNSIGNED, firts_name VARCHAR(50) NOT NULL, last_name VARCHAR(50) NOT NULL, age INT NOT NULL, email VARCHAR(50) NOT NULL, load_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, speciality VARCHAR(50) NOT NULL, experience INT NOT NULL, -- students_id INT, -- FOREIGN KEY (students_id) REFERENCES students(id) ); -- creando la tabla relacionamiento entre cursos y estudiantes CREATE DATAbase students_courses( id INT PRIMARY KEY AUTO_INCREMENT UNSIGNED, student_id INT NOT NULL UNSIGNED, course_id INT NOT NULL UNSIGNED, load_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY(student_id) REFERENCES students(id), FOREIgn KEY(course_id) REFERENCES couuses(id) ); ```

Hola a todos/todas 👩‍💻 Esta seria mi tabla para instructores: `CREATE TABLE INSTRUCTORS (` `INSTRUCTORID INT PRIMARY KEY,` `FIRSTNAME VARCHAR(50),` `LASTNAME VARCHAR(50), ` `AGE INT, ` `EMAIL VARCHAR(100), ` `LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, ` `UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ` `);`

¿Cómo crear una Base de Datos? Super bueno que vaya directo a la práctica, pero me gustaría compartir que hay unos pasos previos. Bien mencionaron la normalización, pero es importante también realizar un pequeño diagrama de las entidades y la relación que existen, así será más facil crear las tablas. En mi caso estoy realizando una base de datos de una ecommerce de ropa. 1. Identificar las Entidades y Atributos (Expondre algunas pocas) **Cliente** (Consumidor) <u>idCliente</u> Nombre Apellido Correo Genero **Genero** <u>idGenero</u> nombreGenero **Articulo** <u>idArticulo</u> Nombre Marca Departamento NumeroDeItems **Marca** <u>idMarca </u> NombreMarca Orden <u>idOrden</u> *idCliente* *idArticulo* Fecha FormadePago Hay Entidades **Fuertes y Debiles**, esto te ayudará al momento de crear las base, por que se sugiere empezar las **Fuertes**, aquellas que **no dependen** de otras tablas, que **sobreviven por si solas** En mi ejemplo la tabla **<u>Marca</u>**<u> </u>y **<u>Genero</u>** no dependen de otra tabla, sin embargo **<u>Orden</u>** ya **dependerá** de mi tabla **<u>Cliente</u>** para saber quien compro através del *IdCliente*, dependerá del articulo, porque querre saber que *idArticulo* adquirio. **La entidad debil no pueden existir sin una entidad Fuerte.**

enotnce no le ponemos lo de AUTOINCREMENT por ser sql lite correcto? 

¡Eres la mejor! Muchas gracias por enseñarnos.

Estoy empezando a ver este curso es la primera vez q veo sql y la verdad estoy perdido con tanta información y veo q la profe está saltando muy rápido y veo q hay cosas a no se explican y ahí es que cuando empieza la confusión no se si sea el nivel o curso para empezar que me recomiendan o a medida q valla pasando el curso se van aclarando estas dudas

```js -- Creación de la tabla STUDENTS (Estudiantes) CREATE TABLE STUDENTS( STUDENTID INT PRIMARY KEY, -- Identificador único del estudiante (clave primaria) FIRSTNAME VARCHAR(50), -- Primer nombre del estudiante LASTNAME VARCHAR(50), -- Apellido del estudiante AGE SMALLINT, -- Edad del estudiante EMAIL VARCHAR(100), -- Correo electrónico del estudiante LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- Fecha y hora de carga, con valor por defecto actual UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP -- Fecha y hora de actualización, con valor por defecto actual ); -- Creación de la tabla TEACHER (Profesores) CREATE TABLE TEACHER( TEACHERID INT PRIMARY KEY, -- Identificador único del profesor (clave primaria) FIRSTNAME VARCHAR, -- Primer nombre del profesor LASTNAME VARCHAR, -- Apellido del profesor AGE SMALLINT, -- Edad del profesor EMAIL VARCHAR(100), -- Correo electrónico del profesor PHONE VARCHAR(20), -- Número de teléfono del profesor DIRECCION VARCHAR(20), -- Dirección del profesor (se sugiere aumentar la longitud) HIRE_DATE DATE, -- Fecha de contratación del profesor SALARY DECIMAL(10,2) -- Salario del profesor en formato decimal ); -- Creación de la tabla COURSES (Cursos) CREATE TABLE COURSES( COURSESID INT PRIMARY KEY, -- Identificador único del curso (clave primaria) COURSESNAME VARCHAR(100), -- Nombre del curso DESCRIPCION TEXT, -- Descripción del curso (texto largo) TEACHERID INT, -- Identificador del profesor que imparte el curso (clave foránea) DURATIONMINUTS SMALLINT, -- Duración del curso en minutos LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- Fecha y hora de carga, con valor por defecto actual FOREIGN KEY (TEACHERID) REFERENCES TEACHER (TEACHERID) -- Clave foránea que referencia a TEACHERID en la tabla TEACHER ); -- Creamos una tabla llamada STUDENT_COURSE para manejar qué estudiantes están inscritos en qué cursos. CREATE TABLE STUDENT_COURSE ( STUDENTID INT, -- Aquí almacenamos el identificador único del estudiante. COURSESID INT, -- Aquí almacenamos el identificador único del curso. ENROLLMENT_DATE DATE, -- La fecha en que el estudiante se inscribió en el curso. PRIMARY KEY (STUDENTID, COURSESID), -- Esta combinación única asegura que cada estudiante no se inscribe dos veces en el mismo curso. FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), -- Nos aseguramos de que el STUDENTID que almacenamos aquí corresponda a un estudiante existente en la tabla STUDENTS. FOREIGN KEY (COURSESID) REFERENCES COURSES(COURSESID) -- Y aquí, que el COURSESID corresponda a un curso existente en la tabla COURSES. ); ```-- Creación de la tabla STUDENTS (Estudiantes)CREATE TABLE STUDENTS(    STUDENTID INT PRIMARY KEY,  -- Identificador único del estudiante (clave primaria)    FIRSTNAME VARCHAR(50),      -- Primer nombre del estudiante    LASTNAME VARCHAR(50),       -- Apellido del estudiante    AGE SMALLINT,               -- Edad del estudiante    EMAIL VARCHAR(100),         -- Correo electrónico del estudiante    LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,  -- Fecha y hora de carga, con valor por defecto actual    UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP  -- Fecha y hora de actualización, con valor por defecto actual); \-- Creación de la tabla TEACHER (Profesores)CREATE TABLE TEACHER(    TEACHERID INT PRIMARY KEY,  -- Identificador único del profesor (clave primaria)    FIRSTNAME VARCHAR,          -- Primer nombre del profesor    LASTNAME VARCHAR,           -- Apellido del profesor    AGE SMALLINT,               -- Edad del profesor    EMAIL VARCHAR(100),         -- Correo electrónico del profesor    PHONE VARCHAR(20),          -- Número de teléfono del profesor    DIRECCION VARCHAR(20),      -- Dirección del profesor (se sugiere aumentar la longitud)    HIRE\_DATE DATE,             -- Fecha de contratación del profesor    SALARY DECIMAL(10,2)        -- Salario del profesor en formato decimal); \-- Creación de la tabla COURSES (Cursos)CREATE TABLE COURSES(    COURSESID INT PRIMARY KEY,         -- Identificador único del curso (clave primaria)    COURSESNAME VARCHAR(100),          -- Nombre del curso    DESCRIPCION TEXT,                  -- Descripción del curso (texto largo)    TEACHERID INT,                     -- Identificador del profesor que imparte el curso (clave foránea)    DURATIONMINUTS SMALLINT,           -- Duración del curso en minutos    LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,  -- Fecha y hora de carga, con valor por defecto actual    FOREIGN KEY (TEACHERID) REFERENCES TEACHER (TEACHERID)  -- Clave foránea que referencia a TEACHERID en la tabla TEACHER); \-- Creamos una tabla llamada STUDENT\_COURSE para manejar qué estudiantes están inscritos en qué cursos.CREATE TABLE STUDENT\_COURSE (    STUDENTID INT,  -- Aquí almacenamos el identificador único del estudiante.    COURSESID INT,  -- Aquí almacenamos el identificador único del curso.    ENROLLMENT\_DATE DATE,  -- La fecha en que el estudiante se inscribió en el curso.    PRIMARY KEY (STUDENTID, COURSESID),  -- Esta combinación única asegura que cada estudiante no se inscribe dos veces en el mismo curso.    FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID),  -- Nos aseguramos de que el STUDENTID que almacenamos aquí corresponda a un estudiante existente en la tabla STUDENTS.    FOREIGN KEY (COURSESID) REFERENCES COURSES(COURSESID)  -- Y aquí, que el COURSESID corresponda a un curso existente en la tabla COURSES.);

Dejo mis apuntes, espero les sirva de ayuda. ## **¿Cómo crear una base de datos en SQL? (clase 3)** En la creación de base de datos, de tablas, y la relación entre ellas, es importante llevar las buenas practicas Por lo que para crear una base de datos relacional y obtener optimización es importante tener en consideración: 1. las 3 reglas de normalización, 2. tener en claro el funcionamiento de la “primary key”, las “foreing key” 3. cual es el concepto de claves de negocios y claves subrogadas. 4. identificar los tipos de datos BUENAS PRACTICAS: 1. es mantener estilos y formatos para todos los nombres de todas las tablas que vaya creando, como para las bases de datos como para los atributos. 2. No es recomendable usar el id de un producto, como primary key Atributos de las tablas * Es importante empezar por los primary keys, claves subrogadas o claves de negocios. * Seguido de claves subrogadas. * Podemos agregar una descripción. * SI VAMOS A CREAR TABLAS DE DIMESIONES O DE HECHOS, ES NECESARIO QUE TENGAS DOS ATRIBUTOS LLAMADOS, “FECHA DE CARGA” (LOADDATE), Y “FECHA DE MODIFICACION” (UPDATEDATE). Esto es importante porque en programas con grandes flujo de datos, es importante saber cuando fueron las fechas de modificaciones, para resolver problemas de soporte, como también saber cuando un dato ingreso al sistema, para hacer los informas mas completos. * No mezclar idiomas. * Dependiendo del motor de base que se utiliza, podemos usar ayudar como lo es el “IDENTITY”, dentro del SQL local, para que automáticamente la clave local se vaya incrementando, a medida que vayamos agregando nuevos registros (en MySQL se utiliza AUTOINCREMENT). * CLAVES FORANEAS (Foreing key) FOREING KEY (INSTRUCTORSID) REFERENCES INSTRUCTORS(INSTRUCTORSID) esta en la forma de hacer el relacionamiento entre Primary key y llaves foraneas * Utilizamos la sentencia “foreing key”. * Especificamos cual es el atributo al cual le hacemos el relacionamiento, entre paréntesis. * Hacemos la referencia a la tabla en la cual se encuentra dicho atributo * Agregamos nuestro campo de referencia, entre paréntesis seguido de la tabla

MIS TABLAS RELACIONADAS \--ESTUDIANTES-- CREATE TABLE STUDENTS ( STUDENTID INT PRIMARY KEY, FIRSTNAME VARCHAR (50), LASTNAME VARCHAR (50), AGE INT, EMAIL VARCHAR (100), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); \-- CURSOS-- CREATE TABLE CURSO ( CURSOID INT PRIMARY KEY, CURSONAME VARCHAR (50), DESCRIPTIONS TEXT, INSTRUCTORID INT, DURATIONHOURS INT, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY(INSTRUCTORID) REFERENCES INSTRUCTORS (INSTRUCTORID) ); \-- MAESTROS-- CREATE TABLE INSTRUCTORS ( INSTRUCTORID INT PRIMARY KEY, NAME VARCHAR(50) NOT NULL, LAST\_NAME VARCHAR (50) NOT NULL, AGE INT, EMAIL VARCHAR(100), CURSOID INT, STUDENTID INT, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), FOREIGN KEY (CURSOID) REFERENCES CURSO(CURSOID) );

Reto completo: 

Recomiendo ocupar **Microsoft SQL Server Management Studio** (comúnmente abreviado como ***SMSS***) es una aplicación utilizada para la gestión y administración de los componentes dentro de [SQL Server](https://es.wikipedia.org/wiki/Microsoft_SQL_Server "Microsoft SQL Server"). Aqui pueden correr los scripts SQL que se ven en el curso.

Este video debería ser mucho mas práctico para personas que no tienen conocimiento base, osea, ir creando paso a paso el tema, desde la creación hasta el guardado, con cada una de las tablas.

Mis tablas son las siguientes: 

Para los que se preguntan qué es una clave subrogada, es una clave que genera artificialmente la base de datos si así se lo pedimos, por ejemplo cuando le asignamos un ID de tipo integer secuencial.. esto es solo un número generado aleatoriamente sin relación alguna con el registro cuyo único propósito es identificarlo.

CREATE forma parte de DDL (Data Definition Languaje) un sublenguaje que ayuda a crear la estructura de una BD, los cimientos, entidades y las relaciones. Dentro de DDL esta como ya vimos * CREATE - Crea base de datos y tablas * ALTER - Altera, modifica * DROP - Borrar

```txt CREATE TABLE INSTRUCTORS ( INSTRUCTORID INT PRIMARY KEY AUTOINCREMENT, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100) LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); ```

UTF8 son las siglas de «8-bit Unicode Transformation Format», un formato de codificación de caracteres Unicode e ISO 10646 que, como particularidad, utiliza símbolos de longitud variable. Tiene una serie de características que lo hacen perfecto para codificar tu correos electrónicos y crear una página web. Para comprender UTF-8, es esencial conocer Unicode también. **Unicode es un estándar global que asigna un número único a cada carácter**, sin importar la plataforma, el programa o el idioma. Es la base de UTF-8 y permite que los caracteres de todos los idiomas se representen de manera coherente.

Es recomendable que los nombres de las tabla sean en singular, ya que las tablas deben hacer referencia a una entidad individual. Tambien es recomendable que los primary se llamen id ya que si ponemos studentid estamos haciendo un poco de redundancia con el nombre de la tabla.

CREATE TABLE INSTRUCTORES ( INSTRUCTORID INT PRIMARY KEY IDENTITY, NOMBRE VARCHAR(50), APELLIDO VARCHAR(50), CEDULA VARCHAR(10), EDAD INT, CORREO VARCHAR(30), FECHACARGA TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP);

![]()Les comparto mi reto: A mano hice un diagrama ERD como guía para empezar a crear la BD y las tablas (no estoy segura de los tipos de cardinalidad):   * DB Browser for SQLite

Cordial saludo Me disculpo solicitar apoyo en este campo, pense que al iniciar el curso seria algo básico pero para algunos lo es pero para mi no. Funciones como VERCHAR TIMESTAMP no se nada de SQL busque cursos en SQL y me aparece este como básico, la profesora u otro compañero tiene algun curso que me puedan recomendar, literal soy desde cero, solo manejo excel y power bi. Busco como potenciar mi conocimiento a traves de SQL como herramienta que me ayude a generar mayor impacto en lo que hago con los datos Agradezco su atención

Me esta gustando esto, de mi lado estoy practicando hacerlo todo desde terminal en mi caso me ha ayudado a reforzar la terminal y la otra entender mucho mejor lo que estamos implementando.

Me parece genial esta clase

Que increible es aprender que con: `CREATE TABLE PRODUCTOS (` `)` Es el inicio para crear nuestra tabla en SQL 👩‍💻

*-- Tabla principal de afiliados*CREATE TABLE afiliados ( id INT PRIMARY KEY AUTO\_INCREMENT, numero VARCHAR(20) NOT NULL, nombre VARCHAR(100) NOT NULL, telefono VARCHAR(20), direccion VARCHAR(200), departamento\_id INT, cargo\_id INT, tipo\_contratacion\_id INT, fecha\_ingreso DATE, fecha\_afiliacion DATE, estamento\_id INT, FOREIGN KEY (departamento\_id) REFERENCES departamentos(id), FOREIGN KEY (cargo\_id) REFERENCES cargos(id), FOREIGN KEY (estamento\_id) REFERENCES estamentos(id), FOREIGN KEY (tipo\_contratacion\_id) REFERENCES tipos\_contratacion(id), UNIQUE KEY uk\_afiliado\_numero (numero));

Lo hice en SQL SERVER

Hola, para crear las tablas cual ser\[ia la mejor practica? se puede hacer todas en una sola pestaña o deben estar separadas? Me refiero a pestaña lo que dice SQLlite.1. 

en sqlite CREATE TABLE STUDENTS ( STUDENTID INTEGER PRIMARY KEY AUTOINCREMENT, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INTEGER, EMAIL VARCHAR(100), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); CREATE TABLE INSTRUCTORS ( INSTRUCTORID INTeger PRIMARY KEY AUTOINCREMENT, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), EMAIL VARCHAR(100), SALARY DECIMAL(10, 2), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); CREATE TABLE COURSES ( COURSEID INTEGER PRIMARY KEY AUTOINCREMENT, COURSENAME VARCHAR(100), DESCRIPTION TEXT, INSTRUCTORID INTEGER, DURATIONHOURS INTEGER, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP , FOREIGN KEY (INSTRUCTORID) REFERENCES INSTRUCTORS(INSTRUCTORID) ); CREATE TABLE STUDENT\_COURSE ( STUDENT\_COURSE\_ID INTEGER PRIMARY KEY AUTOINCREMENT, STUDENTID INTEGER, COURSEID INTEGER, ENROLLMENT\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), FOREIGN KEY (COURSEID) REFERENCES COURSES(COURSEID) );

Algo así me quedo el SQL: ```js CREATE TABLE PRODUCTS ( ID INT PRIMARY KEY, QR VARCHAR(20), DESCRIPCION TEXT ); ``````js CREATE TABLE STUDENTS ( ID INT PRIMARY KEY, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE INSTRUCTORS ( ID INT PRIMARY KEY, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE COURSES ( ID INT PRIMARY KEY, COURSENAME VARCHAR(100), DESCRIPTION TEXT, INSTRUCTORID INT, DURATIONHOURS INT, LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP FOREIGN KEY (INSTRUCTORID) REFERENCES INSTRUCTORS(ID) ); CREATE TABLE COURSE ( ID INT PRIMARY KEY, STUDENTID INT, COURSEID INT, FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(ID), FOREIGN KEY (COURSEID) REFERENCES COURSES(ID) ); ```

Código para crear tabla de Instructores: ```js CREATE TABLE INSTRUCTORS ( INSTRUCTORID INT PRIMARY KEY, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); ```

Código para crear la tabla de instructoresCREATE TABLE TEACHERS ( TEACHERID INT PRIMARY KEY, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); ```txt CREATE TABLE INSTRUCTORS ( INSTRUCTORID INT PRIMARY KEY, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); ```

Para ejecutar lo que se enseña en el curso de Bases de Datos con SQL, necesitarás un editor de texto o un sistema de gestión de bases de datos (DBMS) que soporte SQL. Puedes optar por herramientas como MySQL Workbench, SQLite Studio o incluso utilizar un entorno en línea como DB Fiddle o SQL Fiddle. Estas aplicaciones te permitirán crear bases de datos, tablas y ejecutar consultas SQL de manera efectiva.

Recursos para practicar SQL 

El formato UTF-8 es una codificación de caracteres que permite representar texto en múltiples idiomas y símbolos utilizando un sistema de bytes variable. En SQL, usar UTF-8 asegura que se puedan almacenar y recuperar correctamente caracteres especiales y acentos, lo cual es fundamental para aplicaciones que manejan texto diverso, como nombres de usuarios o descripciones. Utilizar UTF-8 es especialmente importante al crear tablas y definir tipos de datos para que la información se guarde de manera precisa y sin pérdida de datos.

Una clave subrogada es un identificador único creado para una tabla que no tiene un significado real en el mundo, mientras que una clave de negocio es un identificador natural que tiene significado en el contexto del negocio. **Ejemplo:** Si tienes una tabla de productos: - **Clave de negocio**: Código de producto (ej. "001PBTBUZO"). - **Clave subrogada**: ID de producto (ej. 1, 2, 3), que se genera automáticamente y no tiene un significado fuera de la base de datos.

Para las personas que han llegado hasta aquí y no saben que herramienta se esta utilizando en el video, la herramienta es esta: <https://sqliteonline.com/>

Les comparto mi codigo de las tablas creadas en esta clase.    ![]()

yo haría la tabla de relación así: `CREATE TABLE RELATIONT (` ` ` `ID INT PRIMARY KEY,` ` ` `CUORSEID INT,` ` ` `STUDENTSID INT,` ` ` `LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,` ` ` `UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,` ` ` `FOREIGN KEY (CUORSEID) REFERENCES COURSES(courseid),` ` ` `FOREIGN KEY (STUDENTSID) REFERENCES STUDENTS(studentid)` ` );`

Aquí dejo mi tarea. Agradecería mucho una retroalimentación 

Por acá lo mio, agradezco el feedback 

Como se guardan las tablas hechas, no quedan en el lado izquierdo guardadas

Bueno yo las hice asi :CREATE TABLE student ( studentId INT PRIMARY KEY AUTO\_INCREMENT, firsName VARCHAR(50), lastName VARCHAR(50), age INT, email VARCHAR(100), loadDate TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, updateDate TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); ```js CREATE TABLE student ( studentId INT PRIMARY KEY AUTO_INCREMENT, firsName VARCHAR(50), lastName VARCHAR(50), age INT, email VARCHAR(100), loadDate TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updateDate TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE instructors( instructorsId INT PRIMARY KEY AUTO_INCREMENT, firstNameInstructors VARCHAR(50), lastNameInstructors VARCHAR(50), ageInstructors INT, emailIntructors VARCHAR (100), loadDate TIMESTAMP DEFAULT CURRENT_TIMESTAMP, updateDate TIMESTAMP DEFAULT CURRENT_TIMESTAMP ) CREATE TABLE course ( coursedId INT PRIMARY KEY AUTO_INCREMENT, courseName VARCHAR (100), description TEXT, instructorId INT, durationHours INT, load_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, FOREIGN KEY (instructorId) REFERENCES instructors(instructorsId) ) //otra forma de crear una relacion //name de la ralcion //nombre columna tabla course ALTER TABLE `course` ADD CONSTRAINT `Id_cliente` FOREIGN KEY (`instructorsId`) REFERENCES `instructors`(`instructorId`) ON DELETE RESTRICT ON UPDATE RESTRICT; //nombre de la tabla que se va relacionar //tabla a que va a llamar y name id de esta //Estudiante y cursos CREATE TABLE studentAndCourse ( idstudentAndCourse INT PRIMARY KEY AUTO_INCREMENT, idStudent INT, IdCourse INT, ) ALTER TABLE `studentandcourse` ADD CONSTRAINT `idStudentcourse` FOREIGN KEY (`idStudent`) REFERENCES `student`(`stdentId`) ON DELETE RESTRICT ON UPDATE RESTRICT; ```![]()![]()

# ¿Cómo crear una base de datos en SQL? Sintaxis para crear una base de datos CREATE DATABASE ‘nombre de la base de datos’; Crear una tabla, es importante que en la definición de los atributos de la tabla se empiece por las primary key (llaves primarias), claves subrogadas ó claves de negocio. CREATE TABLE ‘nombre de la taba’ (); Buenas prácticas para la creación de tablas: * agregar dos atributos llamados ‘fecha de carga’ y ‘fecha de modificación’ * no mezclar idiomas al nombrar atributos, priorizar el idioma inglés para el nombre de los atributos `CREATE TABLE INSTRUCTORS (` ` INSTRUCTORID INT PRIMARY KEY AUTO_INCREMENT,` ` FIRSTNAME VARCHAR(50),` ` LASTNAME VARCHAR(50),` ` AGE INT,` ` EMAIL VARCHAR(100),` ` SUBJECT VARCHAR(100), -- Campo adicional para la materia que enseña el instructor` ` EXPERIENCE_YEARS INT, -- Campo adicional para los años de experiencia del instructor` ` LOADDATE TIMESTAMP DEFAULT ``CURRENT_TIMESTAMP``,` ` UPDATEDATE TIMESTAMP DEFAULT ``CURRENT_TIMESTAMP ``ON UPDATE ``CURRENT_TIMESTAMP` `);`

   No se si esto es valido pero a mi me enseñaron a poner los valores en NOT NULL, y que se puede declarar la primary key de esa manera, aqui esta mi aporte

Una base de datos relacional es un tipo de sistema de gestión de bases de datos que organiza la información en tablas, las cuales están interrelacionadas. Utiliza un modelo estructurado que permite definir relaciones entre las tablas mediante claves primarias y foráneas, facilitando la consulta y manipulación de datos de manera eficiente.


No es posible que la profe no haya realizado la clase en un programa gratuito o de pago. como crea las bases de datos y tablas así! La verdad no me está gustando el curso, no se si es mi impresión pero le falta herramientas para el desarrollo. lo siento pero ya no continuaré.

donde consigo el simulador de BD

Soy nuevo en esto y no he entendido absolutamente nada, no tengo ni siquiera idea de donde escribir lo que ella dice en el video. No me ha gustado para nada el curso, no está diseñado para principiantes.

buenas tardes , ami no me deja crear la tabla con dos campos de tipo timesatamp en sql server

Alguien sabe cómo editar un campo de la tabla? En especial el ID, Cómo lo convierto en Primary Key si lo he olvidado??

   

Hola, dejo mi Tabla <u>Intermedia de student and curses!</u> CREATE TABLE STUDENT\_CURSES ( STUDENTCURSESID INTEGER PRIMARY KEY IDENTITY, STUDENTSID INT, CURSESID INT, LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (STUDENTCURSESID) REFERENCES STUDENTS(STUDENTID), FOREIGN KEY (CURSESID) REFERENCES CURSES(CURSESID) );

Hola, esta es mi tabla de Instructores. CREATE TABLE INSTRUCTORS ( INSTRUCTORID INT PRIMARY KEY IDENTITY, FIRSTNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP );

Posiblemente nos sea de ayuda, tener en cuenta que el nombrar las tablas se defina que almacenara para así darle un nombre en plural o en singular según su necesidad, y que también manejemos una misma si taxis para que al momento de leer nuestras query sea mucho mas fácil tal como camelCase que es una de las que mas se utilizan así como la separación con raya al piso.

CONVENCIONES ADICIONALES: * Otra convención es que se debe de crear los nombres de bases de datos, tablas y columnas en inglés. * También está el tema de los campos como dijo la instructora de de los campos de CREATED\_AT y UPDATED\_AT, que son para llevar un registro de creación y modificación del registro.

NOMBRES DE TABLAS La elección entre usar nombres de tablas en singular o plural en bases de datos es una cuestión de estilo y consistencia. Aquí hay algunas consideraciones para ayudar a decidir: ### Singular * **Ventajas**: * **Claridad**: Un nombre en singular puede ser más claro y directo, indicando que cada fila representa una entidad única. * **Consistencia con el modelo de objetos**: Si usamos un ORM (Object-Relational Mapping), los nombres en singular pueden coincidir mejor con los nombres de las clases en el código. * **Ejemplo**: `Usuario`, `Producto`, `Pedido`. ### Plural * **Ventajas**: * **Intuitivo**: Puede ser más intuitivo para algunos, ya que una tabla contiene múltiples registros. * **Consistencia con el lenguaje natural**: En muchos casos, hablar de “usuarios” o “productos” en plural puede parecer más natural. * **Ejemplo**: `Usuarios`, `Productos`, `Pedidos`. ### Recomendación Lo más importante es **mantener la consistencia** en todo el esquema de base de datos. Si se decide usar nombres en singular, debemos de asegurarnos de que todas las tablas sigan esa convención, y lo mismo si optamos por nombres en plural.

Me parece bien que vayamos a la práctica inmediatamente y que las teorías que quizás tenían sus dudas queden resueltas con la práctica.

siento que es importante aclarar desde el inicio del curso, cuáles van a ser las herramientas para el desarrollo del curso. La instructora va saltando de una la pantalla a escribir código sin decir en qué tipo de plataforma lo está haciendo

Cordial saludo profe Caro, aqui mi tablita de instructores 😎 create table instructors( instructorid int primary key, firstname varchar(50), lastname varchar(50), age int, studentGroup varchar(50), schoolSubject varchar(50), email varchar(150), loadDate timestamp default current\_timestamp, updateDate timestamp default current\_timestamp ); Gracias por la clase! 😁

Tabla Instructor: CREATE TABLE INSTRUCTORS (     INSTRUCTOR INT PRIMARY KEY,     FIRSTNAME VARCHAR (100),     LASTNAME VARCHAR (100),     AGE INT,     EMAIL VARCHAR (100),     LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,     UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, );

CREATE TABLE STUDENTS ( STUDENTSID INT PRIMARY KEY, FIRTSNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT EMAIL VARCHAR(100), LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); /// CREATE TABLE INSTRUCTOR ( INSTRUCTORID INT PRIMARY KEY, FIRTSNAME VARCHAR(50), LASTNAME VARCHAR(50), AGE INT EMAIL VARCHAR(100), PHONE VARCHAR(20), CURSES LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); // CREATE TABLE CURSES ( CURSESID INT PRIMARY KEY, CURSESNAME VARCHAR(100), DESCRIPTION TEXT, INTRUCTORID INT, DURATIONHOURS INT, LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (INTRUCTORID) REFERENCES INSTRUCTORS(INTRUCTORID) ); // CREATE TABLE STUDENTCURSES ( STUDENTCURSESID INT PRIMARY KEY, STUDENTSID INT, CURSESID INT, LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (STUDENTCURSESID) REFERENCES STUDENTS(STUDENTSID), FOREIGN KEY (CURSESID) REFERENCES CURSES(CURSESID) );


Una cosa interesante es que la forma en que relaciona las tablas por detrás los motores como por ejemplo MySQL es mediante **BTREE** que podemos omitir o especificar, de tal forma que si se modifica un elemento, las referencias también. Esto puede llevar a errores por lo cual lo ideal primero es **hacer tu DER**, y si lo vemos como un árbol empezar a hacer las tablas por las hojas y terminar en la que tiene la tabla con mas referencias ya que al ejecutar las instrucciones va a buscar una referencia de una tabla que no se ha creado. :)

✅

No tengo experiencia con SQL y este se supone que es el curso mas basico. Alguién sabe dónde o en que link puedo aprender a intalarlo e identificar todo el funcionamiento. Gracias.

```python CREATE TABLE Profesores ( IDPROFESOR PRIMARY KEY IDENTITY, NOMBRE VARCHAR(100), APELLIDO VARCHAR (100), EDAD INT, CUMPLE DATE DESCRIPCION TEXT, LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, ); 'Esto es va en la tabla general (la de CURSES del ejericio de la profe) para relacionar esta de arriba :' FOREIGN KEY (IDPROFESOR) REFERENCES Profesores(IDPROFESOR) ```

Yo no cree una tabla student ya que considero que un teacher y un student tienen datos en comun. ```js CREATE TABLE user ( id INT PRIMARY KEY, firtname VARCHAR(50), lastname VARCHAR(50), age INT, email VARCHAR(100), created_at TIMESTAMP DEFAULT current_timestamp, updated_at TIMESTAMP DEFAULT current_timestamp ON UPDATE current_timestamp ) CREATE TABLE teacher ( id INT PRIMARY KEY, user_id INT, created_at TIMESTAMP DEFAULT current_timestamp, updated_at TIMESTAMP DEFAULT current_timestamp ON UPDATE current_timestamp FOREIGN KEY (user_id) REFERENCES user(id) ) CREATE TABLE course ( id INT PRIMARY KEY, name VARCHAR(100), description TEXT, teacher_id INT, duration INT, created_at TIMESTAMP DEFAULT current_timestamp, updated_at TIMESTAMP DEFAULT current_timestamp ON UPDATE current_timestamp, FOREIGN KEY (teacher_id) REFERENCES teacher(id) ) CREATE TABLE student_course ( id INT PRIMARY KEY, user_id INT, course_id INT, created_at TIMESTAMP DEFAULT current_timestamp, updated_at TIMESTAMP DEFAULT current_timestamp ON UPDATE current_timestamp, FOREIGN KEY (user_id) REFERENCES user(id), FOREIGN KEY (course_id) REFERENCES course(id) ) ```

No guardó ninguna de mis tablas, pero de igual forma lo entendí todo

Tuve una duda de por qué no me ejecutaba la Foreign Key, pero tenía un error. Por lo que entiendo la estructura sería lo siguiente: En la Foreign Key primero se pone la columna donde vas a almacenar la información (Instructorid), que pertenece a tu actual tabla, y después escribimos la referencia hacia la columna de la tabla externa "References Instructors(instructorid). Puede ser una duda muy básica, pero creo logré entenderlo ja! Saludos!

NO ENTIENDO porque me da este error: se salta las cosas no se porque no lo hace paso a paso :( 

Por qué sucede esto? 

Quisiera que me informaran cual es el programa que ella utiliza, que gestor de Db es?. Dice que utiliza un editor de texto online pero no menciona cual y con que gestor está asociado.

CREATE TABLE STUDENTS\_COURSES( id INT NOT NULL AUTO\_INCREMENT, studentID INT NOT NULL, courseID INT NOT NULL, FOREIGN KEY studentID REFERENCES STUDENTS(studentId), FOREIGN KEY coursesID REFERENCES COURSES(courseId ) );

Buen día muchas gracias, al generar el cod me sale una serie de errores que no entiendo mucho. la verdad es mi primer acercamiento en el mundo de SQL. 

CREATE TABLE INSTRUCTOR() INSTRUCTORID INT PRIMARY KEY, INSTRUCTORNAME VARCHAR(100), COURSEID INT, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPTADE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN (COURSESID) REFERENCES COURSES(COURSESID) ;

deacuerdo a la investigacion podemos usar tipo de dato unicode que se representa de la sigueinte manera (nchar, avarchar, ntexto)

* Creación de Bases de Datos y Tablas: \- Es una parte esencial del trabajo de un ingeniero de datos. \- Es crucial seguir buenas prácticas y reglas de normalización. * Buenas Prácticas: \- Tener en cuenta las tres reglas de normalización. \- Entender el funcionamiento de las claves primarias (primary key) y foráneas (foreign key). \- Conocer el concepto de claves de negocios y claves subrogadas. \- Identificar correctamente los tipos de datos. * Sintaxis de SQL: \- **Crear Base de Datos**: `CREATE DATABASE nombre\_de\_la\_base\_de\_datos`. \- **Crear Tablas**: `CREATE TABLE nombre\_de\_la\_tabla (atributos);`. \- Mantener consistencia en el formato de nombres (mayúsculas o minúsculas). * Definición de Atributos: \- Comenzar con las claves primarias, subrogadas o de negocios. \- Ejemplo: `id\_producto INT PRIMARY KEY`, `nombre\_producto VARCHAR(20)`. * Tipos de Datos y Formato: \- Investigar y utilizar correctamente el formato UTF-8 para caracteres especiales. \- Importancia de elegir el tipo de dato adecuado para optimizar almacenamiento y procesamiento. * Ejemplo de Base de Datos de Estudiantes: \- Atributos comunes: ID de estudiante, nombre, apellido, edad, correo. \- Incluir fecha de carga y fecha de modificación para seguimiento y soporte. * Relaciones y Claves Foráneas: \- Utilizar `FOREIGN KEY` para relacionar tablas. \- Ejemplo: `FOREIGN KEY (instructor\_id) REFERENCES instructors(id)`. * Consistencia de Idiomas y Motores de Bases de Datos: \- Mantener un idioma consistente en nombres y comandos. \- Diferencias en autoincrementos: `IDENTITY` para SQL Server, `AUTO\_INCREMENT` para MySQL.

Le puse SMALLINT porque creo que nos podemos ahorrar esos dos bytes, en algunas tablas, se las comparto. ```txt -- Creación de la tabla STUDENTS (Estudiantes) CREATE TABLE STUDENTS( STUDENTID INT PRIMARY KEY, -- Identificador único del estudiante (clave primaria) FIRSTNAME VARCHAR(50), -- Primer nombre del estudiante LASTNAME VARCHAR(50), -- Apellido del estudiante AGE SMALLINT, -- Edad del estudiante EMAIL VARCHAR(100), -- Correo electrónico del estudiante LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- Fecha y hora de carga, con valor por defecto actual UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP -- Fecha y hora de actualización, con valor por defecto actual ); -- Creación de la tabla TEACHER (Profesores) CREATE TABLE TEACHER( TEACHERID INT PRIMARY KEY, -- Identificador único del profesor (clave primaria) FIRSTNAME VARCHAR, -- Primer nombre del profesor LASTNAME VARCHAR, -- Apellido del profesor AGE SMALLINT, -- Edad del profesor EMAIL VARCHAR(100), -- Correo electrónico del profesor PHONE VARCHAR(20), -- Número de teléfono del profesor DIRECCION VARCHAR(20), -- Dirección del profesor (se sugiere aumentar la longitud) HIRE_DATE DATE, -- Fecha de contratación del profesor SALARY DECIMAL(10,2) -- Salario del profesor en formato decimal ); -- Creación de la tabla COURSES (Cursos) CREATE TABLE COURSES( COURSESID INT PRIMARY KEY, -- Identificador único del curso (clave primaria) COURSESNAME VARCHAR(100), -- Nombre del curso DESCRIPCION TEXT, -- Descripción del curso (texto largo) TEACHERID INT, -- Identificador del profesor que imparte el curso (clave foránea) DURATIONMINUTS SMALLINT, -- Duración del curso en minutos LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, -- Fecha y hora de carga, con valor por defecto actual FOREIGN KEY (TEACHERID) REFERENCES TEACHER (TEACHERID) -- Clave foránea que referencia a TEACHERID en la tabla TEACHER ); ```-- Creación de la tabla STUDENTS (Estudiantes)CREATE TABLE STUDENTS(    STUDENTID INT PRIMARY KEY,  -- Identificador único del estudiante (clave primaria)    FIRSTNAME VARCHAR(50),      -- Primer nombre del estudiante    LASTNAME VARCHAR(50),       -- Apellido del estudiante    AGE SMALLINT,               -- Edad del estudiante    EMAIL VARCHAR(100),         -- Correo electrónico del estudiante    LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,  -- Fecha y hora de carga, con valor por defecto actual    UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP  -- Fecha y hora de actualización, con valor por defecto actual); \-- Creación de la tabla TEACHER (Profesores)CREATE TABLE TEACHER(    TEACHERID INT PRIMARY KEY,  -- Identificador único del profesor (clave primaria)    FIRSTNAME VARCHAR,          -- Primer nombre del profesor    LASTNAME VARCHAR,           -- Apellido del profesor    AGE SMALLINT,               -- Edad del profesor    EMAIL VARCHAR(100),         -- Correo electrónico del profesor    PHONE VARCHAR(20),          -- Número de teléfono del profesor    DIRECCION VARCHAR(20),      -- Dirección del profesor (se sugiere aumentar la longitud)    HIRE\_DATE DATE,             -- Fecha de contratación del profesor    SALARY DECIMAL(10,2)        -- Salario del profesor en formato decimal); \-- Creación de la tabla COURSES (Cursos)CREATE TABLE COURSES(    COURSESID INT PRIMARY KEY,         -- Identificador único del curso (clave primaria)    COURSESNAME VARCHAR(100),          -- Nombre del curso    DESCRIPCION TEXT,                  -- Descripción del curso (texto largo)    TEACHERID INT,                     -- Identificador del profesor que imparte el curso (clave foránea)    DURATIONMINUTS SMALLINT,           -- Duración del curso en minutos    LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,  -- Fecha y hora de carga, con valor por defecto actual    FOREIGN KEY (TEACHERID) REFERENCES TEACHER (TEACHERID)  -- Clave foránea que referencia a TEACHERID en la tabla TEACHER);

```txt ```

Estas serían las tablas del ejercicio de esta clase: ```txt CREATE TABLE STUDENTS ( STUDENT_ID INT PRIMARY KEY, FIRST_NAME VARCHAR(50), LAST_NAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE INSTRUCTORS( INSTRUCTOR_ID INT PRIMARY KEY, FIRST_NAME VARCHAR(50), LAST_NAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE COURSES( COURSE_ID INT PRIMARY KEY, COURSE_NAME VARCHAR(100), DESCRIPTION TEXT, INSTRUCTOR_ID INT, DURATION_HOURS INT, LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (INSTRUCTOR_ID) REFERENCES INSTRUCTORS(INSTRUCTOR_ID) ); CREATE TABLE STUDENTS_COURSES ( ID INT PRIMARY KEY, STUDENT_ID INT, COURSE_ID LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (STUDENT_ID) REFERENCES STUDENTS(STUDENT_ID), FOREIGN KEY (COURSE_ID) REFERENCES COURSES(COURSE_ID) ); ```CREATE TABLE STUDENTS ( STUDENT\_ID INT PRIMARY KEY, FIRST\_NAME VARCHAR(50), LAST\_NAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); CREATE TABLE INSTRUCTORS( INSTRUCTOR\_ID INT PRIMARY KEY, FIRST\_NAME VARCHAR(50), LAST\_NAME VARCHAR(50), AGE INT, EMAIL VARCHAR(100), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); CREATE TABLE COURSES( COURSE\_ID INT PRIMARY KEY, COURSE\_NAME VARCHAR(100), DESCRIPTION TEXT, INSTRUCTOR\_ID INT, DURATION\_HOURS INT, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (INSTRUCTOR\_ID) REFERENCES INSTRUCTORS(INSTRUCTOR\_ID) ); CREATE TABLE STUDENTS\_COURSES ( ID INT PRIMARY KEY, STUDENT\_ID INT, COURSE\_ID LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (STUDENT\_ID) REFERENCES STUDENTS(STUDENT\_ID), FOREIGN KEY (COURSE\_ID) REFERENCES COURSES(COURSE\_ID) );

Las instrucciones al momento: CREATE DATABASE PLATZI\_SCHOOL; CREATE TABLE STUDENTS( STUDENTID INT PRIMARY KEY, FIRSTNAME VARCHAR(20), LASTNAME VARCHAR(20), AGE INT, EMAIL VARCHAR(60), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); CREATE TABLE INSTRUCTORS ( INSTRUCTORID INT PRIMARY KEY, FIRSTNAME VARCHAR(30), LASTNAME VARCHAR(30), AGE INT, EMAIL VARCHAR(60), COURSEID INT, SALARY DECIMAL (10, 2), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), FOREIGN KEY (COURSEID) REFERENCES COURSE(COURSEID) ); CREATE TABLE COURSES ( COURSEID INT PRIMARYKEY, COURSENAME VARCHAR(100), DESCRIPTION TEXT, INSTRUCTORID INT, DURATIONHOURS INT, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP , FOREIGN KEY (INSTRUCTORID) REFERENCES INSTRUCTORS(INSTRUCTORID) ); CREATE TABLE STUDENT\_COURSES ( STUDENT\_COURSE\_ID INT PRIMARY KEY, STUDENTID INT, COURSEID INT, ENROLLMENT\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), FOREIGN KEY (COURSEID) REFERENCES COURSES(COURSEID) );

![]()Así quedó, con las instrucciones de la clase:

Así quedó con las instrucciones al momento: ![]()![]()![]()![]()![]() CREATE DATABASE PLATZI\_SCHOOL; CREATE TABLE STUDENTS( STUDENTID INT PRIMARY KEY, FIRSTNAME VARCHAR(20), LASTNAME VARCHAR(20), AGE INT, EMAIL VARCHAR(60), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP ); CREATE TABLE INSTRUCTORS ( INSTRUCTORID INT PRIMARY KEY, FIRSTNAME VARCHAR(30), LASTNAME VARCHAR(30), AGE INT, EMAIL VARCHAR(60), COURSEID INT, SALARY DECIMAL (10, 2), LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), FOREIGN KEY (COURSEID) REFERENCES COURSE(COURSEID) ); CREATE TABLE COURSES ( COURSEID INT PRIMARYKEY, COURSENAME VARCHAR(100), DESCRIPTION TEXT, INSTRUCTORID INT, DURATIONHOURS INT, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP , FOREIGN KEY (INSTRUCTORID) REFERENCES INSTRUCTORS(INSTRUCTORID) ); CREATE TABLE STUDENT\_COURSES ( STUDENT\_COURSE\_ID INT PRIMARY KEY, STUDENTID INT, COURSEID INT, ENROLLMENT\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, LOAD\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, UPDATE\_DATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), FOREIGN KEY (COURSEID) REFERENCES COURSES(COURSEID) );

Siento que necesitaba un conocimiento previo antes de iniciar el curso, por ahora solo copiare todo, y después entenderé ... 🤯

```js -- CREATE TABLE FOR STUDENTS CREATE TABLE students ( studentid SERIAL PRIMARY KEY, firstname VARCHAR(50), lastname VARCHAR(50), age INT, email VARCHAR(100), load_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- CREATE TABLE FOR INSTRUCTORS CREATE TABLE instructors ( instructorid SERIAL PRIMARY KEY, firstname VARCHAR(50), lastname VARCHAR(50), email VARCHAR(100), salary DECIMAL(10, 2), load_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); -- CREATE TABLE FOR COURSES CREATE TABLE courses ( courseid SERIAL PRIMARY KEY, coursename VARCHAR(100), description TEXT, instructorid INT, durationhours INT, load_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (instructorid) REFERENCES instructors(instructorid) ); -- CREATE TABLE FOR STUDENT_COURSE RELATIONSHIP CREATE TABLE student_course ( student_course_id SERIAL PRIMARY KEY, studentid INT, courseid INT, enrollment_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, load_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, update_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY (studentid) REFERENCES students(studentid), FOREIGN KEY (courseid) REFERENCES courses(courseid) ); ```

Por qué la tabla courses se relacionó con la tabla instructors usando la foreign key, pero no se relacinó de las misma manera con la tabla students? Por qué debemos crear una tabla de relacionamiento entre estudiantes y cursos, pero no creamos una nueva tabla de relacionamiento entre instructores y cursos? Estoy usando el SQL online editor que está en los recursos de la clase, pero siempre que refresco se borran las tablas, el código no se borra, pero sí las tablas

Me gustaria aportar que al utilizar MySQL Workbench, podemos crear las tablas y los esquemas y MySQL genera el codigo automaticamente

CREATE TABLE COURSES2 ( COURSESID INT PRIMARY KEY, COURSENAME VARCHAR(100), DESCRIPTION TEXT, STUDENTID INT, DURATIONHOURS INT, loaddate TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, updatedate TIMESTAMP DEFAULT CURRENT\_TIMESTAMP, FOREIGN KEY (studentid) REFERENCES STUDENTS (studentid) );