Ajouter une colonne à l'aide d'une expression Signalement d'enregistrements cibles à l'aide d'une expression Réplication des en-têtes d’une table source à l'aide d'expressions Utilisation de SQLite fonctions pour créer des expressions Ajout de métadonnées à une table cible à l’aide d’expressions

Utilisation d'expressions de règle de transformation pour définir le contenu d’une colonne

Pour définir le contenu de colonnes nouvelles et existantes, vous pouvez utiliser une expression dans une règle de transformation. Par exemple, des expressions peuvent vous permettre d’ajouter une colonne ou de répliquer des en-têtes de table source à une cible. Vous pouvez également utiliser des expressions pour signaler des enregistrements des tables cibles comme insérés, mis à jour ou supprimés à la source.

Rubriques

Ajouter une colonne à l'aide d'une expression
Signalement d'enregistrements cibles à l'aide d'une expression
Réplication des en-têtes d’une table source à l'aide d'expressions
Utilisation de SQLite fonctions pour créer des expressions
Ajout de métadonnées à une table cible à l’aide d’expressions

Ajouter une colonne à l'aide d'une expression

Pour ajouter des colonnes à des tables à l'aide d'une expression dans une règle de transformation, utilisez une action de règle add-column et une cible de règle column.

L'exemple suivant ajoute une nouvelle colonne à la table ITEM. Il définit le nouveau nom de colonne sur FULL_NAME, avec un type de données string de 50 caractères. L'expression concatène les valeurs de deux colonnes existantes, FIRST_NAME et LAST_NAME, pour les évaluer selon FULL_NAME. schema-name, table-name et les paramètres d’expression font référence aux objets de la table de base de données source. Value et le bloc data-type font référence aux objets de la table de base de données cible.


{
    "rules": [
        {
            "rule-type": "selection", 
            "rule-id": "1",
            "rule-name": "1",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "%"
            },
            "rule-action": "include"
        },
        {
            "rule-type": "transformation",
            "rule-id": "2",
            "rule-name": "2",
            "rule-action": "add-column",
            "rule-target": "column",
            "object-locator": {
                "schema-name": "Test",
                "table-name": "ITEM"
            },
            "value": "FULL_NAME",
            "expression": "$FIRST_NAME||'_'||$LAST_NAME",
            "data-type": {
                 "type": "string",
                 "length": 50
            }
        }
    ]
}

Signalement d'enregistrements cibles à l'aide d'une expression

Pour signaler des enregistrements dans des tables cibles comme insérés, mis à jour ou supprimés dans la table source, utilisez une expression dans une règle de transformation. L'expression utilise une fonction operation_indicator pour signaler les enregistrements. Les enregistrements supprimés de la source ne sont pas supprimés de la cible. Au lieu de cela, l'enregistrement cible est signalé avec une valeur fournie par l'utilisateur pour indiquer qu'il a été supprimé de la source.

Note

La fonction operation_indicator fonctionne uniquement sur les tables qui ont une clé primaire à la fois sur les bases de données sources et cibles.

Par exemple, la règle de transformation suivante ajoute d'abord une nouvelle colonne Operation à une table cible. Elle met ensuite à jour la colonne avec la valeur D chaque fois qu'un enregistrement est supprimé d'une table source.


{
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "add-column",
      "value": "Operation",
      "expression": "operation_indicator('D', 'U', 'I')",
      "data-type": {
        "type": "string",
        "length": 50
      }
}

Réplication des en-têtes d’une table source à l'aide d'expressions

Par défaut, les en-têtes des tables sources ne sont pas répliqués sur la cible. Pour indiquer les en-têtes à répliquer, utilisez une règle de transformation avec une expression qui inclut l'en-tête de colonne du tableau.

Vous pouvez utiliser les en-têtes de colonne suivants dans les expressions.

En-tête	Valeur de la réplication continue	Valeur en pleine charge	Type de données
AR_H_STREAM_POSITION	Valeur de position du flux à partir de la source. Cette valeur peut être le numéro de modification système (SCN) ou le numéro de séquence de journal (LSN), selon le point de terminaison source.	Une chaîne vide.	CHAÎNE
AR_H_TIMESTAMP	Horodatage indiquant l'heure de la modification.	Horodatage indiquant l’heure à laquelle les données arrivent au niveau de la cible.	DATETIME (scale=7)
AR_H_COMMIT_TIMESTAMP	Un horodatage indiquant l'heure de la validation.	Horodatage indiquant l'heure actuelle.	DATETIME (scale=7)
AR_H_OPERATION	INSERT, UPDATE ou DELETE	INSERT	CHAÎNE
AR_H_USER	Nom d'utilisateur, ID ou toute autre information fournie par la source sur l'utilisateur qui a effectué la modification. Cet en-tête est pris en charge uniquement sur les points de terminaison source SQL Server et Oracle (version 11.2.0.3 et supérieure).	Transformation à appliquer à l'objet. Les actions de règle de transformation sont sensibles à la casse.	CHAÎNE
AR_H_CHANGE_SEQ	Nombre incrémentiel unique issu de la base de données source, composé d’un horodatage et d’un nombre incrémentiel automatique. La valeur dépend du système de base de données source.	Une chaîne vide.	CHAÎNE

Dans l'exemple suivant, une nouvelle colonne est ajoutée à la cible en utilisant la valeur de position du flux à partir de la source. Pour SQL Server, la valeur de position de flux est le LSN du point de terminaison source. Pour Oracle, la valeur de position de flux est le SCN du point de terminaison source.


{
      "rule-type": "transformation",
     "rule-id": "2",
      "rule-name": "2",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "add-column",
      "value": "transact_id",
      "expression": "$AR_H_STREAM_POSITION",
      "data-type": {
        "type": "string",
        "length": 50
      }
    }

L’exemple suivant ajoute une nouvelle colonne à la cible qui possède un nombre incrémentiel unique issu de la source. Cette valeur représente un nombre unique à 35 chiffres au niveau de la tâche. Les 16 premiers chiffres font partie d’un horodatage et les 19 derniers chiffres sont le numéro record_id incrémenté par le SGBD.


{
"rule-type": "transformation",
"rule-id": "2",
"rule-name": "2",
"rule-target": "column",
"object-locator": {
"schema-name": "%",
"table-name": "%"
},
"rule-action": "add-column",
"value": "transact_id",
"expression": "$AR_H_CHANGE_SEQ",
"data-type": {
"type": "string",
"length": 50
}
}

Utilisation de SQLite fonctions pour créer des expressions

Vous utilisez les paramètres de table pour spécifier les paramètres que vous souhaitez appliquer à la table ou à la vue sélectionnée pour une opération spécifiée. Les règles table-settings sont facultatives.

Note

Plutôt que d’utiliser des tables et des vues, les bases de données MongoDB et DocumentDB stockent les enregistrements de données sous forme de documents regroupés dans des collections. Ainsi, lors de la migration depuis une source MongoDB ou DocumentDB, prenez en compte le type de segmentation par plage des paramètres de chargement parallèle pour les collections sélectionnées plutôt que les tables et les vues.

Vous trouverez ci-dessous les fonctions de chaîne que vous pouvez utiliser pour créer des expressions de règle de transformation.

Fonctions de chaîne	Description
`lower(x)`	La fonction `lower(x)` renvoie une copie de la chaîne `x` avec tous les caractères convertis en minuscules. La fonction `lower` intégrée par défaut fonctionne uniquement pour les caractères ASCII.
`upper(x)`	La fonction `upper(x)` renvoie une copie de la chaîne `x` avec tous les caractères convertis en majuscules. La fonction `upper` intégrée par défaut fonctionne uniquement pour les caractères ASCII.
`ltrim(x,y)`	La fonction `ltrim(x,y)` renvoie une chaîne constituée en supprimant du côté gauche de x tous les caractères qui apparaissent dans y. S’il n’y a aucune valeur pour y, `ltrim(x)` supprime les espaces du côté gauche de x.
`replace(x,y,z)`	La fonction `replace(x,y,z)` renvoie une chaîne constituée en substituant la chaîne z pour chaque occurrence de la chaîne y dans la chaîne x.
`rtrim(x,y)`	La fonction `rtrim(x,y)` renvoie une chaîne constituée en supprimant du côté droit de x tous les caractères qui apparaissent dans y. S’il n’y a aucune valeur pour y, `rtrim(x)` supprime les espaces du côté droit de x.
`substr(x,y,z)`	La fonction `substr(x,y,z)` renvoie une sous-chaîne de la chaîne d’entrée `x` qui commence par le `y`ème caractère et qui comporte `z` caractères. Si `z` est omis, `substr(x,y)` renvoie tous les caractères jusqu’à la fin de la chaîne `x` en commençant par le `y`ème caractère. Le caractère le plus à gauche de `x` est le 1er caractère. Si `y` est négatif, le premier caractère de la sous-chaîne est trouvé en comptant à partir de la droite plutôt que de la gauche. Si `z` est négatif, les `abs(z)` caractères précédant le `y`ème caractère sont renvoyés. Si `x` est une chaîne, les index des caractères font référence aux caractères UTF-8 réels. Si `x` est un objet BLOB, les index font référence à des octets.
`trim(x,y)`	La fonction `trim(x,y)` renvoie une chaîne constituée en supprimant des deux côtés de `x` tous les caractères qui apparaissent dans `y`. Si `y` n’a pas de valeur, `trim(x)` supprime les espaces des deux côtés de `x`.

Vous trouverez ci-dessous les fonctions LOB que vous pouvez utiliser pour créer des expressions de règle de transformation.

Fonctions LOB	Description
`hex(x)`	La fonction `hex` reçoit un objet BLOB en tant qu’argument et renvoie une version en chaîne hexadécimale en majuscules du contenu BLOB.
`randomblob (N)`	La fonction `randomblob(N)` renvoie un objet BLOB de `N` octet(s) contenant des octets pseudo-aléatoires. S'il `N` est inférieur à 1, un BLOB aléatoire de 1 octet est renvoyé.
`zeroblob(N)`	La fonction `zeroblob(N)` renvoie un objet BLOB composé de `N` octet(s) de 0x00.

Vous trouverez ci-dessous les fonctions numériques que vous pouvez utiliser pour créer des expressions de règle de transformation.

Fonctions numériques	Description
`abs(x)`	La fonction `abs(x)` renvoie la valeur absolue de l’argument numérique `x`. La `abs(x)` fonction renvoie NULL si cette valeur `x` est NULL. La `abs(x)` fonction renvoie 0,0 s'il s'`x`agit d'une chaîne ou d'un BLOB qui ne peut pas être converti en valeur numérique.
`random()`	La fonction `random` renvoie un entier pseudo-aléatoire compris entre -9 223 372 036 854 775 808 et +9 223 372 036 854 775 807.
`round (x,y)`	La `round (x,y)` fonction renvoie une valeur à virgule flottante `x` arrondie aux `y` chiffres situés à droite de la virgule décimale. S'il n'y a aucune valeur pour`y`, elle est supposée être 0.
`max (x,y...)`	La fonction `max` à plusieurs arguments renvoie l’argument avec la valeur maximale, ou renvoie NULL si l’un des arguments est NULL. La fonction `max` recherche dans ses arguments de gauche à droite un argument qui définit une fonction de classement. Si elle en trouve un, elle utilise cette fonction de classement pour toutes les comparaisons de chaînes. Si aucun des arguments de `max` ne définit une fonction de classement, la fonction de classement `BINARY` est utilisée. La fonction `max` est une fonction simple lorsqu’elle possède deux arguments ou plus, mais elle fonctionne comme une fonction d’agrégation si elle n’a qu’un seul argument.
`min (x,y...)`	La fonction `min` à plusieurs arguments renvoie l’argument avec la valeur minimale. La fonction `min` recherche dans ses arguments de gauche à droite un argument qui définit une fonction de classement. Si elle en trouve un, elle utilise cette fonction de classement pour toutes les comparaisons de chaînes. Si aucun des arguments de `min` ne définit une fonction de classement, la fonction de classement `BINARY` est utilisée. La fonction `min` est une fonction simple lorsqu’elle possède deux arguments ou plus, mais elle fonctionne comme une fonction d’agrégation si elle n’a qu’un seul argument.

Vous trouverez ci-dessous les fonctions de vérification NULL que vous pouvez utiliser pour créer des expressions de règle de transformation.

Fonctions de vérification NULL Description

Fonctions de vérification NULL	Description
`coalesce (x,y...)`	La fonction `coalesce` renvoie une copie de son premier argument non NULL, mais elle renvoie NULL si tous les arguments sont NULL. La fonction coalesce comporte au moins deux arguments.
`ifnull(x,y)`	La fonction `ifnull` renvoie une copie de son premier argument non NULL, mais elle renvoie NULL si les deux arguments sont NULL. La fonction `ifnull` possède exactement deux arguments. La fonction `ifnull` est identique à `coalesce` avec deux arguments.
`nullif(x,y)`	La fonction `nullif(x,y)` renvoie une copie de son premier argument si les arguments sont différents, mais elle renvoie NULL si les arguments sont identiques. La fonction `nullif(x,y)` recherche dans ses arguments de gauche à droite un argument qui définit une fonction de classement. Si elle en trouve un, elle utilise cette fonction de classement pour toutes les comparaisons de chaînes. Si aucun des arguments NULLIF ne définit de fonction de classement, la fonction de classement `BINARY` est utilisée.

coalesce (x,y...)

La fonction coalesce renvoie une copie de son premier argument non NULL, mais elle renvoie NULL si tous les arguments sont NULL. La fonction coalesce comporte au moins deux arguments.

ifnull(x,y)

La fonction ifnull renvoie une copie de son premier argument non NULL, mais elle renvoie NULL si les deux arguments sont NULL. La fonction ifnull possède exactement deux arguments. La fonction ifnull est identique à coalesce avec deux arguments.

nullif(x,y)

La fonction nullif(x,y) renvoie une copie de son premier argument si les arguments sont différents, mais elle renvoie NULL si les arguments sont identiques.

La fonction nullif(x,y) recherche dans ses arguments de gauche à droite un argument qui définit une fonction de classement. Si elle en trouve un, elle utilise cette fonction de classement pour toutes les comparaisons de chaînes. Si aucun des arguments NULLIF ne définit de fonction de classement, la fonction de classement BINARY est utilisée.

Vous trouverez ci-dessous les fonctions de date/heure que vous pouvez utiliser pour créer des expressions de règle de transformation.

Fonctions de date et d’heure	Description
`date(timestring, modifier, modifier...)`	La `date` fonction renvoie la date au format YYYY-MM-DD.
`time(timestring, modifier, modifier...)`	La fonction `time` renvoie l’heure au format HH:MM:SS.
`datetime(timestring, modifier, modifier...)`	La `datetime` fonction renvoie la date et l'heure au format YYYY-MM-DD HH:MM:SS.
`julianday(timestring, modifier, modifier...)`	La fonction `julianday` renvoie le nombre de jours écoulés depuis midi, heure de Greenwich, le 24 novembre 4714 av JC.
`strftime(format, timestring, modifier, modifier...)`	La fonction `strftime` renvoie la date conformément à la chaîne de format spécifiée comme premier argument, en utilisant l’une des variables suivantes : `%d` : jour du mois `%H` : heure entre 00 et 24 `%f` : fractions de seconde SS.SSS `%j` : jour de l’année entre 001 et 366 `%J` : numéro du jour julien `%m` : mois entre 01 et 12 `%M` : minute entre 00 et 59 `%s` : secondes depuis le 01/01/1970 `%S` : secondes entre 00 et 59 `%w` : jour de la semaine entre 0 et 6, dimanche = 0 `%W` : semaine de l’année entre 00 et 53 `%Y` : année entre 0000 et 9999 `%%`: %

Vous trouverez ci-dessous une fonction de hachage que vous pouvez utiliser pour créer des expressions de règle de transformation.

Fonction de hachage Description

Fonction de hachage	Description
`hash_sha256(x)`	La fonction `hash` génère une valeur de hachage pour une colonne d’entrée (à l’aide de l’algorithme SHA-256) et renvoie la valeur hexadécimale de la valeur de hachage générée. Pour utiliser la fonction `hash` dans une expression, ajoutez `hash_sha256(x)` à l’expression et remplacez `x` par le nom de la colonne source.

hash_sha256(x)

La fonction hash génère une valeur de hachage pour une colonne d’entrée (à l’aide de l’algorithme SHA-256) et renvoie la valeur hexadécimale de la valeur de hachage générée.

Pour utiliser la fonction hash dans une expression, ajoutez hash_sha256(x) à l’expression et remplacez x par le nom de la colonne source.

Utilisation d’une expression CASE

L' SQLite CASEexpression évalue une liste de conditions et renvoie une expression en fonction du résultat. La syntaxe est la suivante.


    CASE case_expression
     WHEN when_expression_1 THEN result_1
     WHEN when_expression_2 THEN result_2
     ...
     [ ELSE result_else ] 
    END

# Or 

     CASE
     WHEN case_expression THEN result_1
     WHEN case_expression THEN result_2
     ...
     [ ELSE result_else ] 
    END

Exemples

Exemple d’ajout d’une nouvelle colonne de chaîne à la table cible en utilisant une condition de casse

L’exemple de règle de transformation suivant ajoute une nouvelle colonne de chaîne emp_seniority à la table cible employee. Il utilise la SQLite round fonction de la colonne des salaires, avec une condition de cas pour vérifier si le salaire est égal ou supérieur à 20 000. Si c’est le cas, la colonne obtient la valeur SENIOR et tout le reste a la valeur JUNIOR.


  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "emp_seniority",
      "expression": " CASE WHEN round($emp_salary)>=20000 THEN ‘SENIOR’ ELSE ‘JUNIOR’ END",
      "data-type": {
        "type": "string",
        "length": 50
      }

  }

Exemple d’ajout d’une nouvelle colonne de date à la table cible

L’exemple suivant ajoute une nouvelle colonne de date createdate à la table cible employee. Lorsque vous utilisez la fonction de SQLite datedatetime, la date est ajoutée à la table nouvellement créée pour chaque ligne insérée.


  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "createdate",
      "expression": "datetime ()",
      "data-type": {
        "type": "datetime",
        "precision": 6
      }
  }

Exemple d’ajout d’une nouvelle colonne numérique à la table cible

L’exemple suivant ajoute une nouvelle colonne numérique rounded_emp_salary à la table cible employee. Elle utilise la SQLite round fonction pour ajouter le salaire arrondi.


  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "rounded_emp_salary",
      "expression": "round($emp_salary)",
      "data-type": {
        "type": "int8"
      }
  }

Exemple d’ajout d’une nouvelle colonne de chaîne à la table cible en utilisant la fonction de hachage

L’exemple suivant ajoute une nouvelle colonne de chaîne hashed_emp_number à la table cible employee. La SQLite hash_sha256(x) fonction crée des valeurs hachées sur la cible pour la colonne source,emp_number.


  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "public",
        "table-name": "employee"
      },
      "value": "hashed_emp_number",
      "expression": "hash_sha256($emp_number)",
      "data-type": {
        "type": "string",
        "length": 64
      }
  }

Ajout de métadonnées à une table cible à l’aide d’expressions

Vous pouvez ajouter les informations de métadonnées à la table cible en utilisant les expressions suivantes :

$AR_M_SOURCE_SCHEMA : nom du schéma source.
$AR_M_SOURCE_TABLE_NAME : nom de la table source.
$AR_M_SOURCE_COLUMN_NAME : nom d’une colonne de la table source.
$AR_M_SOURCE_COLUMN_DATATYPE : type de données d’une colonne de la table source.

Exemple d’ajout d’une colonne pour un nom de schéma en utilisant le nom de schéma issu de la source

L’exemple suivant ajoute une nouvelle colonne nommée schema_name à la cible en utilisant le nom de schéma issu de la source.


  {
      "rule-type": "transformation",
      "rule-id": "2",
      "rule-name": "2",
      "rule-action": "add-column",
      "rule-target": "column",
      "object-locator": {
        "schema-name": "%",
        "table-name": "%"
      },
      "rule-action": "add-column",
      "value":"schema_name",
      "expression": "$AR_M_SOURCE_SCHEMA", 
      "data-type": { 
         "type": "string",
         "length": 50
      }
  }

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

Règles et actions de transformation

Règles des paramètres de table et de collection et opérations