---
# System prepended metadata

title: Curso SQL - DÍA 2

---

# Curso SQL - DÍA 2

## Manipulacion de datos (INSERT, UPDATE, DELETE)
En esta sección, vamos a aprender a como manipular los datos en una tabla de base de datos sql.

### INSERT
La estructura del INSERT te permite insertar 1 o varios registros a una tabla (SÓLO 1 tabla).
La estructura básica de un INSERT se compone de la siguiente manera:
```sql=
INSERT INTO table_name (column1, column2, column3, ...., columnN)
VALUES (value1, value2, value3, ..., valueN);
```
En donde:
- ***table_name*** corresponde al nombre de la tabla donde queremos insertar un registro.
- ***column1, column2, column3, columnN*** corresponde a las columnas específicas que queremos especificar el valor a tomar.
- ***value1, value2, value3, valueN*** corresponde los valores que se van a tomar para las columnas especificadas, el orden del valor corresponde al orden de la columna; por ejemplo, el ``value1``, es el valor que se va a setear para dicho registro en el campo ``column1``, el ``value2`` con el ``column2`` y así sucesivamente.

***Nota:*** la cantidad de values debe coincidir con la cantidad de columns.
***Nota 2:*** No es necesario especificar todas las columnas de una tabla. Por ej., si la tabla permite que un campo sea null, y queres que al insertar un registro dicho campo siga siendo null, entonces bastaría con no agregarlo como columna (y por consecuente, como valor tampoco).

Ejemplo:
```sql=
INSERT INTO films (code, title, did, date_prod, kind)
VALUES ('B6717', 'Tampopo', 110, '1985-02-10', 'Comedy');
```
Tambien se podrían agregar varios valores al mismo insert de la siguiente manera:
```sql=
INSERT INTO films (code, title, did, date_prod, kind)
VALUES
    ('B6717', 'Tampopo', 110, '1985-02-10', 'Comedy'),
    ('HG120', 'The Dinner Game', 140, DEFAULT, 'Comedy');
```

Para más informacion sobre el ``INSERT``, se recomienda leer la [documentacion oficial](https://www.postgresql.org/docs/current/sql-insert.html).

### UPDATE
La sintaxis del ``UPDATE`` te permite actualizar 1 o varios registros de una tabla (SÓLO 1 tabla).

La estructura básica de un ``UPDATE`` se compone de la siguiente manera:
```sql=
UPDATE table_name
SET
    column1 = value1,
    column2 = value2
WHERE
    id = idValue;
```
En donde:
- ***table_name*** corresponde al nombre de la tabla donde queremos actualizar el(los) registro(s).
- ***column1, column2*** corresponde a las columnas que queremos actualizar de el(los) registro(s) de la tabla.
- ***value1, value2*** corresponde al valor (o a los valores) que van a tomar dichas columnas.
- ***Sentencia WHERE***: filtra sobre qué registros se va a realizar la actualización de campos. Si la sentencia ``WHERE`` no está presente a la hora de ejecutar el ``UPDATE``, entonces la actualización se va a aplicar a TODOS los registros de la tabla.

Ejemplo:
```sql=
UPDATE films SET kind = 'Dramatic' WHERE kind = 'Drama';
```
Tambien se puede tomar valores del registro y alterarlos para no tener que obtener el valor previamente, como se ve en el siguiente ejemplo:
```sql=
UPDATE employees SET sales_count = sales_count + 1;
```
Para más informacion sobre el ``UPDATE``, se recomienda leer la [documentacion oficial](https://www.postgresql.org/docs/current/sql-update.html).

### DELETE
La estructura del ``DELETE`` te permite eliminar 1 o varios registros de una tabla (SÓLO 1 tabla).

La estructura básica de un ``DELETE`` se compone de la siguiente manera:
```sql=
DELETE FROM table_name WHERE column1 = value1;
```
En donde:
- ***tablename*** corresponde al nombre de la tabla en la cual queremos eliminar registros.
- ***Sentencia WHERE:*** Filtra los registros que se quieren eliminar. Si la sentencia no se especifica, entonces se eliminan TODOS los registros de la tabla.

Para más informacion sobre el ``DELETE``, se recomienda leer la [documentacion oficial](https://www.postgresql.org/docs/current/sql-delete.html).

## Consultas (SELECT, WHERE (LIKE, =, <, >, IN), ORDER BY, LIMIT)
La sentencia SELECT te permite consultar los datos de 1 o varias tablas.

NOTA: por ahora nos vamos a limitar a consultar sobre 1 tabla. Para ver cómo consultar en varias tablas al mismo tiempo (o relacionadas), recomendamos leer Consultas 2 de este mismo curso.

La sentencia básica del ``SELECT`` se compone de la siguiente manera:
```sql=
SELECT column1, column2, column3 FROM table_name;
```
En donde:
- ``column1``, ``column2`` y ``column3`` son las columnas que nos interesan que se devuelvan. Si se especifica ``*`` en lugar de un listado de columnas, entonces se devolverían todos los campos de la tabla(s) consultada(s).
- ``table_name`` es la tabla a la cual vamos a consultar, donde estan definidas dichas columnas.

Ahora bien, si no nos interesan consultar todos los registros, podemos aplicar el WHERE para filtrar los registros, como se muestra en el siguiente ejemplo:
```sql=
SELECT column1, column2, column3 FROM table_name WHERE id = 1;
```
En este caso, estamos buscando todos los registros de la tabla ``table_name`` cuyo ``id`` sean igual a ``1``.
De la misma manera, en vez de aplicar el ``=``, se pueden aplicar el ``<``, ``>`` o ``<>`` para buscar por menor, mayor y distinto, respectivamente.

### LIKE en WHERE
Dentro del ``WHERE`` se puede aplicar el filtro por ``LIKE``. Esto es útil a la hora de buscar un texto (substring) dentro de un campo tipo string.
La forma de aplicarlo sería de la siguiente manera:
```sql=
SELECT * FROM usuarios WHERE nombre LIKE '%pepe%';
```
De esta manera, buscaría aquellos registros en la tabla ``usuarios`` que contentan en el campo ``nombre`` el valor ``pepe``.

[Más información sobre el LIKE](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-like/).

**Nota**: Cabe destacar que, el LIKE es ``case sensitive``. Existe la sentencia ILIKE que es case insensitive y se utiliza de la misma forma. Esto es algo EXCLUSIVO de Postgresql. [Informacion más detallada](https://www.postgresql.org/docs/current/functions-matching.html).

### IN en WHERE
Dentro del ``WHERE`` se puede aplicar el filtro por ``IN``, el cual nos permite filtrar por un conjunto de valores. Esto nos ahorra tener que añadir ``OR`` con un ``=`` para todos los valores.

La forma de aplicarlo sería de la siguiente manera:
```sql=
SELECT * FROM usuarios WHERE rol IN ('ADMIN', 'GER');
```
De esta manera, la consulta devolvería aquellos registros de la tabla ``usuarios`` que en el campo ``rol`` posea el valor ``ADMIN`` o ``GER``.

[Mas información acerca del IN](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-in/).

### ORDER BY
La sentencia ORDER BY, nos permite ordenar el resultado del SELECT.
Se puede hacer de la siguiente manera:
```sql=
--SIN WHERE
SELECT * FROM usuarios ORDER BY id DESC;
--CON WHERE
SELECT * FROM usuarios WHERE rol IN ('ADMIN', 'GER') ORDER BY id;
```
Se puede ordenar por ``ASC`` (ascendente) o ``DESC`` (descendente), pero sino se especifica, el valor por defecto es ``ASC``.
[Más información acerca del ORDER BY](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-order-by/).

### LIMIT
El LIMIT nos permite filtrar la cantidad de registros que queremos obtener, por ejemplo:
```sql=
--CON ORDER BY
SELECT * FROM usuarios ORDER BY id LIMIT 10;
--SIN ORDER BY
SELECT * FROM usuarios LIMIT 10;
```
Esta consulta nos va a devolver los primeros 10 registros.
[Más información acerda del LIMIT](https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-limit/).

## Laboratorio II
### Manipular los datos de la tabla ``Usuarios``
Se requiere hacer una consulta donde se agreguen usuarios a la tabla creada en el Laboratorio I.
Se requiere que hayan POR LO MENOS 2 usuarios tipo ``ADMIN``, 7 usuarios tipo ``USER`` y 3 usuarios tipo ``GER``.
Se deben especificar TODOS los campos creados con valores DIFERENTES.
### Hacer consultas filtradas
Realizar una consulta que devuelva todos los usuarios del tipo ``USER`` y ``GER``, que tengan una edad comprendida entre los ``18`` (inclusive) y ``27`` años (inclusive), cuyas direcciones de mail sean de ``gmail``.
### Los 3 usuarios más viejos de tipo USER
Obtener los 3 usuarios más viejos que sean del tipo ``USER``.