Comandos UPDATE Y DELETE

Es mejor hacer pruebas antes de ejecutar instrucciones que puedan afectar la integridad de nuestra data
Iniciamos una transacción

BEGIN

Ahora supongamos que elimino información de una tabla y se me olvida el WHERE

DELETE FROM authors;

Rayos ya perdí todo, haa pero como estoy dentro de una transacción debo confirmar las operaciones hechas a la base de datos, de lo contrario no se ejecutarán.

Si confirmo, entonces no hay vuelta atras. Se eliminarían todos los datos de dicha tabla

COMMIT

pero si hago un retroceso de dichos cambios. Entonces es como si nunca hubiese pasado nada.

ROLLBACK

Fiuuu, que alivio.

WHEN realizas un select de las personas que te han gustado durante toda tu vida:
9999 row in set(0.50 sec)
BUT repites el select pero a la inversa:
Empty set (0.00 sec)
😅😅

Como aporte.
ALTER es a las columnas lo que UPDATE es a las filas
DROP es a las columnas lo que DELETE es a las filas

Y la siguiente canción para nunca olvidar poner el WHERE en el DELETE FROM.
https://www.youtube.com/watch?v=i_cVJgIz_Cs

Resumen de la clase:

-- DELETE: borra el registro.
-- Adicionalmente filtrar con WHERE por id y limitarlo.
DELETE FROM authors WHERE author_id = 161 LIMIT 1;

-- UPDATE: actualizar datos de una tupla existente.
-- También se debe filtrar con WHERE
UPDATE clients
SET active = 0
WHERE client_id = 80
LIMIT 1;

UPDATE clients
SET active = 0
WHERE client_id IN (1,6,8,27,90)
  OR NAME like '%Lopez%';


-- TRUNCATE: Borra todo el contenido de una tabla
TRUNCATE transactions;

select client_id, name from clients order by rand() limit 10; en está sentencia RAND() permite ordenar de forma aleatoria, no recomendado hacerlo en producción.
select client_id, name from clients where active <> 1; en donde <> significa que es diferente

Para eliminar todo el contenido de una tabla y dejarla vacía:

TRUNCATE nameTable;

Pero si quieres eliminar toda la tabla, estructura y datos:

DROP nameTable;

Resumen de la Clase:
Tips:

• Los datos no deberían borrarse, siempre y cuando se respete el acuerdo con el usuario final.
• SIEMPRE usar WHERE con comandos UPDATE.
• Al hacer UPDATE o DELETE usar LIMIT para limitar el impacto del comando si algo saliese mal.

Comandos:

• DELETE: elimina información.
• UPDATE: actualiza información en una tabla.
• TRUNCATE: elimina el contenido de una tabla por completo.

Código:

-- Clase 19 UPDATE Y DELETE

-- Ejemplos de Delete y Update

DELETE FROM authors WHERE author_id = 161 LIMIT 1;

SELECT client_id, name FROM clients WHERE active <> 1;

UPDATE clients SET active = 0 WHERE client_id = 80 LIMIT 1;

UPDATE clients
SET 
    email = '[email protected]'
WHERE
    client_id = 7
LIMIT 1;

--Desactivar clientes con ID especifica y apellido lopez

UPDATE clients
SET 
    active = 0
WHERE
    client_id IN (1,6,8,27)
    OR name like '%Lopez%';

-- Buscar con ID y Lopez

SELECT client_id, name
FROM clients
WHERE
    client_id IN (1,6,8,27)
    OR name like '%Lopez%';```

• Muy buen consejo colocar el limit en un Delete o update

Me encanta que @Alberto Alcocer siempre comparte las “buenas prácticas” eso no se ve en todos los cursos.

Hasta ahorita el MEJOR curso ,y el MEJOR DOCENTE 😃

![](

El comando truncate [nombre de tabla] borra el contenido de la tabla, pero no borra la tabla.

Beco, tu historia del periódico sí que motiva a no olvidar ell uso del WHERE. jaja

DELETE en una bases de datos no debería ocurrir siempre y cuando sea legal, ético y vaya de acuerdo con los términos que se tienen con los clientes.

Cuando se realiza un UPDATE y un DELETE se recomienda hacerlo con un campo que identifica de manera puntual a esa registro utilizando el WHERE. Otra buena práctica que se le puede añadir a esto es utilizar un LIMIT 1 para que sólo actualice ese registro puntual

DELETE borra la tabla, TRUNCATE borra el contenido de la tabla, pero no la tabla.

El maestro tiene razón,
En sistemas de información no es una buena practicar eliminar datos, lo que generalmente se hace es crear un campo en el cuál se describe si está “activo” o “desactivado” el registro.
Así, en vez de eliminar lo que se hace es actualizar ese campo en cada registro.

jajaja cuando un mexicano dice aguas, la cosa es enserio, aguas con el WHERE!

El truco de usar LIMIT 1 para hacer un UPDATE o DELETE me parece super útil, lo implementaré inmediatamente.

Comprendido

SELECT count(*) FROM authors;

DELETE FROM authors WHERE author_id = 1 LIMIT 1;

SELECT name , client_id FROM clients WHERE active = '0';

SELECT name , client_id, active FROM clients ORDER BY RAND() LIMIT 10; 

SELECT * FROM clients WHERE client_id IN  (80, 7);

UPDATE clients SET active = '0' WHERE client_id = 80 LIMIT 1; 

UPDATE clients SET email = '[email protected]' WHERE client_id = 80 LIMIT 1; 

SELECT * FROM clients WHERE client_id IN  (1,6,8,27,90) OR name LIKE '%Lopez%';

UPDATE clients SET active = '0' WHERE client_id IN  (1,6,8,27,90) OR name LIKE '%Lopez%';

DELETE FROM clients WHERE active = '0' LIMIT 1;

TRUNCATE transactions; 

Las tablas que creadas en clase no se definió ninguna FOREIGN KEY. No són obligatorias siempre?

Yo creo que si has diseñado bien una aplicación y una base de datos no es necesario hacer DELETE o DROP (que ya de por si son peligrosos).Simplemente se añade un campo mas que sea de Activo o inactivo como hizo el profe para poder filtrar los datos que no están siendo usados.Y si esos datos ya no son usados por mucho tiempo se van para un data warehause para su posterior minado (ya que los datos muertos también son valiosos)

BEGIN;
SELECT * FROM clients WHERE name LIKE '%david%';
UPDATE clients
SET active = 0
WHERE name LIKE '%david%'
LIMIT 1;
SELECT * FROM clients WHERE name LIKE '%david%';
ROLLBACK;
SELECT * FROM clients WHERE name LIKE '%david%';

Sí deseamos deshacernos de los datos pero no de la tabla en sí podemos utilizar el comando TRUNCATE TABLE. La sintaxis es: TRUNCATE table_name;

Triste y excelente ejemplo de la tragicomedia vivida por el profesor para nunca olvidar el WHERE tanto en una setencia UPDATE como DELETE, además de restringir la cantidad de tuplas afectadas con el uso de LIMIT

Minuto 10:32

Un shortcut muy útil para buscar en queries que ya se ejecutaron es: Ctrl + R y empezar a escribir la tabla o la condición del query que se busca. Al presionar nuevamente Ctrl + R busca la siguiente coincidencia.

• La función rand() sólo se recomienda para casos de prueba
  y no programaticamente*

• TRUNCATE borra el contenido de la tabla pero deja la estructura*/

-la opción Delete debe ser un recursos que no se debe usar, siempre y cuando se legal, viable y es lo que el usuario quiere.
-Es buena práctica colocar un limit 1 o limit…n dependiendo de cuántos registros
se quiera borrar.
-Si va a borrar por datos por coincidencias LIKE es necesario averiguar cuántos registros son esos y cuáles id tienen para cuando se haga la sentencia ser bastante específico y luego colocamos nuevamente el LIMIT

• caso Update: Es buena práctica obtener un campo “active” que es un booleano que nos ayuda
  a desactivar registro virtualmente

Muy importante el uso de funciones por ejemplo en el caso de rand() que desordena muy bonito pero hace un consumo casi de x8 en rendimiento de la respuesta con solo 131 registros.

select * from authors order by rand() ;
select * from authors ;

Me gusta cuando nos enseñan las buenas prácticas, no se me habría ocurrido poner LIMIT 1 como un comando “defensivo” al evitar que se borren más datos de lo esperado 😃

Aunque RAND() no es eficiente computacionalmente: se sugiere desde la aplicación cliente: 1- obtener la consulta al Servidor de los datos puntuales desde la BD evitando el ORDER BY 2- una vez recibido en un cursor del lado de nuestra aplicación, aplicar el ORDER BY RAND()

He prendido mucho con este profesor, es como…uds no saben yo si déjense enseñar…todo me ha quedado super claro

Delete from Authors; Tengo entendido que no se puede ejecutar esa instrucción.

Genial

Me gusta los consejos que dejan, lo que más hago es dejar el punto y coma en otra línea para no dañar la base de datos

Alguien sabe cómo es el símbolo <> en MariaDB?

UPDATE: Para actualizar un dato.

Truco con LIMIT en caso de error.

“Aguas siempre pongan el WHERE”. Me ha quedado claro de por vida. 😃

Buena anécdota la del periódico :v

muy buen curso, quiero seguir aprendiendo

Buen curso

En mi trabajo tenía la práctica de hacer un select con el where correspondiente y comprobar la condición que luego usaría con el update o delete.

Todos tienen sus historias con el where triste en su momento luego divertidas como todo.

Genial!! 😄

Cuando hay que hacer uso del DELETE siempre debe ir acompañado de un WHERE y es buena practica colocarle un LIMIT de la cantidad de tuplas a borrar.

TRUNCATE TABLA: lo que hace es borrar el contenido de la tabla pero permanece la estructura de la misma.

Que buen consejo el utilizar LIMIT en las sentencias DELETE

Y no solo poner el where sino tambien poner la columna, una vez me dañe una base de datos de produccion por colocar where y el valor pero sin decirle a que columna xD menos mal hice copia antes de.

Me gustan las recomendaciones sobre las buenas prácticas, agrega mucho valor.

truncate: Borra el contenido de una tabla, pero no la estructura.

Al ejecutar el update, no por consola. Nos dará un error.
Se debe cambiar el OR de esta consulta por ‘AND’

original
select client_id, name, active from clients where client_id in(1, 6, 8, 27, 90) or name like ‘%Lopez%’;

modificado
select client_id, name, active from clients where client_id in(1, 6, 8, 27, 90) and name like ‘%Lopez%’;

ahora tambien me paso un error:

puse el where pero justo antes me olvide borrar ‘;’ que estaban antes. Y se cambio toda la BD

Como Frontend developer me parece muy interesante todo este mundo de los datos, etc. Tal vez algun dia me muevo mas por aca, por ahora seguire usando ORM cuando me toque hacr back.

Excelente curso

Si hay que tener cuidado en ejecutar estos dos comandos en la Base de datos
TRUNCATE -> No puedes dar un rollback posterior a realizar el TRUNCATE a tabla, no se puede regresar la información
DELETE-> Puedes hacer rollback posterior a realizar el DELETE a tabla siempre y cuando no hayas hecho COMMIT sino tampoco puedes regresar los cambios

Recomendacion: Antes de usar una sentencia UPDATE o DELETE usar START TRANSACTION y cuando estan seguros que el resultado fue correcto usar el COMMIT, de lo contrario ROLLBACK. Ejemplo:

SET AUTOCOMMIT = OFF;
START TRANSACTION;
<sentencia UPDATE o DELETE>
-- Si el resultado fue el esperado
COMMIT;
-- Si el resultado no es el esperado
ROLLBACK;
SET AUTOCOMMIT = ON;

El COMMIT guarda los cambios en la base de datos.
El ROLLBACK descarta los cambios realizados y los deja como estaban antes de la ejecucion del query.

El comando ROLLBACK puede ser usado para deshacer algo una transacción en la base de datos, indiferentemente de si usé DELETE o TRUNCATE. SIEMPRE Y CUANDO EL DELETE O EL TRUNCATE ESTÉN DENTRO DE UNA TRANSACCIÓN.

`-- Borrar
begin transaction
truncate table clients
select * from clients

– Recuperar
ROLLBACK TRANSACTION
select * from Employee`

select * from authors order by rand() limit 10;
select count(*) from authors;
delete from authors where author_id = 5 limit 1;
select client_id, name from clients where active <> 1;
select client_id,name, active from clients order by rand() limit 10;
update clients set active = 0
where client_id = 80 limit 1
update clients
set
active = 0
where
client_id in (1,6,8,27,90)
or name like '%lopez%'
select client_id, name, active from clients
where client_id in (1,6,8,27,90) or name like ‘%lopez%’
–truncate transactions

-- comandos DELETE y UPDATE son muy importantes y muy peligrosos ya que si hacemos algo mal
-- en el query podria tener serios problemas en los datos modificados o borrados.
-- es buena practica colocar al final del query LIMIT 1, ya que si cometemos un error
-- por lo menos solo afectara a un solo registro. Además siempre va acompañado de un WHERE

-- Su estructura es la siguiente
DELETE FROM clients WHERE client_id = 1 LIMIT 1;
DELETE clients;
-- Estructura de UPDATE
UPDATE authors SET nationality = 'MEX' WHERE author_id = 1 LIMIT 1;

-- Estructura de TRUNCATE, sirve para reiniciar la tabla
TRUNCATE clients;```

dejo por qui mis notas del curso

CREATE TABLE IF NOT EXISTS books (
    book_id  INTEGER UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    author_id INTEGER UNSIGNED ,
    title VARCHAR(100) NOT NULL ,
    `year` INTEGER UNSIGNED NOT NULL DEFAULT 1900,
    `laguage` VARCHAR(2) NOT NULL DEFAULT 'es' COMMENT 'ISO 639_1 Language',
    `cover_url` VARCHAR(500),
    price DOUBLE(6,2) NOT NULL DEFAULT 10.0,
    sellable TINYINT(1) DEFAULT 1,
    copies INTEGER NOT NULL DEFAULT 1,
    description TEXT
);

CREATE TABLE IF NOT EXISTS authors (
    author_ID INTEGER UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(100) NOT NULL,
    nationality VARCHAR(3)
);

CREATE TABLE clients (
    client_id INTEGER UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    `name` VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    birthdate DATETIME,
    gender ENUM('M', 'F', 'ND') NOT NULL,
    active TINYINT(1) NOT NULL DEFAULT 1,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP 
        ON UPDATE CURRENT_TIMESTAMP
);

CREATE TABLE IF NOT EXISTS operations(
    operation_id INTEGER UNSIGNED PRIMARY KEY AUTO_INCREMENT,
    book_id INTEGER UNSIGNED,
    client_id INTEGER UNSIGNED,
    type ENUM('p', 'd', 'v') not null,
    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    finished TINYINT(1) NOT NULL DEFAULT 0
); 

INSERT INTO authors(author_id, name, nationality)
VALUES('', 'JUEAN RULFO', 'MEX')

INSERT INTO authors(name, nationality)
VALUES('Gabriel Garcia Márquez', 'COL')

#podemos utilizar el comando ON DUPLICATE KEY UPDATE para actulizar los datos que ya existen

#con el query de abajo revisamos varios  cindicionales
SELECT name, email, YEAR(NOW()) - YEAR(birthdate), gender FROM clients WHERE gender = 'F' AND name LIKE '%Lop%'

#aqui comenzamos a cruzar las tablas 
select count(*) from //alguna-tabla//

select * from authors where author_id > 0 and author_id <= 5;
select  book_id, author_id, title from books  where author_id between 1 and 5;

/*
select b.book_id, a.name, b.title
from books as b
join authors as a
    on a.author_id = b.author_id
where a.author_id between 1 and 5;
*/

/*
select c.name, b.title, a.name, t.type
from transactions as t
join books as b
    on t.book_id = b.book_id
join clients as c
    on t.client_id = c.client_id;
join authors as a
    on b.author_id = a.author_id
where c.gender = 'F'
    and t.type = 'sell'
*/

/*
select c.name, b.title, a.name, t.type
from transactions as t
join books as b
    on t.book_id = b.book_id
join clients as c
    on t.client_id = c.client_id;
join authors as a
    on b.author_id = a.author_id
where c.gender = 'F'
    and t.type IN ('sell', 'lend')
*/


#ejemplo de inner join con poca semantica
/*

select b.title, a.name 
from authors as a, books as b
where a.author_id = b.author_id
limit 10

*/

#este ejemplo nos muestra un inner join de facil lectura

/*

select b.title, a.name
from books as b
inner join authors as a
    on a.author_id = b.author_id
limit 10

*/

***         LEFT Join         ***

select a.author_id, a.name, a.nationality, b.title
from authors as a
join  books as b
    on b.author_id = a.author_id
where a.author_id between 1 and 5
order by a.author_id desc;

select a.author_id, a.name, a.nationality, COUNT(b.book_id) as "number of books"
from authors as a
join  books as b
    on b.author_id = a.author_id
where a.author_id between 1 and 5
GROUP BY a.author_id
order by a.author_id desc;

/*   ***        casos de negocios        ***   */

preguntas para el modelo negocio
1) ¿que nacionalidades hay?

SELECT DISTINCT nationality FROM authors ORDER BY nationality;

2) ¿cuantos escritores hay de cada nacionalidad?

SELECT nationality, COUNT(author_id) AS c_authors
FROM authors
WHERE nationality IS NOT NULL
    AND nationality NOT IN('RUS')
GROUP BY nationality
ORDER BY c_authors DESC, nationality ASC;

3) cual es el precio de la desviacion standard ("Precio de los libros")

SELECT nationality, 
COUNT(book_id) as libros, 
AVG(price) as promedio, 
STDDEV(price) as std
FROM books as b
JOIN authors as a 
    on a.author_id = b.author_id 
GROUP BY nationality
ORDER BY libros DESC;

4) cual es el preico maximo de un libro

SELECT a.nationality, MAX(price), MIN(price)
FROM books as b
JOIN authors AS a 
    ON a.author_id = b.author_id
GROUP BY nationality;

reporte final de prestamos

SELECT c.name, t.type, b.title, a.name, CONCAT(a.name, "(", a.nationality, ")") as author,
    TO_DAYS(NOW()) - TO_DAYS(t.created_at) as ago
FROM transactions AS t
LEFT JOIN clients AS c
    ON c.client_id = t.client_id
LEFT JOIN books AS b
    ON b.book_id = t.book_id
LEFT JOIN authors AS a
    on b.author_id = a.author_id;





/*
    ***     *   agregar transaciones   *     ***

INSERT INTO `transactions`(book_id, client_id, type, finished) 
VALUES (25, 10 , "sell", 1),
(20, 15 , "lend", 0),
(22, 11 , "lend", 0),
(23, 18 , "lend", 0),
(34, 27 , "sell", 1),
(40, 43 , "sell", 1),
(2, 5 , "sell", 1); 


*/

"Comandos Upadate y Delete"
DELETE FROM author_id = 161 LIMIT 1 
;

UPDATE tabla 
SET  
    [columna = valor, ...]
WHERE 
    [condiciones]
LIMIT 1;

UPDATE clients 
SET activate = 0 
WHERE client_id = 80 
LIMIT 1; 

UPDATE clients
SET  
    email = '[email protected]'
WHERE 
    client_id = 7 
    OR client_id = 9 
LIMIT 1
;

TRUNCATE transaction "elimina todo "```

DELETEfromauthors
WHERE author_id = 84
LIMIT1;```

Excelente la clase

IN()

excelentes clases

El limit, en DB2 es equivalente a FETCH FIRST # ROWS ONLY

excelente clase.

Genial el desarrollo.

Super la buena practica del LIMIT a la hora de hacer un update o delete

SELECT client_id, name, active FROM clients WHERE client_id IN (80, 65, 76, 1, 61, 7, 19, 97);

UPDATE clients
SET active = 0
WHERE client_id = 80
LIMIT 1;

Utilizo windows y este código no me corre igual, ¿alguien sabe por qué?

DELETE FROM table
WHERE (info, key2) IN (
SELECT info, key2
FROM table
WHERE info = 1
ORDER BY key2
FETCH FIRST ROW ONLY
);

Genial !

cual es la principal diferencia entre UPDATE y ALTER?

El profesor habla de backups, ¿Por qué no los enseñan a hacer en este curso?

muy buenas se puede hacer un VIEW con parametros de entrada?

¿Qué le costaba al profesor explicar la sintaxis de esta forma en todo el curso? Muy desorganizada la estructura de este curso.

DELETE no creo que al menos en un sistema de producción se borre algo.

Este curso se hace verdaderamente tedioso al tener que arreglar manualmente todos los archivos que dejan en la parte de recursos … Se pierde mucho tiempo y el hilo de la clase

Muy bueno, gracias!!!

Cuando usemos el comando DELETE debemos ser muy específicos con lo que queremos borrar.

UPDATE:

• Correcciones
• Actualización información.

±---------------------------------------±---------------------------------------------+
| Truncate | Delete |
±---------------------------------------±---------------------------------------------+
| Es posible hacer rollback | Es posible hacer rollback |
| | |
| | |
| Ejemplo: | Ejemplo: |
| BEGIN TRAN | BEGIN TRAN |
| TRUNCATE TABLE #Personas | DELETE FROM #Personas |
| SELECT * FROM #Personas | SELECT * FROM #Personas |
| ROLLBACK | ROLLBACK |
| SELECT * FROM #Personas | SELECT * FROM #Personas |
±---------------------------------------±---------------------------------------------+
| Truncate resetea el campo identity de | Delete no resetea el campo identity de la |
| la Tabla | Tabla |
±---------------------------------------±---------------------------------------------+
| Bloquea la tabla completa | Bloquea solo la fila a borrar |
±---------------------------------------±---------------------------------------------+
| Es un comando DDL | Es un comando DML |
| (Data Definition Language) |(Data Manipulation Language) |
±---------------------------------------±---------------------------------------------+
| No se puede usar WHERE | Se puede usar WHERE para filtrar las filas |
±---------------------------------------±---------------------------------------------+
| El trigger de la tabla no se ejecuta | El trigger de la tabla sí se ejecuta |
±---------------------------------------±---------------------------------------------+
| Sintaxis: | Sintaxis: |
| 1) TRUNCATE TABLE #Personas | 1) DELETE FROM #Personas |
| | 2) DELETE FROM #Personas WHERE |
| | Id IN (1,2,3) |
±---------------------------------------±----------------------------

Excelente clase, aprendi bastante

-- Eliminar un registro
DELETE FROM table_name WHERE condition;
-- Ejemplo Delete
DELETE FROM clients WHERE client_id = 4;

-- Actualizar un registro
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

-- Ejemplo de update
UPDATE clients SET active = 0 WHERE client_id = 10;

Qué pasa si nos equivocamos? Hay algún tipo crtl +z ? o sistema de versiones de la base de datos?

Aprendí la práctica del LIMIT para las sentencias UPDATE y DELETE

Que diferencia existe entre DELETE, TRUNCATE y DROP

Siempre recordar colocar el WHERE al usar DELETE

¿Un TRUNCATE es equivalente a un DELETE sin WHERE?

Querys bastante importante y utiles

siempre poner el WHERE

Dos casos para actualizar.

rand(): Para números aleatorios

no nos olvidemos de poner el WHERE en el DELETE FROM

DELETE FROM

Buena practica colocar LIMIT en el DELETE

Mucho cuidado con el WHERE a la hora de actualizar una tabla.

Seria bueno incluir en dos clases mas los TRIGGERS

Apuntes de clase:

----Uso del DELETE 
DELETE FROM  authors where author_id = 161 limit 1;

----Uso del UPDATE 
select client_id, name from clients where active <> 1;
select client_id, name, active from clients ORDER BY rand() LIMIT 10;
select client_id, name, active from clients WHERE  client_id in (80, 65, 76, 1, 61,19,97);
UPDATE clients 
SET active = 0
WHERE client_id = 80
LIMIT 1; 

SELECT  client_id, name, email, active 
FROM clients 
WHERE client_id IN (7, 80, 65, 76, 1, 61, 19, 97);

UPDATE clients 
SET email = '[email protected]'
WHERE client_id = 7 OR client_id = 9
LIMIT 1; 

SELECT client_id, name, active
FROM clients
WHERE 
   client_id IN (1,6,8,27,90)
   OR name LIKE '%lopez%';

UPDATE clients 
SET active = 0
WHERE 
    client_id IN (1,6,8,27,90)
    OR name LIKE '%lopez%';

---- Borrar toda una tabla
SELECT * FROM transactions;
TRUNCATE transactions;