La sentencia Store crea un archivo QVD, Parquet, CSV o TXT.
Sintaxis:
Store [ fieldlist from] table into filename [ format-spec ];
La sentencia creará un archivo denominado explícitamente QVD, Parquet o archivo de texto.
La sentencia solo puede exportar campos de una tabla de datos, a menos que esté almacenando en archivos Parquet. Si los campos de varias tablas se van a exportar a un archivo QVD, CSV o TXT, se debe hacer un join explícito previamente en el script para crear la tabla de datos que se debe exportar. Puede almacenar varias tablas en un solo Parquet nidando los datos en los archivos Parquet.
Los valores de texto se exportan al archivo CSV en formato UTF-8. Se puede especificar un delimitador, vea LOAD. La sentencia store a un CSV no admite exportación BIFF.
Argumentos:
| Argumento | Descripción |
|---|---|
| fieldlist::= ( * | field) { , field } ) |
Una lista de los campos que se van a seleccionar. Usar un asterisco * indica la totalidad de campos. field::= fieldname [as aliasname ] fieldname es un texto que es idéntico a un nombre de campo en table. (Tenga en cuenta que el nombre de campo debe ir entre comillas dobles rectas o corchetes si contiene por ejemplo espacios u otros caracteres no estándar.) aliasname es un nombre alternativo para el campo que se utilizará en el archivo QVD o CSV resultante. |
| table | Es una tabla etiquetada en el script, ya cargada, que se usará como fuente de datos. |
| filename |
El nombre del archivo destino, incluyendo una ruta válida a una conexión de datos de carpetas. Ejemplo: 'lib://Table Files/target.qvd' En el modo de elaboración de scripts de legado, se admiten también los diguientes formatos de ruta:
|
| format-spec ::=( ( txt | qvd | parquet), compression is codec) |
Puede establecer la especificación de formato en cualquiera de estos formatos de archivo. Si se omite la especificación de formato, se asume qvd.
Si utiliza parquet, también puede establecer qué códec de compresión usar con compression is. Si no especifica el códec de compresión con compresión con compression is, se utiliza snappy. Están disponibles las siguientes opciones de compresión:
Ejemplo: Store mytable into [lib://AttachedFiles/myfile.parquet] (parquet, compression is lz4); |
Ejemplos:
Store mytable into xyz.qvd (qvd);
Store * from mytable into 'lib://FolderConnection/myfile.qvd';
Store Name, RegNo from mytable into xyz.qvd;
Store Name as a, RegNo as b from mytable into 'lib://FolderConnection/myfile.qvd';
Store mytable into myfile.txt (txt);
Store mytable into myfile.parquet (parquet);
Store * from mytable into 'lib://FolderConnection/myfile.qvd';
Almacenamiento en archivos parquet
Parquet es un formato de archivo fuertemente tipado, en el que cada campo contiene un único tipo específico de datos (como in32, double, timestamp o text). Qlik Sense almacena datos internos como un dual escrito libremente, donde los datos de diferentes fuentes se pueden mezclar en los mismos campos. Como solo se puede almacenar una parte del dual en cada campo de Parquet, es importante saber qué contiene cada campo. De forma predeterminada, Qlik Sense utiliza el tipo de campo para determinar cómo se debe almacenar el campo. Al almacenar datos en archivos Parquet en un formato específico, debe especificar qué tipo de datos son sus campos al cargarlos. Si trata de almacenar datos en campos incompatibles en un archivo Parquet, como números en un campo de texto o texto en un campo de marca de tiempo, terminará con valores nulos.
Al cargar datos que desea almacenar en Parquet, es posible cambiar el comportamiento predeterminado. Puede darles formato para cambiar su tipo de datos, o bien etiquetarlos para obligar a unos tipos de columnas específicos en Parquet.
Formateado de datos para almacenamiento en Parquet
Puede utilizar las funciones de formato de Qlik Sense para clasificar sus datos. Por ejemplo, Text(), Num(), Interval() o Timestamp() pueden aplicar formatos de datos al almacenar datos en Parquet. Qlik Sense puede almacenar datos en casi 20 tipos de datos según los atributos de campo y las etiquetas de campo automáticas. Para más información, vea Funciones de interpretación.
Ejemplo: Formateado de datos con Num() y Text()
El ejemplo siguiente demuestra la preparación de datos para su almacenamiento en Parquet. Num() se aplica al campo numérico. Text() se aplica tanto a texto como a mixto. En el caso de formato mixto, Text() evita que se trate como un campo numérico en Parquet y que los valores de texto se cambien a valores nulos.
NoConcatenate LOAD num, text, Text(mixed) as mixed RESIDENT Data; STORE Format INTO [lib://AttachedFiles/Tmp.parquet] (parquet);
Etiquetado de datos para almacenamiento en Parquet
Puede etiquetar sus datos con etiquetas $parquet para obligar a tener unos tipos de columnas específicos al almacenar datos en Parquet. Cada tipo de datos se puede aplicar agregando la etiqueta de control correspondiente. Por ejemplo, para almacenar un campo como INT32 en Parquet, etiquételo con $parquet-int32 en el script de carga. Dependiendo del tipo de datos, se almacenará la cadena o la representación numérica de los datos duales.
Las siguientes etiquetas de control de Parquet se pueden utilizar para etiquetar campos con el fin de almacenarlos en archivos Parquet.
| Etiqueta de control | Dual | Tipo físico | Tipo lógico | Tipo convertido |
|---|---|---|---|---|
| $parquet-boolean | Número | BOOLEAN | NONE | NONE |
| $parquet-int32 | Número | INT32 | NONE | NONE |
| $parquet-int64 | Número | INT64 | NONE | NONE |
| $parquet-float | Número | FLOAT | NONE | NONE |
| $parquet-double | Número | DOUBLE | NONE | NONE |
| $parquet-bytearray | Cadena | BYTE_ARRAY | NONE | UTF8 |
| $parquet-bytearrayfix | Número | FIXED_LEN_BYTE_ARRAY | NONE | DECIMAL |
| $parquet-decimal | Número | INT64 | DECIMAL | DECIMAL |
| $parquet-date | Número | INT32 | DATE | DATE |
| $parquet-time | Número | INT64 | TIME | TIME_MICROS |
| $parquet-timestamp | Número | INT64 | TIMESTAMP | TIMESTAMP_MICROS |
| $parquet-string | Cadena | BYTE_ARRAY | STRING | UTF8 |
| $parquet-enum | Cadena | BYTE_ARRAY | ENUM | ENUM |
| $parquet-interval | Número | FIXED_LEN_BYTE_ARRAY | INTERVAL | INTERVAL |
| $parquet-json | Cadena | BYTE_ARRAY | JSON | JSON |
| $parquet-bson | Cadena | BYTE_ARRAY | BSON | BSON |
| $parquet-uuid | Cadena | FIXED_LEN_BYTE_ARRAY | UUID | NONE |
Ejemplo: Etiquetado de datos para almacenamiento en Parquet
En este ejemplo, se utilizan dos etiquetas para definir los datos de Parquet. El campo num va etiquetado con $parquet-int32 para definirlo como un campo numérico que se establecerá como INT32 en Parquet.
Almacenar datos anidados en archivos Parquet
Puede almacenar varias tablas en archivos Parquet anidándolas en datos estructurados. Store admite nodos estructurados y nodos de lista en un esquema en estrella. Las tablas individuales también se pueden almacenar en modo anidado utilizando el especificador Delimiter is.
Al almacenar tablas, especifique las tablas que desea incluir separadas por comas. Por ejemplo: STORE Table1, Table2, Table3 INTO [lib://<file location>/<file name>.parquet] (parquet);. Puede controlar qué campos se almacenan utilizando una lista de campos en la sentencia Store. Por ejemplo STORE Field1, Field2, FROM Table1, Table2 INTO [lib://<file location>/<file name>.parquet] (parquet);. Todos los campos de la lista de campos deben estar en una o más de las tablas enumeradas. La primera tabla en la sentencia Store se utilizará como tabla de hechos en el esquema en estrella.
Los nombres de los campos se utilizan para controlar cómo se crearán y anidarán los grupos. De forma predeterminada, los nombres de los campos se dividen en nodos con un punto. (.). El delimitador se puede cambiar configurando la variable del sistema FieldNameDelimiter o usando el especificador Delimiter is. El especificador anulará la variable del sistema.Para más información, vea Trabajar con variables en el editor de carga de datos.
Los nombres de los campos se dividen por el delimitador y las partes se utilizan para crear el esquema con grupos anidados. Por ejemplo, STORE Field1, Field1.Field2, Field1.Field3, Field1.Field4 FROM Table1 INTO [nested.parquet] (parquet, delimiter is '.'); creará dos grupos (Grupo1 y Grupo2) con Campo1, Campo2 y Campo3, Campo4.
Al almacenar datos anidados en Parquet, las claves entre tablas se transforman en nodos de enlace en el esquema. Las tablas se transforman en nodos estructurados en el esquema.Puede anular la transformación predeterminada utilizando nombres de campos.
Ejemplo: Almacenar datos anidados en un archivo Parquet
El archivo Parquet resultante tiene el siguiente esquema:
Limitaciones
El almacenamiento de datos anidados en Parquettiene las siguientes limitaciones:
El almacenamiento no admite nodos de mapas.
El almacenamiento no incluye campos clave generados al cargar archivos de parquet anidados.
No puede almacenar datos de tablas conjuntas que no estén vinculadas con campos clave.
El archivo anidado desnormaliza el modelo de datos. Los valores a los que no se hace referencia no se guardarán y los valores a los que se hace referencia varias veces se copiarán.