Funções Diff no Jitterbit Integration Studio

Use funções Diff para sincronizar dados

O recurso Jitterbit Diff / Synchronize pode ser usado em transformações para sincronizar dados em uma única tabela para qualquer tipo de destino.

A fonte deve ser um banco de dados ou um arquivo CSV. Se for um banco de dados, a tabela de origem deve ter um conjunto de chaves que identifique exclusivamente uma linha de dados. Relações de tabela de origem hierárquicas não são suportadas.

O recurso diff é usado para dividir os dados de origem em três categorias:

• linhas adicionadas
• linhas atualizadas
• linhas deletadas

Na primeira vez que uma operação diff é executada, todas as linhas de origem são classificadas como "adicionadas". Com cada execução subsequente, apenas as linhas adicionadas, alteradas ou excluídas serão processadas pelo Jitterbit. Isso pode economizar um tempo de processamento significativo em casos em que uma tabela de origem tem vários registros que mudam com pouca frequência.

Como veremos nas etapas abaixo, uma " operação diff" geralmente consiste em várias operações encadeadas; cada operação sucessiva lida com adições, atualizações e exclusões, respectivamente.

Para configurar uma operação diff, siga estas etapas:

1. Inicialize a sessão diff e defina o tipo de algoritmo diff a ser usado. Atualmente, "chunked" ou "ordered" são suportados. Chunked sempre funcionará, mas ordered pode ser mais rápido se a ordem das linhas de dados de origem for garantida.
2. Manipule linhas adicionadas, atualizadas e excluídas. A ordem em que elas são manipuladas é arbitrária e depende da ordem das operações que implementam a sincronização.
3. Finalize a sessão diff. Isso sinaliza o processo diff como completo; caso contrário, uma operação diff futura pode resultar em nenhum registro sendo processado.

Etapa 1: inicializar a sessão Diff

Inicialize a sessão diff chamando o InitializeDiff função com um "ID diff" exclusivo seguido por DiffKeyList função (para um diff em blocos) ou o OrderedDiffKeyList função (para um diff ordenado) para definir a(s) chave(s) primária(s) da tabela de origem:

InitializeDiff("A-unique-diff-ID-for-each-diff-process");
DiffKeyList("pk1", "pk2");

Etapa 2: manipular linhas adicionadas, atualizadas e excluídas

Antes de cada transformação, as funções DiffAdd, DiffUpdate, e DiffDelete são chamadas. Qualquer transformação em execução após essas chamadas de função receberá as linhas adicionadas, atualizadas ou excluídas, respectivamente. A origem das transformações precisa ser a mesma tabela de banco de dados ou arquivo CSV, mas o destino pode ser diferente em todos os três casos.

Etapa 3: Finalizar a sessão Diff

O DiffComplete a função deve ser chamada quando os três casos forem tratados com sucesso. (No caso de erros, a ResetDiff (a função deve ser usada em seu lugar.) Isso sinaliza o processo diff como concluído; caso contrário, uma operação diff futura pode resultar em nenhum registro sendo processado.

Funções Diff adicionais

• DiffNode: Para fontes hierárquicas, especifica o nó que será usado como o nó de repetição para executar o diff.
• OrderedDiffKeyList: Especifica a ordem de classificação da fonte quando o algoritmo diff "ordenado" é usado.
• ResetDiff: Reinicia ou limpa a sessão diff. Usado no tratamento de erros para reiniciar a sessão diff em caso de falha.
• SetDiffChunkSize: Define um parâmetro para o algoritmo diff "chunked". Um valor maior é mais rápido, mas usa mais memória.

Exemplos de Diff

Para um exemplo usando diff em Design Studio, consulte Capturar alterações de dados com alterações de tabela ou arquivo. Isso pode ser extrapolado para uso no Integration Studio.

DiffAdd

Declaração

void DiffAdd()

Sintaxe

DiffAdd()

Descrição

Solicita os registros adicionados como entrada para a próxima transformação executada.

Exemplos

// Start by processing the added records in this operation:
DiffAdd();

DiffComplete

Declaração

void DiffComplete()

Sintaxe

DiffComplete()

Descrição

Sinaliza o processo diff como concluído. Este método deve ser chamado quando o processo diff for concluído com sucesso; caso contrário, o processo diff será deixado em um estado inconsistente. Nesse caso, na próxima vez que a operação diff for executada, nenhum registro será processado.

Exemplos

// Flag the diff operation as complete
DiffComplete();

DiffDelete

Declaração

void DiffDelete()

Sintaxe

DiffDelete()

Descrição

Solicita os registros excluídos como entrada para a próxima transformação executada.

Exemplos

// Requesting deleted records for the transformation run
DiffDelete();

DiffKeyList

Declaração

void DiffKeyList(string k1[, string k2,... string kN])

Sintaxe

DiffKeyList(<k1>[, <k2>,... <kN>])

Parâmetros obrigatórios

• k1, k2,... kN: Chaves de string que identificam as colunas na fonte diff a serem usadas para identificar exclusivamente cada registro

Descrição

Define a lista de chaves a serem usadas para identificar exclusivamente um registro na fonte diff. Este método é normalmente chamado em conjunto com o InitializeDiff função.

Exemplos

// Using a chunked diff with the synchronizing primary keys
// of CustomerId and OrderId:
DiffKeyList("CustomerId", "OrderId");

DiffNode

Declaração

void DiffNode(string nodeName)

Sintaxe

DiffNode(<nodeName>)

Parâmetros obrigatórios

• nodeName: Uma string que especifica o nó de repetição a ser usado para a operação diff

Descrição

Para fontes hierárquicas, isso especifica o nó a ser usado como o nó de repetição no qual o diff é executado.

Exemplos

// Run the diff on the XML element node <Listing>
DiffNode("Listing");

DiffUpdate

Declaração

void DiffUpdate()

Sintaxe

DiffUpdate()

Descrição

Solicita os registros atualizados como entrada para a próxima transformação executada.

Exemplos

// Requesting updated records for the transformation run
DiffUpdate();

InitializeDiff

Declaração

void InitializeDiff(string diffId)

Sintaxe

InitializeDiff(<diffId>)

Parâmetros obrigatórios

• diffId: Uma string que identifica exclusivamente a operação diff de outras operações diff em execução no sistema. A string deve ser a mesma para cada execução da operação para identificar o diff corretamente.

Descrição

Inicializa uma nova sessão diff.

A string passada como diffId deve ser diferente de todos os outros identificadores de diff usados no sistema, mas tem que ser o mesmo toda vez que a operação for executada. Se uma sessão de diff já estiver em execução, uma chamada para este método falhará. Para limpar uma sessão de diff antiga (como no caso de uma falha do sistema), chame a função ResetDiff uma vez.

Este método é normalmente chamado no script pré-fonte da primeira operação que implementa uma diferença/sincronização.

Exemplos

// Synchronize the order database:
InitializeDiff("Order Database Synchronization");

// Using chunked diff with the synchronizing primary keys
// of CustomerId and OrderId:
DiffKeyList("CustomerId", "OrderId");

// With sufficient memory available, increase the chunk size:
SetDiffChunkSize(100000);

// Start by processing the added records in this operation:
DiffAdd();

OrderedDiffKeyList

Declaração

void OrderedDiffKeyList(string k1, bool isAscending1[, string k2, bool isAscending2,... string kN, bool isAscendingN])

Sintaxe

OrderedDiffKeyList(<k1>, <isAscending1>[, <k2>, <isAscending2>,... <kN>, <isAscendingN>])

Parâmetros obrigatórios

• k1, k2,... kN: Nomes de strings de chaves de coluna a serem usadas para identificar exclusivamente um registro em uma fonte

• isAscending1, isAscending2,... isAscendingN: Valores booleanos para cada coluna indicando se cada coluna está classificada em ordem crescente (true) ou descendente (false)

• O número de argumentos fornecidos deve ser dois ou mais e deve ser um número par.

Descrição

Define a lista de chaves usadas para identificar exclusivamente um registro na fonte e especifica a ordem de registro da chave como crescente (true) ou descendente (false).

Use este método (em vez do DiffKeyList função) nos casos em que é garantido que os registros de origem estejam em uma ordem específica.

O processamento de Diff é mais eficiente se os campos de origem forem ordenados da mesma forma todas as vezes. Nesses casos, nenhum tamanho de bloco será usado e o uso de memória não será um problema. Esse método é normalmente chamado em conjunto com o InitializeDiff função.

ResetDiff

Declaração

void ResetDiff(string diffId, int action)

Sintaxe

ResetDiff(<diffId>, <action>)

Parâmetros obrigatórios

• diffId: Uma string que identifica exclusivamente a operação diff de outras operações diff em execução no sistema
• action: Um inteiro (ou 0 ou 1) especificando como a sessão diff deve ser reiniciada

Descrição

Reinicia uma sessão diff existente.

O action parâmetro (qualquer um 0 ou 1) especifica como a sessão diff deve ser reiniciada:

• 0(Reset): Esquece completamente o último snapshot e começa do começo. Isso forçará o sistema a tratar todas as entradas como "adicionadas".
• 1(Purge): Remove quaisquer arquivos restantes de uma sessão diff anterior. Isso não redefine o snapshot mais recente; ele apenas limpa arquivos obsoletos deixados por sessões diff antigas, com falha ou canceladas.

Este método é normalmente chamado quando algo foi alterado em um processo diff existente ou se um processo diff falhou e ficou em um estado inconsistente. Ele não deve ser chamado durante o processamento diff normal. Se nenhuma sessão diff estiver presente para isso diff_id, nenhuma ação é realizada.

Exemplos

// Purge any files left over from a previous diff session,
// but keep the latest snapshot
ResetDiff("Order Database Synchronization", 1);

SetDiffChunkSize

Declaração

void SetDiffChunkSize(int chunkSize)

Sintaxe

SetDiffChunkSize(<chunkSize>)

Parâmetros obrigatórios

• chunkSize: Tamanho em bytes para blocos usados durante a comparação

Descrição

Define o tamanho do bloco (em bytes) usado durante a comparação.

Um tamanho de bloco maior fará com que o sistema use mais memória, mas processará a comparação mais rápido. O padrão é 50000 bytes; se você tiver memória suficiente, poderá aumentar esse número.

Este método é normalmente chamado em conjunto com o InitializeDiff função.

Exemplos

// With sufficient memory available, increase the chunk size:
SetDiffChunkSize(100000);