Validation des mappages de données

Les données sont répliquées vers OpenSearch à partir de Neptune selon le processus suivant :

Si un mappage pour le champ en question est déjà présent dans OpenSearch :
- Si les données peuvent être converties en toute sécurité dans le mappage existant à l'aide des règles de validation des données, stockez le champ dans OpenSearch.
- Si ce n'est pas le cas, abandonnez l'enregistrement de mise à jour du flux correspondant.
S'il n'existe aucun mappage pour le champ en question, recherchez un type de données OpenSearch correspondant au type de données du champ dans Neptune.
- Si les données du champ peuvent être converties en toute sécurité en type de données OpenSearch à l'aide des règles de validation des données, stockez le nouveau mappage et les nouvelles données de champ dans OpenSearch.
- Si ce n'est pas le cas, abandonnez l'enregistrement de mise à jour du flux correspondant.

Les valeurs sont validées par rapport aux types OpenSearch équivalents ou aux mappages OpenSearch existants plutôt qu'aux types Neptune. Par exemple, la validation de la valeur "123" dans "123"^^xsd:int est effectuée par rapport au type long plutôt qu'au type int.

Bien que Neptune essaie de répliquer toutes les données dans OpenSearch, il arrive que les types de données dans OpenSearch soient totalement différents de ceux de Neptune. Dans ce cas, les enregistrements sont ignorés au lieu d'être indexés dans OpenSearch.

Par exemple, dans Neptune, une propriété peut avoir plusieurs valeurs de différents types, alors que dans OpenSearch, un champ doit avoir le même type dans l'ensemble de l'index.

En activant les journaux de débogage, vous pouvez voir quels enregistrements ont été abandonnés lors de l'exportation entre Neptune et OpenSearch. Voici un exemple d'entrée du journal de débogage :


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

Les types de données sont validés comme suit :

text : toutes les valeurs dans Neptune peuvent être mappées en toute sécurité avec du texte dans OpenSearch.
long : les règles suivantes pour les types de données Neptune s'appliquent lorsque le type de mappage OpenSearch est long (dans les exemples ci-dessous, on suppose que "testLong" possède un type de mappage long) :
- boolean : non valide, ne peut pas être converti, et l'enregistrement de mise à jour du flux correspondant est supprimé.
  
  Voici des exemples Gremlin non valides :
```
  "testLong" : true.
  "testLong" : false.
```
  Voici des exemples SPARQL non valides :
```
  ":testLong" : "true"^^xsd:boolean
  ":testLong" : "false"^^xsd:boolean
```
- datetime : non valide, ne peut pas être converti, et l'enregistrement de mise à jour du flux correspondant est supprimé.
  
  Voici un exemple Gremlin non valide :
```
  ":testLong" :  datetime('2018-11-04T00:00:00').
```
  Voici un exemple SPARQL non valide :
```
  ":testLong" : "2016-01-01"^^xsd:date
```
- float, double ou decimal : si la valeur dans Neptune est un entier pouvant contenir 64 bits, elle est valide et est stockée dans OpenSearch sous forme longue, mais si elle comporte une partie fractionnaire, s'il s'agit d'une valeur NaN ou INF, ou si elle est supérieure à 9 223 372 036 854 775 807 ou inférieure à -9 223 372 036 854 775 808, elle n'est pas valide, et l'enregistrement de mise à jour du flux correspondant est abandonné.
  
  Voici des exemples Gremlin valides :
```
  "testLong" :  145.0.
  ":testLong" :  123
  ":testLong" :  -9223372036854775807
```
  Voici des exemples SPARQL valides :
```
  ":testLong" : "145.0"^^xsd:float
  ":testLong" :  145.0
  ":testLong" : "145.0"^^xsd:double
  ":testLong" : "145.0"^^xsd:decimal
  ":testLong" : "-9223372036854775807"
```
  Voici des exemples Gremlin non valides :
```
  "testLong" :  123.45
  ":testLong" :  9223372036854775900
```
  Voici des exemples SPARQL non valides :
```
  ":testLong" :  123.45
  ":testLong" :  9223372036854775900
  ":testLong" : "123.45"^^xsd:float
  ":testLong" : "123.45"^^xsd:double
  ":testLong" : "123.45"^^xsd:decimal
```
- string : si la valeur dans Neptune est une représentation sous forme de chaîne d'un entier pouvant être contenu dans un entier de 64 bits, elle est valide et est convertie en long dans OpenSearch. Toute autre valeur de chaîne n'est pas valide pour un mappage Elasticsearch long, et l'enregistrement de mise à jour du flux correspondant est abandonné.
  
  Voici des exemples Gremlin valides :
```
  "testLong" :  "123".
  ":testLong" :  "145.0"
  ":testLong" :  "-9223372036854775807"
```
  Voici des exemples SPARQL valides :
```
  ":testLong" : "145.0"^^xsd:string
  ":testLong" : "-9223372036854775807"^^xsd:string
```
  Voici des exemples Gremlin non valides :
```
  "testLong" :  "123.45"
  ":testLong" :  "9223372036854775900"
  ":testLong" :  "abc"
```
  Voici des exemples SPARQL non valides :
```
  ":testLong" : "123.45"^^xsd:string
  ":testLong" : "abc"
  ":testLong" : "9223372036854775900"^^xsd:string
```
double : si le type de mappage OpenSearch est double, les règles suivantes s'appliquent (ici, il est présumé que le champ « TestDouble » possède un mappage double dans OpenSearch) :
- boolean : non valide, ne peut pas être converti, et l'enregistrement de mise à jour du flux correspondant est supprimé.
  
  Voici des exemples Gremlin non valides :
```
  "testDouble" : true.
  "testDouble" : false.
```
  Voici des exemples SPARQL non valides :
```
  ":testDouble" : "true"^^xsd:boolean
  ":testDouble" : "false"^^xsd:boolean
```
- datetime : non valide, ne peut pas être converti, et l'enregistrement de mise à jour du flux correspondant est supprimé.
  
  Voici un exemple Gremlin non valide :
```
  ":testDouble" :  datetime('2018-11-04T00:00:00').
```
  Voici un exemple SPARQL non valide :
```
  ":testDouble" : "2016-01-01"^^xsd:date
```
- NaN ou INF à virgule flottante : si la valeur dans SPARQL est une valeur NaN ou INF à virgule flottante, elle n'est pas valide, et l'enregistrement de mise à jour du flux correspondant est abandonné.
  
  Voici des exemples SPARQL non valides :
```
"  :testDouble" : "NaN"^^xsd:float
  ":testDouble" : "NaN"^^double
  ":testDouble" : "INF"^^double
  ":testDouble" : "-INF"^^double
```
- Nombre ou chaîne numérique : si la valeur dans Neptune est un autre nombre ou une autre représentation de chaîne numérique d'un nombre pouvant être exprimé en toute sécurité en tant que double, elle est valide et est convertie en double dans OpenSearch. Toute autre valeur de chaîne n'est pas valide pour un mappage double OpenSearch, et l'enregistrement de mise à jour du flux correspondant est abandonné.
  
  Voici des exemples Gremlin valides :
```
  "testDouble" :  123
  ":testDouble" :  "123"
  ":testDouble" :  145.67
  ":testDouble" :  "145.67"
```
  Voici des exemples SPARQL valides :
```
  ":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
```
  Voici un exemple Gremlin non valide :
```
  ":testDouble" :  "abc"
```
  Voici un exemple SPARQL non valide :
```
  ":testDouble" : "abc"
```

date : si le type de mappage OpenSearch est date, les valeurs Neptune date et dateTime sont valides, de même que toute valeur de chaîne pouvant être analysée avec succès dans un format dateTime.

Voici des exemples valides dans Gremlin ou 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"

Voici des exemples non valides :


  123.45
  True
  "abc"

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Mappage des types de données

Exemples de requêtes