Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Consulta ejemplos con parquet

El siguiente ejemplo de consulta devuelve el número de filas de un archivo Parquet determinado:

CALL neptune.read(
  {
    source: "<s3 path>",
    format: "parquet"
  }
)
YIELD row
RETURN count(row)

Puede ejecutar el ejemplo de consulta mediante la execute-open-cypher-query operación de AWS CLI ejecutando el siguiente código:

aws neptunedata execute-open-cypher-query \
--open-cypher-query "CALL neptune.read({source: '<s3 path>', format: 'parquet'}) YIELD row RETURN count(row)" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182

Una consulta puede ser flexible en cuanto a lo que hace con las filas leídas de un archivo Parquet. Por ejemplo, la siguiente consulta crea un nodo con un campo que se establece con los datos que se encuentran en el archivo Parquet:

CALL neptune.read(
  {
    source: "<s3 path>",
    format: "parquet"
  }
)
YIELD row
CREATE (n {someField: row.someCol}) 
RETURN n

Tipos de columnas de parquet compatibles

Tipos de datos de parquet:

Tipos de datos específicos de Neptuno:

A diferencia de los encabezados de las columnas de propiedades del formato CSV, los encabezados de las columnas de propiedades del formato Parquet solo necesitan tener los nombres de las propiedades, por lo que no es necesario tener los nombres de los tipos ni la cardinalidad.

Sin embargo, hay algunos tipos de columnas especiales en el formato Parquet que requieren anotaciones en los metadatos, como el tipo Any, el tipo Date, el tipo DateTime y el tipo Geometry. El siguiente objeto es un ejemplo de la anotación de metadatos necesaria para los archivos que contienen columnas de estos tipos especiales:

"metadata": {
    "anyTypeColumns": ["UserCol1"],
    "dateTypeColumns": ["UserCol2"],
    "dateTimeTypeColumns": ["UserCol3"],
    "geometryTypeColumns": ["UserCol4"]
}

A continuación, se muestran detalles sobre la carga útil esperada asociada a estos tipos:

Ejemplo de salida de parquet

Dado un archivo de parquet como este:

<s3 path>

Parquet Type:
    int8     int16       int32             int64              float      double    string
+--------+---------+-------------+----------------------+------------+------------+----------+
|   Byte |   Short |       Int   |                Long  |     Float  |    Double  | String   |
|--------+---------+-------------+----------------------+------------+------------+----------|
|   -128 |  -32768 | -2147483648 | -9223372036854775808 |    1.23456 |    1.23457 | first    |
|    127 |   32767 |  2147483647 |  9223372036854775807 |  nan       |  nan       | second   |
|      0 |       0 |           0 |                    0 | -inf       | -inf       | third    |
|      0 |       0 |           0 |                    0 |  inf       |  inf       | fourth   |
+--------+---------+-------------+----------------------+------------+------------+----------+

Este es un ejemplo del resultado devuelto por neptune.read mediante la siguiente consulta:

aws neptunedata execute-open-cypher-query \
--open-cypher-query "CALL neptune.read({source: '<s3 path>', format: 'parquet'}) YIELD row RETURN row" \
--endpoint-url https://my-cluster-name.cluster-abcdefgh1234.us-east-1.neptune.amazonaws.com:8182

{
 "results": [{
 "row": {
 "Float": 1.23456,
 "Byte": -128,
 "Int": -2147483648,
 "Long": -9223372036854775808,
 "String": "first",
 "Short": -32768,
 "Double": 1.2345678899999999
 }
 }, {
 "row": {
 "Float": "NaN",
 "Byte": 127,
 "Int": 2147483647,
 "Long": 9223372036854775807,
 "String": "second",
 "Short": 32767,
 "Double": "NaN"
 }
 }, {
 "row": {
 "Float": "-INF",
 "Byte": 0,
 "Int": 0,
 "Long": 0,
 "String": "third",
 "Short": 0,
 "Double": "-INF"
 }
 }, {
 "row": {
 "Float": "INF",
 "Byte": 0,
 "Int": 0,
 "Long": 0,
 "String": "fourth",
 "Short": 0,
 "Double": "INF"
 }
 }]
}

Actualmente, no hay forma de establecer una etiqueta de nodo o borde en un campo de datos procedente de un archivo Parquet. Se recomienda dividir las consultas en varias consultas, una para cada etiqueta/tipo.

CALL neptune.read({source: '<s3 path>', format: 'parquet'})
 YIELD row 
WHERE row.`~label` = 'airport'
CREATE (n:airport)

CALL neptune.read({source: '<s3 path>', format: 'parquet'})
YIELD row 
WHERE row.`~label` = 'country'
CREATE (n:country)