# Usar cargas inline para cargar datos
Escriba datos manualmente en un script para definir una tabla inline, la cual se puede cargar en una app. Puede trabajar con cargas inline en el Editor de carga de datos.
Las tablas inline se crean escribiendo datos manualmente en el script, en lugar de conectarse a archivos y bases de datos. Utilice la sintaxis requerida para indicar que el texto del script debe interpretarse como datos inline. Los datos agregados mediante cargas inline estarán contenidos en la aplicación si ésta se exporta. Las tablas inline se pueden leer y editar dentro del script de carga.
Una carga inline básica crea una tabla e inserta los campos de datos y los registros.
Carga inline en el editor de carga de datos
Carga inline en el editor de carga de datos
Carga inline en el editor de carga de datos 
## Ejemplo de sintaxis básica
El siguiente script contiene una carga simple inline.
```
MyTable:
Load * Inline [
Country, Year, Sales
Argentina, 2014, 66295.03
Argentina, 2015, 140037.89
Austria, 2014, 54166.09
Austria, 2015, 182739.87
];
```
La siguiente sintaxis se utiliza para la carga inline superior:
* Load \* Inline instruye a Qlik Sense para que cargue todos los campos de la tabla inline que aparece a continuación.
* MyTable: define el nombre de la tabla. Se puede acceder a la lista de tablas de la aplicación desde Visor del modelo de datos y otras áreas.
* Los corchetes delimitan los datos.
* La primera línea de la sentencia de carga define los campos de datos.
* Los campos de datos y los registros van separados por comas.
* Un punto y coma cierra la sentencia de carga.
## Cargar una tabla inline
Haga lo siguiente:
1. En una app, abra Editor de carga de datos.
2. En una nueva línea, defina la tabla usando la sintaxis requerida.
[Ejemplo de sintaxis básica](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#BasicSyntax)
3. Cuando haya terminado, haga clic en Cargar datos.
## ¿Por qué utilizar cargas inline?
Las cargas inline pueden resultar útiles en varios casos de uso:
* Administrar y editar datos sin necesidad de conectarse a fuentes externas.
* Complementar los datos existentes en el modelo de datos. Por ejemplo, podría agregar una tabla adicional a un modelo de datos que provenga principalmente de fuentes de bases de datos.
* Agregar datos que le gustaría evitar cargar continuamente desde fuentes externas. Esto puede ahorrar tiempo si sabe que la fuente de datos podría cambiar en el futuro, pero los valores de los datos seguirán siendo los mismos.
* Facilidad de uso para copiar y pegar contenido en el script desde otros archivos. Por ejemplo, archivos o tablas .csv de documentos de procesadores de texto.
* Crear scripts de prueba que se puedan copiar y pegar rápidamente.
## Descripción general de la sintaxis
### Dar nombre a la tabla
Puede agregar un nombre para la tabla inline, como lo haría con otras tablas cargadas. Definir el nombre de la tabla es opcional.
Después del nombre de la tabla, inserte dos puntos.
### Las sentencias LOAD y inline
Una tabla inline se carga mediante la cláusula inline cuando utiliza la sentencia de script LOAD. La cláusula inline indica que el texto siguiente en la tabla contendrá datos que se escriben manualmente en el editor. A menos que se indique lo contrario, una tabla inline utiliza el formato txt que sigue la estructura de un archivo de texto delimitado.
Para más información sobre la sentencia LOAD, vea [Load](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm).
### Inclusiones y entrada de datos.
Los datos introducidos mediante una cláusula inline deben ir entre caracteres específicos. A continuación se indican las combinaciones de caracteres aceptadas para enmarcar los datos:
* Corchetes: `[` y `]`
* Comillas dobles: `"` y `"`
* Comillas simples: `'` y `'`
* Tildes: `` ` `` y `` ` ``
El carácter que elija como símbolo puede ayudarle a cargar datos inline que contengan caracteres en conflicto. Por ejemplo, si sus datos contienen registros con corchetes, puede incluirlos entre comillas o tildes en su lugar.
Para ver un ejemplo de inclusiones alternativas, vea [Ejemplo: inclusiones alternativas de datos](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExDataEnc).
A menos que especifique un formato de tabla alternativo (por defecto es txt), el texto entre las inclusiones se interpreta de la misma forma que el contenido de un archivo. Por lo tanto, cuando inserte una nueva línea en un archivo de texto, también debe hacerlo en el texto de una cláusula inline: pulsando la tecla Intro al escribir la secuencia de script.
### Finalización de la carga inline
El final de la sentencia de carga inline se indica mediante un punto y coma.
### Transformaciones de datos
En una carga inline simple, sin transformaciones, el número de columnas viene definido por la primera línea. Hay tres columnas en la tabla cargada por el siguiente ejemplo: `Product_ID`, `Supplier_Name` y `Product_Category`.
```
Products:
Load * Inline [
Product_ID, Supplier_Name, Product_Category
1, Paracel, Home Decor
2, PageWave, Electronics
3, Talarian, Software
4, Userland, Appliances
];
```
También puede realizar transformaciones y crear nuevas columnas dentro de la misma tabla inline. Puede usar loads precedentes y se puede utilizar más de una sentencia LOAD para cargar la misma tabla.
Si desea ejemplos específicos, vea [Ejemplos: cargas inline con transformaciones](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExTransform).
### Configurar la especificación de formato en una carga inline
Al igual que con otras tablas cargadas, puede modificar la especificación de formato de la tabla inline utilizando elementos de especificación de formato. La especificación del formato se añade entre paréntesis. Debe agregarse después de los datos adjuntos, pero antes del punto y coma que finaliza la sentencia LOAD. Algunas de las personalizaciones que puede añadir son:
* Cambiar el delimitador de una coma a otro carácter. Para ejemplos, vea [Ejemplos: delimitadores alternativos](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExDelimiter).
Vea: [Delimiter is](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/delimiter.htm)
* Omitir cabeceras de columnas de tablas. Puede ver un ejemplo en [Ejemplo: omitir los encabezados de columna](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExOmitLabels).
Vea: [Labels](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/labels.htm)
* Utilizar otro formato de datos (por ejemplo, formato de registro fijo). [Ejemplo: cargar otro tipo de datos](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExChangeFormat)
Vea: [Table format](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/table-format.htm)
Nota informativaNo todas las opciones de Table format son compatibles con las cargas inline.
* Permitir contenido con varias líneas. [Ejemplo: contenido multilínea](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExMultLine)
Vea: [Quotes](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/quotes.htm)
Para utilizar varios elementos de especificación de formato en la misma tabla, sepárelos mediante comas. Por ejemplo:` (Delimiter is '|', no labels) `
Para obtener detalles completos sobre la especificación de formato, vea [Elementos de especificación de formato](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm).
### Operadores y otras cláusulas
Además, dado que una carga inline es una sentencia LOAD, puede combinar otros argumentos para la sentencia LOAD en la carga inline. Por ejemplo, utilice la cláusula where o while para definir si se carga una fila específica o no, según el texto que contiene.
Del mismo modo, también puede utilizar operadores fuera del propio contenido del texto. Con los operadores puede personalizar la forma de transformar los datos inline y también definir cuándo cargar determinados datos o no.
Para un ejemplo concreto, vea [Ejemplo: operadores para transformaciones y cláusulas](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#ExOpsAndClauses).
## Ejemplo: inclusiones alternativas de datos
Puede utilizar corchetes, comillas o tildes para incluir una carga inline. Esta sección lo ilustra con un ejemplo. Para más información, vea [Inclusiones y entrada de datos.](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#Enclosure).
#### Script de carga y resultados
Este ejemplo muestra cómo se pueden utilizar las marcas traseras para incluir los datos inline. Los datos del ejemplo contienen caracteres entre corchetes, lo que hace que los corchetes sean incompatibles como espacios adjuntos para la sentencia LOAD.
Vista general
Abra el Editor de carga de datos y agregue el siguiente script de carga en una nueva pestaña.
Script de carga
```
DataTable:
Load * inline
`
custom_property, date, amount
[11402], 1/1/2024, 92.99
[11403], 1/2/2024, 102.34
[11404], 1/3/2024, 50.26
[11405], 1/4/2024, 153.69
[11406], 1/5/2024, 75.62
`;
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue estos campos como dimensiones:
* `custom_property`
* `date`
* `amount`
Tabla de resultados
| custom\_property | date | amount |
| --- | --- | --- |
| [11402] | 1/1/2024 | 92.99 |
| [11403] | 1/2/2024 | 102.34 |
| [11404] | 1/3/2024 | 50.26 |
| [11405] | 1/4/2024 | 153.69 |
| [11406] | 1/5/2024 | 75.62 |
## Ejemplos: delimitadores alternativos
Puede utilizar un carácter distinto de la coma para delimitar los valores de las columnas de la tabla. Para más información, vea [Configurar la especificación de formato en una carga inline](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
#### Script de carga y resultados
Vista general
Intercambiar el delimitador es útil cuando los datos de la tabla contienen comas, que de otro modo señalarían el paso a la siguiente columna de la tabla.
Abra el editor de carga de datos y agregue el script de carga a continuación a una nueva pestaña.
El script de carga contiene:
* Hay que cargar cuatro tablas. Son las siguientes:
* Table1: el delimitador es una barra vertical. Los datos de la columna Phrase contienen comas.
* Table2: el delimitador son dos puntos.
* Table3: el delimitador es una barra invertida.
* Table4: la tabla se delimita pulsando la tecla Tab del teclado. Esta opción es útil cuando se copia una tabla de un procesador de textos y se pega en el script.
Table1 muestra un caso de uso práctico para utilizar un delimitador alternativo. Las otras tablas muestran más opciones de delimitadores.
Script de carga
```
Table1:
LOAD * INLINE [
ID|Phrase
1 | 'The transaction was complete, but the order has not yet shipped.'
2 | 'We need to confirm the following details: sales rep number, order status, and shipping priority.'
] (Delimiter is '|');
Table2:
LOAD * INLINE [
Num1:Chr1
1:A
2:B ] (Delimiter is ':');
Table3:
LOAD * INLINE [
Num2\Chr2
1\A
2\B ] (Delimiter is \\);
Table4:
LOAD * INLINE [
Num3 Chr3
1 A
2 B ] (Delimiter is '\t');
```
Resultados
Cargue los datos y abra una hoja. Cree cuatro tablas y añádales las dimensiones que se indican a continuación:
* Table1: ID, Phrase
* Table2: Num1, Chr1
* Table3: Num2, Chr2
* Table4: Num3, Chr3
Tabla de resultados Table1Table1
| ID | Phrase |
| --- | --- |
| 1 | The transaction was complete, but the order has not yet shipped. |
| 2 | We need to confirm the following details: sales rep number, order status, and shipping priority. |
Tabla de resultados: Table2Table2
| Num1 | Chr1 |
| --- | --- |
| 1 | A |
| 2 | B |
Tabla de resultados: Table3Table3
| Num2 | Chr2 |
| --- | --- |
| 1 | A |
| 2 | B |
Tabla de resultados: Table4Table4
| Num3 | Chr3 |
| --- | --- |
| 1 | A |
| 2 | B |
## Ejemplo: mezcla de cargas inline y cargas procedentes de otras fuentes de datos
#### Script de carga y resultados
Vista general
El siguiente script carga primero una serie de campos de un conector y, a continuación, carga una tabla inline con un campo común y un campo adicional. Este nuevo campo proporciona otra propiedad sobre el elemento de la fila que no se cargó a través de la conexión de datos. Tenga en cuenta que esto solo funciona correctamente cuando hay un único nombre de campo en común entre las dos tablas. Si hay más de un nombre de campo común, se produce una clave sintética.
En este ejemplo truncado, cargamos una tabla de detalles de pedidos desde una conexión de datos. Luego, usamos una tabla inline para agregar un campo adicional, Supplemental Info. Esta podría, por ejemplo, contener detalles sobre comentarios especiales acerca de ID de pedidos específicos.
Script de carga
```
SET DateFormat='MM/DD/YYYY';
Orders:
LIB CONNECT TO 'My_Generic_Connection';
LOAD PRODUCT_DIVISION_A_ORDER_ID as Order ID,
PRODUCT_DIVISION_A_ORDER_DATE as ISSUE_KEY as Order Date,
PRODUCT_DIVISION_A_TYPE as Product Type,
PRODUCT_DIVISION_A_SALES_MANAGER as Manager,
PRODUCT_DIVISION_A_SHIPPED_STATUS as Shipped Status;
SELECT PRODUCT_DIVISION_A_ORDER_ID,
PRODUCT_DIVISION_A_ORDER_DATE,
PRODUCT_DIVISION_A_TYPE,
PRODUCT_DIVISION_A_SALES_MANAGER,
PRODUCT_DIVISION_A_SHIPPED_STATUS
FROM SourceTable
WITH PROPERTIES (
[...]
);
Orders_Inline_Info:
load * inline [
Order ID,Supplemental Info
PSF-001014,'Bulk order, pending deal with Paracel.'
PSF-001625,'NOTE: Product damaged. Investigation required.'
];
```
Resultados
Después de cargar los datos, pongamos que añadimos las siguientes dimensiones a una tabla:
* Order ID
* Order Date
* Product Type
* Manager
* Shipped Status
* Supplemental Info
El gráfico resultante podría tener este aspecto.
Tabla de resultados: OrdersOrders
| Order ID | Order Date | Product Type | Manager | Shipped Status | Supplemental Info |
| --- | --- | --- | --- | --- | --- |
| PSF-000998 | 1/13/2024 | Electronics | Amanda Honda | Shipped | - |
| PSF-000999 | 1/15/2024 | Automotive | Molly McKenzie | Not Shipped | - |
| PSF-001014 | 1/17/2024 | Home Appliances | Amalia Craig | Undefined | Bulk order, pending deal with Paracel. |
| PSF-001625 | 1/21/2024 | Electronics | Amanda Honda | Undefined | Product damaged. Investigation required. |
Observe cómo todos los campos de ambas tablas pueden añadirse a la misma visualización. Las tablas están asociadas entre sí en el modelo de datos.
## Ejemplo: omitir los encabezados de columna
Edite la especificación de formato para cargar una tabla inline sin definir encabezados de columna. Esto se realiza con la especificación labels (estableciéndola en un valor de no labels). Para más información, vea [Configurar la especificación de formato en una carga inline](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
Cuando carga una tabla sin definir nombres de columnas, los nombres de columnas definidos por el sistema se utilizan automáticamente.
#### Script de carga y resultados
Vista general
Este ejemplo demuestra cómo se puede cargar una tabla inline sin definir nombres de columnas.
Abra el Editor de carga de datos y agregue el siguiente script de carga en una nueva pestaña.
Script de carga
```
Expenses:
Load * inline
[
1,Category1,40566.49
2,Category2,3504.54
3,Category3,593206.30
] (no labels);
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue estos campos como dimensiones:
* @1
* @2
* @3
Tabla de resultados
| @1 | @2 | @3 |
| --- | --- | --- |
| 1 | Category1 | 40566.49 |
| 2 | Category2 | 3504.54 |
| 3 | Category3 | 593206.30 |
## Ejemplo: cargar otro tipo de datos
Este ejemplo demuestra cómo se puede cargar una tabla inline en formato de registro fijo. Vea [Configurar la especificación de formato en una carga inline](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
#### Script de carga y resultados
Vista general
Abra el editor de carga de datos y agregue el script de carga a continuación a una nueva pestaña.
El script de carga contiene:
* Una instrucción de carga inline que define la tabla DataTable.
* El uso de fix (como parte de la especificación de Table format) para indicar que los datos que se han de cargar están en formato de registro fijo.
Script de carga
```
DataTable:
LOAD
"@1:4",
"@5:8",
"@9:12",
"@13:16"
INLINE [
a b c d
1 2 3 4
x y z w
] (fix, utf8, embedded labels);
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue estos campos como dimensiones:
* a
* b
* c
* d
Tabla de resultados
| a | b | c | d |
| --- | --- | --- | --- |
| 1 | 2 | 3 | 4 |
| x | y | z | w |
## Ejemplo: contenido multilínea
Este ejemplo demuestra cómo puede insertar contenido de campo de varias líneas en una tabla inline. Vea [Configurar la especificación de formato en una carga inline](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#FormatSpec).
#### Script de carga y resultados
Vista general
Abra el editor de carga de datos y agregue el script de carga a continuación a una nueva pestaña.
El script de carga contiene:
* Una carga inline simple para definir la tabla T1.
* El uso del especificador Quotes (con el valor msq) para admitir contenido de varias líneas.
* Valores de longitud especificados en pies y pulgadas.
* El símbolo de comillas dobles (") indica el final de una entrada de varias líneas. En este ejemplo, también se utiliza el mismo símbolo para indicar los valores en pulgadas. Esto se hace para mostrar la sintaxis y el comportamiento resultante si necesita utilizar ambos en la misma sentencia LOAD. Básicamente, insertar el símbolo " para dos caracteres consecutivos ("") indica que el código debe interpretarse como una única instancia de texto del símbolo.
Script de carga
```
T1:
Load *, recno() as ID inline [
Length
"1' 2""
22' 10"""
14' 8" ] (msq);
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue estos campos como dimensiones:
* ID
* Length
Para ver el contenido de varias líneas tal como se esperaba, la configuración Ajustar texto en celdas debe estar activada en el panel de propiedades. Además, la plantilla de la aplicación (o la configuración de visualización) debe permitir una Altura de fila suficiente (en líneas).
Tabla de resultados
| ID | Length |
| --- | --- |
| 1 | 1' 2"
22' 10" |
| 2 | 14' 8" |
En la tabla anterior, el registro con un valor ID de 1 contiene contenido de varias líneas.
## Ejemplos: cargas inline con transformaciones
Estos ejemplos muestran cómo puede realizar cálculos en campos cargados inline para crear nuevos campos en el modelo de datos.
Para más información, vea [Transformaciones de datos](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#Transform).
#### Ejemplo: cambio simple de nombre de un campo
Vista general
Abra el Editor de carga de datos y agregue el siguiente script de carga en una nueva pestaña.
Script de carga
```
ORDERS:
Load Original as Updated,
* Inline
[
Original
ProductA
ProductB
ProductC
];
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue estos campos como dimensiones:
* Original
* Updated
Tabla de resultados
| Original | Updated |
| --- | --- |
| ProductA | ProductA |
| ProductB | ProductB |
| ProductC | ProductC |
#### Ejemplo: inserción simple de un campo de ID
Vista general
Este ejemplo muestra cómo puede definir un campo calculado para indicar el ID de cada fila de datos, sin escribir manualmente cada valor de ID.
Abra el Editor de carga de datos y agregue el siguiente script de carga en una nueva pestaña.
Script de carga
```
ORDERS:
Load RowNo() as ID,
* Inline
[
ProductName
A
B
C
D
E
];
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue estos campos como dimensiones:
* ID
* ProductName
Tabla de resultados
| ID | ProductName |
| --- | --- |
| 1 | A |
| 2 | B |
| 3 | C |
| 4 | D |
| 5 | E |
#### Ejemplo: configuración de sentencias LOAD para manejar las transformaciones
Vista general
Este ejemplo muestra varias formas en las que se puede aplicar una transformación simple a datos inline. Puede utilizar una o varias sentencias LOAD y configurar la sintaxis de diferentes maneras para definir si una transformación reemplaza o no el campo original o si se cargan tanto el campo original como el nuevo.
En particular, tenga en cuenta las variaciones en lo siguiente y cómo afectan la salida:
* Número de sentencias LOAD dentro de la tabla.
* Presencia o ausencia del símbolo \* (carga todos los campos subsiguientes).
* Presencia o ausencia de comas (símbolo ,).
Abra el editor de carga de datos y agregue el script de carga a continuación a una nueva pestaña.
El script de carga contiene:
* Cuatro tablas, todas las cuales hacen referencia a los mismos datos. Los nombres de los campos son diferentes.
* DerivedYears1: utiliza dos sentencias LOAD para cargar una columna c y una columna que contiene una transformación de la columna inline.
* DerivedYears2: utiliza dos sentencias LOAD. El script carga una columna inline y luego carga un campo calculado transformado a partir de la columna original. Con la segunda sentencia LOAD, la columna original no se carga en la tabla, lo que efectivamente hace que el nuevo campo reemplace al campo original.
* DerivedYears3: utiliza una única sentencia LOAD para cargar tanto la columna inline original como una columna transformada.
* DerivedYears4: utiliza una única sentencia LOAD para definir un campo inline y una transformación de ese campo original. Sólo el campo transformado se carga en la tabla.
Script de carga
```
DerivedYears1:
Load *,
Year(initial_date1) as derived_year1
;
Load
* inline [
initial_date1
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears2:
Load
Year(initial_date2) as derived_year2
;
Load
* inline [
initial_date2
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears3:
Load Year(initial_date3) as derived_year3,
* inline [
initial_date3
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
DerivedYears4:
Load Year(initial_date4) as derived_year4
inline [
initial_date4
'1/1/2022'
'1/1/2023'
'1/1/2024'
];
```
Resultados
Cargue los datos y abra una hoja. Cree cuatro tablas y añádales las dimensiones que se indican a continuación:
* DerivedYears1: initial\_date1, derived\_year1
* DerivedYears2: initial\_date2
* DerivedYears3: initial\_date3, derived\_year3
Tabla de resultados: DerivedYears1DerivedYears1
| initial\_date1 | derived\_year1 |
| --- | --- |
| 1/1/2022 | 2022 |
| 1/1/2023 | 2023 |
| 1/1/2024 | 2024 |
Tabla de resultados: DerivedYears2DerivedYears2
| derived\_year2 |
| --- |
| 2022 |
| 2023 |
| 2024 |
Tabla de resultados: DerivedYears3DerivedYears3
| initial\_date3 | derived\_year3 |
| --- | --- |
| 1/1/2022 | 2022 |
| 1/1/2023 | 2023 |
| 1/1/2024 | 2024 |
Tabla de resultados: DerivedYears4DerivedYears4
| derived\_year4 |
| --- |
| 2022 |
| 2023 |
| 2024 |
#### Ejemplo: modificar el contenido de campos
Vista general
Supongamos que está pegando información procedente de un archivo de texto de gran tamaño en el editor de script, pero desea realizar un procesamiento adicional de los registros del conjunto de datos. Por ejemplo, desea eliminar determinados caracteres y prefijos, y escribir cada palabra en mayúsculas.
Abra el editor de carga de datos y agregue el script de carga a continuación a una nueva pestaña.
El script de carga contiene:
* Una tabla inline, Transformations, en la que se define una transformación para cambiar el contenido del texto de un campo. El texto que se transforma se añade a continuación.
* Dos sentencias LOAD. Con la configuración del ejemplo, sólo se carga en la tabla el campo derivado ProductName\_Trimmed.
Script de carga
```
Transformations:
Load
Capitalize(TextBetween(OrigColumn, '{','}')) as ProductName_Trimmed;
Load * inline [
OrigColumn
Product: {soft drinks and other beverages}
Product: {snack food}
Product: {electronics and video games}
];
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue este campo como dimensión: ProductName\_Trimmed.
Tabla de resultados
| ProductName\_Trimmed |
| --- |
| Soft Drinks And Other Beverages |
| Snack Food |
| Electronics And Video Games |
## Ejemplo: operadores para transformaciones y cláusulas
Puede utilizar operadores para definir transformaciones y cláusulas específicas en la sentencia LOAD. Para más información, vea [Operadores y otras cláusulas](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/inline-loads-qs.htm#OpsAndClauses).
[Operadores](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/Operators/operators.htm)
#### Script de carga y resultados
Vista general
Abra el editor de carga de datos y agregue el script de carga a continuación a una nueva pestaña.
El script de carga contiene:
* Una carga inline simple para definir la tabla Purchases.
* La inserción de un campo calculado, OrderSize. Este campo es una transformación del campo amount del conjunto de datos inline. Clasifica las compras en pequeñas o grandes, dependiendo de si el importe supera o no los 2.000,00 dólares.
* Una cláusula where que impide la carga de registros cuando la cantidad (amount) es inferior a 0,05 $.
Script de carga
```
Purchases:
Load
If(amount<2000,'Small Purchase','Large Purchase') as OrderSize,
* inline
[
ID, amount
1,2660.39
2,100.01
3,500.42
4,5023.99
5,0.04
6,2002.39
7,31034.53
8,1643.58
9,3993.65
10,614.34
11,675.93
]
WHERE
amount>0.05
;
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue estos campos como dimensiones:
* ID
* amount
* OrderSize
Tabla de resultados
| ID | amount | OrderSize |
| --- | --- | --- |
| 1 | 2660.39 | Large Purchase |
| 2 | 100.01 | Small Purchase |
| 3 | 500.42 | Small Purchase |
| 4 | 5023.99 | Large Purchase |
| 6 | 2002.39 | Large Purchase |
| 7 | 31034.53 | Large Purchase |
| 8 | 1643.58 | Small Purchase |
| 9 | 3993.65 | Large Purchase |
| 10 | 614.34 | Small Purchase |
| 11 | 675.93 | Small Purchase |
En la tabla anterior, la transacción con un ID de 5 no se cargó en la tabla. Esto se debe a que el valor de amount es inferior a 0,05 $.
## Ejemplo: creación de valores nulos en una tabla inline
Este ejemplo demuestra cómo puede utilizar la variable NullInterpret para crear valores nulos en sus datos inline.
[NullInterpret](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ValueHandlingVariables/NullInterpret.htm)
#### Script de carga y resultados
Vista general
Abra el editor de carga de datos y agregue el script de carga a continuación a una nueva pestaña.
El script de carga contiene:
* Una carga inline simple para definir la tabla T2.
* La variable NullInterpret definida como dos comillas simples. Cuando se carga el script, los registros que contienen este valor se procesan como valores nulos.
Script de carga
```
set nullinterpret = '';
T2:
Load * inline [
Test
''
x ];
```
Resultados
Cargue los datos y abra una hoja. Cree una nueva tabla y agregue este campo como dimensión: Test.
Tabla de resultados
| Test |
| --- |
| x |
En la tabla anterior, el primer registro es un valor nulo. Por lo tanto, no se incluye en la visualización. Los valores nulos existentes en tablas con dimensiones adicionales se denotan mediante un símbolo -.
## Más ejemplos
Para ver ejemplos adicionales, consulte [Load](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm).
APRENDIZAJE RELACIONADO:
* [Introducción al editor de carga de datos](https://help.qlik.com/lnk/Intro_Data_Load_Editor_QS)
## Más información
* [Load](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptRegularStatements/Load.htm)
* [Elementos de especificación de formato](https://help.qlik.com/es-ES/sense/November2024/Subsystems/Hub/Content/Sense_Hub/Scripting/ScriptSpecifiers/format-specification-items.htm)
* [Introducción al editor de carga de datos](https://help.qlik.com/lnk/Intro_Data_Load_Editor_QS)