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
Ejemplo de sintaxis básica
El siguiente script contiene una carga simple 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.
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.
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.
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.
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:
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.
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..
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.
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 Table1
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: Table2
Num1
Chr1
1
A
2
B
Tabla de resultados: Table3
Num2
Chr2
1
A
2
B
Tabla de resultados: Table4
Num3
Chr3
1
A
2
B
Ejemplo: mezcla de cargas inline y cargas procedentes de otras fuentes de datos
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: Orders
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.
Cuando carga una tabla sin definir nombres de columnas, los nombres de columnas definidos por el sistema se utilizan automáticamente.
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.
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.
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
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
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.
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: DerivedYears1
initial_date1
derived_year1
1/1/2022
2022
1/1/2023
2023
1/1/2024
2024
Tabla de resultados: DerivedYears2
derived_year2
2022
2023
2024
Tabla de resultados: DerivedYears3
initial_date3
derived_year3
1/1/2022
2022
1/1/2023
2023
1/1/2024
2024
Tabla de resultados: DerivedYears4
derived_year4
2022
2023
2024
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.
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 $.
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 -.
No dude en indicarnos en qué podemos mejorar si encuentra algún problema en esta página o su contenido, como, por ejemplo, errores tipográficos, pasos que falta o errores técnicos.
