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"
}
]
}
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"
Si nous voulons également le renommer « Table2 », la ligne doit être la suivante :
"OriginalSchema.Table1": "SchemaSF.Table2"
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"
},
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"
}
],
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",
},
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"
}
],
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;
Et les informations de renommage suivantes
Renommer un fichier (.JSON)
{
"Tables": {
"CLIENT": "USER"
}
}
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;
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;
Remarquez que toutes les références à « CLIENT » sont renommées en « USER »