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.

Ejemplos de consultas con parquet

El siguiente ejemplo de consulta devuelve el número de filas de un archivo de 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 descrita en el 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 lo que respecta a lo que hace con las filas leídas desde un archivo de Parquet. Por ejemplo, la siguiente consulta crea un nodo con un campo establecido en los datos del 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:

Neptune-specific tipos de datos:

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 Cualquier tipo, el tipo de fecha, el tipo de fecha y hora y el tipo de geometría. El siguiente objeto es un ejemplo de la anotación de metadatos requerida 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 de borde para un campo de datos procedente de un archivo de Parquet. Se recomienda dividir las consultas en varias consultas, una para cada una label/Type.

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)