Saltar al contenido

Funciones de instancia en Jitterbit Integration Studio

Introducción

Estas funciones están pensadas para usarse en asignaciones de transformación (o secuencias de comandos llamados durante las asignaciones), ya que utilizan las instancias de elementos de datos (fuentes y destinos) que se encuentran en las asignaciones.

Inserción de un hash para devolver una matriz

En los casos en que un parámetro de entrada requerido para una función de instancia sea una matriz, se utiliza un símbolo de almohadilla. (#)Se puede insertar en la ruta de referencia de un elemento de datos para devolver una matriz de datos en lugar de un solo campo.

Por ejemplo:

SumString(_Root$customer.contact#.Email, ",", true);

En el ejemplo anterior, la ruta del elemento de datos (_Root$customer.contact#.Email) está construido para devolver una matriz de direcciones de correo (.Email) dentro de una matriz de contactos (.contact). El # se inserta antes de la matriz de direcciones de correo (#.Email) para indicar que en cada contacto podría haber una matriz de direcciones de correo. Esto genera una asignación que recorre la matriz en los registros de contacto, pero no recorre la matriz en los correos.

Este concepto también se aplica a nodos de bucle en transformaciones. Para obtener una explicación más detallada de la sintaxis de las rutas de elementos de datos, consulte Notación de ruta de referencia en Nodos y campos.

Uso avanzado

En general, las funciones de instancia pueden anidarse unas dentro de otras. Al estar anidadas, los resultados ascenderán en la jerarquía y abarcarán más resultados. Estas funciones pueden devolver un único valor o una matriz de valores, según el contexto en el que se utilicen.

Por ejemplo, una Sum función que tiene una Count La función interna sumará los resultados de cada invocación de la Count función, y producir un total:

Sum(Count(_Root$customer.sales#.items#.ID));

Count

Declaración

int Count(type de)

int Count(array arr)

Sintaxis

Count(<de>)

Count(<arr>)

Parámetros requeridos

  • de: (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
  • arr: (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

Descripción

Cuenta todas las instancias de un elemento de datos en un nivel jerárquico específico en un origen o destino, donde dicho elemento de datos contiene un valor válido (y no es nulo).

La función devuelve un entero o una matriz de instancias, según el contexto en el que se llama.

Ejemplos

Supongamos que una base de datos contiene un campo "Cantidad" en una tabla "Artículos", que es un elemento secundario de "POHeader" (una orden de compra), y que hay muchos artículos dentro de un POHeader. Entonces, esta instrucción devuelve el número de filas de artículos para un POHeader en particular que tienen valores en la columna Cantidad que no son nulos:

Count(POHeader.Items#.Quantity);

En este caso, supongamos un archivo de datos con varias instancias, con clientes que tienen ventas que tienen artículos; y cada artículo tiene un campo ID. Esta instrucción contará cuántos artículos diferentes hay en cada venta y utilizará el Sum Función para sumar todos los artículos devueltos en cada venta; este será el número total de artículos diferentes comprados:``` Sum(Count(_Root$customer.sales#.items#.ID));

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

[[Volver arriba]](#top)

</div>

## `CountSourceRecords` {: #instancefunctions-countsourcerecords }

### Declaración {: #declaration }
int CountSourceRecords()
### Sintaxis {: #syntax }
CountSourceRecords()
### Descripción {: #description }

Devuelve el número de instancias de origen de un nodo de destino, cuando este hace referencia a un padre de un campo de mapeo.

Si el nodo de destino no es un nodo de bucle, la función devuelve 1. Véase también `SourceInstanceCount` función.

!!! note "Nota"
    El modo de transmisión de una transformación _Flat-to-Flat_ no se vería afectado por el uso de esta función, mientras que el modo de transmisión se desactivaría para una transformación_XML-to-Flat_.


### Ejemplos {: #examples }

Supongamos una fuente con registros de _clientes_ que contienen instancias de _ventas_ con instancias de _artículos_ con un campo _Tipo_:
// This statement shows the instance count of a record compared // to the total number of source records "Record " + SourceInstanceCount() + " of " + CountSourceRecords();
<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `Exist` {: #instancefunctions-exist }

### Declaración {: #declaration }
bool Exist(type v, type de)

bool Exist(type v, array arr)

### Sintaxis {: #syntax }
Exist(, )

Exist(, )

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

- **`v`:** Un valor por encontrar
- **`de`:** (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo y del mismo tipo que `v`

### Descripción {: #description }

Comprueba la existencia de un valor. `(v)`en instancias de un elemento de datos `(de)` o una matriz (`arr`) y devuelve verdadero (o falso) según se encuentre.

La función devuelve un valor booleano o un array de instancias, según el contexto en el que se llama.

### Ejemplos {: #examples }

Supongamos una fuente con registros de _clientes_ que contienen instancias de _ventas_ con instancias de _artículos_ con un campo _Tipo_:
// Returns if true if the value "subscription" is // found in any instances of a field "customer.sales.items.Type" // at the level of "sales": Exist("subscription",_Root$customer.sales.items#.Type);

// To test this at the next highest level of the hierarchy, // at the level of the customer, // enclose this in a nested "Exist", testing for "true": Exist(true, Exist("subscription",_Root$customer.sales#.items#.Type));

// The last statement answers, at the customer level, if a customer // has any items in any sales with a Type field equal to "subscription"

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

[[Volver arriba]](#top)

</div>

## `FindByPos` {: #instancefunctions-findbypos }

### Declaración {: #declaration }
type FindByPos(int pos, type de)

type FindByPos(int pos, array arr)

### Sintaxis {: #syntax }
FindByPos(, )

FindByPos(, )

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

- **`pos`** El índice (de donde surge la ocurrencia; basado en 1) para recuperar el valor.
- **`de`:** (Primera forma) Una ruta de entidad a instancias de un elemento de datos en un origen o un destino; o
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

### Descripción {: #description }

Devuelve el valor de un elemento de datos de una instancia que aparece varias veces. También se puede usar para devolver un elemento de una matriz, partiendo de 1.

Si se especifica un número negativo para la instancia o la matriz, el recuento comenzará desde la última fila o elemento. Tenga en cuenta que el índice está basado en 1.

### Ejemplos {: #examples }
// Assume a database has a child-parent relationship // where for each parent the child occurs multiple times

// To retrieve the second child, use: FindByPos(2, ParentTab.ChildTab#.Value$);

// To retrieve the last child, use: FindByPos(-1, ParentTab.ChildTab#.Value$);

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

[[Volver arriba]](#top)

</div>

## `FindValue` {: #instancefunctions-findvalue }

### Declaración {: #declaration }
type FindValue(type0 v, type1 de1, type2 de2)
### Sintaxis {: #syntax }
FindValue(, , )
#### Parámetros requeridos {: #required-parameters }

- **`v`:** Un valor a buscar
- **`de1`:** Una ruta de entidad a instancias de un elemento de datos en un origen o un destino, para usarse como coincidencia.
- **`de2`** Ruta de entidad a instancias de un elemento de datos en un origen o un destino, que se devolverá si se encuentra una coincidencia.

### Descripción {: #description }

Busca múltiples instancias de un elemento de datos (`de1`) buscando el valor especificado en `v` Si la función encuentra el valor, devuelve el valor en el campo especificado en el tercer parámetro (`de2`) para la instancia encontrada. Si no se encuentra el valor, la función devuelve nulo. Véase también `HasKey` función.

### Ejemplos {: #examples }

Esta declaración buscará las instancias de `B` bajo `A` y comprobar el contenido de `field1` Seleccionará la primera instancia de `B` Encuentra donde `field1` contiene "`ID`", y luego devolver el valor de `field2` De esa misma instancia:
FindValue("ID", A.B#.field1, A.B#.field2);
Estas sentencias muestran cómo desplegar una prueba de un array para la inclusión de un valor. Busca un valor en un array y devuelve verdadero si lo encuentra y falso si no. Es el array equivalente al diccionario. `HasKey` función. Tenga en cuenta que se pasan dos instancias del mismo array a la función:
arr = {1, 2, 3}; value = 1; t = (FindValue(value, arr, arr) == value); // t will be 1 (true)

value = 4; t = (FindValue(value, arr, arr) == value); // t will be 0 (false)

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

[[Volver arriba]](#top)

</div>

## `GetInstance` {: #instancefunctions-getinstance }

### Declaración {: #declaration }
type GetInstance()
### Sintaxis {: #syntax }
GetInstance()
### Descripción {: #description }

Esta función devuelve el elemento de datos de instancia definido al llamar a `SetInstances` Función durante la generación del padre. Como alternativa a esta función, consulte la `ArgumentList` función.

### Ejemplos {: #examples }

Supongamos que una de las asignaciones principales de una transformación contiene estas declaraciones:
... r1=DBLookupAll("endpoint:database/My Database", "SELECT key_name, key_value, key_type FROM key_values"); SetInstances("DETAILS", r1); r2={"MS","HP"}; SetInstances("COMPANIES", r2); ...
En el `"DETAILS"` Nodo de destino: podemos crear una condición de mapeo usando:```
<trans>
GetInstance()["key_value"] != "";
// Same as GetInstance()[0] != ""
</trans>

O bien, en uno de los atributos, la asignación puede contener:

<trans>
x=GetInstance();
x["key_name"] + "=" + x["key_value"];
// Same as x[0] + "=" + x[1]
</trans>

En uno de los atributos de la "COMPANIES" Nodo de destino, el mapeo puede contener:``` GetInstance(); // This will return // "MS" for the first instance // "HP" for the second instance

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

[[Volver arriba]](#top)

</div>

## `Max` {: #instancefunctions-max }

### Declaración {: #declaration }
type Max(type de)

type Max(array arr)

### Sintaxis {: #syntax }
Max()

Max()

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

- **`de`:** (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

### Descripción {: #description }

Devuelve el valor máximo de las instancias de un elemento de datos en un nivel específico de la jerarquía de una estructura de datos. Verifica todas las instancias en ese nivel y devuelve la mayor. También se puede usar para devolver el valor máximo de una matriz.

### Ejemplos {: #examples }

Supongamos que una base de datos contiene un campo `"Quantity"` en una mesa `"Items"` Ese es un niño de `"POHeader"`(una orden de compra) y que hay muchos artículos dentro de un _POHeader_. Entonces, esta declaración devuelve el valor máximo de _Quantity_ para cualquier artículo de un _POHeader_ en particular:
Max(POHeader.Items#.Quantity);
<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `Min` {: #instancefunctions-min }

### Declaración {: #declaration }
type Min(type de)

type Min(array arr)

### Sintaxis {: #syntax }
Min()

Min()

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

- **`de`:** (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

### Descripción {: #description }

Devuelve el valor mínimo de las instancias de un elemento de datos en un nivel específico de la jerarquía de una estructura de datos. Verifica todas las instancias en ese nivel y devuelve la más pequeña. También se puede usar para devolver el valor mínimo de una matriz.

### Ejemplos {: #examples }

Supongamos que una base de datos contiene un campo `"Quantity"` en una mesa `"Items"` Ese es un niño de `"POHeader"`(una orden de compra) y que hay muchos artículos dentro de un _POHeader_. Entonces, esta declaración devuelve el valor mínimo de _Quantity_ para cualquier artículo de un _POHeader_ en particular:
Min(POHeader.Items#.Quantity);
<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `ResolveOneOf` {: #instancefunctions-resolveoneof }

### Declaración {: #declaration }
type ResolveOneOf(type de)

type ResolveOneOf(array arr)

### Sintaxis {: #syntax }
ResolveOneOf()

ResolveOneOf()

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

- **`de`:** (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

### Descripción {: #description }

Devuelve el primer valor no nulo de las instancias de un elemento de datos. Esta función se utiliza generalmente para recuperar el valor de un elemento de datos de origen único. También se puede usar con matrices y devolverá el primer elemento no nulo.

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

[[Volver arriba]](#top)

</div>

## `SetInstances` {: #instancefunctions-setinstances }

### Declaración {: #declaration }
null SetInstances(string nodeName, array de)
### Sintaxis {: #syntax }
SetInstances(, )
#### Parámetros requeridos {: #required-parameters }

- **`nodeName`:** El nombre de un objetivo
- **`de`:** Una ruta de entidad a instancias de un elemento de datos en el destino.

### Descripción {: #description }

Define las instancias de origen para un nodo de bucle de destino. Normalmente, una instancia de destino de bucle se genera a partir de una instancia de origen de bucle. En ocasiones, los datos pueden provenir de otras fuentes. Esta función está pensada para casos en los que los datos se encuentran en varios conjuntos y cada conjunto genera un único elemento de destino.

La instancia es un elemento de datos que puede ser un valor simple o una matriz de elementos de datos. Al crear el destino, cada instancia se utilizará para generar una instancia de destino.

Para ver cómo usar un elemento de datos de instancia, consulte `GetInstance` y `ArgumentList` Funciones.

Esta función debe llamarse en las asignaciones del nodo padre del objetivo deseado. Si no hay ningún nodo hoja disponible en el padre, puede crear un nodo de condición que llame a esta función. La condición debe terminar con **.`true`** para que siempre se acepte.

La función no debe llamarse más de una vez con el mismo nodo de destino, ya que la última llamada anula las anteriores. Para evitar la anulación, puede crear varias carpetas de mapeo.

Esta función devuelve un elemento de datos nulo, que debe ignorarse.

### Ejemplos {: #examples }

Supongamos que:

- existe un padre común para los nodos de destino "DETALLES" y "EMPRESAS";
- ambos son nodos de bucle; y
- se ha creado una carpeta de mapeo múltiple para el nodo de destino "DETALLES".
... r1 = DBLookupAll("endpoint:database/My Database", "SELECT key_name, key_value FROM key_values"); SetInstances("DETAILS", r1); SetInstances("DETAILS#1", r1); // DETAILS#1 is the name of the // 1st multiple-mapping-folder for DETAILS

r2 = {"MS", "HP", "Apple"}; SetInstances("COMPANIES", r2);

// Note: Renaming the display name of a // multiple-mapping-folder doesn't change // the folder's actual name, which can be // found by control-clicking the node and using // "Copy node name to clipboard" ...

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

[[Volver arriba]](#top)

</div>

## `SortInstances` {: #instancefunctions-sortinstances }

### Declaración {: #declaration }
null SortInstances(string nodeName, array sourceDataElements1[, bool sortOrder, ..., array sourceDataElementsN, bool sortOrderN])
### Sintaxis {: #syntax }
SortInstances(, [, , ..., , ])
#### Parámetros requeridos {: #required-parameters }

- **`nodeName`:** Nombre de los elementos del bucle de destino a ordenar
- **`sourceDataElements`:** Ruta de entidad a instancias de un elemento de datos en un origen o un destino.

#### Parámetros opcionales {: #optional-parameters }

- **`sourceDataElementsN`:** Una ruta de entidad a instancias de un elemento de datos en un origen o un destino
- **`sortOrder`** Un orden de clasificación opcional, el valor predeterminado es verdadero para orden ascendente. El argumento no es opcional si hay varios **`sourceDataElements`** Se proporcionan argumentos.

### Descripción {: #description }

Ordena la generación de elementos de datos del bucle de destino según uno o más elementos de datos en el origen o el destino.

Todas las instancias de ordenación deben tener el mismo número de instancias que el número de instancias de destino.

Se asume que el orden de ordenación es ascendente, y se puede añadir un argumento escalar opcional junto a cada elemento de datos de ordenación para anular el orden de ordenación predeterminado. Si `sortOrder` es falso, el orden de clasificación es descendente.

Los elementos de datos del bucle de destino se ordenarán primero por las instancias de los primeros elementos de datos de origen, y luego se ordenarán por las instancias de los segundos elementos de datos, y así sucesivamente.

Esta función debe llamarse en las asignaciones del nodo principal. Si no hay ningún campo que asignar en el nodo principal, se puede llamar a un secuencia de comandos con esta función o añadir una condición para tal fin.

Esta función devuelve un valor nulo y debe ignorarse.


### Ejemplos {: #examples }
// The target node "detail" will be ordered // by "price" from high to low and, // if the prices are the same for two items, // the node will be ordered by "quantity" from low to high SortInstances("detail", Invoice\(Item#.price, false, Invoice\)Item#.quantity);
El siguiente ejemplo podría usarse en una condición de mapeo para ordenar todas las ventas de cada cliente por fecha. Se colocaría al nivel de **`customer`** nodo. Nótese la inclusión de la declaración **`true`** al final del bloque de código para que la condición siempre se acepte:
SortInstances("SalesOrders", _Root$customer.sales#.SalesDate); true
<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `Sum` {: #instancefunctions-sum }

### Declaración {: #declaration }
type Sum(type de)

type Sum(array arr)

### Sintaxis {: #syntax }
Sum()

Sum()

Parámetros obligatorios

- **`de`:** (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

### Descripción {: #description }

Toma el valor de cada instancia de un elemento de datos en un nivel jerárquico específico y devuelve la suma. El tipo de dato de ambos `de` y `arr` Debe ser entero, largo, flotante, doble o cadena. Los tipos de datos de todas las instancias o elementos deben ser iguales.

Si el array está vacío, se devuelve 0 (cero). Aunque los valores nulos se ignoran en arrays con otro tipo de datos, un array con solo valores nulos devolverá un error.

### Ejemplos {: #examples }

Supongamos que una base de datos contiene un campo "Cantidad" en una tabla "Artículos" que es un elemento secundario de POHeader (hay muchos artículos dentro de un POHeader).
// Returns the sum of the field "Quantity" for // all items for a particular "POHeader" Sum(POHeader.Items#.Quantity);
<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `SumCSV` {: #instancefunctions-sumcsv }

### Declaración {: #declaration }
string SumCSV(type de)

string SumCSV(array arr)

### Sintaxis {: #syntax }
SumCSV()

SumCSV()

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

- **`de`:** (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

### Descripción {: #description }

Concatena cada instancia de un campo de un elemento de datos o cada elemento de una matriz, con un separador de coma entre cada instancia o elemento.

Si el campo o elemento de la matriz contiene caracteres especiales, como saltos de línea o comas, se encierra entre comillas dobles. No se añade ningún delimitador después de la última instancia o elemento concatenado.

Véase también `SumString` Función para una función similar, pero con opciones adicionales.

### Ejemplos {: #examples }
// Concatenates all instances of a field of email addresses // with a comma between each address SumCSV(_Root$customer.contact#.Email);
<div markdown="1" class="conf-macro output-inline" align="center" hasbody="false" macro-name="backtotop">

[[Volver arriba]](#top)

</div>

## `SumString` {: #instancefunctions-sumstring }

### Declaración {: #declaration }
string SumString(type de[, string delimiter, bool omitLast])

string SumString(array arr[, string delimiter, bool omitLast])

### Sintaxis {: #syntax }
SumString([, , ])

SumString([, , ])

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

- **`de`:** (Primera forma) Ruta de entidad a instancias de un elemento de datos en un origen o un destino.
- **`arr`:** (Segunda forma) Una matriz; todos los elementos de la matriz deben ser del mismo tipo.

#### Parámetros opcionales {: #optional-parameters }

- **`delimiter`** Una cadena para delimitar los elementos; el valor predeterminado es un punto y coma. 
- **`omitLast`** Una bandera que indica si se debe incluir el delimitador después del último elemento; el valor predeterminado es falso.

### Descripción {: #description }

Concatena cada instancia de los elementos de datos especificados o cada elemento de una matriz, añadiendo automáticamente un delimitador al final de cada cadena concatenada.

Si el parámetro `omitlast` es verdadero, se omite el delimitador después de la última cadena.

Véase también `SumCSV` función.

### Ejemplos {: #examples }
// Concatenates all instances of a field of email addresses // with a comma between each address, // but does not place a delimiter after the last address SumString(_Root$customer.contact#.Email, ",", true); ```