SnowConvert: Recurso de renomeação

Renomear objetos durante um processo de migração de banco de dados é algo que muitos usuários precisam fazer. Por esse motivo, o SnowConvert habilita o recurso Renaming para permitir a definição de novos nomes para os seguintes tipos de objetos definidos pelo usuário:

Nota

Esse recurso é compatível com Teradata e Redshift ONLY.

  • Tabelas

  • Exibições

  • Exibições materializadas

  • Procedimentos

  • Funções

  • Macros

Nota

O recurso de renomeação será aplicado à definição do objeto e aos usos do objeto.

Esses objetos geralmente são qualificados em um esquema ou em um banco de dados, portanto, dependendo da plataforma do banco de dados, o objeto Table1 pode ser referenciado simplesmente como Table1, como MySchema.Table1 ou como MyDatabase.MySchema.Table1. É essencial qualificar totalmente cada objeto no arquivo de renomeação para evitar ambiguidade.

Os novos nomes de objetos são especificados por meio de um arquivo .json com o seguinte formato.

Nota

Observe que este exemplo contém uma seção «Macros», que é um elemento específico do Teradata e pode variar dependendo da linguagem especificada.

{
  "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

Uso

Para usar o recurso de renomeação, você deve executar a versão CLI do SnowConvert com o seguinte argumento --RenamingFile e fornecer o caminho para o arquivo .json que contém as informações de renomeação. Um exemplo de comando pode ser o seguinte:

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

Modos de renomeação

Observe que há dois campos para cada tipo de objeto: "Tables" e "TablesRegex", "Views" e "ViewsRegex", e assim por diante. Isso ocorre porque há duas maneiras de especificar as renomeações.

Objeto por objeto (linha por linha)

Nesse modo, cada linha representa um objeto e deve conter o nome original totalmente qualificado e o novo nome. Portanto, se quisermos mover um objeto chamado «Table1» dentro do esquema «OriginalSchema» para o esquema «SchemaSF», a linha deverá ser a seguinte:

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

Se também quisermos renomeá-la para «Table2», a linha deverá ser a seguinte:

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

Essas informações devem ser especificadas nas seções "Tables", _ "Views", _ "Procedures"_, _ "Macros" e "Functions" do arquivo .json e cada linha deve ser separada por vírgula. Vamos dar uma olhada em um exemplo:

TableExample1

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

O exemplo acima diz que as únicas três tabelas em toda a carga de trabalho a serem renomeadas são as chamadas «Table1», «Table2» e «Table3», todas localizadas dentro do esquema «Schema1»; elas devem ser renomeadas para «_SF\Table1», «SF_Table2» e «SF_Table3», respectivamente; e, por fim, elas estarão localizadas no esquema «SF_Schema1» no Snowflake.

Expressões regulares

Se houver necessidade de renomear vários objetos da mesma forma, o recurso também permite que expressões regulares definam padrões a serem aplicados a objetos do mesmo tipo. São necessárias duas linhas para especificar cada renomeação, a primeira linha é "RegexExpr", que é a expressão de correspondência, e a segunda linha é "RegexReplace", que é a expressão de substituição. Essas informações devem ser fornecidas nas seções "TablesRegex", "ViewsRegex", "ProceduresRegex", "MacrosRegex" e "FunctionsRegex" do arquivo .json. Portanto, o exemplo anterior também pode ser escrito da seguinte maneira, usando o recurso de expressão regular.

TableExample2

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

A única diferença é que essa forma se aplica a todas as tabelas localizadas no esquema «Schema1». A expressão regex corresponderia a todas as tabelas definidas no esquema «Schema1» e criaria um grupo de captura com tudo o que estiver após o ponto. A substituição de regex moverá as tabelas para o esquema «SF_Schema1» e adicionará o prefixo «SF_» a todas as tabelas encontradas fazendo referência ao primeiro grupo criado ($1) na expressão regex.

Renomear a prioridade

Pode haver renomeações que se aplicam ao mesmo objeto e apenas uma delas é escolhida. Na mesma seção, o SnowConvert aplicará a primeira renomeação que corresponder ao nome do objeto atual e interromperá a tentativa de renomear esse objeto. Portanto, no exemplo a seguir, apesar do fato de a seção "Tables" especificar a renomeação de «Table1» para «Table1-a» e também para «Table1-b», SnowConvert só a renomeará para «Table1-a».

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

Além disso, o SnowConvert tentará renomear um objeto primeiro verificando a seção de renomeação de objeto por objeto antes de tentar a seção de expressões regulares. Portanto, no exemplo a seguir, apesar de ambas as renomeações poderem ser aplicadas ao mesmo objeto «Schema1.Table1», apenas a definida na seção "Tables" é aplicada.

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

Exemplo

Digamos que temos o seguinte código de entrada.

Código de entrada

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

E as seguintes informações de renomeação

Renomeando o arquivo (.JSON)

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

Esse seria o código de saída com e sem renomeação.

Código de saída do 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

Observe como todas as referências a «CLIENT» foram renomeadas para «USER»