Validación de mapeos de datos

Los datos se replican 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 él 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 OpenSearch datos correspondiente al tipo de datos del campo en Neptune.
- Si los datos del campo se pueden convertir de forma segura al OpenSearch tipo de datos mediante reglas de validación de datos, almacene los nuevos datos de mapeo y campo en él. OpenSearch
- Si no es así, borre el registro de actualización del flujo correspondiente.

Los valores se validan con OpenSearch tipos equivalentes o OpenSearch mapeos 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 Neptuno intenta replicar todos los datos OpenSearch, hay casos en los que los tipos de datos OpenSearch son totalmente diferentes a los de Neptuno y, en esos casos, los registros se omiten en lugar de indexarlos. 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 OpenSearch Neptune a. 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 asignar de forma segura al texto. OpenSearch
long— Las siguientes reglas para los tipos de datos de Neptune se aplican cuando el tipo de OpenSearch mapeo 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 Neptuno es un número entero que puede caber en 64 bits, es válido y se almacena OpenSearch como un largo, pero si tiene una parte fraccionaria, es un o un, o es mayor que 9.223.372.036.854.775.807 NaN o menor que -9.223.372.036.854.775.808INF, 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 un long in. 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 OpenSearch mapeo esdouble, se aplican las siguientes reglas (en este caso, se supone que el campo «TestDouble» tiene un double mapeo): 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
```
- número 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 undouble, entonces es válido y se convierte a in. double OpenSearch Cualquier otro valor de cadena no es válido para un OpenSearch double mapeo 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 OpenSearch mapeo esdate, Neptune date y el dateTime valor 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