atualizando linhas da tabela no postgres usando subconsulta

Usando o postgres 8.4, meu objetivo é atualizar a tabela existente:

CREATE TABLE public.dummy
(
  address_id SERIAL,
  addr1 character(40),
  addr2 character(40),
  city character(25),
  state character(2),
  zip character(5),
  customer boolean,
  supplier boolean,
  partner boolean

)
WITH (
  OIDS=FALSE
);

Inicialmente, testei minha consulta usando a instrução insert:

insert into address customer,supplier,partner
SELECT  
    case when cust.addr1 is not null then TRUE else FALSE end customer, 
    case when suppl.addr1 is not null then TRUE else FALSE end supplier,
    case when partn.addr1 is not null then TRUE else FALSE end partner
from (
    SELECT *
        from address) pa
    left outer join cust_original cust
        on (pa.addr1=cust.addr1 and pa.addr2=cust.addr2 and pa.city=cust.city 
            and pa.state=cust.state and substring(cust.zip,1,5) = pa.zip  )
    left outer join supp_original suppl 
        on (pa.addr1=suppl.addr1 and pa.addr2=suppl.addr2 and pa.city=suppl.city 
                and pa.state=suppl.state and pa.zip = substring(suppl.zip,1,5))
    left outer join partner_original partn
        on (pa.addr1=partn.addr1 and pa.addr2=partn.addr2 and pa.city=partn.city
                  and pa.state=partn.state and pa.zip = substring(partn.zip,1,5) )
where pa.address_id = address_id

sendo novato, estou falhando em converter para atualizar a instrução, atualizando as linhas existentes com valores retornados pela instrução select. Qualquer ajuda é muito apreciada.

O Postgres permite:

UPDATE dummy
SET customer=subquery.customer,
    address=subquery.address,
    partn=subquery.partn
FROM (SELECT address_id, customer, address, partn
      FROM  /* big hairy SQL */ ...) AS subquery
WHERE dummy.address_id=subquery.address_id;

Essa sintaxe não é o SQL padrão, mas é muito mais conveniente para esse tipo de consulta do que o SQL padrão. Acredito que a Oracle (pelo menos) aceite algo semelhante.

Você está atrás da UPDATE FROMsintaxe.

UPDATE 
  table T1  
SET 
  column1 = T2.column1 
FROM 
  table T2 
  INNER JOIN table T3 USING (column2) 
WHERE 
  T1.column2 = T2.column2;

Referências

• Exemplo de código aqui: GROUP BY na cláusula UPDATE FROM
• E aqui
• Especificação formal de sintaxe

Se não houver ganhos de desempenho usando uma associação, prefiro CTEs (Common Table Expressions) para facilitar a leitura:

WITH subquery AS (
    SELECT address_id, customer, address, partn
    FROM  /* big hairy SQL */ ...
)
UPDATE dummy
SET customer = subquery.customer,
    address  = subquery.address,
    partn    = subquery.partn
FROM subquery
WHERE dummy.address_id = subquery.address_id;

IMHO um pouco mais moderno.

Existem várias maneiras de atualizar as linhas.

Quando se trata de UPDATElinhas usando subconsultas, você pode usar qualquer uma dessas abordagens.

1. Abordagem-1 [Usando referência direta da tabela]

UPDATE
  <table1>
SET
  customer=<table2>.customer,
  address=<table2>.address,
  partn=<table2>.partn
FROM
  <table2>
WHERE
  <table1>.address_id=<table2>.address_i;

Explicação: table1é a tabela que queremos atualizar, table2 é a tabela da qual obteremos o valor a ser substituído / atualizado. Estamos usando a FROMcláusula, para buscar os table2dados. WHERE A cláusula ajudará a definir o mapeamento de dados adequado.

2. Abordagem-2 [Usando subconsultas]

UPDATE
  <table1>
SET
  customer=subquery.customer,
  address=subquery.address,
  partn=subquery.partn
FROM
  (
    SELECT
      address_id, customer, address, partn
    FROM  /* big hairy SQL */ ...
  ) AS subquery
WHERE
  dummy.address_id=subquery.address_id;

Explicação: Aqui estamos usando a subconsulta dentro da FROMcláusula e fornecendo um alias para ela. Para que ele atue como a mesa.

3. Abordagem-3 [Usando várias tabelas unidas]

UPDATE
  <table1>
SET
  customer=<table2>.customer,
  address=<table2>.address,
  partn=<table2>.partn
FROM
  <table2> as t2
  JOIN <table3> as t3
  ON
    t2.id = t3.id
WHERE
  <table1>.address_id=<table2>.address_i;

Explicação: Às vezes, enfrentamos a situação nessa junção de tabela, é tão importante para obter dados adequados para a atualização. Para fazer isso, o Postgres nos permite juntar várias tabelas dentro da FROMcláusula.

4. Abordagem-4 [Usando a declaração WITH]

   • 4.1 [Usando consulta simples]

WITH subquery AS (
    SELECT
      address_id,
      customer,
      address,
      partn
    FROM
      <table1>;
)
UPDATE <table-X>
SET customer = subquery.customer,
    address  = subquery.address,
    partn    = subquery.partn
FROM subquery
WHERE <table-X>.address_id = subquery.address_id;

• 4.2 [Usando consulta com JOIN complexo]

WITH subquery AS (
    SELECT address_id, customer, address, partn
    FROM
      <table1> as t1
    JOIN
      <table2> as t2
    ON
      t1.id = t2.id;
    -- You can build as COMPLEX as this query as per your need.
)
UPDATE <table-X>
SET customer = subquery.customer,
    address  = subquery.address,
    partn    = subquery.partn
FROM subquery
WHERE <table-X>.address_id = subquery.address_id;

Explicação: No Postgres 9.1, este WITHconceito ( ) foi introduzido. Usando isso, podemos fazer consultas complexas e gerar resultados desejados. Aqui estamos usando essa abordagem para atualizar a tabela.

Espero que isso seja útil.

update json_source_tabcol as d
set isnullable = a.is_Nullable
from information_schema.columns as a 
where a.table_name =d.table_name 
and a.table_schema = d.table_schema 
and a.column_name = d.column_name;

@ Mayur "4.2 [Usando a consulta com JOIN complexo]" com Common Table Expressions (CTEs) fez o truque para mim.

WITH cte AS (
SELECT e.id, e.postcode
FROM employees e
LEFT JOIN locations lc ON lc.postcode=cte.postcode
WHERE e.id=1
)
UPDATE employee_location SET lat=lc.lat, longitude=lc.longi
FROM cte
WHERE employee_location.id=cte.id;

Espero que isso ajude ...: D