Fundo

Procurando passar um conjunto de pares de nome/valor para um procedimento armazenado de maneira independente do banco de dados, usando JDBC. Uma estrutura de banco de dados é definida da seguinte forma:

CREATE TYPE array_parameters AS (
  v_name VARCHAR2(255),
  v_value CLOB
);

Essa estrutura, que pode ter definições equivalentes na maioria dos bancos de dados relacionais modernos, está sendo proposta como uma forma de passar um número arbitrário de pares nome/valor para um procedimento armazenado. A chamada do procedimento armazenado é semelhante a:

SELECT rxm( '...map...', array_parameters );

Onde o ...map...pode incluir qualquer número de referências variáveis, assumindo a seguinte forma :

account.id = $id &&
person.last_name = $surname && ...

O array_parameters, em teoria, poderia ser preenchido como:

array_parameters[0].v_name = "$id";
array_parameters[0].v_value = "123456789";
array_parameters[1].v_name = "$surname";
array_parameters[1].v_value = "O'Malley, The \"Great\"";

Problema

JDBC4 define um método chamado createArrayOf , que é o New South China Mall of APIs:

• Não suportado pela Oracle
• Não suportado pelo MySQL
• Não suportado pelo Microsoft SQL Server
• Não suportado pelo Apache Derby
• Sem suporte da Sybase

Sem a capacidade de criar a matriz de par de nome/valor, não vejo nenhuma maneira óbvia de passar os valores sem recorrer a implementações específicas do banco de dados (como usar o ARRAY da Oracle ou contorções obtusas para oferecer suporte ao MySQL).

Pergunta

Como você definiria e, em seguida, chamaria um procedimento armazenado que pode receber um número arbitrário de pares nome/valor de maneira independente do banco de dados?

Ideia #1

Uma ideia seria definir duas matrizes de strings, em vez de uma estrutura de matriz de objeto, e chamar o procedimento armazenado da seguinte maneira:

SELECT rxm( '...map...', array_names, array_values );

As duas matrizes seriam vinculadas a índices, mas isso provavelmente createArrayOf()também dependeria de .

Ideia #2

Pode ser possível passar os pares como strings separadas por vírgulas. No entanto, os próprios valores podem conter vírgulas, o que dificulta a codificação de parâmetros usando strings separadas por vírgula. (Falando de modo geral, qualquer separador pode aparecer como um caractere em algum lugar nos valores, o que também inclui separadores de escape, como \,.)

Essa parece ser a solução mais independente de banco de dados, mas implementar uma rotina de decodificação CSV em vários bancos de dados em PL/SQL não é trivial nem eficiente.

Ideia #3

Use o Hibernate como uma camada de abstração e implemente uma rotina JPQL que passa na matriz de pares nome/valor. Por exemplo, chamar query.setParameterList , que pode funcionar apenas para INcláusulas, em vez de parâmetros de procedimentos armazenados.

Fundo

Procurando encontrar o sufixo de string correspondente mais longo.

Configurar

Considere o seguinte violino :

CREATE TABLE noun
    ("label" varchar(10))
;

INSERT INTO noun
    ("label")
VALUES
    ('bar'),
    ('blue bar'),
    ('red bar'),
    ('green bar'),
    ('purple bar'),
    ('handlebar')
;

CREATE TABLE noun_inflection
    ("label_singular" varchar(9), "label_plural" varchar(9))
;

INSERT INTO noun_inflection
    ("label_singular", "label_plural")
VALUES
    ('bar', 'bars'),
    ('handlebar', 'handlebar')
;

E a seguinte consulta:

select * from noun n, noun_inflection ni
where
  n.label = 'handlebar' and
  n.label ilike '%'||ni.label_singular;

Isso retorna duas linhas:

LABEL       | LABEL_SINGULAR | LABEL_PLURAL
------------+----------------+-------------
handlebar   | bar            | bars
handlebar   | handlebar      | handlebar

A primeira linha está correta, mas não desejada. Para este propósito específico, a distância de Levenshtein pode ser usada para eliminar a duplicata:

select * from noun n, noun_inflection ni
where
  n.label = 'handlebar' and
  n.label ilike '%'||ni.label_singular
order by
  levenshtein( n.label, ni.label_singular )
limit 1;

Isso reordena as linhas com base na semelhança do rótulo. Neste exemplo, "handlebar" corresponde exatamente a "handlebar" e tem uma distância de 0. Adicionar o limit 1restringe a consulta a uma única linha.

Problema

A configuração funciona, exceto que o PostgreSQL 9.1 não respeita os modificadores LIMIT em funções agregadas. Ou seja, o seguinte não funciona:

SELECT
  xmlagg( xmlement( ... ) ORDER BY levenshtein( ... ) LIMIT 1 )
FROM
  noun n, noun_inflection ni

O problema persiste. A palavra 'handlebar'corresponde a '%bar'e '%handlebar', portanto, isso retorna duas linhas, que, por sua vez, injetam dois elementos xml no documento XML resultante quando apenas um é esperado.

Atualização nº 1

Esclarecer:

select
  xmlagg(
    xmlelement(
      name "noun",
      trim( TRAILING label_singular FROM n.label ) || ni.label_plural
    )
  )
from
  noun n, noun_inflection ni
where
  n.label = 'handlebar' and
  n.label ilike '%'||ni.label_singular;

Isso deve retornar um único elemento XML 'handlebar'. Atualmente, ele retorna 'handlebars' e 'handlebar':

{ "Value": "<noun>handlebars</noun><noun>handlebar</noun>", "Type": "xml" }

A saída desejada é:

{ "Value": "<noun>handlebar</noun>", "Type": "xml" }

Atualização nº 2

Mesmo que o código a seguir resolva o problema do guidão/guidão, ele evita que vários substantivos diferentes sejam retornados:

select
  xmlagg(
    xmlelement(
      name "noun",
      trim( TRAILING label_singular FROM n.label ) || ni.label_plural
    )
  )
from
  noun n, noun_inflection ni
where
  n.label = 'handlebar' and
  n.label ilike '%'||ni.label_singular
group by n.label, ni.label_singular
order by levenshtein( n.label, ni.label_singular )
limit 1

Atualização nº 3

Isso parece exigir uma função armazenada. Algo na linha de:

  SELECT
    trim( TRAILING label_singular FROM p_noun ) || ni.label_plural
  FROM
    noun_inflection ni
  WHERE
    p_noun ILIKE '%'||ni.label_singular
  ORDER BY
    levenshtein( p_noun, ni.label_singular )
  LIMIT 1;

Pergunta

Como você combinaria e retornaria apenas a substring mais longa?

Fundo

Usando uma hierarquia de menu para conduzir um processo de login para usuários. Os usuários podem definir seu item de menu preferido. Quando eles fazem login, se tiverem um item de menu preferido definido, o sistema os direciona para esse item. Se nenhum item de menu preferido for definido, eles farão login no item de menu padrão para sua função "mais importante".

Código

A consulta usa connect by priorpara obter a lista de menus:

  SELECT
    LEVEL AS menu_level,
    t.name AS menu_name,
    t.id AS menu_id
  FROM
    jhs_menu_items t, (
      SELECT
        jmi.id
      FROM
        jhs_users ju
      JOIN jhs_user_role_grants jurg ON
        ju.id = jurg.usr_id
      LEFT OUTER JOIN user_menu_preferences ump ON
        ju.id = ump.jhs_usr_id
      LEFT OUTER JOIN default_menu_preferences dmp ON
        jurg.rle_id = dmp.jhs_rle_id
      JOIN jhs_menu_items jmi ON
        -- Retrieve the user's preferred menu item, failing to the default
        -- if no preference is set.
        jmi.id = coalesce(
          ump.jhs_menu_items_id,
          dmp.jhs_menu_items_id
        )
      WHERE
        ju.username = 'USERNAME' AND
        ROWNUM = 1
      ORDER BY
        dmp.role_priority_sort
    ) menu_preference

  -- Derive the menu hierarchy starting at the user's preference, going back to 
  -- the root menu item.
  START WITH t.id = menu_preference.id
  CONNECT BY PRIOR t.mim_id = t.id

Problema

Um item de menu raiz tem NULLcomo pai ( mim_id). A preferência de menu do usuário é um nó de folha de item de menu, que pode ser encontrado em qualquer nível na hierarquia (a profundidade máxima é 3, neste caso).

Quando os dados são retornados, os valores da LEVELpseudocoluna (alias MENU_LEVEL) estão na ordem inversa:

╔════════════╦═══════════╦══════════════╗
║ MENU_LEVEL ║ MENU_NAME ║ MENU_ITEM_ID ║
╠════════════╬═══════════╬══════════════╣
║          1 ║ MenuTab3  ║ 100436       ║
║          2 ║ MenuTab2  ║ 101322       ║
║          3 ║ MenuTab1  ║ 101115       ║
╚════════════╩═══════════╩══════════════╝

Isso realmente deve retornar:

╔════════════╦═══════════╦══════════════╗
║ MENU_LEVEL ║ MENU_NAME ║ MENU_ITEM_ID ║
╠════════════╬═══════════╬══════════════╣
║          3 ║ MenuTab3  ║ 100436       ║
║          2 ║ MenuTab2  ║ 101322       ║
║          1 ║ MenuTab1  ║ 101115       ║
╚════════════╩═══════════╩══════════════╝

No entanto, como a hierarquia connected bycomeça no item de menu preferido do usuário e trabalha de volta ao item de menu raiz, faz sentido LEVELcontar "para trás".

Ter o nível invertido significa que podemos perguntar: "Qual é o item de menu de terceiro nível para o usuário chamado 'USERNAME'"? Expresso como uma cláusula where do SQL:

WHERE menu_level = 3 AND username = 'USERNAME';

Pergunta

Como você inverteria o valor de LEVELpara uma hierarquia arbitrariamente profunda?

Por exemplo, algo como:

SELECT
  LEVEL AS MENU_LEVEL_UNUSED,
  max(LEVEL) - LEVEL + 1 AS MENU_LEVEL
FROM ...

Obviamente isso não vai funcionar porque maxé uma função agregada.

violino

http://sqlfiddle.com/#!4/60678/3/0

Estranhamente, estou vendo comportamentos diferentes na instância 11g R2 do Fiddle do que na instância local do Oracle - o ROWNUM está captando "1" no Fiddle quando deveria estar captando "3". Isso evita ver a hierarquia do menu e, portanto, o arquivo LEVEL. Não sei por quê.

Ideias

• Poderíamos adicionar uma coluna para jhs_menu_itemsarmazenar a profundidade. Isso é um pouco redundante, porque a própria hierarquia contém essas informações.
• Poderíamos envolver a jhs_menu_itemstabela em uma exibição que calcula a profundidade. Isso pode ficar computacionalmente caro.
• Este é um bom candidato para WITH?

Fundo

Usando o PostgreSQL 9.1, portanto WITH ORDINAL(um recurso 9.4) não está disponível.

Problema

Procurando simplificar o código que gira uma matriz bidimensional.

Código

Um exemplo de trabalho excessivamente detalhado que ilustra o problema é:

SELECT
  u.aspect,
  u.preference
FROM (
  SELECT
    t.aspect_preference AS aspect,
    -- Skip every second row
    seq % 2 AS seq,
    lead( aspect_preference, 1 ) OVER (ORDER BY t.seq) AS preference
  FROM (
    SELECT
      unnest( '{ {"COLOUR_SCHEME", "RASPBERRY_BLISS"}, {"FONT", "TERMES_HEROS"}, {"LIST_LAYOUT", "BULLET_SNOWFLAKE"} }'::text[] ) aspect_preference,
      -- Maintain array order after unnesting to a result set
      generate_series( 1,
       (array_ndims( '{ {"COLOUR_SCHEME", "RASPBERRY_BLISS"}, {"FONT", "TERMES_HEROS"}, {"LIST_LAYOUT", "BULLET_SNOWFLAKE"} }'::text[] ) *
        array_length( '{ {"COLOUR_SCHEME", "RASPBERRY_BLISS"}, {"FONT", "TERMES_HEROS"}, {"LIST_LAYOUT", "BULLET_SNOWFLAKE"} }'::text[], 1 ) )
      ) seq
  ) t
  ORDER BY
    t.seq
) u
WHERE
  u.seq = 1

Isso produz os resultados corretos com as unnestlinhas da matriz 'ed dinamizadas nas colunas desejadas:

aspect          | preference
----------------+--------------------
COLOUR_SCHEME   | RASPBERRY_BLISS
FONT            | TERMES_HEROS
LIST_LAYOUT     | BULLET_SNOWFLAKE

Pergunta

Qual é a maneira mais simples de escrever essa consulta (por exemplo, menos linhas de código, menos SELECTs aninhados ou menos referências ao array)?

Procurando calcular a unidade de medida mais adequada para uma lista de substâncias em que as substâncias são dadas em unidades de volume diferentes (mas compatíveis).

Tabela de conversão de unidades

A tabela de conversão de unidades armazena várias unidades e como essas unidades se relacionam:

id  unit          coefficient                 parent_id
36  "microlitre"  0.0000000010000000000000000 37
37  "millilitre"  0.0000010000000000000000000 5
 5  "centilitre"  0.0000100000000000000000000 18
18  "decilitre"   0.0001000000000000000000000 34
34  "litre"       0.0010000000000000000000000 19
19  "dekalitre"   0.0100000000000000000000000 29
29  "hectolitre"  0.1000000000000000000000000 33
33  "kilolitre"   1.0000000000000000000000000 35
35  "megalitre"   1000.0000000000000000000000 0

A classificação pelo coeficiente mostra que parent_idvincula uma unidade filho ao seu superior numérico.

Esta tabela pode ser criada no PostgreSQL usando:

CREATE TABLE unit_conversion (
  id serial NOT NULL, -- Primary key.
  unit text NOT NULL, -- Unit of measurement name.
  coefficient numeric(30,25) NOT NULL DEFAULT 0, -- Conversion value.
  parent_id integer NOT NULL DEFAULT 0, -- Relates units in order of increasing measurement volume.
  CONSTRAINT pk_unit_conversion PRIMARY KEY (id)
)

Deve haver uma chave estrangeira de parent_idpara id.

Tabela de substâncias

A Tabela de Substâncias lista quantidades específicas de substâncias. Por exemplo:

 id  unit          label     quantity
 1   "microlitre"  mercury   5
 2   "millilitre"  water     500
 3   "centilitre"  water     2
 4   "microlitre"  mercury   10
 5   "millilitre"  water     600

A tabela pode se parecer com:

CREATE TABLE substance (
  id bigserial NOT NULL, -- Uniquely identifies this row.
  unit text NOT NULL, -- Foreign key to unit conversion.
  label text NOT NULL, -- Name of the substance.
  quantity numeric( 10, 4 ) NOT NULL, -- Amount of the substance.
  CONSTRAINT pk_substance PRIMARY KEY (id)
)

Problema

Como você criaria uma consulta que encontra uma medida para representar a soma das substâncias usando o menor número de dígitos que possui um número inteiro (e, opcionalmente, componente real)?

Por exemplo, como você retornaria:

  quantity  unit        label
        15  microlitre  mercury 
       112  centilitre  water

Mas não:

  quantity  unit        label
        15  microlitre  mercury 
      1.12  litre       water

Porque 112 tem menos dígitos reais do que 1,12 e 112 é menor do que 1120. No entanto, em certas situações, o uso de dígitos reais é menor - como 1,1 litros versus 110 centilitros.

Principalmente, estou tendo problemas para escolher a unidade correta com base na relação recursiva.

Código fonte

Até agora eu tenho (obviamente não trabalho):

-- Normalize the quantities
select
  sum( coefficient * quantity ) AS kilolitres
from
  unit_conversion uc,
  substance s
where
  uc.unit = s.unit
group by
  s.label

Ideias

Isso requer o uso de log ₁₀ para determinar o número de dígitos?

Restrições

As unidades não estão todas em potências de dez. Por exemplo: http://unitsofmeasure.org/ucum-essence.xml

A documentação do PostgreSQL declara:

Qualquer função com efeitos colaterais deve ser rotulada como VOLÁTIL...

Considere a seguinte função:

CREATE OR REPLACE FUNCTION count_items()
  RETURNS integer AS
$BODY$
DECLARE
  v_result INTEGER DEFAULT 0;
BEGIN
  SELECT
    count( t.id )
  INTO
    v_result
  FROM
    some_table t;

  RETURN v_result;

EXCEPTION
  WHEN OTHERS THEN
    PERFORM error_log_insert( SQLSTATE, SQLERRM, current_query() );
    RETURN 0;
END;
$BODY$
  LANGUAGE plpgsql STABLE
  COST 10;

Como error_log_insertaltera o banco de dados (executa uma inserção em uma exceção), isso significa que a count_itemsfunção tem um efeito colateral (embora indireto) e, portanto, não pode ser declarada STABLE, mas deve ser VOLATILE?

Em outras palavras, a estabilidade ou volatilidade de uma função também depende das funções que ela chama dentro de seu bloco de exceção ?

Se for esse o caso, como você criaria STABLEfunções no PostgreSQL que registram todas as exceções em uma tabela de banco de dados?

Executando o PostgreSQL 9.1.8 no Xubuntu 12.04, instalado a partir dos repositórios.

No shell, executei:

createlang plperl db_name;
createlang plperlu db_name;

Como superusuário executando psql, executei:

GRANT ALL ON LANGUAGE plperl TO account_name;
GRANT ALL ON LANGUAGE plperlu TO account_name;

A pg_languagetabela revela:

select lanname,lanpltrusted from pg_language where lanname like 'plperl%';

"plperl";t
"plperlu";t

Quando crio a seguinte função:

CREATE OR REPLACE FUNCTION get_hostname()
  RETURNS text AS
$BODY$
  use Sys::Hostname;
  return hostname;
$BODY$
  LANGUAGE plperlu IMMUTABLE
  COST 1;
ALTER FUNCTION get_hostname()
  OWNER TO account_name;

Eu recebo o seguinte erro:

ERROR:  Unable to load Sys/Hostname.pm into plperl at line 2.
BEGIN failed--compilation aborted at line 2.
CONTEXT:  compilation of PL/Perl function "get_hostname"

Ainda as seguintes obras:

CREATE OR REPLACE FUNCTION get_hostname()
  RETURNS text AS
$BODY$
  return '127.0.0.1';
$BODY$
  LANGUAGE plperlu IMMUTABLE
  COST 1;
ALTER FUNCTION get_hostname()
  OWNER TO account_name;

O script Perl a seguir funciona conforme o esperado do shell:

use Sys::Hostname;
print hostname;

Tentei executar a função como um bloco anônimo:

DO $$
  use Sys::Hostname;
  print hostname;
$$ LANGUAGE plperlu;

Isso retornou o mesmo erro de antes, com esta informação adicional:

ERROR: Unable to load Sys/Hostname.pm into plperl at line 3.
BEGIN failed--compilation aborted at line 3.
SQL state: 42601
Context: PL/Perl anonymous code block

Na documentação , o erro 42601 é um erro de sintaxe.

Não vejo nenhum erro de sintaxe.

Além disso, a função carregou bem com a conta de superusuário quando importei o banco de dados:

psql -d db_name -U account_name -W -f db-dump.sql > import.log 2> error.log

Tentei simplificar o código sem sucesso:

CREATE OR REPLACE FUNCTION get_hostname() RETURNS text AS
$$
  use Sys::Hostname;
  return hostname;
$$
LANGUAGE plperlu;

Mesmo erro de antes.

O que não entendo é por que, de acordo com a mensagem de erro, o PostgreSQL está tentando carregar o código em plperlvez de plperlu.

Alguma ideia?

Atualização nº 1

Observe que o usuário postgres é um superusuário:

                             List of roles
 Role name |                   Attributes                   | Member of 
-----------+------------------------------------------------+-----------
 postgres  | Superuser, Create role, Create DB, Replication | {}

Fundo

Esse problema está relacionado a ignorar inserções duplicadas usando o PostgreSQL 9.2 ou superior. A razão pela qual eu pergunto é por causa deste código:

  -- Ignores duplicates.
  INSERT INTO
    db_table (tbl_column_1, tbl_column_2)
  VALUES (
    SELECT
      unnseted_column,
      param_association
    FROM
      unnest( param_array_ids ) AS unnested_column
  );

O código é livre de verificações de valores existentes. (Nesta situação específica, o usuário não se importa com erros de inserção de duplicatas -- a inserção deve "simplesmente funcionar".) Adicionar código nessa situação para testar explicitamente duplicatas traz complicações.

Problema

No PostgreSQL, encontrei algumas maneiras de ignorar inserções duplicadas.

Ignorar duplicatas #1

Crie uma transação que detecte violações de restrição exclusivas, sem realizar nenhuma ação:

  BEGIN
    INSERT INTO db_table (tbl_column) VALUES (v_tbl_column);
  EXCEPTION WHEN unique_violation THEN
    -- Ignore duplicate inserts.
  END;

Ignorar duplicatas #2

Crie uma regra para ignorar duplicatas em uma determinada tabela:

CREATE OR REPLACE RULE db_table_ignore_duplicate_inserts AS
    ON INSERT TO db_table
   WHERE (EXISTS ( SELECT 1
           FROM db_table
          WHERE db_table.tbl_column = NEW.tbl_column)) DO INSTEAD NOTHING;

Perguntas

Minhas perguntas são principalmente acadêmicas:

• Qual método é mais eficiente?
• Qual método é mais sustentável e por quê?
• Qual é a maneira padrão de ignorar erros de duplicação de inserção com o PostgreSQL?
• Existe uma maneira tecnicamente mais eficiente de ignorar inserções duplicadas; Se assim for, o que é?

Obrigada!

Fundo

Tenho um banco de dados com dezenas de tabelas, algumas das quais deveriam ter colunas de auditoria.

Problema

Gostaria de evitar o trabalho penoso de criar colunas de auditoria manualmente e escrever os gatilhos updatee uma vez.delete

Código

Existem vários pedaços diferentes de código que devem vir juntos.

Tabela de Auditoria

O código a seguir cria uma tabela de auditoria e uma tabela de cidade:

CREATE TABLE audit (
  created timestamp with time zone NOT NULL DEFAULT ('now'::text)::timestamp with time zone,
  deleted timestamp with time zone,
  updated timestamp with time zone
);

Tabela de Exemplo

Uma tabela simples para servir de exemplo do problema:

CREATE TABLE city (
  name       text,
  population real,
  altitude   int
);

Acionador da tabela pai

O código a seguir cria um gatilho de banco de dados e uma regra de prevenção de exclusão na tabela de auditoria:

CREATE FUNCTION audit_delete() RETURNS trigger AS
$audit_delete$
BEGIN
  OLD.deleted := current_timestamp;
  RETURN NULL;
END;
$audit_delete$
LANGUAGE plpgsql;

CREATE TRIGGER audit_delete BEFORE DELETE ON audit
    FOR EACH ROW EXECUTE PROCEDURE audit_delete();

Adicionando colunas

A herança requer que as colunas na tabela filho correspondam à tabela pai e devem ser criadas manualmente. Tal como:

for $name in (SELECT list of tables); do
  ALTER TABLE $name ADD COLUMN
    created timestamp with time zone NOT NULL DEFAULT ('now'::text)::timestamp with time zone;
  ALTER TABLE $name ADD COLUMN
    deleted timestamp with time zone;
  ALTER TABLE $name ADD COLUMN
    updated timestamp with time zone;
done

Provavelmente existe uma maneira de detectar e adicionar automaticamente as colunas ausentes usando o esquema de informações.

Estabelecer Hierarquia de Herança

O código a seguir aplica a herança à tabela fornecida:

ALTER TABLE city INHERIT audit;

Inserir Dados

Adicione alguns dados no banco de dados:

INSERT INTO city ('Vancouver', 603502, 10 );
INSERT INTO city ('Seattle', 620887, 10 );
INSERT INTO city ('La Rinconada', 30000, 5100 );
INSERT INTO city ('Jericho', 20300, -260 );

Excluir dados

Remova alguns dados:

DELETE FROM city WHERE name = 'Jericho';

Nesse ponto, eu esperava que a deletedcoluna contivesse a data para o valor de "Jericho". Em vez disso, a linha foi realmente removida do banco de dados.

O gatilho para audit_delete()não disparou.

Perguntas

1. Qual é a maneira ideal (ou usual) de criar um gatilho que define a data de exclusão em deleteconsultas para todas as tabelas herdadas da tabela de auditoria (usando o PostgreSQL 9.2)?
2. (Opcional) Esse é um bom uso para gatilhos?

Obrigada!

Links Relacionados

• http://projects.nocternity.net/index.py/en/psql-inheritance
• http://www.postgresql.org/docs/current/static/tutorial-inheritance.html
• https://stackoverflow.com/questions/8469116/how-can-i-make-a-trigger-to-use-inheritance-with-that-tables
• http://tapoueh.org/blog/2010/11/24-dynamic-triggers-in-plpgsql.html
• http://www.postgresql.org/docs/current/static/plpgsql-trigger.html
• http://archives.postgresql.org/pgsql-general/2009-08/msg00026.php
• http://andreas.scherbaum.la/blog/archives/100-Log-Table-Changes-in-PostgreSQL-with-tablelog.html

Fundo

Usando o Oracle, há várias ferramentas que ajudam na migração e na aplicação de alterações de desenvolvimento no ambiente de produção (como o Embarcadero Change Manager ). Essas ferramentas podem ser configuradas para executar qualquer atualização DDL de banco de dados com pouca ou nenhuma intervenção humana.

Problema

Tenho servidores de desenvolvimento e produção rodando PostgreSQL 9.x. Após a implantação inicial do banco de dados DDL no servidor de produção, continuarei a fazer alterações no banco de dados de desenvolvimento. Essas alterações incluirão correções de erros em procedimentos armazenados, alterações em tabelas, sequências adicionais, novas exibições, mais tipos, mais tabelas e assim por diante.

Pergunta

Quais são as etapas para atualizar/migrar o DDL para um aplicativo de banco de dados PostgreSQL de produção de maneira automática (ou quase automática) de modo que as novas alterações sejam feitas no desenvolvimento?

Relacionado

• http://apgdiff.startnet.biz/

Obrigada!