¡El poder de los datos!
¡El poder de los datos!
Fundamentos de Bases de Datos
Sistema de Gestión de Bases de Datos
¿Qué es una base de datos?
¿Qué es SQL?
Los comandos SQL más importantes
Operaciones básicas en SQL
Modelo Entidad Relación (ER)
Normalización
Introducción a las bases de datos relacionales
Tipos de datos en SQL
¿Cómo crear una base de datos en SQL?
Buenas practicas de bases de datos con SQL
Práctica: Tu primera consulta en bases de datos
Manipulación de Datos
Insertando Datos con SQL (INSERT)
Práctica: Creación de Tablas en SQL (CREATE TABLE)
Consultas y Selecciones en SQL (SELECT)
Práctica: SELECT en SQL
Eliminación de Datos con SQL (DELETE)
Actualización de Datos con SQL (UPDATE)
Práctica: CRUD con SQL
Manipulación Avanzada de Datos
🛠️ Guía de instalación de MySQL y MySQL Workbench
¿Qué es la cláusula WHERE de SQL?
Filtrar y Ordenar Datos en SQL (LIKE)
Cláusulas de Comparación Textual en SQL (AND, NULL, IN, NOT)
Funciones de Aritmética Básica en SQL (COUNT)
Funciones de Aritmética Básica en SQL (MIN, MAX)
Agrupación de Datos
Agrupación de Datos en SQL: GROUP BY, HAVING y CASE para Análisis Avanzado
Tipos de JOIN en SQL
¿Cómo funciona INNER JOIN, LEFT JOIN, RIGHT JOIN y FULL JOIN?
Transformación de Datos
Vistas Materializadas en SQL: Como optimizar tus consultas y reportes.
Vistas Materializadas y Temporales en SQL
Expresiones de Tablas Comunes (CTE) en SQL
Procedimientos Almacenados
Procedimientos Almacenados en SQL
Procedimientos Almacenados en SQL: Gestión de Variables y Manejo de Excepciones
Administración de Base de Datos
Respaldos y Restauración de Bases de Datos
Análisis de Datos Avanzados
Potenciando los Datos en la Nube: Data Science, Big Data, ML e AI
SQL para Análisis de Datos: Primeros pasos con Power BI
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Recursos
¿Por qué es crucial seguir buenas prácticas al crear bases de datos?
La correcta creación de bases de datos, tablas y sus relaciones es fundamental para un ingeniero de datos. Estas habilidades no solo facilitan la organización de la información, sino que también optimizan el rendimiento y la ejecución de los procesos. Al considerar ciertos principios, como las reglas de normalización y el uso adecuado de claves primarias y foráneas, se garantiza integridad y eficiencia. Además, es esencial comprender los conceptos de claves de negocio y subrogadas, junto con la adecuada identificación de tipos de datos para mantener la calidad de la información.
¿Cómo crear una base de datos y tablas en SQL?
Cuando se trabaja en SQL, la sintaxis y el formato son cruciales. Comienza creando una base de datos con el comando CREATE DATABASE seguido del nombre deseado, recordando que el estilo de nombres (mayúsculas o minúsculas) debe ser coherente para todas las bases de datos, tablas y atributos.
Sintaxis básica para crear una tabla
Para crear tablas, utiliza el comando CREATE TABLE seguido del nombre de la tabla y una lista de sus atributos:
CREATE TABLE Estudiantes (
ID_Estudiante INT PRIMARY KEY,
Nombre VARCHAR(50),
Apellido VARCHAR(50),
Edad INT,
Correo VARCHAR(100),
Fecha_Carga DATE,
Fecha_Modificacion DATE
);
Es importante comenzar con las claves primarias, subrogadas o de negocio. Por ejemplo, en un comercio digital, un producto con un ID interno sería mejor gestionado con una clave subrogada dentro de la base de datos, mientras que la clave de negocio podría estar más relacionada con la identificación externa del producto.
Buenas prácticas adicionales
- Incluye atributos de fecha de carga y modificación en tus tablas para control de versiones y soporte.
- Define los nombres de tablas y atributos en un solo idioma para prevenir errores de interpretación.
- Dependiendo del motor de base de datos, realiza ajustes necesarios como el uso de
IDENTITYoAUTOINCREMENTpara las claves primarias numéricas.
¿Cómo gestionar las relaciones entre tablas con foreign keys?
La clave foránea o foreign key es fundamental para relacionar tablas. Al definir estos vínculos, debes especificar qué atributo se relaciona con otra tabla. Utiliza la sentencia FOREIGN KEY para establecer estas conexiones.
Ejemplo de relación entre tablas
Imaginemos que deseamos relacionar la tabla de estudiantes con la de instructores utilizando el atributo ID_Instructor:
CREATE TABLE Cursos (
ID_Curso INT PRIMARY KEY,
Nombre_Curso VARCHAR(100),
ID_Instructor INT,
FOREIGN KEY (ID_Instructor) REFERENCES Instructores(ID_Instructor)
);
Esta declaración asegura que cada registro de curso tenga asignado un instructor existente en la tabla Instructores.
¿Qué considerar al usar distintos motores de bases de datos?
No todos los comandos son compatibles con todos los motores de bases de datos. Por ejemplo:
- En motores como SQL Server se puede usar
IDENTITYpara autoincrementar claves. - En MySQL se utiliza
AUTO_INCREMENT. - SQLite no soporta directamente estas funcionalidades, pero se pueden implementar mediante procedimientos almacenados.
Es fundamental adaptar el código según el motor de base de datos usado y saber que algunas funcionalidades pueden variar o requerir soluciones alternativas.
Práctica recomendada
Te desafío a crear una tabla para instructores siguiendo estas pautas, y a compartir tus hallazgos o dudas sobre la sintaxis y tipos de datos en los comentarios. También, intenta crear una tabla de relación entre estudiantes y cursos, identificando cómo conectarás las claves foráneas, y revisa qué otros campos podrías incluir. Esta práctica fortalecerá tus habilidades y profundidad de conocimiento en gestión de bases de datos.
Aportes 76
Preguntas 1
Ordenar por:
Editor DB utilizado en la clase:
📌 <https://sqliteonline.com/>
Hola porque no nos explicas qué aplicación estás usando, como abrirla y ahí si como usarla. Muchos de acá venimos desde cero y yo al menos me perdí en esta clase. Gracias por entender.
les ahorro el resto de clase para los novatos como yo, aqui esta la mejor documentacion de sql <https://www.w3schools.com/sql/default.asp>
UTF-8 (Unicode Transformation Format - 8-bit) is a character encoding standard used to represent characters and symbols in text. It is widely adopted because it can encode all possible characters (called code points) in Unicode, which includes virtually every character from every writing system in the world. Here are some key points about UTF-8:
### Key Features of UTF-8
1. **Variable-Length Encoding**:
* UTF-8 uses a variable number of bytes to encode characters. Common characters (like those in the ASCII set) are encoded using a single byte, while less common characters can use up to four bytes.
2. **Backward Compatibility with ASCII**:
* UTF-8 is designed to be backward-compatible with ASCII. The first 128 characters of UTF-8 are the same as ASCII, which means that ASCII text is also valid UTF-8 text.
3. **Efficient Storage**:
* Because common characters are encoded using fewer bytes, UTF-8 is generally more storage-efficient than other encoding schemes like UTF-16 or UTF-32, especially for texts that primarily use ASCII characters.
4. **Wide Adoption**:
* UTF-8 is the default encoding for the web and is supported by most modern programming languages, databases, and operating systems.
No entendi la clase. No supe que programa se esta usando, como usarlo. No entendi por que se hizo lo que se hizo, y el lenguaje fue demasiado tecnico. Vengo comenzando desde 0 y no aprendi nada.
Propuesta de tabla de relacionamiento entre estudiantes y cursos:
Soy un novato en bases de datos y la verdad este curso me ha dejado mas confundido que cuando no sabia nada del tema. El orden de las clases en las cuales se abarca el mismo tema, y la generalización de los conceptos importantes dejan mucho que desear.
Incluir los campos `loaddate` y `updatedate` en una tabla es crucial para el manejo de datos. Estos campos permiten rastrear cuándo se ingresó un registro por primera vez y cuándo se actualizó por última vez. Esto es especialmente importante en escenarios de grandes volúmenes de datos, ya que facilita la auditoría, gestión de cambios y soporte. Además, ayuda en la toma de decisiones informadas al proporcionar un historial temporal que puede ser analizado.
Propuesta de la tabla de Intructores:
tabla de relacionamiento entre estudiantes y cursos:
En SQL, el tipo de dato que te permite almacenar texto que puede incluir caracteres especiales de cualquier idioma (como letras acentuadas, caracteres chinos, árabes, emojis, etc.) es `NVARCHAR` o `NCHAR`, dependiendo del uso.
El formato **UTF-8** (Unicode Transformation Format - 8-bit) es un estándar de codificación de caracteres ampliamente utilizado que permite representar texto en cualquier idioma y conjunto de caracteres utilizando Unicode.
Actualmente estoy usando MS SQL Server 18 que es la que usa la empresa donde trabajo. No me permite crear 2 atributos TIMESTAMP dentro de una misma tabla, pero según la IA, puedo usar DATETIME para ambas columnas, por si alguien se pregunta como solucionar este error.
UTF-8 es un sistema de codificación de caracteres que puede representar cualquier carácter en el estándar Unicode. Utiliza entre 1 y 4 bytes por carácter, permitiendo incluir caracteres de diferentes alfabetos y símbolos. Es compatible con ASCII, lo que significa que los primeros 128 caracteres son iguales a los de ASCII. Esto lo hace muy útil para aplicaciones web y bases de datos, asegurando que los datos se manejen correctamente en múltiples idiomas. Se recomienda su uso en la creación de bases de datos para garantizar la correcta representación de textos.
En mi opinion, platzi tiene muy buenos cursos y es un buen lugar para aprender, pero este curso y el formato que llevan no me gusta. Demasiado texto, no explican bien y si alguien esta iniciando de cero quedara perdido.
Mi propuesta para estudiantes-cursos cuya cardinalidad es muchos a muchos.
```js
create database Academy_2025;
use Academy_2025;
create table students(
student_id int primary key,
firstname varchar(50),
lastname varchar(50),
age int,
email varchar(50),
LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
create table instructors(
instructors_id int primary key,
firstname varchar(50),
lastname varchar(50),
email varchar(50),
LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
create table courses (
course_id int primary key,
coursename varchar(100),
descriptions text,
instructors_id int,
durationhours int,
LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
foreign key (instructors_id) references instructors(instructors_id)
);
create table coursesXstudents(
coursesXstudent_id int primary key,
course_id int,
student_id int,
foreign key (student_id) references students(student_id),
foreign key (course_id) references courses(course_id),
LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```create database Academy\_2025;
use Academy\_2025;
create table students(
student\_id int primary key,
firstname varchar(50),
lastname varchar(50),
age int,
email varchar(50),
LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP
);
create table instructors(
instructors\_id int primary key,
firstname varchar(50),
lastname varchar(50),
email varchar(50),
LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP
);
create table courses (
course\_id int primary key,
coursename varchar(100),
descriptions text,
instructors\_id int,
durationhours int,
LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,
foreign key (instructors\_id) references instructors(instructors\_id)
);
create table coursesXstudents(
coursesXstudent\_id int primary key,
course\_id int,
student\_id int,
foreign key (student\_id) references students(student\_id),
foreign key (course\_id) references courses(course\_id),
LOADDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT\_TIMESTAMP
);
En MySQL:
```js
CREATE TABLE STUDENTS (
STUDENTID INT PRIMARY KEY AUTO_INCREMENT,
FIRSTNAME VARCHAR(50),
LASTNAME VARCHAR(50),
AGE INT,
EMAIL VARCHAR(100),
LOADDATE timestamp DEFAULT current_timestamp,
UPDATEDATE timestamp DEFAULT current_timestamp
);
CREATE 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
);
CREATE TABLE COURSES (
COURSESID INT PRIMARY KEY,
COURSENAME VARCHAR(10),
DESCRIPTION TEXT,
TEACHERID INT,
DURATIONHOURS INT,
LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (TEACHERID) REFERENCES TEACHERS(TEACHERID)
);
```
Crear tabla para profesores
```js
CREATE TABLE TEACHER (
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
);
```
CREATE TABLE ENROLLMENTS (
ENROLLMENTID INT IDENTITY(1,1) PRIMARY KEY, -- Clave primaria con IDENTITY
STUDENTID INT NOT NULL, -- Clave foránea para STUDENTS
COURSEID INT NOT NULL, -- Clave foránea para COURSES
ENROLL\_DATE DATETIME DEFAULT CURRENT\_TIMESTAMP, -- Fecha de inscripción
LOAD\_DATE DATETIME DEFAULT CURRENT\_TIMESTAMP, -- Fecha de creación del registro
UPDATE\_DATE DATETIME DEFAULT CURRENT\_TIMESTAMP, -- Fecha de la última actualización
\[STATUS] VARCHAR(20) DEFAULT 'ACTIVE', -- Estado de la inscripción
FOREIGN KEY (STUDENTID) REFERENCES STUDENTS(STUDENTID), -- Relación con STUDENTS
FOREIGN KEY (COURSEID) REFERENCES COURSES(COURSEID) -- Relación con COURSES
);
Esta es la propuesta que tengo respecto a una posible tabla de estudiantes, profesores, y cursos. Abierto a correcciones, ya que tengo muy pocos conocimientos sobre SQL.
El tipo de dato `timestamp` es fundamental en bases de datos relacionales, ya que se utiliza para almacenar información sobre la fecha y hora en que ocurrió un evento. Esto es esencial para el seguimiento de cambios en los registros, como cuándo se creó o se actualizó un dato.
Por ejemplo, una tabla de estudiantes podría tener un campo `created_at` de tipo `timestamp` para registrar la fecha y hora de creación de cada registro. La definición en SQL podría verse así:
```sql
CREATE TABLE estudiantes (
id_estudiante INT PRIMARY KEY,
nombre VARCHAR(50),
correo VARCHAR(100),
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```
Aquí, `created_at` se llenará automáticamente con la fecha y hora actuales cuando se inserte un nuevo estudiante.
Concuerdo con el compañero, de tener unas mejores ayudas graficas para este curso, para los que no tienen conocimiento en bd deben estar perdidos... sería fantastico la instlación del motor y como usarlo desde cero antes de crear lineas sql... gracias por comprender!
Comparto lo que considero es el codigo para crear la tabla de instructores, atento al feedback que pueda recibir :)
`CREATE TABLE INSTRUCTORS (`
` INSTRUCTORID INT PRIMARY KEY,`
` FIRSTNAME VARCHAR(50),`
` LASTNAME VARCHAR(50),`
` AGE INT,`
` EMAIL VARCHAR(100),`
` COURSENAME VARCHAR(20),`
` COURSEID INT,`
` LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,`
` UPDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP);`
` `
No entendi la clase. No supe que programa se esta usando, como usarlo. No entendi por que se hizo lo que se hizo, y el lenguaje fue demasiado tecnico. Vengo comenzando desde 0 y no aprendi nada.
Hasta el momento este curso no tiene el rigor que tenía el anterior, era largo, en algunas ocasiones denso, pero mucho más completo. Si no tienes conocimientos previos, avanzar con este curso puede ser complejo. Veremos como termina
Asignación de la profesora
Esta es mi propuesta, atendiendo lo que he tratado de entender.
Hola a todos, estoy diseñando la tabla de instructores y pensé en añadir atributos para su título de pregrado ("bachelorDegree") y posgrado ("postgraduateDegree"). Sin embargo, me surgió una duda: ¿cómo manejar el caso de instructores con múltiples títulos sin violar las formas normales? ¿Sería necesario crear una tabla adicional para almacenar esta información?
¿Por qué la instructora no indica cual herramienta usar, cual descargar y ejecutar ejemplo MySQL o SQL, se me hace difícil entender, si voy aprender a conducir una moto, lo ideal no seria tener una para ello!!!
MySQL:
```txt
CREATE DATABASE PlatziCursoDBSQL;
USE PlatziCursoDBSQL;
CREATE TABLE Estudiantes (
ID_Estudiante INT PRIMARY KEY,
Nombre VARCHAR(50),
Apellido VARCHAR(50),
Edad INT,
Correo VARCHAR(100),
Fecha_Carga DATE,
Fecha_Modificacion DATE
);
CREATE TABLE Instructores (
ID_Instructor INT PRIMARY KEY,
Nombre VARCHAR(50),
Apellido VARCHAR(50),
Edad INT,
Correo VARCHAR(100),
Fecha_Carga DATE,
Fecha_Modificacion DATE
);
CREATE TABLE Cursos (
ID_Curso INT PRIMARY KEY,
Nombre_Curso VARCHAR(100),
ID_Instructor INT,
Fecha_Carga DATE,
Fecha_Modificacion DATE,
FOREIGN KEY (ID_Instructor) REFERENCES Instructores(ID_Instructor)
);
CREATE TABLE EstudiantesCursos (
ID_EstudiantesCursos INT PRIMARY KEY,
ID_Estudiante INT,
ID_Curso INT,
Fecha_Carga DATE,
Fecha_Modificacion DATE,
FOREIGN KEY (ID_Estudiante) REFERENCES Estudiantes(ID_Estudiante),
FOREIGN KEY (ID_Curso) REFERENCES Cursos(ID_Curso)
);
```
PARA LOS QUE USAN SQL SERVER
Así quedaría para la tabla de las inscripciones que es la relación entre los estudiantes y los cursos
# Propuestas de tablas:
hola, estas son las propuestas para la creación de las tablas de profesores y de relacionamiento entre estudiantes y cursos.
## Tabla de profesores:
## Tabla de relación entre estudiantes y cursos:
la verdad creando las tablas de paso aprendí una que otra cosita interesante😎.
LISTO, aqui dejo mi tarea
```js
create table students_courses (
student_course_id int primary key auto_increment,
student_id int,
course_id int,
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\_courses ( student\_course\_id int primary key auto\_increment, student\_id int, course\_id int, 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))
Para los instructores se me ocurrió hacerlo así, pero no se si sea correcto. 😅
```js
create table teachers (
teacher_id int primary key auto_increment,
first_name varchar(50),
last_name varchar(50),
age int,
email varchar(100),
course varchar(100),
load_date timestamp default current_timestamp,
update_date timestamp default current_timestamp
)
```
Para establecer la relación entre estudiantes y cursos, es recomendable crear una tabla intermedia que contenga las claves foráneas de ambas tablas. Por ejemplo, si tienes la tabla "estudiantes" con "ID_estudiante" como clave primaria y la tabla "cursos" con "ID_curso", la tabla intermedia podría llamarse "inscripciones".
La estructura de la tabla "inscripciones" sería:
```sql
CREATE TABLE inscripciones (
ID_inscripcion INTEGER PRIMARY KEY,
ID_estudiante INTEGER,
ID_curso INTEGER,
fecha_inscripcion DATE,
FOREIGN KEY (ID_estudiante) REFERENCES estudiantes(ID_estudiante),
FOREIGN KEY (ID_curso) REFERENCES cursos(ID_curso)
);
```
Esto permite gestionar múltiples inscripciones de estudiantes a diferentes cursos.
Pero en un modelo dimensional o almacén de datos la información a nivel de registro no es estática? Me refiero al campo UPDATEDATE.
Yo hice la tabla de instructores de la siguiente manera:
`CREATE TABLE INSTRUCTORS(`
` ``INSTRUCTORID INT PRIMARY KEY,`
` `` ``COURSEID INT,`
` `` ``FIRSTNAME VARCHAR(50),`
` `` ``LASTNAME VARCHAT(50),`
` `` ``LOAD_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,`
` `` ``UPDATE_DATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,`
` `` ``FOREIGN KEY (COURSEID) REFERENCES COURSES(COURSEID)`
`);`
Crear tablas usando código en lugar de la interfaz gráfica de un gestor de bases de datos tiene varias ventajas. Primero, el código permite una mayor precisión y control sobre la estructura de la tabla, incluyendo tipos de datos y restricciones. Segundo, es más eficiente para realizar cambios en masa o replicar estructuras en diferentes entornos. Además, escribir código fomenta una mejor comprensión de la lógica detrás de la creación de bases de datos y es una habilidad valiosa en proyectos más complejos, donde las interfaces gráficas pueden ser limitadas.
Hola
Alguien me podría ayudar, soy nueva y estoy perdida
Chale, qué fea clase, el curso anterior era mil veces mejor...
BUEN DIA
alguien sabe porque me sale error?
Una tabla de hechos es un componente central en un modelo de datos que almacena eventos o transacciones cuantificables, como ventas o visitas. Contiene medidas numéricas, como ingresos, que se pueden analizar.
Por otro lado, una tabla de dimensiones proporciona contexto a esos hechos. Almacena información descriptiva y cualitativa sobre las dimensiones de análisis, como fechas, productos o clientes. Juntas, estas tablas permiten realizar análisis multidimensionales en bases de datos, mejorando la comprensión de los datos y facilitando la generación de informes.
Les dejo mi ejericio, hecho en VSC con MariaDB. Pero antes, quiero recomendarles ver el curso de MySQL y MariaDB (no se van a arrepentir).
```txt
create table realations_students_courses
(
relationId int primary key,
foreing key (studentId) reference students(studentId)
foreing key (courseId) reference courses(courseId)
loadDate timestampt default current_timestampt,
updateDate timestampt default current_timestampt
)
```create table realations\_students\_courses( relationId int primary key, foreing key (studentId) reference students(studentId) foreing key (courseId) reference courses(courseId) loadDate timestampt default current\_timestampt, updateDate timestampt default current\_timestampt)
hola me gustaria su opinion hacerca de mi ejercicio especialmente en la tabla courses donde intento asociar una clave foranea ```txt
create table instructors
(
instructor int primary key,
firstNmame varchar(50),
lastName varchar(50),
title varchar(50),
email varchar(100),
loadDate timestampt default current_timestampt,
updateDate timestampt default current_timestampt
)
create table courses
(
courseId int primary key
courseName varchar(100)
instructor int forange key
)
```
Excelente curso y excelente profesora me encanta.
Tabla de cursos por estudiante
```js
CREATE TABLE COURSES_STUDENT (
COURSES_STUDENTID INT PRIMARY KEY,
studentid INT,
courseid INT,
LOADDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (studentid) REFERENCES STUDENTS (studentid),
FOREIGN KEY (courseid) REFERENCES COURSES (courseid)
);
```
asi que cree la tabla de instructores CREATE TABLE INSTRUCTORS (
INSTRUCTORID INT PRIMARY KEY ,
FIRSTNAME VARCHAR(50),
LASTNAME VARCHAR(50),
AGE INT,
EMAIL VARCHAR (100),
CLASS VARCHAR (50),
);
Me genero este error en la tabla students Msg 2738, Level 16, State 2, Line 1
A table can only have one timestamp column. Because table 'STUDENTS' already has one, the column 'UPDATEDATE' cannot be added.
Tabla de instructores creada con marca de ingreso y update de data
Ejercicio propuesto para el relacionamiento de la tabla estudiantes y cursos
Este es mi ejercicio propuesto para la tabla y relacionamiento de instructores
Comparto mi aporte
Para crear una tabla de relacionamiento en SQL, debes usar la sentencia `CREATE TABLE` junto con la declaración de claves foráneas (foreign key). Por ejemplo, si tienes dos tablas, "estudiantes" e "instructores", y deseas relacionarlas, podrías hacer algo así:
```sql
CREATE TABLE relacion_estudiante_instructor (
estudiante_id INT,
instructor_id INT,
PRIMARY KEY (estudiante_id, instructor_id),
FOREIGN KEY (estudiante_id) REFERENCES estudiantes(id),
FOREIGN KEY (instructor_id) REFERENCES instructores(id)
);
```
Asegúrate de que las claves foráneas correspondan a las claves primarias en sus respectivas tablas. Esto establece la relación entre ambas tablas.
Para crear las tablas en SQL, debes utilizar un editor de texto o un entorno de desarrollo que soporte SQL, como MySQL Workbench, SQL Server Management Studio o un editor online. La creación de las tablas se realiza en un archivo con extensión `.sql`, que contendrá las sentencias SQL. Puedes abrir este archivo en el entorno, ejecutar las instrucciones y así crear las tablas en la base de datos que tienes configurada.
Esta es la tabla para instructores
CREATE TABLE INSTRUCTORS (
INSTRUCTORID INT PRIMARY KEY,
FIRSTNAME VARCHAR(50),
LASTNAME VARCHAR(50),
EMAIL VARCHAR(100),
SPECIALIZATION VARCHAR(100),
HIREDATE DATETIME DEFAULT CURRENT\_TIMESTAMP
);
Las claves de negocio son identificadores únicos que tienen un significado en el contexto del negocio, como un número de producto o un correo electrónico. Son utilizadas para distinguir registros dentro de una tabla y tienen relevancia en el mundo real.
Las claves subrogadas, en cambio, son identificadores generados por el sistema, como un número entero auto-incremental. No tienen significado fuera de la base de datos y se utilizan para asegurar la unicidad de los registros sin depender de los datos del negocio.
CREATE TABLE ENROLLMENTS (
ENROLLMENTSID INT IDENTITY(1,1) PRYMARY KEY,
STUDENTID INT,
COURSEID INT,
ENROLL\_DATE TIMESTAMP DEFAUL CURRENT\_TIMESTAMP,
LOAD\_DATE TIMESTAMP DEFAUL CURRENT\_TIMESTAMP,
UPDATE\_DATE TIMESTAMP DEFAUL CURRENT\_TIMESTAMP,
FORENIG KEY (STUDENTID) REFERENCES STUDENT(STUDENTID),
FORENIG KEY (COURSEID) REFERENCES COURSE(COURSEID)
);
Creo que en la tabla de alumnos falta la asignatura.
Tengo este error con las fechas, si alguien sabe cómo solucionarlo, muchas gracias
CREATE TABLE INSTRUCTORS (
INSTRUCTORID INT IDENTITY(1,1) PRIMARY KEY, -- Clave primaria con IDENTITY
FIRSTNAME VARCHAR(50), -- Primer nombre
LASTNAME VARCHAR(50), -- Apellido
EMAIL VARCHAR(100) UNIQUE, -- Email único
SPECIALIZATION VARCHAR(100), -- Especialización del instructor
LOAD\_DATE DATETIME DEFAULT CURRENT\_TIMESTAMP, -- Fecha de creación
UPDATE\_DATE DATETIME DEFAULT CURRENT\_TIMESTAMP -- Fecha de actualización
);
Tengo una duda, tal vez dos:
1. ¿Poner studentId a la PK, no sería redundante?, es decir, si estamos en la tabla students, ya se debería saber que el id, sería el de estudiantes, si tal vez la tabla contiene una relación FK, si debería usarse el nombre de la tabla que viene más el Id
2. Con relación a la escritura - sintaxis, esta dependerá de las buenas prácticas según el motor que se este usando, o es lo que conozco, pero lo pregunto, podría ser SnakeCase, UpperCase, CamelCase.
No sé si esta información sea cierta o no.
Hola. Por alguna razón cuando ejecuto los comandos de TIMESTAMP me aparece error. Me gustaría saber el porqué.
![]()
La sentencia `UPDATEDATE TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP` es una forma válida de establecer un campo que se actualiza automáticamente cada vez que se modifica la fila. Esto permite que el campo `UPDATEDATE` refleje la fecha y hora de la última modificación.
Es importante verificar que tu motor de base de datos soporte esta sintaxis. En general, es una buena práctica para mantener un registro de cambios en las tablas. Esto se relaciona con las buenas prácticas de diseño de bases de datos que se mencionan en la clase.
Yo lo hice asi
CREATE TABLE INSTRUCTORES (
INSTRUCTORID INT IDENTITY(1,1) PRIMARY KEY,
FIRSTNAME VARCHAR(50),
LASTNAME VARCHAR(50),
AGE INT,
\[ADDRESS] VARCHAR(100),
EMAIL VARCHAR(100),
TELEPHONE VARCHAR(20),
LOADDATE DATETIME2 DEFAULT CURRENT\_TIMESTAMP,
UPDATED DATETIME2 DEFAULT CURRENT\_TIMESTAMP,
IsActive BIT DEFAULT 1 -- 1 = activo, 0 = oculto
);
Este es la tabla que creé, pero en este caso (yo sé que se explicó teóricamente) ¿se hace un registro por cada asignatura que dicte el profesor, en el caso que dicte mas de una asignatura?
Gracias :3
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?