Funciones de Diff en Jitterbit Integration Studio

Utilice funciones Diff para sincronizar datos

La función Jitterbit Diff /Synchronize se puede utilizar en transformaciones para sincronizar datos en una sola tabla con cualquier tipo de destino.

La fuente debe ser una base de datos o un archivo CSV. Si se trata de una base de datos, la tabla de origen debe tener un conjunto de claves que identifique de forma única cada fila de datos. No se admiten relaciones jerárquicas entre tablas de origen.

La función diff se utiliza para dividir los datos de origen en tres categorías:

se agregaron filas
filas actualizadas
filas eliminadas

La primera vez que se ejecuta una operación de comparación, todas las filas de origen se clasifican como "añadidas". En cada ejecución posterior, Jitterbit solo procesará las filas añadidas, modificadas o eliminadas. Esto puede ahorrar un tiempo de procesamiento considerable en casos donde una tabla de origen tiene numerosos registros que cambian con poca frecuencia.

Como se verá en los pasos siguientes, una " operación de diferencia" generalmente consta de varias operaciones encadenadas; cada operación sucesiva maneja agregaciones, actualizaciones y eliminaciones respectivamente.

Para configurar una operación de diferenciación, siga estos pasos:

Inicialice la sesión de diff y defina el tipo de algoritmo de diff que se usará. Actualmente, se admiten tanto "fragmentado" como "ordenado". El método "fragmentado" siempre funcionará, pero el método "ordenado" puede ser más rápido si se garantiza el orden de las filas de datos de origen.
Gestionar las filas añadidas, actualizadas y eliminadas. El orden de gestión es arbitrario y depende del orden de las operaciones que implementan la sincronización.
Finalice la sesión de comparación. Esto marca el proceso de comparación como completado; de lo contrario, una futura operación de comparación podría resultar en que no se procesen registros.

Advertencia

Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.

Paso 1: Inicializar la sesión Diff

Inicialice la sesión de diferencias llamando a InitializeDiff función con un "ID de diferencia" único seguido de DiffKeyList función (para una diferencia fragmentada) o la OrderedDiffKeyList Función (para una diferencia ordenada) para definir la(s) clave(s) principal(es) de la tabla fuente:``` title="Example" InitializeDiff("A-unique-diff-ID-for-each-diff-process"); DiffKeyList("pk1", "pk2");

### Paso 2: Manejar filas agregadas, actualizadas y eliminadas {: #step-2-handle-added-updated-and-deleted-rows }

Antes de cada transformación, las funciones `DiffAdd`, `DiffUpdate`, y `DiffDelete` Se llaman. Cualquier transformación que se ejecute después de estas llamadas de función recibirá las filas agregadas, actualizadas o eliminadas, respectivamente. El origen de las transformaciones debe ser la misma tabla de base de datos o archivo CSV, pero el destino puede ser diferente en los tres casos.


### Paso 3: Finalizar la sesión Diff {: #step-3-finalize-the-diff-session }

El `DiffComplete` La función debe llamarse cuando los tres casos se hayan manejado correctamente. (En caso de errores, la `ResetDiff` (En su lugar se debe utilizar la función .) Esto marca el proceso de diferencia como completo; de lo contrario, una operación de diferencia futura puede provocar que no se procesen registros.


### Funciones Diff adicionales {: #additional-diff-functions }

- **`DiffNode`** Para fuentes jerárquicas, especifica el nodo que se utilizará como nodo repetitivo para realizar la comparación.
- **`OrderedDiffKeyList`:** Especifica el orden de clasificación de la fuente cuando se utiliza el algoritmo de diferenciación "ordenada".
- **`ResetDiff`:** Restablece o purga la sesión de diferencias. Se utiliza en la gestión de errores para restablecer la sesión de diferencias en caso de fallo.
- **`SetDiffChunkSize`:** Establece un parámetro para el algoritmo de diferenciación fragmentada. Un valor mayor es más rápido, pero consume más memoria.

### Ejemplos de Diff {: #diff-examples }

Para ver un ejemplo del uso de diff en [Design Studio](/es/design-studio), consulte [Capturar cambios de datos con cambios de tabla o archivo](/es/design-studio/design-studio-how-tos/capture-data-changes-with-table-or-file-changes). Esto se puede extrapolar para su uso en [Integration Studio](/es/integration-studio).

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `DiffAdd` {: #difffunctions-diffadd }

### Declaración {: #declaration }

void DiffAdd()

### Sintaxis {: #syntax }

DiffAdd()

### Descripción {: #description }

Solicita los registros agregados como entrada para la próxima transformación que se ejecuta.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `DiffComplete` {: #difffunctions-diffcomplete }

### Declaración {: #declaration }

void DiffComplete()

### Sintaxis {: #syntax }

DiffComplete()

### Descripción {: #description }

Marca el proceso de diff como completado. Este método se llama cuando el proceso de diff se completa correctamente; de lo contrario, el proceso de diff quedará en un estado inconsistente. En ese caso, la próxima vez que se ejecute la operación de diff, no se procesará ningún registro.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `DiffDelete` {: #difffunctions-diffdelete }

### Declaración {: #declaration }

void DiffDelete()

### Sintaxis {: #syntax }

DiffDelete()

### Descripción {: #description }

Solicita los registros eliminados como entrada para la próxima transformación que se ejecuta.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `DiffKeyList` {: #difffunctions-diffkeylist }

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

DiffKeyList([, ,... ])

#### Parámetros requeridos {: #required-parameters }

- `k1, k2,... kN`Claves de cadena que identifican las columnas en la fuente de diferencias que se usarán para identificar de forma única cada registro.

### Descripción {: #description }

Establece la lista de claves que se usarán para identificar de forma única un registro en la fuente diff. Este método se suele llamar junto con el `InitializeDiff` función.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `DiffNode` {: #difffunctions-diffnode }

### Declaración {: #declaration }

void DiffNode(string nodeName)

### Sintaxis {: #syntax }

DiffNode()

#### Parámetros requeridos {: #required-parameters }

- `nodeName`: Una cadena que especifica el nodo repetitivo que se utilizará para la operación de diferencia


### Descripción {: #description }

Para fuentes jerárquicas, esto especifica el nodo que se utilizará como nodo repetitivo en el que se realizará la comparación.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `DiffUpdate` {: #difffunctions-diffupdate }

### Declaración {: #declaration }

void DiffUpdate()

### Sintaxis {: #syntax }

DiffUpdate()

### Descripción {: #description }

Solicita los registros actualizados como entrada para la próxima transformación que se ejecuta.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `InitializeDiff` {: #difffunctions-initializediff }

### Declaración {: #declaration }

void InitializeDiff(string diffId)

### Sintaxis {: #syntax }

InitializeDiff()

#### Parámetros requeridos {: #required-parameters }

- `diffId`: Una cadena que identifica de forma única la operación de comparación de otras operaciones de comparación que se ejecutan en el sistema. La cadena debe ser la misma en cada operación para que la comparación se identifique correctamente.


### Descripción {: #description }

Inicializa una nueva sesión de diff.

La cadena pasada como `diffId` Debe ser **distinto** de todos los demás identificadores de diff utilizados en el sistema, pero debe ser el **mismo** cada vez que se ejecuta la operación. Si ya hay una sesión de diff en ejecución, la llamada a este método fallará. Para borrar una sesión de diff antigua (por ejemplo, en caso de un fallo del sistema), llame a la función. `ResetDiff` una vez.

Este método normalmente se llama en el secuencia de comandos de origen previo de la primera operación que implementa una diferencia/sincronización.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

// 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();

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `OrderedDiffKeyList` {: #difffunctions-ordereddiffkeylist }

### Declaración {: #declaration }

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

### Sintaxis {: #syntax }

OrderedDiffKeyList(, [, , ,... , ])

#### Parámetros requeridos {: #required-parameters }

- `k1, k2,... kN`: Cadenas con los nombres de las claves de columna que se usarán para identificar de forma única un registro en una fuente.
- `isAscending1, isAscending2,... isAscendingN`: Valores booleanos para cada columna que indican si cada columna está ordenada en orden ascendente (`true`) o descendente (`false`)

- El número de argumentos proporcionados debe ser dos o más y debe ser un número par.

### Descripción {: #description }

Establece la lista de claves utilizadas para identificar de forma única un registro en la fuente y especifica el orden de registro de la clave como ascendente (`true`) o descendente (`false`).

Utilice este método (en lugar del `DiffKeyList` función) en los casos en que se garantiza que los registros fuente estarán en un orden específico.

El procesamiento de Diff es más eficiente si los campos de origen se ordenan siempre de la misma manera. En esos casos, no se utilizará el tamaño del fragmento y el uso de memoria no será un problema. Este método se suele llamar junto con el `InitializeDiff` función.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.

<div markdown="1" clase="conf-macro output-inline" alinear="centro" hasbody="false" nombre-macro="volver-arriba">

[[Volver al inicio]](#top)

</div>

## `ResetDiff` {: #difffunctions-resetdiff }

### Declaración {: #declaration }

void ResetDiff(string diffId, int action)

### Sintaxis {: #syntax }

ResetDiff(, )

#### Parámetros requeridos {: #required-parameters }

- `diffId`:Una cadena que identifica de forma única la operación de diferenciación de otras operaciones de diferenciación que se ejecutan en el sistema
-   `action`:Un número entero (ya sea `0` o `1`) especificando cómo se restablecerá la sesión de diferencias.

### Descripción {: #description }

Restablece una sesión de diferencias existente.

El `action` parámetro (ya sea `0` o `1`) especifica cómo se debe restablecer la sesión de diferencias:

- **`0`(Restablecer):** Olvida por completo la última instantánea y comienza desde el principio. Esto obligará al sistema a tratar todas las entradas como "añadidas".
- **`1`(Purgar):** Elimina los archivos restantes de una sesión de diff anterior. Esto no restablece la última instantánea; solo borra los archivos obsoletos de sesiones de diff antiguas, fallidas o canceladas.

Este método se suele llamar cuando se ha modificado algo en un proceso de diff existente o si un proceso de diff ha fallado y ha quedado en un estado inconsistente. No debe llamarse durante el procesamiento normal de diff. Si no hay ninguna sesión de diff presente para esto `diff_id` No se realiza ninguna acción.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `SetDiffChunkSize` {: #difffunctions-setdiffchunksize }

### Declaración {: #declaration }

void SetDiffChunkSize(int chunkSize)

### Sintaxis {: #syntax }

SetDiffChunkSize()

#### Parámetros requeridos {: #required-parameters }

- `chunkSize` Tamaño en bytes de los fragmentos utilizados durante la comparación.

### Descripción {: #description }

Establece el tamaño del fragmento (en bytes) utilizado durante la comparación.

Un tamaño de fragmento mayor hará que el sistema utilice más memoria, pero procesará la comparación más rápido. El valor predeterminado es 50 000 bytes; si tiene suficiente memoria, puede aumentar este número.

Este método se suele ejecutar junto con el método `InitializeDiff` función.

!!! warning "Advertencia"
    Las funciones de Diff solo se pueden usar en un solo agente privado, ya que las instantáneas de diferenciación no se comparten. No las use en un grupo de agentes con más de un agente. No son compatibles con agentes en la nube.


### Ejemplos {: #examples }

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

[Volver arriba]