INNER JOIN dans UPDATE sql pour DB2

Est-il un moyen d'utiliser les jointures dans la mise à jour des déclarations pour DB2?

Google a vraiment marché pour moi sur ce un

C'est à peu près ce que je suis en train de réaliser (... à l'exception évidemment de travail ....)

update file1 inner join file2                                 
       on substr(file1.firstfield,10,20) = substr(file2.anotherfield,1,10)                                                                    
set file1.firstfield = ( 'BIT OF TEXT' concat file2.something )                                                                             
where file1.firstfield like 'BLAH%'

Acclamations

source d'informationauteur Hamish

db2 sql

8

Vous ne dites pas ce que la plateforme que vous ciblez. Se référant aux tables de fichiers, cependant, m'amène à croire que vous n'êtes PAS sous DB2 pour Linux, UNIX ou Windows (LUW).

Toutefois, si vous sont sur DB2 LUW, voir la FUSION déclaration:

Pour votre exemple de déclaration, ce serait écrit que:
```
merge into file1 a
   using (select anotherfield, something from file2) b
   on substr(a.firstfield,10,20) = substr(b.anotherfield,1,10)
when matched and a.firstfield like 'BLAH%'
   then update set a.firstfield = 'BIT OF TEXT' || b.something;
```
Veuillez noter: Pour DB2, le troisième argument de la fonction SUBSTR est le nombre d'octets de retour, pas de la position de fin. Par conséquent, SUBSTR(un.firstfield,10,20) renvoie CHAR(20). Cependant, SUBSTR(b.anotherfield,1,10) renvoie CHAR(10). Je ne sais pas si cela a été fait sur le but, mais il peut affecter votre comparaison.

Rejoint dans update déclarations sont non-standard et non pris en charge par tous les fournisseurs. Ce que vous essayez de faire ce qui peut être accompli avec une sous-sélection:

update
  file1
set
  firstfield = (select 'stuff' concat something from file2 where substr(file1.field1, 10, 20) = substr(file2.xxx,1,10) )
where
  file1.foo like 'BLAH%'

Essayer cela et me dire ensuite les résultats:

UPDATE File1 AS B                          
SET    b.campo1 = (SELECT DISTINCT A.campo1
                   FROM  File2 A           
                   INNER JOIN File1      
                   ON A.campo2 = File1.campo2 
                   AND A.campo2 = B.campo2)

Voici un bon exemple de quelque chose que je viens de recevoir de travail:

update cac c
set ga_meth_id = (
    select cim.ga_meth_id 
    from cci ci, ccim cim 
    where ci.cus_id_key_n = cim.cus_id_key_n
    and ci.cus_set_c = cim.cus_set_c
    and ci.cus_set_c = c.cus_set_c
    and ci.cps_key_n = c.cps_key_n
)
where exists (
    select 1  
    from cci ci2, ccim cim2 
    where ci2.cus_id_key_n = cim2.cus_id_key_n
    and ci2.cus_set_c = cim2.cus_set_c
    and ci2.cus_set_c = c.cus_set_c
    and ci2.cps_key_n = c.cps_key_n
)

Mise à jour de la réponse https://stackoverflow.com/a/4184237/565525:

si vous voulez plusieurs colonnesqui peut être réalisée comme ceci:

update file1
set
  (firstfield, secondfield) = (
        select 'stuff' concat 'something from file2', 
               'some secondfield value' 
        from file2
        where substr(file1.field1, 10, 20) = substr(file2.xxx,1,10) )
where
  file1.foo like 'BLAH%'

Source: http://www.dbforums.com/db2/1615011-sql-update-using-join-subquery.html#post6257307

1

Juste pour mettre à jour uniquement les lignes qui correspondent aux conditions, et éviter de mettre à jour les valeurs null dans les autres lignes:
```
update table_one set field_1 = 'ACTIVE' where exists 
(select 1 from table_two where table_one.customer = table_two.customer);
```
Il travaille dans une base de données DB2/AIX64 9.7.8

La documentation de référence pour l'instruction de mise à JOUR sur DB2 LUW 9.7 donne l'exemple suivant:

   UPDATE (SELECT EMPNO, SALARY, COMM,
     AVG(SALARY) OVER (PARTITION BY WORKDEPT),
     AVG(COMM) OVER (PARTITION BY WORKDEPT)
     FROM EMPLOYEE E) AS E(EMPNO, SALARY, COMM, AVGSAL, AVGCOMM)
   SET (SALARY, COMM) = (AVGSAL, AVGCOMM)
   WHERE EMPNO = '000120'

Les parenthèses après la mise à JOUR peut contenir plein de sélectionner, de sens pour être valable, toute instruction SELECT peut y aller.

Sur cette base, je vous suggère les suivantes:

UPDATE (
  SELECT
    f1.firstfield,
    f2.anotherfield,
    f2.something
  FROM file1 f1
  WHERE f1.firstfield like 'BLAH%' 
  INNER JOIN file2 f2
  ON substr(f1.firstfield,10,20) = substr(f2.anotherfield,1,10)
)
AS my_files(firstfield, anotherfield, something)
SET
  firstfield = ( 'BIT OF TEXT' || something )

Edit: Ian est droit. Mon premier réflexe a été d'essayer les sous-sélections à la place:

UPDATE file1 f1
SET f1.firstfield = ( 'BIT OF TEXT' || (
  SELECT f2.something
  FROM file2 f2
  WHERE substr(f1.firstfield,10,20) = substr(f2.anotherfield,1,10)
))
WHERE f1.firstfield LIKE 'BLAH%' 
AND substr(f1.firstfield,10,20) IN (
  SELECT substr(f2.anotherfield,1,10)
  FROM file2 f2
)

Mais je ne suis pas sûr si la concaténation serait de travailler. Il suppose également qu'il y a un mappage 1:1 entre les sous-chaînes. Si il y a plusieurs lignes qui correspondent, ça ne marcherait pas.

pour vous demander

update file1 f1
set file1.firstfield=
(
select 'BIT OF TEXT' || f2.something
from file2 f2
where substr(f1.firstfield,10,20) = substr(f2.anotherfield,1,10)
)
where exists
(
select * from file2 f2
where substr(f1.firstfield,10,20) = substr(f2.anotherfield,1,10)
)
and f1.firstfield like 'BLAH%'

si rejoindre donner plusieurs résultats, vous pouvez forcer la mise à jour comme ceci

update file1 f1
set file1.firstfield=
(
select 'BIT OF TEXT' || f2.something
from file2 f2
where substr(f1.firstfield,10,20) = substr(f2.anotherfield,1,10)
fetch first rows only
)
where exists
(
select * from file2 f2
where substr(f1.firstfield,10,20) = substr(f2.anotherfield,1,10)
)
and f1.firstfield like 'BLAH%'

modèle methode

update table1 f1
set (f1.field1, f1.field2, f1.field3, f1.field4)=
(
select f2.field1, f2.field2, f2.field3, 'CONSTVALUE'
from table2 f2
where (f1.key1, f1.key2)=(f2.key1, f2.key2) 
)
where exists 
(
select * from table2 f2
where (f1.key1, f1.key2)=(f2.key1, f2.key2)
)

-2

Dans le standard SQL ce type de mise à jour ressemble à:
```
update a
   set a.firstfield ='BIT OF TEXT' + b.something
  from file1 a
  join file2 b
    on substr(a.firstfield,10,20) = 
       substr(b.anotherfield,1,10)
 where a.firstfield like 'BLAH%' 
```
Avec de légères variations syntaxiques de ce genre de chose va travailler sur Oracle ou SQL Server et (bien que je n'ai pas de DB/2 exemple de la main de test) sera presque certainement travailler sur DB/2.

Vous devez vous connecter pour publier un commentaire.