Funções de Diff¶

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 origem deve ser um banco de dados ou um arquivo CSV. Se for um banco de dados, a tabela de origem deverá ter um conjunto de chaves que identifique exclusivamente uma linha de dados. As relações hierárquicas da tabela de origem não são suportadas.

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

• linhas adicionadas
• linhas atualizadas
• linhas excluídas

Na primeira vez que uma operação diff é executada, todas as linhas de origem são classificadas como "adicionadas". A 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 nos casos em que uma tabela de origem possui vários registros que são alterados com pouca frequência.

Como veremos nas etapas abaixo, uma “ operação diff” geralmente consiste em diversas operações encadeadas; cada operação sucessiva trata de 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, há suporte para "fragmentos" ou "ordenados". Chunked sempre funcionará, mas ordered poderá ser mais rápido se a ordem das linhas de dados de origem for garantida.
2. Lidar com linhas adicionadas, atualizadas e excluídas. A ordem em que são tratados é arbitrária e depende da ordem das operações que implementam a sincronização.
3. Finalize a sessão de comparação. Isso sinaliza o processo diff como concluído; caso contrário, uma operação de comparação futura poderá resultar no processamento de nenhum registro.

Etapa 1: Inicializar a Sessão Diff¶

Inicialize a sessão diff chamando o InitializeDiff função com um "ID de diferença" exclusivo seguido pelo DiffKeyList função (para uma diferença fragmentada) ou o OrderedDiffKeyList função (para uma comparação ordenada) para definir as chaves primárias da tabela de origem:

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

Etapa 2: Lidar com Linhas Adicionadas, Atualizadas e Excluídas¶

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

Etapa 3: Finalizar a Sessão de Diff¶

O DiffComplete A função deve ser chamada quando os três casos forem tratados com sucesso. (No caso de erros, o ResetDiff deve ser usada em vez disso.) Isso sinaliza o processo diff como concluído; caso contrário, uma operação de comparação futura poderá resultar no processamento de nenhum registro.

Funções de Diff Adicionais¶

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

Exemplos de Diff¶

Por 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 em Cloud 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 de comparação como concluído. Este método deve ser chamado quando o processo diff for concluído com sucesso; caso contrário, o processo diff ficará 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 método 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ó repetidor a ser usado para a operação diff

Descrição¶

Para fontes hierárquicas, especifica o nó a ser usado como o nó repetidor no qual a comparação é executada.

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 a diferença corretamente.

Descrição¶

Inicializa uma nova sessão diff.

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

Esse método normalmente é chamado no script pré-fonte da primeira operação que implementa uma comparação/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: Strings com nomes de chaves de coluna a serem usadas para identificar exclusivamente um registro em uma origem

• 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 origem 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 Diff é mais eficiente se os campos de origem forem ordenados sempre da mesma maneira. Nesses casos, nenhum tamanho de bloco será usado e o uso de memória não será um problema. Este método normalmente é chamado em conjunto com o método 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 número inteiro (ou 0 ou 1) especificando como a sessão diff deve ser redefinida

Descrição¶

Redefine uma sessão de comparação existente.

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

• 0 (Redefinir): Esquece completamente o instantâneo mais recente e recomeça desde o início. Isto forçará o sistema a tratar todas as entradas como "adicionadas".
• 1 (Purge): Remove todos os arquivos que sobraram de uma sessão de comparação anterior. Isso não redefine o snapshot mais recente; ele apenas limpa arquivos obsoletos deixados por sessões de comparação antigas, com falha ou canceladas.

Este método normalmente é chamado quando algo foi alterado em um processo de comparação existente ou se um processo de comparação falhou e saiu em um estado inconsistente. Não deve ser chamado durante o processamento normal de diferenças. Se nenhuma sessão de comparação estiver presente para este diff_id, nenhuma ação será executada.

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 pedaços usados durante a comparação

Descrição¶

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

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

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

Exemplos¶

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