SQLEXEC

Válido Para

Extract e Replicat

Descrição

Use o parâmetro SQLEXEC para executar um procedimento armazenado, uma consulta ou um comando de banco de dados no contexto do processamento do Oracle GoldenGate. O SQLEXEC permite que o Oracle GoldenGate se comunique diretamente com o banco de dados para executar qualquer trabalho suportado pelo banco de dados. Esse trabalho pode fazer parte do processo de sincronização, como recuperar valores para conversão de coluna, ou pode ser independente de extrair ou replicar dados, como executar um procedimento armazenado que executa uma ação no banco de dados.

Observação: SQLEXEC fornece suporte mínimo à globalização. Para usar SQLEXEC no arquivo de parâmetros de captura da captura de origem, certifique-se de que o conjunto de caracteres do cliente no arquivo .prm de origem seja igual ou um superconjunto do conjunto de caracteres do banco de dados de origem.

SQLEXEC funciona da seguinte forma:

Como uma instrução standalone no nível raiz de um arquivo de parâmetros para executar um procedimento ou consulta SQL armazenado ou para executar um comando de banco de dados. Como instrução stand-alone, SQLEXEC é executado independentemente de uma instrução TABLE ou MAP durante o processamento do Oracle GoldenGate. Quando usada em um parâmetro SQLEXEC stand-alone, uma consulta ou procedimento não pode incluir parâmetros. Consulte "Standalone SQLEXEC".
Como parte de um parâmetro TABLE ou MAP para executar um procedimento armazenado ou consulta com ou sem parâmetros. Quando usado com parâmetros, o procedimento ou a consulta que é executada pode aceitar parâmetros de entrada das linhas de origem ou de destino e passar parâmetros de saída. Consulte "SQLEXEC em um TABLE ou Parâmetro MAP".
Em casos de uso de captura remota, o uso de SQLEXEC pode introduzir latência adicional, pois a operação SQLEXEC deve ser feita em série para cada registro que o processo Extract. Se a filtragem especial que exigiria um SQLEXEC for feita por um Extract de hub remoto e o impacto no desempenho for muito grave, pode ser necessário aproximar o processo Extract do banco de dados de origem. Cuidado: Tenha cuidado ao executar procedimentos do SQLEXEC no banco de dados, especialmente no banco de dados de produção. Todas as alterações submetidas a commit pelo procedimento podem resultar na substituição dos dados existentes.

Observação: O parâmetro SQLEXECONBEFOREIMAGE suporta a execução SQLEXEC nos registros Antes da Imagem.

Observação: O parâmetro SQLEXECONBEFOREIMAGE é ignorado na atualização da PK ou no registro de atualização unificada quando o tipo EXEC é TRANSACTION, SOURCEROW ou ONCE.

SQLEXEC Independente

Um parâmetro SQLEXEC standalone é aquele que é usado no nível raiz de um arquivo de parâmetros e age independentemente de um parâmetro TABLE ou MAP. A seguir estão as diretrizes para o uso de um parâmetro SQLEXEC independente.

Uma instrução SQLEXEC stand-alone é executada na ordem em que aparece no arquivo de parâmetros em relação a outros parâmetros.
Um procedimento ou consulta SQLEXEC deve conter todo o tratamento de exceções.
Uma consulta ou procedimento deve ser estruturado corretamente ao executar uma instrução SQLEXEC, com sintaxe SQL legal para o banco de dados; caso contrário, o Replicat será interrompido, independentemente de quaisquer regras de tratamento de erros que estejam em vigor. Consulte o guia de referência SQL fornecido pelo fornecedor do banco de dados para obter a sintaxe SQL permitida.
Uma credencial de banco de dados para o usuário do Oracle GoldenGate deve preceder a cláusula SQLEXEC. Para Extract, use os parâmetros USERIDALIAS conforme apropriado para o banco de dados. Para Replicat, use os parâmetros USERIDALIAS, conforme apropriado.
A credencial de banco de dados que o processo do Oracle GoldenGate usa é a que executa o SQL. Essa credencial deve ter o privilégio para executar comandos e procedimentos armazenados e chamar procedimentos fornecidos pelo banco de dados.
Uma instrução SQLEXEC independente não pode ser usada para obter parâmetros de entrada de registros ou especificar parâmetros de saída. Você pode usar procedimentos armazenados e consultas com parâmetros usando uma instrução SQLEXEC em uma instrução TABLE ou MAP. Consulte "SQLEXEC em um TABLE ou Parâmetro MAP".
Todos os objetos afetados por uma instrução SQLEXEC stand-alone devem existir antes do início dos processos do Oracle GoldenGate. Devido a isso, o suporte a DDL deve ser desativado para esses objetos; caso contrário, as operações DDL poderão alterar a estrutura ou excluir um objeto antes que o procedimento SQLEXEC ou a consulta seja executada nele.
Os nomes de objetos devem ser totalmente qualificados no formato de nome de duas ou três partes.
Para Db2 no z/OS, o Oracle GoldenGate usa a função SQLExecDirect ODBC para executar uma instrução SQL dinamicamente. O ODBC prepara a instrução SQL toda vez que ela é executada, em um intervalo especificado. Para suportar esta função, o servidor de banco de dados conectado deve ser configurado para preparar SQL dinamicamente. Consulte o Db2 para obter mais informações sobre a documentação do z/OS.

Obtendo Mais Informações sobre o Uso do SQLEXEC Standalone

Consulte Usar SQLEXEC para Executar Comandos, Procedimentos Armazenados e Consultas para obter mais informações sobre como usar o SQLEXEC.

Sintaxe para SQLEXEC Standalone

SQLEXEC
{'call <procedure_name>()' | '<SQL_query>' | '<database_command>'}
[EVERY <n> {SECONDS | MINUTES | HOURS | DAYS}]
[ONEXIT]
[, THREADS (<threadID>[, <threadID>][, ...][, <thread_range>[, <thread_range>][, ...])]

'chamar <procedure_name ()'>

Especifica o nome de um procedimento armazenado a ser executado. Coloque a instrução entre aspas simples. A palavra-chave call é obrigatória. Veja a seguir um exemplo de como executar um procedimento com SQLEXEC independente:

SQLEXEC 'call prc_job_count ()'

<'SQL_query'>

Especifica o nome de uma consulta a ser executada. Coloque a consulta entre aspas simples. Especifique nomes de objetos com distinção entre maiúsculas e minúsculas no mesmo formato exigido pelo banco de dados. Veja a seguir um exemplo de como executar uma consulta com o SQLEXEC independente:

SQLEXEC ' select x from dual '

Para uma consulta de várias linhas, use as aspas simples em cada linha. Para obter melhores resultados, digite um espaço após cada aspas iniciais e antes de cada aspas finais (ou pelo menos antes de cada aspas finais).

<'database_command'>

Executa um comando de banco de dados. Veja a seguir um exemplo de como executar um comando de banco de dados com SQLEXEC independente:

SQLEXEC 'SET TRIGGERS OFF'

EVERY <n> {SECONDS | MINUTES | HOURS | DAYS}

Faz com que um procedimento ou consulta armazenados standalone seja executado em um intervalo definido, por exemplo:

SQLEXEC 'call prc_job_count ()' EVERY 30 SECONDS

O intervalo deve ser um inteiro, inteiro positivo.

ONEXIT

Executa a SQL quando o processo Extract ou Replicat é interrompido normalmente, por exemplo:

SQLEXEC 'call prc_job_count ()' ONEXIT

THREADS (<threadID>[, <threadID>][, ...][, <thread_range>[, <thread_range>][, ...])

Executa SQLEXEC somente para o thread ou threads especificados de um Replicat coordenado.

<threadID>[, <threadID>][, ...]

Especifica um thread ID ou uma lista de threads delimitada por vírgulas no formato threadID, threadID, threadID.

[, <thread_range>[, <thread_range>][, ...]

Especifica uma faixa de threads na forma de threadIDlow-threadIDhigh ou uma lista de faixas delimitada por vírgulas no formato de threadIDlow-threadIDhigh, threadIDlow-threadIDhigh.

Uma combinação desses formatos é permitida, como threadID, threadID, threadIDlow-threadIDhigh.

Se nenhuma cláusula THREADS for usada, a SQL será executada por todos os threads configurados para esse grupo Replicat pelo comando ADD REPLICAT. No entanto, se o SQL atender aos critérios de uma transação de barreira, a instrução SQLEXEC inteira será processada pelo thread 0, independentemente do mapeamento de thread real.

SQLEXEC em um Parâmetro TABLE ou MAP

Um parâmetro SQLEXEC em um parâmetro TABLE ou MAP pode ser usado para executar um procedimento armazenado ou uma consulta que aceita ou não parâmetros. Veja a seguir as dependências e restrições SQLEXEC quando usadas em uma instrução MAP ou TABLE:

O SQL é executado pelo usuário do banco de dados no qual o processo do Oracle GoldenGate está em execução. Este usuário deve ter o privilégio para executar procedimentos armazenados e chamar procedimentos fornecidos pelo banco de dados.
Uma consulta ou procedimento deve ser estruturado corretamente ao executar uma instrução SQLEXEC. Se o Replicat encontrar um problema com a consulta ou o procedimento, o processo será encerrado imediatamente, apesar das regras de tratamento de erros em vigor. Consulte o guia de referência SQL fornecido pelo fornecedor do banco de dados para obter a sintaxe SQL permitida.
A operação COMMIT de uma transação Replicat para o banco de dados de destino também faz commit de quaisquer alterações DML feitas em uma instrução SQLEXEC dentro do limite da transação de origem original. Isso não se aplica ao processo Extract porque o processo Extract não executa transações SQL. Ao usar SQLEXEC para Extract, você pode ativar commits implícitos ou executar um commit explícito no procedimento SQLEXEC.
Especifique literais entre aspas simples. Especifique nomes de objetos com distinção entre maiúsculas e minúsculas da mesma forma que são especificados no banco de dados.
Não use SQLEXEC para alterar o valor de uma coluna de chave primária. O valor da chave primária é passado do processo Extract para o processo Replicat. Sem ela, as operações Replicat não poderão ser concluídas. Se os valores de chave primária precisarem ser alterados com SQLEXEC, você poderá evitar erros mapeando o valor de chave original para outra coluna e definindo essa coluna como uma chave substituta com a opção KEYCOLS dos parâmetros TABLE e MAP.
Para Db2 no z/OS, o Oracle GoldenGate usa a função SQLExecDirect do ODBC para executar uma instrução SQL dinamicamente. O ODBC prepara a instrução SQL toda vez que ela é executada, em um intervalo especificado. Para suportar esta função, o servidor de banco de dados conectado deve ser configurado para preparar o SQL dinamicamente. Consulte o Db2 para obter mais informações sobre a documentação do z/OS.
Ao usar o Oracle GoldenGate para replicar DDL, todos os objetos afetados por um procedimento armazenado ou consulta devem existir com as estruturas corretas antes da execução da SQL. Consequentemente, DDL nesses objetos que afetam a estrutura (como CREATE ou ALTER) deve ser executado antes da execução de SQLEXEC.
Todos os nomes de objetos em uma instrução SQLEXEC devem ser totalmente qualificados com os nomes de duas ou três partes, conforme apropriado para o banco de dados.
Não use SQLEXEC para tabelas que estão sendo processadas no modo de passagem por um grupo Extract de data-pump.
Os tipos de dados a seguir são suportados pelo SQLEXEC para parâmetros de entrada e saída.
- Tipos de dados numéricos
- Tipos de dados de data
- Tipos de dados de caracteres
Quando executado por um Replicat coordenado, o SQLEXEC é executado pelo thread ou threads especificados com a opção THREAD ou THREADRANGE da instrução MAP. No entanto, se o SQLEXEC for especificado em um parâmetro MAP que contenha a palavra-chave COORDINATED, ele será executado como uma transação de barreira automaticamente pelo thread com o número ID mais baixo, independentemente do mapeamento de thread real.

Sintaxe de SQLEXEC em TABLE ou MAP

SQLEXEC (
{SPNAME <procedure_name>[, ID <logical_name>] |
   ID <logical_name>, QUERY ' <SQL_query> '}
{, PARAMS [OPTIONAL | REQUIRED] <parameter_name> = {<source_column> | <OGG_function>} |
   NOPARAMS}
[, AFTERFILTER | BEFOREFILTER]
[, ALLPARAMS {OPTIONAL | REQUIRED}]
[, ERROR {IGNORE | REPORT | RAISE | FINAL | FATAL}]
[, EXEC {MAP | ONCE | TRANSACTION | SOURCEROW}][, MAXVARCHARLEN <bytes>]
[, PARAMBUFSIZE <bytes>]
[, TRACE]
[, ...]
[, BEFORE_col1 = @BEFORE(col1),
)

SPNAME <procedure_name>[, ID <logical_name>]

Executa um procedimento armazenado.

SPNAME <procedure_name>

Especifica o nome do procedimento a ser executado.

O exemplo a seguir mostra uma única execução de um procedimento armazenado chamado lookup. Neste caso, o nome real do procedimento é usado. Não é necessário um nome lógico.

SQLEXEC (SPNAME lookup), PARAMS (param1 = srccol)), &
COLMAP (targcol = lookup.param1);

ID <logical_name>

Define um nome lógico opcional para o procedimento. Por exemplo, os nomes lógicos de um procedimento chamado lookup podem ser lookup1, lookup2 e assim por diante. Use essa opção para executar o procedimento várias vezes dentro de uma instrução MAP. Um procedimento pode ser executado até 20 vezes por instrução MAP. ID não é necessário ao executar um procedimento uma vez.

O exemplo a seguir mostra o uso da opção ID para ativar várias execuções de um procedimento armazenado que obtém valores de uma tabela de pesquisa. Os valores são mapeados para colunas de destino.

SQLEXEC (SPNAME lookup, ID lookup1, &
  PARAMS (long_name = current_residence_state)), &
SQLEXEC (SPNAME lookup, ID lookup2, &
  PARAMS (long_name = birth_state)), &
COLMAP (custid = custid, current_residence_state_long = lookup
1.long_name, & birth_state_long = lookup2.long_name);

`ID , CONSULTA ' '

Executa uma consulta.

ID <logical_name>

Define um nome lógico para a consulta. É necessário um nome lógico para extrair valores dos resultados da consulta. <ID logical_name> faz referência aos valores de coluna retornados pela consulta.

QUERY '<SQL_query>'

Especifica a sintaxe de consulta SQL a ser executada no banco de dados. A consulta pode retornar resultados com uma instrução SELECT ou executar uma instrução INSERT, UPDATE ou DELETE. Uma instrução SELECT deve retornar somente uma linha. Se várias linhas forem retornadas, somente a primeira linha será processada. Não especifique uma cláusula INTO ... para qualquer consulta SELECT statements.The que deva ser uma linguagem de consulta padrão válida para o banco de dados no qual ela está sendo executada. A maioria das consultas requer espaços reservados para parâmetros de entrada. O modo como os parâmetros são especificados na consulta depende do tipo de banco de dados, da seguinte forma:

Para o Oracle, os parâmetros de entrada são especificados usando dois-pontos (:) seguido pelo nome do parâmetro, como no exemplo a seguir.

'SELECT NAME FROM ACCOUNT WHERE SSN = :SSN AND ACCOUNT = :ACCT'

Para outros bancos de dados, os parâmetros de entrada são especificados usando um ponto de interrogação, como no exemplo a seguir.

'SELECT NAME FROM ACCOUNT WHERE SSN = ? AND ACCOUNT = ?'

A consulta deve estar contida em uma linha, entre aspas simples. Não são necessárias aspas em torno de um nome de parâmetro para nenhum banco de dados.

Os exemplos a seguir ilustram o uso de uma consulta SQLEXEC para consultas do Oracle e do SQL Server, respectivamente.

Exemplo Oracle:

MAP sales.account, TARGET sales.newacct, &
  SQLEXEC (ID lookup, &
  QUERY 'select desc_col into desc_param from lookup_table &
  where code_col = :code_param', &
  PARAMS (code_param = account_code)), &
  COLMAP (newacct_id = account_id, newacct_val = lookup.desc_param);

Exemplo de SQL Server:

MAP sales.account, TARGET sales.newacct, &
  SQLEXEC (ID lookup, &
  QUERY 'select desc_col into desc_param from lookup_table &
  where code_col = ?', &
  PARAMS (p1 = account_code)), &
  COLMAP (newacct_id = account_id, &
  newacct_val = lookup.desc_param);

PARAMS [OPTIONAL | REQUIRED] <parameter_name> = {<source_column> | <OGG_function>} | NOPARAMS

Define se o procedimento ou consulta aceita ou não parâmetros e, se sim, mapeia os parâmetros para a origem de entrada. Uma cláusula PARAMS ou NOPARAMS deve ser usada.

OPTIONAL REQUIRED

Determina se o procedimento ou a consulta é executada quando valores de parâmetro estão ausentes.

OPTIONAL indica que um valor de parâmetro não é necessário para a execução do SQL. Se uma coluna de origem obrigatória estiver ausente na operação do banco de dados ou se uma função de conversão de coluna não puder ser concluída com sucesso porque uma coluna de origem está ausente, o SQL será executado mesmo assim. OPTIONAL é o padrão para todos os bancos de dados, exceto o Oracle. Para o Oracle, se um parâmetro é opcional ou não, é determinado automaticamente ao recuperar a definição de procedimento armazenado.

REQUIRED indica que um valor de parâmetro deve estar presente. Se o valor do parâmetro não estiver presente, o SQL não será executado.

<parameter_name> = {<source_column> | <OGG_function>}

Mapeia o nome de um parâmetro para uma coluna ou função que fornece a entrada. Os tipos de dados a seguir são suportados pelo SQLEXEC para parâmetros de entrada e saída.

Tipos de dados numéricos
Tipos de dados de data
Tipos de dados de caracteres

<parameter_name> é uma das seguintes:

Para um procedimento armazenado, é o nome de qualquer parâmetro no procedimento que pode aceitar a entrada.
Para uma consulta Oracle, é o nome de qualquer parâmetro de entrada na consulta, excluindo os dois-pontos à esquerda. Por exemplo, :vemplid seria especificado como vemplid na cláusula PARAMS. O Oracle permite nomear um parâmetro de entrada para qualquer nome lógico.

SQLEXEC (ID appphone, QUERY ' select per_type from ps_personal_data '
    ' where emplid = :vemplid '
    ' and per_status = 'N' and per_type = 'A' ',
    PARAMS (vemplid = emplid)),
TOKENS (applid = @GETVAL(appphone.per_type));

Para uma consulta não Oracle, é P <n>, em que <n> é o número do parâmetro na instrução, começando por 1. Por exemplo, em uma consulta com dois parâmetros, as entradas <parameter_name> são p1 and p2. Considere se o banco de dados requer que o p seja maiúsculo ou minúsculo.

SQLEXEC (ID appphone, QUERY ' select per_type from ps_personal_data '
    ' where emplid = ? '
    ' and per_status = 'N' and per_type = 'A' ',
    PARAMS (p1 = emplid)),
TOKENS (applid = @GETVAL(appphone.per_type));

<source_column> é o nome de uma coluna de origem que fornece a entrada. Por padrão, se a coluna especificada não estiver presente no log (porque o registro contém apenas os valores das colunas que foram atualizadas), o parâmetro assumirá qualquer valor padrão especificado pelo procedimento ou consulta para o parâmetro.

<OGG_function> é o nome de uma função de conversão de coluna do Oracle GoldenGate que é executada para fornecer a entrada. Consulte "Funções de Mapeamento de Tabela e Coluna".

Para transmitir valores de saída do procedimento armazenado ou da consulta como entrada para uma cláusula FILTER ou COLMAP, use a seguinte sintaxe:

{<procedure_name> | <logical_name>}.<parameter>

Onde:

<procedure_name> é o nome real de um procedimento armazenado, que deve corresponder ao valor fornecido para SPNAME na instrução SQLEXEC. Use esse argumento somente se estiver executando um procedimento uma vez durante o curso da execução do Oracle GoldenGate.
<logical_name> é o nome lógico especificado com a opção ID do SQLEXEC. Use esse argumento para passar valores de entrada de uma consulta ou instância de um procedimento armazenado quando o procedimento for executado várias vezes dentro de uma instrução MAP.
<parameter> é o nome de um parâmetro ou RETURN_VALUE se estiver extraindo valores retornados. Por padrão, os valores de saída são truncados em 255 bytes por parâmetro. Se os parâmetros de saída precisarem ser maiores, use a opção MAXVARCHARLEN. Observação: Como alternativa à sintaxe anterior, você pode usar a função @GETVAL.

Os exemplos a seguir se aplicam a um conjunto de tabelas de origem e destino da Oracle e a uma tabela de lookup. Estes exemplos mostram como os parâmetros para as tabelas são passados para uma única instância de um procedimento armazenado e para várias instâncias de um procedimento armazenado.

Cliente da tabela de origem:

custid                     Number
current_residence_state    Char(2)
birth_state                Char(2)

Tabela de destino cust_extended:

custid                          Number
current_residence_state_long    Varchar(30)
birth_state_long                Varchar(30)

Tabela de pesquisa state_lookup

abbreviation     Char(2)
long_name        Varchar(30)

O exemplo a seguir mostra o uso de um procedimento armazenado que é executado uma vez para obter um valor da tabela de pesquisa. Ao processar registros da tabela cust, o Oracle GoldenGate executa o procedimento armazenado lookup antes de executar o mapa de colunas. O parâmetro long_name no procedimento aceita entrada do valor column.The de origem do birth_state é mapeado para a coluna de destino birth_state_long na instrução COLMAP.

MAP sales.cust, TARGET sales.cust_extended, &
SQLEXEC (SPNAME lookup, &
PARAMS (long_name = birth_state)), &
COLMAP (custid = custid, &
birth_state_long = lookup.long_name);

MAP sales.cust, TARGET sales.cust_extended, &
SQLEXEC (SPNAME lookup, ID lookup1, &
PARAMS (long_name = current_residence_state)), &
SQLEXEC (SPNAME lookup, ID lookup2, &
PARAMS (long_name = birth_state)), &
COLMAP (custid = custid, current_residence_state_long = lookup1.long_name, & birth_state_long = lookup2.long_name);

AFTERFILTER BEFOREFILTER

Use AFTERFILTER e BEFOREFILTER para especificar quando executar o procedimento armazenado ou a consulta em relação à cláusula FILTER de uma instrução MAP.

AFTERFILTER

Faz com que a SQL seja executada após a instrução FILTER. Isso permite ignorar a sobrecarga da execução do SQL, a menos que o filtro seja bem-sucedido. Este é o padrão.

BEFOREFILTER

Faz com que a SQL seja executada antes da instrução FILTER, para que os resultados possam ser usados no filtro.

Veja a seguir um exemplo usando BEFOREFILTER.

SQLEXEC (SPNAME check, NOPARAMS, BEFOREFILTER)

ALLPARAMS [OPTIONAL REQUIRED]

Use ALLPARAMS como uma regra global que determina se todos os parâmetros especificados devem ou não estar presentes para que o procedimento armazenado ou a consulta seja executada. As regras para parâmetros individuais estabelecidas na cláusula PARAMS substituem o conjunto de regras global por ALLPARAMS.

OPTIONAL

Permite que o SQL execute se todos os parâmetros estão ou não presentes. Este é o padrão.

REQUIRED

requer que todos os parâmetros estejam presentes para a execução do SQL.

Veja a seguir um exemplo usando OPTIONAL.

SQLEXEC (SPNAME lookup,
PARAMS (long_name = birth_state, short_name = state),
ALLPARAMS OPTIONAL)

ERROR {IGNORE REPORT RAISE FINAL FATAL}

Use ERROR para definir uma resposta a erros associados ao procedimento armazenado ou à consulta. Sem tratamento explícito de erros, o processo do Oracle GoldenGate é interrompido em erros. Certifique-se de que seus procedimentos retornem erros ao processo e especifique as respostas com ERROR.

Com o Oracle GoldenGate 21c, a funcionalidade permite que você especifique diferentes comportamentos com base no erro de tipo SQL.

O exemplo a seguir demonstra um processo ER de término anormal quando o código de erro SQL 1403 ou 1405 é detectado ao executar a pesquisa de procedimento armazenado. Todos os outros erros são reportados e a replicação continua.

SQLEXEC ( SPNAME lookup,
  PARAMS( long_name = birth_state, short_name = state),
  ERROR REPORT, ERROR FATAL (1403, 1405) );

IGNORE

Faz com que o Oracle GoldenGate ignore todos os erros associados ao procedimento armazenado ou à consulta e continue o processamento. Qualquer extração de parâmetro resultante resulta em condições "coluna ausente". Este é o padrão.

REPORT

Garante que todos os erros associados ao procedimento armazenado ou à consulta sejam reportados ao arquivo de descarte. O relatório é útil para rastrear a causa do erro. Ela inclui uma descrição de erro e o valor dos parâmetros passados de/para o procedimento ou a consulta. O Oracle GoldenGate continua o processamento após relatar o erro.

RAISE

Trata erros de acordo com regras definidas por um parâmetro REPERROR. O Oracle GoldenGate continua processando outros procedimentos armazenados ou consultas associadas à instrução MAP atual antes de processar o erro.

FINAL

É semelhante a RAISE, exceto que quando um erro associado a um procedimento ou consulta é encontrado, os demais procedimentos armazenados e consultas são ignorados. O processamento de erros é chamado imediatamente após o erro.

FATAL

Faz com que o Oracle GoldenGate seja encerrado imediatamente após encontrar um erro associado a um procedimento ou consulta.

EXEC {MAP ONCE TRANSACTION SOURCEROW}

Use EXEC para controlar a frequência com que um procedimento armazenado ou consulta em uma instrução MAP é executado e por quanto tempo os resultados são considerados válidos, se estiver extraindo parâmetros de saída.

MAP

Executa o procedimento ou a consulta uma vez para cada mapa de tabela de origem-destino para o qual ele é especificado. O uso de MAP torna os resultados inválidos para qualquer mapa subsequente que tenha a mesma tabela de origem. MAP é o padrão.

O exemplo a seguir mostra o uso incorreto do padrão de MAP. Como MAP é o padrão, ele não precisa ser listado explicitamente na instrução SQLEXEC. Neste exemplo, uma tabela de origem é mapeada em parâmetros MAP separados para duas tabelas de destino diferentes. Nesse caso, os resultados são válidos apenas para o primeiro mapeamento. Os resultados do procedimento lookup expiraram no momento em que o segundo parâmetro MAP é executado e o segundo MAP resulta em uma condição "coluna ausente". Para implementar isso corretamente para que cada MAP retorne resultados válidos, SOURCEROW deve ser usado.

MAP sales.srctab, TARGET sales.targtab, &
SQLEXEC (SPNAME lookup, PARAMS (param1 = srccol)), &
COLMAP (targcol = lookup.param2);

MAP sales.srctab, TARGET sales.targtab2, &
COLMAP (targcol2 = lookup.param2);

ONCE

Executa o procedimento ou a consulta uma vez durante o curso do Oracle GoldenGate executado, na primeira chamada da instrução MAP associada. Os resultados permanecem válidos enquanto o processo permanecer em execução.

Veja a seguir um exemplo de uso da ONCE.

MAP sales.cust, TARGET sales.cust_extended, &
SQLEXEC (SPNAME lookup, PARAMS (long_name = birth_state), EXEC ONCE), &
COLMAP (custid = custid, &
birth_state_long = lookup.long_name);

TRANSACTION

Executa o procedimento ou consulta uma vez por transação de origem. Os resultados permanecem válidos para todas as operações da transação.

Veja a seguir um exemplo de uso da TRANSACTION.

MAP sales.cust, TARGET sales.cust_extended, &
SQLEXEC (SPNAME lookup, PARAMS (long_name = birth_state), EXEC TRANSACTION), &
COLMAP (custid = custid, &
birth_state_long = lookup.long_name);

SOURCEROW

Executa o procedimento ou consulta uma vez por operação de linha de origem. Use essa opção quando estiver sincronizando uma tabela de origem com mais de uma tabela de destino, para que os resultados do procedimento ou da consulta sejam chamados para cada mapeamento de origem-destino.

Veja a seguir um exemplo de uso da SOURCEROW. Nesse caso, o segundo mapa retorna um valor válido porque o procedimento é executado em cada operação de linha de origem.

MAP sales.srctab, TARGET sales.targtab, &
SQLEXEC (SPNAME lookup, PARAMS (param1 = srccol), EXEC SOURCEROW), &
COLMAP (targcol = lookup.param2);

MAP sales.srctab, TARGET sales.targtab2, &
COLMAP (targcol2 = lookup.param2);

MAXVARCHARLEN <bytes>

Use MAXVARCHARLEN para especificar o tamanho máximo de byte alocado para o valor de saída de qualquer parâmetro em um procedimento ou consulta armazenado. Além desse máximo, os valores de saída são truncados. O padrão é 255 bytes sem uma cláusula MAXVARCHARLEN explícita. O intervalo válido de valores é de 50 a 32767 bytes.

O exemplo a seguir limita o comprimento de byte dos valores de saída a 100.

MAXVARCHARLEN 100

PARAMBUFSIZE <bytes>

Use PARAMBUFSIZE para especificar o número máximo de bytes permitidos para o buffer de memória que armazena informações de parâmetro SQLEXEC, incluindo parâmetros de entrada e saída. O padrão é 10.000 bytes sem uma cláusula PARAMBUFSIZE explícita. O intervalo válido de valores é de 1000 a 2000000 bytes. O Oracle GoldenGate emite uma advertência sempre que a memória alocada para parâmetros estiver dentro de 500 bytes do máximo.

O exemplo a seguir aumenta o buffer para 15.000 bytes.

PARAMBUFSIZE 15000

TRACE {ALL ERROR}

Use TRACE para registrar parâmetros de entrada e saída do SQLEXEC no arquivo de relatório.

Veja a seguir um arquivo de relatório de amostra com o rastreamento SQLEXEC ativado:

Input parameter values...
LMS_TABLE: INTERACTION_ATTR_VALUES
   KEY1: 2818249
  KEY2: 1
Report File:
From Table MASTER.INTERACTION_ATTR_VALUES to MASTER.INTERACTION_ATTR_VALUES:
       #  inserts:      0
       #  updates:      0
       #  deletes:      0
       #  discards:     1

  Stored procedure GGS_INTERACTION_ATTR_VALUES:
       attempts:        2
       successful:      0

ALL

Grava os parâmetros de entrada e saída para cada chamada do procedimento ou consulta no arquivo de relatório. Este é o padrão.

ERROR

Grava os parâmetros de entrada e saída para cada chamada do procedimento ou consulta no arquivo de relatório somente após a ocorrência de um erro SQL.