Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Formati di serializzazione in Neptune Streams
Formati di record Streams

Amazon Neptune utilizza due diversi formati per la serializzazione dei dati delle modifiche al grafo in flussi di log, a seconda che il grafo sia stato creato utilizzando Gremlin o SPARQL.

Entrambi i formati condividono un formato di serializzazione dei record comune, come descritto in [Formato della risposta API di Neptune Streams](streams-using-api-reponse.md), che contiene i seguenti campi:
+ `commitTimestamp`: l'ora in cui è stato richiesto il commit per la transazione, in millisecondi dall'epoca Unix.
+ `eventId`: identificatore di sequenza del record di modifica del flusso.
+ `data`— Il record serializzato Gremlin, SPARQL o Change. OpenCypher I formati di serializzazione di ciascun record sono descritti più dettagliatamente nelle sezioni successive.
+ `op`: operazione che ha creato la modifica.

**Topics**
+ [

## Formato di serializzazione delle modifiche PG\$1JSON
](#streams-change-formats-gremlin)
+ [

## Formato di serializzazione della modifica SPARQL NQUADS
](#streams-change-formats-sparql)

## Formato di serializzazione delle modifiche PG\$1JSON
PG\$1JSON

**Nota**  
Il formato di output del flusso Gremlin (`GREMLIN_JSON`) emesso dal Gremlin stream endpoint () è obsoleto. `https://Neptune-DNS:8182/gremlin/stream` È stato sostituito da PG\$1JSON, che attualmente è identico a `GREMLIN_JSON`.

Un record di modifica Gremlin o openCypher, contenuto nel campo `data` di una risposta del flusso di log, dispone dei seguenti campi:
+ `id`: stringa, obbligatorio.

  L'ID dell'elemento Gremlin o openCypher.
+ `type`: stringa, obbligatorio.

  Il tipo di questo elemento Gremlin o openCypher. Deve essere uno dei seguenti:
  + `vl`: etichetta di vertice per Gremlin; etichetta di nodo per openCypher.
  + `vp`: proprietà di vertice per Gremlin; proprietà di nodo per openCypher.
  + `e`: arco ed etichetta di arco per Gremlin; relazione e tipo di relazione per openCypher.
  + `ep`: proprietà di arco per Gremlin; proprietà di relazione per openCypher.
+ `key`: stringa, obbligatorio.

  Il nome della proprietà. Per le etichette degli elementi, questo è "label".
+ `value`: oggetto `value`, obbligatorio.

  Si tratta di un oggetto JSON che contiene un campo `value` per il valore stesso e un campo `datatype` per il tipo di dati JSON di tale valore.

  ```
    "value": {
      "value": "the new value",
      "dataType": "the JSON datatype of the new value"
    }
  ```
+ `from`: stringa, facoltativo.

  Se si tratta di un arco (tipo="e"), è l'ID del vertice *from* o del nodo di origine corrispondente.
+ `to`: stringa, facoltativo.

  Se si tratta di un arco (tipo="e"), ID del vertice *to* corrispondente o del nodo di destinazione.

**Esempi di Gremlin**
+ Di seguito è riportato un esempio di un'etichetta del vertice Gremlin.

  ```
  {
    "id": "an ID string",
    "type": "vl",
    "key": "label",
    "value": {
      "value": "the new value of the vertex label",
      "dataType": "String"
    }
  }
  ```
+ Di seguito è riportato un esempio di una proprietà del vertice Gremlin.

  ```
  {
    "id": "an ID string",
    "type": "vp",
    "key": "the property name",
    "value": {
      "value": "the new value of the vertex property",
      "dataType": "the datatype of the vertex property"
    }
  }
  ```
+ Di seguito è riportato un esempio di un edge Gremlin.

  ```
  {
    "id": "an ID string",
    "type": "e",
    "key": "label",
    "value": {
      "value": "the new value of the edge",
      "dataType": "String"
    },
    "from": "the ID of the corresponding "from" vertex",
    "to": "the ID of the corresponding "to" vertex"
  }
  ```

**Esempi di openCypher**
+ Il seguente è un esempio di etichetta di nodo openCypher.

  ```
  {
    "id": "an ID string",
    "type": "vl",
    "key": "label",
    "value": {
      "value": "the new value of the node label",
      "dataType": "String"
    }
  }
  ```
+ Il seguente è un esempio di proprietà di nodo openCypher.

  ```
  {
    "id": "an ID string",
    "type": "vp",
    "key": "the property name",
    "value": {
      "value": "the new value of the node property",
      "dataType": "the datatype of the node property"
    }
  }
  ```
+ Il seguente è un esempio di relazione openCypher.

  ```
  {
    "id": "an ID string",
    "type": "e",
    "key": "label",
    "value": {
      "value": "the new value of the relationship",
      "dataType": "String"
    },
    "from": "the ID of the corresponding source node",
    "to": "the ID of the corresponding target node"
  }
  ```

## Formato di serializzazione della modifica SPARQL NQUADS
RDF-NQUADS

Neptune registra le modifiche ai quad SPARQL nel grafo utilizzando il linguaggio `N-QUADS` di Resource Description Framework (RDF) definito nella specifica [W3C RDF 1.1 N-Quads](https://www.w3.org/TR/n-quads/).

Il campo `data` nel record di modifica contiene semplicemente un campo `stmt` che contiene un'istruzione N-QUADS che esprime il quad modificato, come nell'esempio seguente.

```
  "stmt" : "<https://test.com/s> <https://test.com/p> <https://test.com/o> .\n"
```