MySQL - mise à JOUR basé sur une requête sur Requête SELECT

J'ai besoin de vérifier (à partir de la même table) si il existe une association entre deux événements en se basant sur la date-heure.

Un jeu de données contient la date de fin-des-temps de certains événements et de l'autre ensemble de données contiendra la date de départ en temps pour d'autres événements.

Si le premier événement se termine avant le deuxième événement, alors je voudrais les relier.

Ce que j'ai jusqu'à présent est:

SELECT name as name_A, date-time as end_DTS, id as id_A 
FROM tableA WHERE criteria = 1


SELECT name as name_B, date-time as start_DTS, id as id_B 
FROM tableA WHERE criteria = 2

Puis je me joindre à eux:

SELECT name_A, name_B, id_A, id_B, 
if(start_DTS > end_DTS,'VALID','') as validation_check
FROM tableA
LEFT JOIN tableB ON name_A = name_B

Puis-je ensuite, en fonction de mon validation_check domaine, exécutez une requête de mise à JOUR avec le SELECT imbriqué?

Je ne suis pas sûr de ce que vous demandez? Vous êtes à essayer de comprendre comment faire une mise à jour avec un Select SQL?

InformationsquelleAutor John M | 2009-08-11

719

Vous pouvez réellement faire de deux façons:

MySQL mise à jour de la syntaxe de jointure:
```
UPDATE tableA a
INNER JOIN tableB b ON a.name_a = b.name_b
SET validation_check = if(start_dts > end_dts, 'VALID', '')
-- where clause can go here
```
ANSI SQL syntaxe:
```
UPDATE tableA SET validation_check = 
    (SELECT if(start_DTS > end_DTS, 'VALID', '') AS validation_check
        FROM tableA
        INNER JOIN tableB ON name_A = name_B
        WHERE id_A = tableA.id_A)
```
Choisir celle qui semble la plus naturelle pour vous.
- La première forme (mise à jour avec une jointure) est un beaucoup plus efficace que la seconde. La première serait de faire une seule jointure, tandis que la seconde à l'exécution de la requête select pour chaque ligne de tableA.
- Pour le premier exemple, ne devriez-vous pas utiliser une jointure interne? Ne sera pas le left join résultat dans validation_check être mis à null pour tableA enregistrements sans correspondance tableB record?
- oui ça m'est arrivé. Il devrait être inner join! Ou tout simplement de la laisser rejoindre. Si vous n'avez pas de jointure interne, la jointure gauche signifie que tous tableA enregistrements seront mis à jour! C'est très dangereux!
- Je deviens fan de la vôtre pour la première requête IF condition de mettre à jour les champs. Grand, Yeppee.
- Merci pour le premier (y). Bien que cette réponse est plus de 7 ans. Je ne peux pas croire pourquoi personne n'a déclaré que la deuxième ne fonctionne pas dans une base de données comme MySQL. Vous obtiendrez cette erreur : You can't specify target table ___ for update in FROM clause SQL.sql
- Il est également à noter que, jusqu'à récemment, la première approche n'a pas fonctionné avec MySQL, quand tableA = tableB. Vous êtes obligés de créer une table temporaire pour stocker les résultats intermédiaires. (dû écrire une requête similaire pour un script de migration)
- Si vous pouviez ajouter une clause where pour l'exemple, je suis sûr que ça vous intéresserait beaucoup de gens, y compris moi-même
- Pourquoi est-ce une jointure gauche? Elle échoue sur les valeurs null. Oh, je peux modifier cela... Ok. Maintenant, c'est une jointure interne
InformationsquelleAutor Eric
267
```
UPDATE
    `table1` AS `dest`,
    (
        SELECT
            *
        FROM
            `table2`
        WHERE
            `id` = x
    ) AS `src`
SET
    `dest`.`col1` = `src`.`col1`
WHERE
    `dest`.`id` = x
;
```
Espérons que cela fonctionne pour vous.
- C'est de loin le plus rapide de la requête. Edit: après Avoir dest avec 22K lignes, et de la src avec 4K lignes, il a fallu moins de 1 sec à réaliser, tout en haut à répondre à plus de 60 sec.
- Oui, c'est le plus rapide requête, BTW, vous pouvez ajouter la clause where trop
- plus rapide implique pas toujours la bonne, cette mise à jour ne fonctionnent pas dans tous les cas, en fait certains cas, vous aurez un comportement inattendu, tout cela est, pourquoi ne pas mettre une condition qui n'est pas une jointure
InformationsquelleAutor massquote

Facile à MySQL:

UPDATE users AS U1, users AS U2 
SET U1.name_one = U2.name_colX
WHERE U2.user_id = U1.user_id

InformationsquelleAutor Sergio

51

Si quelqu'un cherche à mettre à jour les données d'une base de données à l'autre à n'importe quelle table ils sont de ciblage, il doit y avoir certains critères pour le faire.

C'est mieux et propre pour tous les niveaux:
```
UPDATE dbname1.content targetTable

LEFT JOIN dbname2.someothertable sourceTable ON
    targetTable.compare_field= sourceTable.compare_field
SET
    targetTable.col1  = sourceTable.cola,
    targetTable.col2 = sourceTable.colb, 
    targetTable.col3 = sourceTable.colc, 
    targetTable.col4 = sourceTable.cold 
```
Traaa! Il fonctionne très bien!

Avec l'entente ci-dessus, vous pouvez modifier l'ensemble des champs et de la "sur les" critères pour faire votre travail. Vous pouvez également effectuer les contrôles, puis tirez les données dans la table temporaire(s), puis exécutez la mise à jour en utilisant la syntaxe ci-dessus pour le remplacement de vos noms de table et colonne.

Espérons que cela fonctionne, si non faites le moi savoir. Je vais écrire une requête exacte pour vous.

InformationsquelleAutor KMX

UPDATE 
  receipt_invoices dest,
  (
    SELECT 
      `receipt_id`,
      CAST((net * 100) / 112 AS DECIMAL (11, 2)) witoutvat 
    FROM
      receipt 
    WHERE CAST((net * 100) / 112 AS DECIMAL (11, 2)) != total 
      AND vat_percentage = 12
  ) src 
SET
  dest.price = src.witoutvat,
  dest.amount = src.witoutvat 
WHERE col_tobefixed = 1 
  AND dest.`receipt_id` = src.receipt_id ;

Espère que cela va vous aider dans le cas où vous devez faire correspondre et de mise à jour entre deux tables.

InformationsquelleAutor Don

11

J'ai trouvé cette question dans la recherche de mon propre solution à un très jointure complexe. C'est une solution alternative, pour une version plus complexe du problème, qui je pensais peut-être utile.

J'avais besoin pour remplir le product_id champ dans les activités de la table, où les activités sont numérotés dans une unité, et les unités sont numérotées dans un niveau (identifiés à l'aide d'une chaîne de caractères ??N), tels que l'on peut identifier des activités à l'aide d'un SKU ie L1U1A1. Ces Références sont ensuite stockés dans une table différente.

J'ai identifié le suivant pour obtenir une liste de activity_id vs product_id:-
```
SELECT a.activity_id, w.product_id 
  FROM activities a 
  JOIN units USING(unit_id) 
  JOIN product_types USING(product_type_id) 
  JOIN web_products w 
    ON sku=CONCAT('L',SUBSTR(product_type_code,3), 'U',unit_index, 'A',activity_index)
```
J'ai trouvé que c'était trop complexe à intégrer dans un SELECT dans mysql, j'ai donc créé une table temporaire, et a rejoint avec l'instruction de mise à jour:-
```
CREATE TEMPORARY TABLE activity_product_ids AS (<the above select statement>);

UPDATE activities a
  JOIN activity_product_ids b
    ON a.activity_id=b.activity_id 
  SET a.product_id=b.product_id;
```
J'espère que quelqu'un trouve ce utile
- deux requête ne peut pas donner de résultat cohérent en environnement multithread.
InformationsquelleAutor sibaz

UPDATE [table_name] AS T1,
      (SELECT [column_name] 
        FROM [table_name] 
        WHERE [column_name] = [value]) AS T2 
  SET T1.[column_name]=T2.[column_name] + 1
WHERE T1.[column_name] = [value];

InformationsquelleAutor bhavik

4

Vous pouvez mettre à jour les valeurs d'une autre table à l'aide d'une jointure interne comme ce
```
UPDATE [table1_name] AS t1 INNER JOIN [table2_name] AS t2 ON t1.column1_name] = t2.[column1_name] SET t1.[column2_name] = t2.column2_name];
```
Suivez ici pour savoir comment utiliser cette requête http://www.voidtricks.com/mysql-inner-join-update/

ou vous pouvez utiliser le sélectionner en tant que sous-requête pour ce faire
```
UPDATE [table_name] SET [column_name] = (SELECT [column_name] FROM [table_name] WHERE [column_name] = [value]) WHERE [column_name] = [value];
```
requête expliqué en détails ici http://www.voidtricks.com/mysql-update-from-select/

InformationsquelleAutor Anand Roshan

Vous pouvez utiliser:

UPDATE Station AS st1, StationOld AS st2
   SET st1.already_used = 1
 WHERE st1.code = st2.code

InformationsquelleAutor SergeyUr

Pour la même table,

UPDATE PHA_BILL_SEGMENT AS PHA,
     (SELECT BILL_ID, COUNT(REGISTRATION_NUMBER) AS REG 
       FROM PHA_BILL_SEGMENT
        GROUP BY REGISTRATION_NUMBER, BILL_DATE, BILL_AMOUNT
        HAVING REG > 1) T
    SET PHA.BILL_DATE = PHA.BILL_DATE + 2
 WHERE PHA.BILL_ID = T.BILL_ID;

InformationsquelleAutor Gnanam pragasam

J'ai eu un problème avec des entrées en double dans une table elle-même. Ci-dessous les approches de travail pour moi. Il a également été préconisée par @sibaz.

Enfin je l'ai résolu en utilisant le dessous de requêtes:

La requête select est enregistré dans une table temporaire

IF OBJECT_ID(N'tempdb..#New_format_donor_temp', N'U') IS NOT NULL
    DROP TABLE #New_format_donor_temp;

select *
into #New_format_donor_temp
from DONOR_EMPLOYMENTS
where DONOR_ID IN (
  1, 2
)

-- Test New_format_donor_temp
-- SELECT *
-- FROM #New_format_donor_temp;

La table temporaire est joint à la requête de mise à jour.

UPDATE de
SET STATUS_CD=de_new.STATUS_CD, STATUS_REASON_CD=de_new.STATUS_REASON_CD, TYPE_CD=de_new.TYPE_CD
FROM DONOR_EMPLOYMENTS AS de
  INNER JOIN #New_format_donor_temp AS de_new ON de_new.EMP_NO = de.EMP_NO
WHERE
  de.DONOR_ID IN (
    3, 4
)

J'ai pas très connu avec SQL veuillez informer à une meilleure approche que vous connaissez.

Au-dessus de requêtes pour MySql server.

InformationsquelleAutor Rick

1

Vérifier avec la requête ci-dessous.

mettre à jour Un tableA
inner join tableB B sur A. name_a = B. name_b
ensemble validation_check = si(start_dts > end_dts, 'VALIDE', ")

InformationsquelleAutor Anoop Kumar

Vous devez vous connecter pour publier un commentaire.