SnowConvert : renommage d’une fonction

Renommer des objets au cours d’un processus de migration de base de données est quelque chose que beaucoup d’utilisateurs doivent faire. C’est pourquoi SnowConvert propose la fonction Renommage qui permet de définir de nouveaux noms pour les types d’objets suivants définis par l’utilisateur :

Note

Cette fonction est prise en charge pour Teradata et Redshift UNIQUEMENT.

  • Tables

  • Vues

  • Vues matérialisées

  • Procédures

  • Fonctions

  • Macros

Note

La fonction de renommage s’applique à la fois à la définition de l’objet et à ses utilisations.

Ces objets sont généralement qualifiés au sein d’un schéma ou d’une base de données. Ainsi, en fonction de la plateforme de la base de données, l’objet Table1 peut être référencé simplement comme Table1, comme MySchema.Table1 ou comme MyDatabase.MySchema.Table1. Il est essentiel de qualifier complètement chaque objet dans le fichier de renommage afin d’éviter toute ambiguïté.

Les nouveaux noms d’objets sont spécifiés via un fichier .json au format suivant.

Note

Notez que cet exemple contient une section « Macros », il s’agit d’un élément spécifique à Teradata, qui peut varier en fonction de la langue spécifiée.

{
  "Tables": {
    "SchemaName.TableName": "NewSchema.TableNameChanged",
    "Table1": "Table2"
  },
  "TablesRegex": [
    {
      "RegexExpr": "(Schema1)\\.(.*)",
      "RegexReplace": "Prefix_$1.$2"
    }
  ],
  
  "Views": {
    "ViewName": "ViewNameChanged",
    "MaterializedViewName": "MaterializedViewNameChanged",
  },
  "ViewsRegex": [
    {
      "RegexExpr": "(Schema1)\\.(.*)",
      "RegexReplace": "$2.$1"
    }
  ],
  
  "Procedures": {
    "ProcedureName": "ProcedureNameChanged"
  },
  "ProceduresRegex": [
    {
      "RegexExpr": "(Schema1)\\.(.*)",
      "RegexReplace": "$2.$1"
    }
  ],
  
  "Macros": {
    "SchemaName.MacroName": "MacroNameChanged",
    "SimpleMacro": "SimpleMacroSf"
  },
  "MacrosRegex": [
    {
      "RegexExpr": "(Schema1)\\.(.*)",
      "RegexReplace": "$2.$1"
    }
  ],
  
  "Functions": {
    "SchemaName.FunctionName": "FunctionNameChanged",
    "SimpleFunction": "SimpleFunctionSf"
  },
  "FunctionsRegex": [
    {
      "RegexExpr": "(Schema1)\\.(.*)",
      "RegexReplace": "$2.$1"
    }
  ]
}
Copy

Utilisation

Pour utiliser la fonction de renommage, vous devez exécuter la version CLI de SnowConvert avec l’argument suivant : --RenamingFile et fournir le chemin vers le fichier .json contenant les informations de renommage. Un exemple de commande peut ressembler à ceci :

snowct.exe -i « somePath/input » -o « somePath/output » –RenamingFile « somePath/renamings.json »

Modes de renommage

Remarquez qu’il y a deux champs pour chaque type d’objet : « Tables » et « TablesRegex »_, _ « Vues » et « ViewsRegex », et ainsi de suite. En effet, les renommages peuvent être spécifiés de deux manières.

Objet par objet (ligne par ligne)

Dans ce mode, chaque ligne représente un objet et doit contenir le nom complet d’origine et le nouveau nom. Ainsi, si nous voulons déplacer un objet nommé « Table1 » à l’intérieur du schéma « OriginalSchema » vers le schéma « SchemaSF », la ligne doit ressembler à ceci :

"OriginalSchema.Table1": "SchemaSF.Table1"
Copy

Si nous voulons également le renommer « Table2 », la ligne doit être la suivante :

"OriginalSchema.Table1": "SchemaSF.Table2"
Copy

Ces informations doivent être spécifiées dans les sections « Tables », _ « Vues », _ « Procédures »_, _ « Macros » et « Fonctions » du fichier .json et chaque ligne doit être séparée par une virgule. Prenons un exemple :

TableExample1

"Tables": {
    "Schema1.Table1": "SF_Schema1.SF_Table1",
    "Schema1.Table2": "SF_Schema1.SF_Table2",
    "Schema1.Table3": "SF_Schema1.SF_Table3"
  },  
Copy

L’échantillon ci-dessus indique que les trois seules tables de l’ensemble de la charge de travail à renommer sont celles appelées « Table1 », « Table2 » et « Table3 », toutes situées à l’intérieur du schéma « Schema1 » ; elles doivent être renommées en « SF_Table1 », « SF_Table2 » et « SF_Table3 » respectivement ; et enfin, elles seront situées sous le schéma « SF_Schema1 » dans Snowflake.

Expressions régulières

S’il est nécessaire de renommer plusieurs objets de la même manière, la fonction permet également d’utiliser des expressions régulières pour définir des modèles à appliquer aux objets du même type. Deux lignes sont nécessaires pour spécifier chaque renommage, la première ligne est "RegexExpr" qui est l’expression de correspondance et la deuxième ligne est "RegexReplace" qui est l’expression de remplacement. Ces informations doivent être fournies dans les sections "TablesRegex", _ "ViewsRegex", _ "ProceduresRegex"_, _ "MacrosRegex" et "FunctionsRegex" du fichier .json. Ainsi, l’exemple précédent peut également être écrit de la manière suivante, en utilisant la fonction d’expression régulière.

TableExample2

"TablesRegex": [
    {
      "RegexExpr": "Schema1\\.(.*)",
      "RegexReplace": "SF_Schema1.SF_$1"
    }
  ],
Copy

La seule différence est que cette méthode s’applique à toutes les tables situées dans le schéma « Schema1 ». L’expression regex correspondra à toutes les tables définies dans le schéma « Schema1 » et créera un groupe de capture avec tout ce qui se trouve après le point. Le regex de remplacement déplacera les tables vers le schéma « SF_Schema1 » et ajoutera le préfixe « SF_ » à toutes les tables trouvées faisant référence au premier groupe créé ($1) dans l’expression regex.

Renommer la priorité

Il se peut que plusieurs renommages s’appliquent au même objet et qu’un seul d’entre eux soit choisi. Dans la même section, SnowConvert appliquera le premier renommage qui correspond au nom de l’objet en cours, et il cessera d’essayer de renommer cet objet. Ainsi, dans l’exemple suivant, bien que la section « Tables » spécifie de renommer « Table1 » en « Table1-a » et également en « Table1-b », SnowConvert ne la renommera qu’en « Table1-a ».

"Tables": {
    "Schema1.Table1": "Schema1.Table1-a",
    "Schema1.Table1": "Schema1.Table1-b",
  }, 
Copy

De même, SnowConvert essaiera de renommer un objet en vérifiant d’abord la section de renommage objet par objet avant d’essayer la section des expressions régulières. Ainsi, dans l’exemple suivant, bien que les deux renommages puissent s’appliquer au même objet « Schema1.Table1 », seul celui défini dans la section « Tables » est appliqué.

"Tables": {
    "Schema1.Table1": "Schema1.TableA",
  }, 
  "TablesRegex": [
    {
      "RegexExpr": "Schema1\\.(.*)",
      "RegexReplace": "Schema1.SF_$1"
    }
  ],
Copy

Exemple

Supposons que nous ayons le code d’entrée suivant.

Code d’entrée

CREATE TABLE CLIENT ( 
    ID INTEGER, 
    NAME varchar(20));
    
CREATE TABLE TICKET ( 
    CLIENT_ID INTEGER,
    FOREIGN KEY (CLIENT_ID_FK) REFERENCES CLIENT(ID));
    
SELECT * FROM CLIENT;
Copy

Et les informations de renommage suivantes

Renommer un fichier (.JSON)

{
  "Tables": {
    "CLIENT": "USER"
  }
}
Copy

Voici le code de sortie avec et sans renommage.

Code de sortie Snowflake

CREATE OR REPLACE TABLE CLIENT (
    ID INTEGER,
    NAME varchar(20))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "teradata",  "convertedOn": "11/13/2024",  "domain": "test" }}'
;

CREATE OR REPLACE TABLE TICKET (
    CLIENT_ID INTEGER,
       FOREIGN KEY (CLIENT_ID_FK) REFERENCES CLIENT (ID))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "teradata",  "convertedOn": "11/13/2024",  "domain": "test" }}'
;

SELECT
    * FROM
    CLIENT;
Copy
CREATE OR REPLACE TABLE USER (
    ID INTEGER,
    NAME varchar(20))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "teradata",  "convertedOn": "11/13/2024",  "domain": "test" }}'
;

CREATE OR REPLACE TABLE TICKET (
    CLIENT_ID INTEGER,
       FOREIGN KEY (CLIENT_ID_FK) REFERENCES USER (ID))
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "teradata",  "convertedOn": "11/13/2024",  "domain": "test" }}'
;

SELECT
    * FROM
    USER;
Copy

Remarquez que toutes les références à « CLIENT » sont renommées en « USER »