ello!

The most correct answer is 3, I think: 3. Joins work for SELECT, UPDATE, and DELETE statements. Maybe they have misspelled INSERT instead of SELECT.

JOIN works with UPDATE and DELETE ;)

Example:

mysql> select * from names; +------+-------+ | id | name |

+------+-------+ | | | 1 | Lucho | 2 | Lily 3 | Kiro | |

+------+-------+ 3 rows in set (0.00 sec)

mysql> select * from prof; +-----------+------------+ | person_id | prof |

+-----------+------------+ | | | 1 | Programmer | 2 | QA 3 | Sys admin | |

+-----------+------------+ 3 rows in set (0.00 sec)

mysql> update names inner join prof on (id = person_id) set prof = 'Workless' where name = 'Kiro'; Query OK, 1 row affected (0.00 sec) Rows matched: 1 Changed: 1 Warnings: 0

mysql> select * from prof;

+-----------+------------+ | person_id | prof |

+-----------+------------+ | | | 1 | Programmer | 2 | QA 3 | Workless | |

+-----------+------------+ 3 rows in set (0.00 sec)

mysql> delete from names, prof using names inner join prof on (id = person_id) where name = 'Kiro'; Query OK, 2 rows affected (0.00 sec)

mysql> select * from names; +------+-------+ | id | name |

+------+-------+ | | 1 | Lucho | 2 | Lily |

+------+-------+ 2 rows in set (0.00 sec)

mysql> select * from prof; +-----------+------------+ | person_id | prof |

+-----------+------------+ | | 1 | Programmer | 2 | QA |

+-----------+------------+ 2 rows in set (0.00 sec)

DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM table_name [WHERE where_definition]

[ORDER BY ...] [LIMIT row_count]

Sintaxis multitabla:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE] table_name[.*] [, table_name[.*] ...] FROM table-references [WHERE where_definition]

O:
DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM table_name[.*] [, table_name[.*] ...] USING table-references [WHERE where_definition]

DELETE elimina columnas desde "table_name" que satisfagan la condicin dada por la "where_definition", y devuelve el nmero de registros borrados. Si se usa una sentencia DELETE sin clusula WHERE, todas las filas sern borradas. Una forma ms rpida de hacer esto, cuando no se necesita conocer el nmero de filas eliminadas, es usar . En MySQL 3.23, DELETE sin la clusula WHERE retorna cero como nmero de filas afectadas. En esta versin, si realmente se quiere saber cuntas filas fueron eliminadas cuando se borran todas, y se est dispuesto a sufrir una prdida de velocidad, se puede usar una sentencia DELETE con una clusula WHERE que siempre se cumpla. Por ejemplo:
mysql> DELETE FROM table_name WHERE 1>0;

Esto es mucho ms lento que DELETE FROM table_name sin clusula WHERE, porque borra filas una a una. Si se borra la fila que contiene el valor mximo para una columna AUTO_INCREMENT, ese valor podr ser usado por una tabla ISAM o BDB, pero no por una tabla MyISAM o InnoDB. Si se borran todas las filas de una tabla con DELETE FROM tbl_name (sin un WHERE) en modo AUTOCOMMIT, la secuencia comenzar de nuevo para todos los motores de almacenamiento, excepto para InnoDB y (desde MySQL 4.0) MyISAM. Hay algunas excepciones a este comportamiento oara tablas InnoDB. Para tablas MyISAM y BDB, se puede especificar una columna secundaria AUTO_INCREMENT en una clave multicolumna. En ese caso, la reutilizacin de los valores mayores de la secuencia borrados ocurre para tablas MyISAM. La sentencia DELETE soporta los siguientes modificadores: Si se especifica la palabra LOW_PRIORITY, la ejecucin de DELETE se retrasa hasta que no existan clientes leyendo de la tabla.

Para tablas MyISAM, si se especifica la palabra QUICK entonces el motor de almacenamiento no mezcla los permisos de ndices durante el borrado, esto puede mejorar la velocidad en ciertos tipos de borrado. La opcin IGNORE hace que MySQL ignore todos los errores durante el proceso de borrado. (Los errores encontrados durante en anlisis de la sentencia se procesan normalmente.) Los errores que son ignorados por el uso de esta opcin se devuelven como avisos. Esta opcin apareci en la versin 4.1.1.

La velocidad de las operaciones de borrado pueden verse afectadas por otros factores, como el nmero de ndices o el tamao del cach para ndices. En tablas MyISAM, los registros borrados se mantienen en una lista enlazada y subsiguientes operaciones hacen uso de posiciones anteriores. Para recuperar el espacio sin usar y reducir el tamao de los ficheros, usar la sentencia o la utilidad myisamchk para reorganizar tablas. es ms fcil, peromyisamchk es ms rpido. El modificador QUICK afecta a si las pginas de ndice se funden para operaciones de borrado. DELETE QUICK es ms prctico para aplicaciones donde los valores de ndice para las filas borradas sern reemplazadas por valores de ndice similares para filas insertadas ms adelante. En ese caso, los huecos dejados por los valores borrados sern reutilizados. DELETE QUICK no es prctico cuando los valores borrados conducen a bloques de indices que no se llenan dejando huecos en valores de ndice para nuevas inserciones. En ese caso, usar QUICK puede dejar espacios desperdiciados en el ndice que permanecern sin reclamar. Veamos un ejemplo de este tipo de problema: 1. Crear una tabla que contiene un ndice en una columna AUTO_INCREMENT. 2. Insertar muchos registros en esa tabla. Cada insercin produce un valor de ndice que es aadido al extremo mayor del ndice. 3. Borrar un bloque de registros en el extremo inferior del rango de valores de la columna usando DELETE QUICK. En este caso, los bloques de ndices asociados con los valores de ndice borrados quedan vacos por debajo pero no se mezclan con otros bloques de ndices debido al uso de QUICK. Esos bloques permanecen sin rellenar cuando se insertan nuevas filas, ya que los nuevos registros no tienen valores de ndice en el rango borrado. Adems, permanecern sin rellenar aunque despus se use DELETE sin QUICK, a no ser que alguno de los valores de ndice borrados hagan que afecten a bloques de ndices dentro o adyacentes a los bloques vacos por debajo. Para liberar el espacio de ndices no usado bajo estas circunstancias, se puede usar . Si se van a borrar muchas filas de una tabla, puede ser mucho ms rpido usar DELETE QUICK seguido de . Esto reconstruye el ndice en lugar de reliazar muchas operaciones de mezcla de bloques de ndice. La opcin LIMIT row_count, especfica de MySQL para DELETE indica al servidor el mximo nmero de filas a borrar antes de que el control se devuelva al cliente. Esto se puede usar para asegurar que una sentencia DELETE especfica no tomar demasiado tiempo. Se puede repetir la sentencia DELETEhasta que el nmero de filas afectadas sea menor que el valor de LIMIT.

Si se usa una clusula ORDER BY las filas sern borradas en el orden especificado por la clusula. Esto slo ser prctico si se usa en conjuncin con LIMIT. Por ejemplo, la siguiente sentencia encuentra filas que satisfagan la clusula WHERE, las ordena por tiempos, y borra la primera (la ms antigua):
DELETE FROM somelog WHERE user = 'jcole' ORDER BY timestamp LIMIT 1

ORDER BY se puede usar con DELETE desde MySQL 4.0.0. Desde MySQL 4.0, se pueden especificar mltiples tablas en la sentencia DELETE para eliminar filas de una o ms tablas dependiendo de una condicin particular en mltiples tablas. Sin embargo, no es posible usar ORDER BY o LIMIT en un DELETE multitabla. La primera sintaxis de DELETE para tablas mltiples est soportada a partir de MySQL 4.0.0. La segunda desde MySQL 4.0.2. La parte 'table_references' lista las tablas involucradas en la fusin. Su sintaxis se descirbe en . Para la primera sintaxis, slo se borran las filas coincidentes de las tablas listadas antes de la clusula FROM. Para la segunda, slo se borran las filas coincidentes de las tablas listadas en la clusula FROM (antes de la clusula USING). El efecto es que se pueden borrar filas de muchas tablas al mismo tiempo y adems tener tablas adicionales que se usan para bsquedas:
DELETE t1,t2 FROM t1,t2,t3 WHERE t1.id=t2.id AND t2.id=t3.id

O
DELETE FROM t1,t2 USING t1,t2,t3 WHERE t1.id=t2.id AND t2.id=t3.id

Estas sentencias usan los tres ficheros cuando buscan filas para borrar, pero borran las filas coincidentes slo de las tablas t1 y t2. Los ejemplos muestran fusiones internas usando en operador coma, pero las sentencias DELETE multitabla pueden usar caulquier tipo de fusin (join) permitidas en sentencias , como LEFT JOIN. El .* despus de los nombres de tabla aparece slo por compatibilidad con Access: Si se usa una sentencia DELETE multitabla que afecte a tablas InnoDB para las que haya definiciones de claves forneas, el optimizador MySQL procesar las tablas en un orden diferente del de la relacin padre/hijo. En ese caso, la sentencia puede fallar y deshar los cambios (roll back). En su lugar, se debe borrar de una sola tabla y confiar el las capacidades de ON DELETE que proporciona InnoDB que harn que las otras tablas se modifiquen del modo adecuado. Nota: en MySQL 4.0, se deben refirir a los nombre de tablas a borrar mediante su verdadero nombre. En MySQL 4.1, se debe usar un alias (si se ha dado uno) cuando se haga referencia al nombre de la tabla: En MySQL 4.0:

DELETE test FROM test AS t1, test2 WHERE ...

En MySQL 4.1:
DELETE t1 FROM test AS t1, test2 WHERE ...

El motivo por el que no se hizo este cambio en 4.0 es que no se quera romper cualquier aplicacin anterior a 4.0 que usase la sintaxis antigua. Actualmente, no se puede borrar de una tabla y seleccionar de la misma tabla en una subconsulta.

UPDATE
^

UPDATE [LOW_PRIORITY] [IGNORE] tbl_name SET col_name1=expr1 [, col_name2=expr2 ...] [WHERE where_definition] [ORDER BY ...] [LIMIT row_count]

O:
UPDATE [LOW_PRIORITY] [IGNORE] tbl_name [, tbl_name ...] SET col_name1=expr1 [, col_name2=expr2 ...] [WHERE where_definition]

UPDATE actualiza columnas de filas existentes de una tabla con nuevos valores. La clusula SET indica las columnas a modificar y los valores que deben tomar. La clusula WHERE, si se da, especifica qu filas deben ser actualizadas. Si no se especifica, sern actualizadas todas ellas. Si se especifica la clusulaORDER BY, las filas se modificarn en el orden especificado. La clusula LIMIT establece un lmite al nmero de filas que se pueden actualizar. La sentencia UPDATE soporta los modificadores siguientes: Si se usa la palabra LOW_PRIORITY, la ejecucin de UPDATE se retrasar hasta que no haya otros clientes haciendo lecturas de la tabla. Si se especifica IGNORE, la sentencia UPDATE no se abortar si se producen errores durante la actualizacin. Las filas con conflictos de claves duplicadas no se actualizarn. Las filas para las que la actualizacin de columnas se puedan producir errores de conversin se actualizarn con los valores vlidos ms prximos. Si se accede a una columna de "tbl_name" en una expresin, UPDATE usa el valor actual de la columna. Por ejemplo, la siguiente sentencia asigna a la columna "edad" su valor actual ms uno:

mysql> UPDATE persondata SET edad=edad+1;

Las asignaciones UPDATE se evalan de izquierda a derecha. Por ejemplo, las siguientes sentencias doblan el valor de la columna "edad", y despus la incrementan:
mysql> UPDATE persondata SET edad=edad*2, edad=edad+1;

Si se asigna a una columna el valor que tiene actualmente, MySQL lo notifica y no la actualiza. Si se actualiza una columna que ha sido declarada como NOT NULL con el valor NULL, se asigna el valor por defecto apropiado para el tipo de la columna y se incrementa en contador de avisos. El valor por defecto es 0 para tipos numricoss, la cadena vaca ('') para tipos de cadena, y el valor "cero" para tipos de fecha y tiempo. UPDATE devuelve el nmero de filas que se han modificado. A partir de la versin 3.22 de MySQL, la funcin de API C mysql_info devuelve el nmero de filas que han coincidido y actualizado, y el nmero de avisos que se han obtenido durante la actualizacin. Desde la versin 3.23 de MySQL, se puede usar LIMIT row_count para restringir el rango de actualizacin. La clusula LIMIT trabaja del modo siguiente: Antes de MySQL 4.0.13, LIMIT restringa el nmero de filas afectadas. La sentencia se detiene tan pronto como de modifican "row_count" filas que satisfagan la clusula WHERE. Desde 4.0.13, LIMIT se restringe al nmero de filas coincidentes. La sentencia se detiene tan pronto como se encuentran "row_count" filas que satisfagan la clusula WHERE, tanto si se han modificado como si no. Si se usa una clusula ORDER BY, las filas sern actualizadas en el orden especificado. ORDER BY est disponible desde MySQL 4.0.0. Desde la versin 4.0.4 de MySQL, tambin es posible realizar operaciones UPDATE que cubran mltiples tablas:
UPDATE items,month SET items.price=month.price WHERE items.id=month.id;

El ejemplo muestra una fusin interna usando el operador coma, pero un UPDATE multitabla puede usar cualquier tipo de fusin (join) permitido en sentencias , como un LEFT JOIN. Nota: no es posible usar ORDER BY o LIMIT con UPDATE multitabla. Si se usa una sentencia UPDATE multitabla que afecte a tablas InnoDB para las que haya definiciones de claves forneas, el optimizador MySQL procesar las tablas en un orden diferente del de la relacin padre/hijo. En ese caso, la sentencia puede fallar y deshar los cambios (roll back). En su lugar, se debe actualizar una tabla y confiar el las capacidades de ON UPDATE que proporciona InnoDB que harn que las otras tablas se modifiquen del modo adecuado. Actualmente, no se puede actualizar una tabla y seleccionar desde la misma en una subconsulta.