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á.
# Usar SPARQL UPDATE LOAD para importar dados para o Neptune
A sintaxe do comando SPARQL UPDATE LOAD é especificada na [recomendação de atualização do SPARQL 1.1](https://www.w3.org/TR/sparql11-update/#load):
```
LOAD SILENT (URL of data to be loaded) INTO GRAPH (named graph into which to load the data)
```
+ **`SILENT`**: (*opcional*) faz com que a operação seja bem-sucedida mesmo que tenha ocorrido um erro durante o processamento.
Isso pode ser útil quando uma única transação contém várias declarações, como `"LOAD ...; LOAD ...; UNLOAD ...; LOAD ...;"` e você deseja que a transação seja concluída mesmo que alguns dos dados remotos não possam ser processados.
+ *URL of data to be loaded*— (*Obrigatório*) Especifica um arquivo de dados remoto contendo dados a serem carregados em um gráfico.
O arquivo remoto deve ter uma das seguintes extensões:
+ `.nt`para NTriples.
+ `.nq`para NQuads.
+ `.trig` para Trig.
+ `.rdf` para RDF/XML.
+ `.ttl` para Turtle.
+ `.n3` para N3.
+ `.jsonld` para JSON-LD.
+ **`INTO GRAPH`***(named graph into which to load the data)*— (*Opcional*) Especifica o gráfico no qual os dados devem ser carregados.
O Neptune associa cada triplo a um grafo nomeado. É possível especificar o grafo nomeado padrão usando o URI do grafo nomeado de fallback, `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`, da seguinte forma:
```
INTO GRAPH
```
**nota**
Quando você precisar carregar muitos dados, recomendamos usar o carregador em massa do Neptune em vez de UPDATE LOAD. Para obter mais informações sobre o carregador em massa, consulte [Usar o carregador em massa do Amazon Neptune para ingerir dados](bulk-load.md).
É possível usar `SPARQL UPDATE LOAD` para carregar dados diretamente do Amazon S3 ou de arquivos obtidos de um servidor da web hospedado automaticamente. Os recursos a serem carregados devem residir na mesma região que o servidor do Neptune, e o endpoint para os recursos deve ter permissão na VPC. Para obter informações sobre como criar um endpoint do Amazon S3, consulte [Criar o endpoint da VPC do Amazon S3](bulk-load-data.md#bulk-load-prereqs-s3).
Tudo `SPARQL UPDATE LOAD` URIs deve começar com`https://`. Isso inclui o Amazon S3 URLs.
Ao contrário do carregador em massa do Neptune, uma chamada para `SPARQL UPDATE LOAD` é totalmente transacional.
**Carregar arquivos diretamente do Amazon S3 no Neptune usando SPARQL UPDATE LOAD**
Como o Neptune não permite que você transmita um perfil do IAM para o Amazon S3 ao usar SPARQL UPDATE LOAD, o bucket do Amazon S3 em questão deve ser público ou você deve usar um [URL do Amazon S3 pré-assinado](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) na consulta LOAD.
Para gerar uma URL pré-assinada para um arquivo Amazon S3, você pode usar AWS CLI um comando como este:
```
aws s3 presign --expires-in (number of seconds) s3://(bucket name)/(path to file of data to load)
```
Depois, é possível usar o URL pré-assinado resultante no comando `LOAD`:
```
curl https://(a Neptune endpoint URL):8182/sparql \
--data-urlencode 'update=load (pre-signed URL of the remote Amazon S3 file of data to be loaded) \
into graph (named graph)'
```
Para obter mais informações, consulte [Autenticação de solicitações: usando parâmetros de consulta](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html). A [documentação do Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/s3-presigned-urls.html) mostra como usar um script Python para gerar um URL pré-assinado.
Além disso, o tipo de conteúdo dos arquivos a serem carregados deve ser definido corretamente.
1. Defina o tipo de conteúdo de arquivos ao fazer upload deles no Amazon S3 usando o parâmetro `-metadata`, como:
```
aws s3 cp test.nt s3://bucket-name/my-plain-text-input/test.nt --metadata Content-Type=text/plain
aws s3 cp test.rdf s3://bucket-name/my-rdf-input/test.rdf --metadata Content-Type=application/rdf+xml
```
1. Confirme se as informações de tipo de mídia estão realmente presentes. Execute:
```
curl -v bucket-name/folder-name
```
A saída desse comando deve mostrar as informações de tipo de mídia que você define ao carregar os arquivos.
1. Depois, você pode usar o comando `SPARQL UPDATE LOAD` para importar esses arquivos para o Neptune:
```
curl https://your-neptune-endpoint:port/sparql \
-d "update=LOAD "
```
As etapas acima funcionam apenas para um bucket público do Amazon S3 ou para um bucket que você acessa usando um [URL do Amazon S3 pré-assinado](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) na consulta LOAD.
Você também pode configurar um servidor de proxy web para carregar a partir de um bucket privado do Amazon S3, conforme mostrado abaixo:
**Usar um servidor da web para carregar arquivos no Neptune com SPARQL UPDATE LOAD**
1. Instale um servidor da web em uma máquina em execução na VPC que está hospedando Neptune e os arquivos a serem carregados. Por exemplo, usando o Amazon Linux, você pode instalar o Apache da seguinte forma:
```
sudo yum install httpd mod_ssl
sudo /usr/sbin/apachectl start
```
1. Defina os tipos MIME do conteúdo do arquivo RDF que você carregar. O SPARQL usa o cabeçalho `Content-type` enviado pelo servidor da Web para determinar o formato de entrada do conteúdo, portanto, é necessário definir tipos MIME relevantes para o servidor da Web.
Por exemplo, suponha que você use as seguintes extensões de arquivo para identificar formatos de arquivo:
+ `.nt`para NTriples.
+ `.nq`para NQuads.
+ `.trig` para Trig.
+ `.rdf` para RDF/XML.
+ `.ttl` para Turtle.
+ `.n3` para N3.
+ `.jsonld` para JSON-LD.
Se você estiver usando o Apache 2 como servidor da Web, edite o arquivo `/etc/mime.types` e adicione os seguintes tipos:
```
text/plain nt
application/n-quads nq
application/trig trig
application/rdf+xml rdf
application/x-turtle ttl
text/rdf+n3 n3
application/ld+json jsonld
```
1. Confirme se o mapeamento do tipo MIME funciona. Quando você tiver o servidor da Web em execução e hospedando arquivos RDF nos formatos de sua escolha, poderá testar a configuração enviando uma solicitação para o servidor da Web do seu host local.
Por exemplo, você pode enviar uma solicitação como esta:
```
curl -v http://localhost:80/test.rdf
```
Em seguida, na saída detalhada de `curl`, você deve ver uma linha como:
```
Content-Type: application/rdf+xml
```
Isso mostra que o mapeamento de tipo de conteúdo foi definido com êxito.
1. Agora você está com tudo pronto para carregar dados usando o comando SPARQL UDPATE:
```
curl https://your-neptune-endpoint:port/sparql \
-d "update=LOAD "
```
**nota**
O uso de `SPARQL UPDATE LOAD` pode acionar um tempo limite no servidor da Web quando o arquivo de origem que está sendo carregado é grande. O Neptune processa os dados do arquivo à medida que são transmitidos, e, para um arquivo grande, isso pode demorar mais do que o tempo limite configurado no servidor. Isso, por sua vez, pode fazer com que o servidor feche a conexão, o que pode gerar a seguinte mensagem de erro quando o Neptune encontrar um EOF inesperado no fluxo:
```
{
"detailedMessage":"Invalid syntax in the specified file",
"code":"InvalidParameterException"
}
```
Se receber essa mensagem e não acreditar que o arquivo de origem contenha uma sintaxe inválida, tente aumentar as definições de tempo limite no servidor da Web. Também é possível diagnosticar o problema ativando logs de depuração no servidor e procurando tempos limite.