Validación de mapeos de datos

Los datos se replican a OpenSearch desde Neptune mediante este proceso:

Si ya hay un mapeo del campo en cuestión en OpenSearch:
- Si los datos se pueden convertir de forma segura al mapeo existente mediante reglas de validación de datos, guarde el campo en OpenSearch.
- Si no es así, borre el registro de actualización del flujo correspondiente.
Si no existe ningún mapeo para el campo en cuestión, busque un tipo de datos de OpenSearch que corresponda al tipo de dato del campo en Neptune.
- Si los datos del campo se pueden convertir de forma segura al tipo de dato de OpenSearch mediante reglas de validación de datos, almacene los nuevos datos de mapeo y campo en OpenSearch.
- Si no es así, borre el registro de actualización del flujo correspondiente.

Los valores se validan con los tipos de OpenSearch equivalentes o mapeos de OpenSearch existentes en lugar de con los tipos de Neptune. Por ejemplo, la validación del valor "123" en "123"^^xsd:int se realiza en función del tipo long y no del tipo int.

Aunque Neptune intenta replicar todos los datos en OpenSearch, hay casos en los que los tipos de datos de OpenSearch son totalmente diferentes de los de Neptune y, en esos casos, los registros se omiten en lugar de indexarse en OpenSearch.

Por ejemplo, en Neptune, una propiedad puede tener varios valores de distintos tipos, mientras que en OpenSearch un campo debe tener el mismo tipo en todo el índice.

Al habilitar los registros de depuración, puede ver qué registros se han eliminado durante la exportación de Neptune a OpenSearch. Este es un ejemplo de entrada en el registro de depuración:


Dropping Record : Data type not a valid Gremlin type 
<Record>

Los tipos de datos se validan de la siguiente manera:

text: todos los valores de Neptune se pueden mapear de forma segura a texto en OpenSearch.
long: las siguientes reglas para los tipos de datos de Neptune se aplican cuando el tipo de mapeo de OpenSearch es largo (en los ejemplos siguientes, se supone que "testLong" tiene un tipo de mapeo long):
- boolean: no es válido, no se puede convertir y se elimina el registro de actualización del flujo correspondiente.
  
  Estos son algunos ejemplos de Gremlin no válidos:
```
  "testLong" : true.
  "testLong" : false.
```
  Estos son algunos ejemplos de SPARQL no válidos:
```
  ":testLong" : "true"^^xsd:boolean
  ":testLong" : "false"^^xsd:boolean
```
- datetime: no es válido, no se puede convertir y se elimina el registro de actualización del flujo correspondiente.
  
  Este es un ejemplo de un valor de Gremlin no válido:
```
  ":testLong" :  datetime('2018-11-04T00:00:00').
```
  Este es un ejemplo de un valor de SPARQL no válido:
```
  ":testLong" : "2016-01-01"^^xsd:date
```
- float,double o decimal: si el valor de Neptune es un número entero que puede caber en 64 bits, es válido y se almacena en OpenSearch como long, pero si tiene una parte de fracción, es un NaN o un INF, o es mayor que 9.223.372.036.854.775.807 o menor que -9.223.372.036.854.775.808, entonces no es válido y se elimina el registro de actualización de flujo correspondiente.
  
  Estos son algunos ejemplos de valores de Gremlin válidos:
```
  "testLong" :  145.0.
  ":testLong" :  123
  ":testLong" :  -9223372036854775807
```
  Estos son algunos ejemplos de SPARQL válidos:
```
  ":testLong" : "145.0"^^xsd:float
  ":testLong" :  145.0
  ":testLong" : "145.0"^^xsd:double
  ":testLong" : "145.0"^^xsd:decimal
  ":testLong" : "-9223372036854775807"
```
  Estos son algunos ejemplos de Gremlin no válidos:
```
  "testLong" :  123.45
  ":testLong" :  9223372036854775900
```
  Estos son algunos ejemplos de SPARQL no válidos:
```
  ":testLong" :  123.45
  ":testLong" :  9223372036854775900
  ":testLong" : "123.45"^^xsd:float
  ":testLong" : "123.45"^^xsd:double
  ":testLong" : "123.45"^^xsd:decimal
```
- string: si el valor de Neptune es una representación en cadena de un entero que puede estar contenido en un entero de 64 bits, entonces es válido y se convierte en long en OpenSearch. Cualquier otro valor de cadena no es válido para un mapeo long de Elasticseearch y se elimina el registro de actualización del flujo correspondiente.
  
  Estos son algunos ejemplos de valores de Gremlin válidos:
```
  "testLong" :  "123".
  ":testLong" :  "145.0"
  ":testLong" :  "-9223372036854775807"
```
  Estos son algunos ejemplos de SPARQL válidos:
```
  ":testLong" : "145.0"^^xsd:string
  ":testLong" : "-9223372036854775807"^^xsd:string
```
  Estos son algunos ejemplos de Gremlin no válidos:
```
  "testLong" :  "123.45"
  ":testLong" :  "9223372036854775900"
  ":testLong" :  "abc"
```
  Estos son algunos ejemplos de SPARQL no válidos:
```
  ":testLong" : "123.45"^^xsd:string
  ":testLong" : "abc"
  ":testLong" : "9223372036854775900"^^xsd:string
```
double: si el tipo de mapeo de OpenSearch es double, se aplican las siguientes reglas (en este caso, se supone que el campo "testDouble" tiene un mapeo double en OpenSearch):
- boolean: no es válido, no se puede convertir y se elimina el registro de actualización del flujo correspondiente.
  
  Estos son algunos ejemplos de Gremlin no válidos:
```
  "testDouble" : true.
  "testDouble" : false.
```
  Estos son algunos ejemplos de SPARQL no válidos:
```
  ":testDouble" : "true"^^xsd:boolean
  ":testDouble" : "false"^^xsd:boolean
```
- datetime: no es válido, no se puede convertir y se elimina el registro de actualización del flujo correspondiente.
  
  Este es un ejemplo de un valor de Gremlin no válido:
```
  ":testDouble" :  datetime('2018-11-04T00:00:00').
```
  Este es un ejemplo de un valor de SPARQL no válido:
```
  ":testDouble" : "2016-01-01"^^xsd:date
```
- NaN o INF de punto flotante: si el valor de SPARQL es un NaN o INF de punto flotante, entonces no es válido y se elimina el registro de actualización del flujo correspondiente.
  
  Estos son algunos ejemplos de SPARQL no válidos:
```
"  :testDouble" : "NaN"^^xsd:float
  ":testDouble" : "NaN"^^double
  ":testDouble" : "INF"^^double
  ":testDouble" : "-INF"^^double
```
- number o cadena numérica: si el valor de Neptune es cualquier otro número o cadena numérica que represente un número que se pueda expresar de forma segura como double, entonces es válido y se convierte en double en OpenSearch. Cualquier otro valor de cadena no es válido para un mapeo double de OpenSearch y se elimina el registro de actualización del flujo correspondiente.
  
  Estos son algunos ejemplos de valores de Gremlin válidos:
```
  "testDouble" :  123
  ":testDouble" :  "123"
  ":testDouble" :  145.67
  ":testDouble" :  "145.67"
```
  Estos son algunos ejemplos de SPARQL válidos:
```
  ":testDouble" :  123.45
  ":testDouble" :  145.0
  ":testDouble" : "123.45"^^xsd:float
  ":testDouble" : "123.45"^^xsd:double
  ":testDouble" : "123.45"^^xsd:decimal
  ":testDouble" : "123.45"^^xsd:string
```
  Este es un ejemplo de un valor de Gremlin no válido:
```
  ":testDouble" :  "abc"
```
  Estos son algunos ejemplos de SPARQL no válidos:
```
  ":testDouble" : "abc"
```

date: si el tipo de mapeo de OpenSearch es date, los valores de date y dateTime de Neptune son válidos, al igual que cualquier valor de cadena que se pueda analizar correctamente en un formato dateTime.

Estos son algunos ejemplos de valores válidos en Gremlin o SPARQL:


  Date(2016-01-01)
  "2016-01-01" "
  2003-09-25T10:49:41"
  "2003-09-25T10:49"
  "2003-09-25T10"
  "20030925T104941-0300"
  "20030925T104941"
  "2003-Sep-25" "
  Sep-25-2003"
  "2003.Sep.25"
  "2003/09/25"
  "2003 Sep 25" "
  Wed, July 10, '96"
  "Tuesday, April 12, 1952 AD 3:30:42pm PST"
  "123"
  "-123"
  "0"
  "-0"
  "123.00"
  "-123.00"

Estos son ejemplos de valores no válidos:


  123.45
  True
  "abc"

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Mapeo de tipos de datos

Consultas de ejemplo