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à.

# Esempi di filtro dei dati esportati
<a name="export-filtering-examples"></a>

Di seguito sono riportati alcuni esempi che illustrano i modi per filtrare i dati esportati.

## Filtro dell'esportazione dei dati del grafo delle proprietà
<a name="export-property-graph-filtering-examples"></a>

### Esempio di utilizzo di `scope` per esportare solo gli archi
<a name="export-property-graph-filtering-scope-example"></a>

```
{
  "command": "export-pg",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "scope": "edges"
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

### Esempio di utilizzo di `nodeLabels` e `edgeLabels` per esportare solo nodi e archi con etichette specifiche
<a name="export-property-graph-filtering-labels-example"></a>

Il parametro `nodeLabels` nell'esempio seguente specifica che devono essere esportati solo i nodi con un'etichetta `Person` o `Post`. Il parametro `edgeLabels` specifica che devono essere esportati solo gli archi con un'etichetta `likes`:

```
{
  "command": "export-pg",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "nodeLabels": ["Person", "Post"],
    "edgeLabels": ["likes"]
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

### Esempio di utilizzo di `filter` per esportare solo i nodi, gli archi e le proprietà specificati
<a name="export-property-graph-filtering-filter-example"></a>

L'oggetto `filter` in questo esempio esporta i nodi `country` i nodi con le relative proprietà `type`, `code` e `desc` e anche gli archi `route` con la relativa proprietà `dist`.

```
{
  "command": "export-pg",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "filter": {
      "nodes": [
        {
          "label": "country",
          "properties": [
            "type",
            "code",
            "desc"
          ]
        }
      ],
      "edges": [
        {
          "label": "route",
          "properties": [
            "dist"
          ]
        }
      ]
    }
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

### Esempio che utilizza `gremlinFilter`.
<a name="export-property-graph-filtering-gremlinFilter-example"></a>

Questo esempio utilizza `gremlinFilter` per esportare solo i nodi e gli archi creati dopo il 2021-10-10 (ovvero, con una proprietà `created` il cui valore è maggiore del 2021-10-10):

```
{
  "command": "export-pg",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "gremlinFilter" : "has(\"created\", gt(datetime(\"2021-10-10\")))"
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

### Esempio che utilizza `gremlinNodeFilter`.
<a name="export-property-graph-filtering-gremlinNodeFilter-example"></a>

Questo esempio utilizza `gremlinNodeFilter` per esportare solo i nodi eliminati (nodi con una proprietà `deleted` booleana il cui valore è `true`):

```
{
  "command": "export-pg",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "gremlinNodeFilter" : "has(\"deleted\", true)"
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

### Esempio che utilizza `gremlinEdgeFilter`.
<a name="export-property-graph-filtering-gremlinEdgeFilter-example"></a>

Questo esempio usa `gremlinEdgeFilter ` per esportare solo gli archi con una proprietà `strength` numerica il cui valore è 5:

```
{
  "command": "export-pg",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "gremlinEdgeFilter" : "has(\"strength\", 5)"
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

### Combinazione di `filter`, `gremlinNodeFilter`, `nodeLabels`, `edgeLabels` e `scope`
<a name="export-property-graph-filtering-combo-example"></a>

L'oggetto `filter` in questo esempio esporta:
+ nodi `country` con le relative proprietà `type`, `code` e `desc`
+ nodi `airport` con le relative proprietà `code`, `icao` e `runways`
+ archi `route` con la relativa proprietà `dist`

Il parametro `gremlinNodeFilter` filtra i nodi in modo che vengano esportati solo i nodi con una proprietà `code` il cui valore inizia con A.

I parametri `nodeLabels` e `edgeLabels` limitano ulteriormente l'output in modo che vengano esportati solo i nodi `airport` e gli archi `route`.

Infine, il parametro `scope` elimina gli spigoli dall'esportazione, lasciando nell'output solo i nodi `airport` designati.

```
{
  "command": "export-pg",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "filter": {
      "nodes": [
        {
          "label": "airport",
          "properties": [
            "code",
            "icao",
            "runways"
          ]
        },
        {
          "label": "country",
          "properties": [
            "type",
            "code",
            "desc"
          ]
        }
      ],
      "edges": [
        {
          "label": "route",
          "properties": [
            "dist"
          ]
        }
      ]
    },
    "gremlinNodeFilter": "has(\"code\", startingWith(\"A\"))",
    "nodeLabels": [
      "airport"
    ],
    "edgeLabels": [
      "route"
    ],
    "scope": "nodes"
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

## Filtro dell'esportazione dei dati RDF
<a name="export-RDF-filtering-examples"></a>

### Utilizzo di `rdfExportScope` e `sparql` per esportare archi specifici
<a name="export-RDF-filtering-rdfExportScope-sparql-example"></a>

Questo esempio esporta triple il cui predicato è < http://kelvinlawrence. net/air-routes/objectProperty/route> e il cui oggetto non è un valore letterale:

```
{
  "command": "export-rdf",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "rdfExportScope": "query",
    "sparql": "CONSTRUCT { ?s <http://kelvinlawrence.net/air-routes/objectProperty/route> ?o } WHERE { ?s ?p ?o . FILTER(!isLiteral(?o)) }"
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```

### Utilizzo `namedGraph` per esportare un singolo grafico denominato
<a name="export-RDF-filtering-rdfExportScope-sparql-namedGraph-example"></a>

Questo esempio esporta le triple appartenenti al grafico denominato < http://aws.amazon. com/neptune/vocab/v01/DefaultNamedGraph>:

```
{
  "command": "export-rdf",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "rdfExportScope": "graph",
    "namedGraph": "http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph"
  },
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export"
}
```