SQL met à jour les champs d'une table à partir des champs d'une autre

J'ai deux tables:

A [ID, column1, column2, column3]
B [ID, column1, column2, column3, column4]

Asera toujours un sous-ensemble de B(ce qui signifie que toutes les colonnes de Asont également incluses B).

Je souhaite mettre à jour un enregistrement avec un IDin spécifique Bavec leurs données de Apour toutes les colonnes de A. Cela IDexiste à la fois dans Aet B.

Existe-t-il une UPDATEsyntaxe ou tout autre moyen de le faire sans spécifier les noms de colonne, en disant simplement "définir toutes les colonnes de A" ?

J'utilise PostgreSQL, donc une commande non standard spécifique est également acceptée (mais pas préférée).

Vous pouvez utiliser la clause FROM non standard .

UPDATE b
SET column1 = a.column1,
  column2 = a.column2,
  column3 = a.column3
FROM a
WHERE a.id = b.id
AND b.id = 1

_{La question est ancienne mais je sentais que la meilleure réponse n'avait pas encore été donnée.}

Existe-t-il une UPDATEsyntaxe ... sans spécifier les noms des colonnes ?

Solution générale avec SQL dynamique

Vous n'avez pas besoin de connaître les noms de colonnes, à l'exception de certaines colonnes uniques à rejoindre ( iddans l'exemple). Fonctionne de manière fiable pour tous les cas d'angle possibles auxquels je peux penser.

Ceci est spécifique à PostgreSQL. Je construis du code dynamique basé sur le schéma_information , en particulier la table information_schema.columns, qui est définie dans la norme SQL et la plupart des grands SGBDR (sauf Oracle) l'ont. Mais une DOinstruction avec du code PL / pgSQL exécutant du SQL dynamique est une syntaxe PostgreSQL totalement non standard.

DO
$do$
BEGIN

EXECUTE (
SELECT
  'UPDATE b
   SET   (' || string_agg(        quote_ident(column_name), ',') || ')
       = (' || string_agg('a.' || quote_ident(column_name), ',') || ')
   FROM   a
   WHERE  b.id = 123
   AND    a.id = b.id'
FROM   information_schema.columns
WHERE  table_name   = 'a'       -- table name, case sensitive
AND    table_schema = 'public'  -- schema name, case sensitive
AND    column_name <> 'id'      -- all columns except id
);

END
$do$;

En supposant une colonne correspondante bpour chaque colonne de a, mais pas l'inverse. bpeut avoir des colonnes supplémentaires.

WHERE b.id = 123 est facultatif, pour mettre à jour une ligne sélectionnée.

SQL Fiddle.

Réponses connexes avec plus d'explications:

• La mise à jour dynamique échoue en raison de parenthèses indésirables autour de la chaîne dans plpgsql
• Mettre à jour plusieurs colonnes commençant par une chaîne spécifique

Solutions partielles avec SQL brut

Avec liste des colonnes partagées

Vous devez toujours connaître la liste des noms de colonnes que les deux tables partagent. Avec un raccourci de syntaxe pour mettre à jour plusieurs colonnes - plus court que ce que les autres réponses suggèrent jusqu'à présent dans tous les cas.

UPDATE b
SET   (  column1,   column2,   column3)
    = (a.column1, a.column2, a.column3)
FROM   a
WHERE  b.id = 123    -- optional, to update only selected row
AND    a.id = b.id;

SQL Fiddle.

Cette syntaxe a été introduite avec Postgres 8.2 en 2006, bien avant que la question ne soit posée. Détails dans le manuel.

En relation:

• Mise à jour groupée de toutes les colonnes

Avec la liste des colonnes dans B

Si toutes les colonnes de Asont définies NOT NULL(mais pas nécessairement B),
et que vous connaissez les noms de colonnes de B(mais pas nécessairement A).

UPDATE b
SET   (column1, column2, column3, column4)
    = (COALESCE(ab.column1, b.column1)
     , COALESCE(ab.column2, b.column2)
     , COALESCE(ab.column3, b.column3)
     , COALESCE(ab.column4, b.column4)
      )
FROM (
   SELECT *
   FROM   a
   NATURAL LEFT JOIN  b -- append missing columns
   WHERE  b.id IS NULL  -- only if anything actually changes
   AND    a.id = 123    -- optional, to update only selected row
   ) ab
WHERE b.id = ab.id;

Le NATURAL LEFT JOINjoint une ligne à partir de blaquelle toutes les colonnes du même nom contiennent les mêmes valeurs. Nous n'avons pas besoin d'une mise à jour dans ce cas (rien ne change) et pouvons éliminer ces lignes au début du processus ( WHERE b.id IS NULL).
Nous devons encore trouver une ligne correspondante, donc b.id = ab.iddans la requête externe.

db <> violon ici
Ancien sqlfiddle.

Il s'agit du SQL standard à l' exception de la FROMclause .
Cela fonctionne quelle que soit la colonne réellement présente dans A, mais la requête ne peut pas faire la distinction entre les valeurs NULL réelles et les colonnes manquantes dans A, elle n'est donc fiable que si toutes les colonnes de Asont définies NOT NULL.

Il existe plusieurs variantes possibles, en fonction de ce que vous savez sur les deux tables.

Je travaille avec la base de données IBM DB2 depuis plus de dix ans et j'essaie maintenant d'apprendre PostgreSQL.

Il fonctionne sur PostgreSQL 9.3.4, mais ne fonctionne pas sur DB2 10.5:

UPDATE B SET
     COLUMN1 = A.COLUMN1,
     COLUMN2 = A.COLUMN2,
     COLUMN3 = A.COLUMN3
FROM A
WHERE A.ID = B.ID

Remarque: Le problème principal est une cause FROM qui n'est pas prise en charge dans DB2 et pas non plus dans ANSI SQL.

Cela fonctionne sur DB2 10.5, mais ne fonctionne PAS sur PostgreSQL 9.3.4:

UPDATE B SET
    (COLUMN1, COLUMN2, COLUMN3) =
               (SELECT COLUMN1, COLUMN2, COLUMN3 FROM A WHERE ID = B.ID)

ENFIN! Il fonctionne à la fois sur PostgreSQL 9.3.4 et DB2 10.5:

UPDATE B SET
     COLUMN1 = (SELECT COLUMN1 FROM A WHERE ID = B.ID),
     COLUMN2 = (SELECT COLUMN2 FROM A WHERE ID = B.ID),
     COLUMN3 = (SELECT COLUMN3 FROM A WHERE ID = B.ID)

C'est une aide précieuse. Le code

UPDATE tbl_b b
SET   (  column1,   column2,   column3)
    = (a.column1, a.column2, a.column3)
FROM   tbl_a a
WHERE  b.id = 1
AND    a.id = b.id;

fonctionne parfaitement.

a noté que vous avez besoin d'un crochet "" dans

From "tbl_a" a

pour le faire fonctionner.

Pas nécessairement ce que vous avez demandé, mais peut-être que l'utilisation de l'héritage postgres pourrait vous aider?

CREATE TABLE A (
    ID            int,
    column1       text,
    column2       text,
    column3       text
);

CREATE TABLE B (
    column4       text
) INHERITS (A);

Cela évite d'avoir à mettre à jour B.

Mais assurez-vous de lire tous les détails .

Sinon, ce que vous demandez n'est pas considéré comme une bonne pratique - les éléments dynamiques tels que les vues avec SELECT * ...sont déconseillés (car une telle commodité peut casser plus de choses que les choses d'aide), et ce que vous demandez serait équivalent pour la UPDATE ... SETcommande.

vous pouvez créer et exécuter SQL dynamique pour ce faire, mais ce n'est vraiment pas idéal

Essayez de suivre

Update A a, B b, SET a.column1=b.column1 where b.id=1

EDITED: - Mettre à jour plus d'une colonne

Update A a, B b, SET a.column1=b.column1, a.column2=b.column2 where b.id=1