# Cargar datos de tablas inline
Escriba datos manualmente en un script para definir una tabla inline.
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.
Una carga básica inline crea una tabla e inserta los campos y registros de datos.
## ¿Por qué utilizar cargas inline?
Las cargas inline pueden resultar útiles en muchos casos:
* 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 .csv o tablas de documentos de procesadores de texto.
* Crear scripts de prueba que se puedan copiar y pegar rápidamente.
## Ejemplo de sintaxis básica
El siguiente script contiene una carga inline sencilla:
```
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:
* La sentencia Load \* Inline instruye a QlikView para que cargue todos los campos de la tabla inline que viene a continuación.
* MyTable: define el nombre de la tabla.
* Los datos se incluyen entre corchetes.
* La primera línea de la sentencia de carga Load define los campos de datos.
* Las comas separan los campos de datos y los registros.
* Un punto y coma cierra la sentencia de carga.
## Descripción 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.
### Sentencias LOAD e inline
Se carga una tabla inline con la cláusula inline cuando se utiliza la sentencia del 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 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/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptRegularStatements/Load.htm).
### Inclusiones y entrada de datos
Los datos insertados a través de una cláusula inline deben ir incluidos entre caracteres específicos. Se aceptan las siguientes combinaciones de caracteres para inclusiones de datos:
* Corchetes: `[` y `]`
* Comillas dobles: `"` y `"`
* Comillas simples: `'` y `'`
* Tildes invertidas: `` ` `` y `` ` ``
El carácter que elija para enmarcar los datos puede ayudarle a cargar datos inline que contengan caracteres conflictivos. Por ejemplo, si sus datos contienen registros con corchetes, puede incluirlos entre comillas o tildes invertidas en su lugar.
Para ver ejemplos de inclusiones, consulte [Ejemplo: inclusiones de datos alternativas](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExDataEnc).
A menos que especifique un formato de tabla alternativo (por defecto es txt), el texto entre los recuadros 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 deberá hacerlo en el texto de una cláusula inline pulsando la tecla Intro al escribir la secuencia de script.
### Finalizar la carga inline
El final de la sentencia de carga inline se indica con 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 sentencias load precedentes y se puede utilizar más de una sentencia LOAD para cargar la misma tabla.
Para ver ejemplos específicos, consulte [Ejemplos: cargas inline con transformaciones](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExTransform).
### Configurar la especificación de formato en una carga inline
Al igual que sucede 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 de formato se agrega entre paréntesis. Debe agregarse después de los datos adjuntos, pero antes del punto y coma que pone fin a la sentencia LOAD. Algunas de las personalizaciones que puede agregar son las siguientes:
* Cambiar el delimitador de una coma a otro carácter. Para ver ejemplos, consulte: [Ejemplos: delimitadores alternativos](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExDelimiter).
Vea: [Delimiter](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/delimiter.htm)
* Omitir los encabezados de las columnas de la tabla. Para ver un ejemplo, consulte: [Ejemplo: omitir encabezados de columna](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExOmitLabels).
Vea: [Labels](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/labels.htm)
* Usar otro formato de datos (por ejemplo, formato de registro fijo). Para ver un ejemplo, consulte: [Ejemplo: cargar otro tipo de datos](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExChangeFormat).
Vea: [Formato de tabla](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/table-format.htm)
Nota informativaNo todas las opciones de Table format son compatibles para cargas inline.
* Permitir contenido en múltiples líneas. Para ver un ejemplo, consulte: [Ejemplo: contenido de varias líneas](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExMultLine).
Vea: [Quotes](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/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 ver detalles completos sobre la especificación de formato, consulte [Elementos de especificación de formato](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/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.
De manera similar, también puede utilizar operadores fuera del contenido del texto. Con los operadores, puede personalizar cómo transforma los datos inline y también definir cuándo cargar ciertos datos o no.
Para ver un ejemplo específico, consulte: [Ejemplo - Operadores para transformaciones y cláusulas.](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#ExOpsAndClauses).
## Ejemplo: inclusiones de datos alternativas
Puede utilizar corchetes, comillas o tildes invertidas 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/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#Enclosure).
#### Cargar script y resultados
General
Este ejemplo muestra cómo puede utilizar tildes invertidas para incluir los datos inline. Los datos del ejemplo contienen caracteres entre corchetes, lo que hace que los corchetes sean incompatibles como caracteres de inclusión para la sentencia LOAD.
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
* `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 una coma para delimitar los valores de las columnas en la tabla. Para más información, vea [Configurar la especificación de formato en una carga inline](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
#### Cargar script y resultados
General
Intercambiar el delimitador es útil cuando los datos de la tabla contienen comas, lo que de otro modo indicaría el cambio a la siguiente columna de la tabla.
Este ejemplo contiene:
* Cuatro tablas que cargar. Son las siguientes:
* Table1: el delimitador es una barra vertical (canalización). 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 copia una tabla de un procesador de textos y la 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
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: omitir encabezados de columna
Edite la especificación de formato para cargar una tabla inline sin definir encabezados de columna. Esto se hace con la especificación de etiquetas: labels (fijá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/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
Cuando carga una tabla sin definir nombres de columnas, los nombres de columnas definidos por el sistema se utilizan automáticamente.
#### Cargar script y resultados
General
Este ejemplo muestra cómo se puede cargar una tabla inline sin definir nombres de columnas.
Script de carga
```
Expenses:
Load * inline
[
1,Category1,40566.49
2,Category2,3504.54
3,Category3,593206.30
] (no labels);
```
Resultados
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 muestra cómo se puede cargar una tabla inline en formato de registro fijo. Véase [Configurar la especificación de formato en una carga inline](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
#### Cargar script y resultados
General
Este script de ejemplo contiene lo siguiente:
* Una sentencia 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 a 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
Tabla de resultados
| a | b | c | d |
| --- | --- | --- | --- |
| 1 | 2 | 3 | 4 |
| x | y | z | w |
## Ejemplo: contenido de varias líneas
Este ejemplo muestra cómo puede insertar contenido de campo de varias líneas en una tabla inline. Véase [Configurar la especificación de formato en una carga inline](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#FormatSpec).
#### Cargar script y resultados
General
Este script de ejemplo contiene lo siguiente:
* 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
Para ver el contenido de varias líneas según lo previsto, deberá ajustar las Configuraciones de Varias Filas para el gráfico en Propiedades....
Tabla de resultados
| ID | Length |
| --- | --- |
| 1 | 1' 2"
22' 10" |
| 2 | 14' 8" |
En la tabla anterior, el registro con un valor de 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/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#Transform).
#### Ejemplo: cambio simple de un nombre de un campo
Script de carga
```
ORDERS:
Load Original as Updated,
* Inline
[
Original
ProductA
ProductB
ProductC
];
```
Resultados
Tabla de resultados
| Original | Updated |
| --- | --- |
| ProductA | ProductA |
| ProductB | ProductB |
| ProductC | ProductC |
#### Ejemplo: inserción simple de un campo ID
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.
Script de carga
```
ORDERS:
Load RowNo() as ID,
* Inline
[
ProductName
A
B
C
D
E
];
```
Resultados
Tabla de resultados
| ID | ProductName |
| --- | --- |
| 1 | A |
| 2 | B |
| 3 | C |
| 4 | D |
| 5 | E |
#### Ejemplo: configuración de sentencias LOAD para manejar transformaciones
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 al 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 al resultado:
* Número de sentencias LOAD en la tabla.
* Presencia o ausencia del símbolo \* (carga todos los campos posteriores).
* Presencia o ausencia de comas (símbolo ,).
Este script a modo de ejemplo contiene lo siguiente:
* 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 inline 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 sencilla sentencia LOAD para cargar tanto la columna inline original como una columna transformada.
* DerivedYears4: utiliza una sencilla sentencia LOAD para definir un campo en línea 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
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 del campo
General
Supongamos que está pegando información de un archivo de texto grande en el editor de script, pero desea realizar un procesamiento adicional en los registros del conjunto de datos. Por ejemplo, desea eliminar ciertos caracteres y prefijos y poner en mayúscula cada palabra.
Este script a modo de ejemplo contiene lo siguiente:
* 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 está transformando se agrega después de esto.
* Dos sentencias LOAD. Con la configuración del ejemplo, solo 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
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/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/inline-loads-qv.htm#OpsAndClauses).
[Operadores](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/Operators/operators.htm)
#### Cargar script y resultados
General
Este script de ejemplo contiene lo siguiente:
* 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 la cantidad supera o no los 2.000,00 $.
* Una cláusula where que impide que se carguen registros cuando el valor 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>1
;
```
Resultados
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 amount es inferior a 0,05 $.
## Ejemplo: creación de valores nulos en una tabla inline
Este ejemplo muestra cómo puede utilizar la variable NullInterpret para crear valores nulos en sus datos inline.
[NullInterpret](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ValueHandlingVariables/NullInterpret.htm)
#### Cargar script y resultados
General
Este script de ejemplo contiene lo siguiente:
* 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
Tabla de resultados
| Test |
| --- |
| x |
En la tabla anterior, el primer registro es un valor nulo. Por tanto, no se incluye en la visualización. Los valores nulos existentes en tablas con dimensiones adicionales se indicarán con un símbolo -.
## Más ejemplos
Para ver ejemplos adicionales, consulte [Load](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptRegularStatements/Load.htm).
## Más información
* [Load](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptRegularStatements/Load.htm)
* [Elementos de especificación de formato](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Scripting/ScriptSpecifiers/format-specification-items.htm)
* [Asistente de Datos Inline](https://help.qlik.com/es-ES/qlikview/September2026/Subsystems/Client/Content/QV_QlikView/Inline_Data_Wizard.htm)