As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Exemplos de consulta usando parquet
<a name="access-graph-opencypher-21-extensions-s3-read-parquet"></a>

O exemplo de consulta a seguir retorna o número de linhas em um determinado arquivo Parquet:

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

Você pode executar o exemplo de consulta usando a `execute-open-cypher-query` operação no AWS CLI executando o seguinte 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
```

Uma consulta pode ser flexível no que ela faz com linhas lidas de um arquivo Parquet. Por exemplo, a consulta a seguir cria um nó com um campo sendo definido para dados encontrados no arquivo Parquet:

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

**Atenção**  
Não é considerado uma boa prática usar uma grande cláusula produtora de resultados, como `MATCH(n)` antes de uma cláusula. `CALL` Isso levaria a uma consulta de longa duração, devido ao cruzamento entre soluções recebidas de cláusulas anteriores e as linhas lidas por neptune.read. É recomendável iniciar a consulta com `CALL` neptune.read.

## Tipos de colunas de parquet compatíveis
<a name="access-graph-opencypher-21-extensions-s3-read-parquet-column-types"></a>

**Tipos de dados de parquet:**
+ NULL
+ BOOLEAN
+ FLOAT
+ DOUBLE
+ STRING
+ INTEIRO ASSINADO: UINT8, UINT16, UINT32, UINT64
+ MAP: Suporta apenas um nível. Não oferece suporte a aninhados.
+ LISTA: Suporta apenas um nível. Não oferece suporte a aninhados.

**Neptune-specific tipos de dados:**

Ao contrário dos cabeçalhos das colunas de propriedades do formato CSV, os cabeçalhos das colunas de propriedades do formato Parquet precisam ter apenas os nomes das propriedades, portanto, não é necessário ter os nomes dos tipos nem a cardinalidade.

No entanto, existem alguns tipos de colunas especiais no formato Parquet que exigem anotações nos metadados, incluindo o tipo Qualquer tipo, o tipo Data, o tipo DateTime e o tipo Geometria. O objeto a seguir é um exemplo da anotação de metadados necessária para arquivos que contêm colunas desses tipos especiais:

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

Abaixo estão os detalhes sobre a carga útil esperada associada a esses tipos:
+ Um tipo de coluna Qualquer é suportado nas colunas do usuário. Um tipo Qualquer é um tipo de “açúcar sintático” para todos os outros tipos que oferecemos suporte. É extremamente útil se uma coluna de usuário tiver vários tipos. A carga útil de um valor de qualquer tipo é uma lista de strings json da seguinte forma:`{"value": "10", "type": "Int"};{"value": "1.0", "type": "Float"}`, que tem um campo de valor e um campo de tipo em cada string json individual. O valor de cardinalidade de uma coluna Qualquer é definido, o que significa que a coluna pode aceitar vários valores. 
  + O Neptune suporta os seguintes tipos em qualquer tipo: Bool (ou booleano), Byte, Short, Int, Long,,,,, Float, Double UnsignedByte UnsignedShort, Date UnsignedInt UnsignedLong, DateTime, String e Geometry.
  + O tipo de vetor não é suportado em Qualquer tipo.
  + Aninhado Qualquer tipo não é suportado. Por exemplo, .`{"value": {"value": "10", "type": "Int"}, "type": "Any"}`
+ As colunas do tipo Date e Datetime são suportadas nas colunas do usuário. A carga útil dessas colunas deve ser fornecida como strings seguindo o formato XSD ou um dos formatos abaixo: 
  + aaaa- MM-dd
  + aaaa- MM-ddTHH:mm
  + aaaa- MM-ddTHH:mm:ss
  + aaaa- MM-ddTHH:mm:ssZ
  + aaaa- MM-ddTHH:mm:ss.SSSZ
  + aaaa- MM-ddTHH:mm:ss [\+\|-] hhmm
  + aaaa- MM-ddTHH:mm:ss.SSS [\+\|-] hhmm
+ Um tipo de coluna Geometry é suportado nas colunas do usuário. A carga útil dessas colunas deve conter somente geometrias primitivas do tipo Point, fornecidas como cadeias de caracteres no Well-known formato de texto (WKT). Por exemplo, POINT (30 10) seria um valor de geometria válido.

## Exemplo de saída de parquet
<a name="sample-parquet-output"></a>

Dado um arquivo 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   |
+--------+---------+-------------+----------------------+------------+------------+----------+
```

Aqui está um exemplo da saída retornada por neptune.read usando a seguinte 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"
 }
 }]
}
```

Atualmente, não há como definir um rótulo de nó ou borda em um campo de dados proveniente de um arquivo Parquet. É recomendável particionar as consultas em várias consultas, uma para cada. 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)
```