SnowConvert: Referência de conversão de scripts do Teradata para Python

Navegue pelas páginas a seguir para obter mais informações sobre tópicos específicos.

  • BTEQ, explore a referência de conversão para a sintaxe da consulta básica do Teradata.

  • FastLoad, explore a referência de conversão para a sintaxe do FastLoad.

  • MultiLoad, explore a referência de conversão para a sintaxe de MultiLoad.

  • TPT, explore a referência de conversão para a sintaxe de TPT.

TPT

Transformação de instruções TPT

Todas as instruções TPT, assim como outras linguagens de script do Teradata, estão sendo convertidas em código python. Aqui estão alguns exemplos de transformações já suportadas.

Defina a transformação do cabeçalho de trabalho

A instrução de trabalho é convertida para uma classe python com todas as instruções, como operadores, definições de esquema e etapas dentro dela.

Código-fonte

 /* Some comments on the job  */
DEFINE JOB LOADJOB
DESCRIPTION 'LOAD AC_SCHEMA TABLE FROM A FILE'
JobBody
Copy

Código convertido

 ## Some comments on the job
class LOADJOB:
    # DESCRIPTION 'LOAD AC_SCHEMA TABLE FROM A FILE'
    JobBody
Copy

Defina a transformação do esquema

A instrução de esquema é convertida em um atributo na classe criada para a instrução de trabalho.

Código-fonte

 DEFINE SCHEMA DCS_SCHEMA
DESCRIPTION 'DCS DATA'
(
PNRHEADER_ID   PERIOD(DATE),
PNRLOCPERIOD   PERIOD(TIMESTAMP(0)),
CRTDATE        CLOB,
REQTYP         JSON(100000),
seqno          INTEGER,
resdata        INTEGER
);
Copy

Código convertido

 class JOBNAME:
    DCS_SCHEMA = """(
    PNRHEADER_ID VARCHAR(24),
    PNRLOCPERIOD VARCHAR(58),
    CRTDATE VARCHAR /*** MSC-WARNING - SSC-FDM-TD0002 - COLUMN CONVERTED FROM CLOB DATA TYPE ***/,
    REQTYP VARIANT,
    seqno INTEGER,
    resdata INTEGER,
    );"""
Copy

Defina a transformação do operador

Os operadores são convertidos para funções python dentro da classe gerada para o trabalho. Os exemplos fornecidos são os operadores que o SnowConvert suporta atualmente

Operador DDL

Código-fonte do operador DDL

 DEFINE OPERATOR DDL_OPERATOR()
DESCRIPTION 'TERADATA PARALLEL TRANSPORTER DDL OPERATOR'
TYPE DDL
ATTRIBUTES
(
  VARCHAR PrivateLogName ,
  VARCHAR TdpId          = @MyTdpId,
  VARCHAR UserName       = @MyUserName,
  VARCHAR UserPassword   = 'SomePassWord',
  VARCHAR AccountID,
  VARCHAR ErrorList      = ['3807','2580']
);
Copy

Código convertido

 class JobName:
    def DDL_OPERATOR(self):
        #'TERADATA PARALLEL TRANSPORTER DDL OPERATOR'
        global args
        self.con = log_on(user = args.MyUserName, password = 'SomePassWord')
Copy
Operador UPDATE

Código-fonte do operador UPDATE

 DEFINE OPERATOR LOAD_OPERATOR()
DESCRIPTION 'TERADATA PARALLEL TRANSPORTER LOAD OPERATOR'
TYPE UPDATE
SCHEMA AC_MASTER_SCHEMA
ATTRIBUTES
(
    VARCHAR PrivateLogName ,
    INTEGER MaxSessions       =  32,
    INTEGER MinSessions       =  1,
    VARCHAR TargetTable       = '&TARGET_TABLE',
    VARCHAR TdpId             = @MyTdpId,
    VARCHAR UserName          = @MyUserName,
    VARCHAR UserPassword      = @MyPassword,
    VARCHAR AccountId,
    VARCHAR ErrorTable1       = '&LOG_DB_NAME.ERR1',
    VARCHAR ErrorTable2       = '&LOG_DB_NAME.ERR2',
    VARCHAR LogTable          = '&LOG_DB_NAME.LOG_TABLE'
);
Copy

Código convertido

 class JobName:
    def LOAD_OPERATOR(self, query):
        #'TERADATA PARALLEL TRANSPORTER LOAD OPERATOR'
        #USES SCHEMA AC_MASTER_SCHEMA
        operator_name = "LOAD_OPERATOR"
        return query
Copy
Operador DATA CONNECTOR PRODUCER

Código-fonte do operador Data Connector Producer

 DEFINE OPERATOR FILE_READER()
DESCRIPTION 'TERADATA PARALLEL TRANSPORTER DATA CONNECTOR OPERATOR'
TYPE DATACONNECTOR PRODUCER
SCHEMA AC_MASTER_SCHEMA
ATTRIBUTES
(
  VARCHAR PrivateLogName ,
  VARCHAR DirectoryPath   = '&INPUTFILEPATH' ,
  VARCHAR FileName        = '&INPUTTEXTFILE' ,
  VARCHAR Format          = 'delimited',
  VARCHAR OpenMode        = 'Read',
  VARCHAR TextDelimiter     = '~',
  VARCHAR IndicatorMode   = 'N'
);
Copy

Código convertido

 class JobName:
    def FILE_READER(self):
        #'TERADATA PARALLEL TRANSPORTER DATA CONNECTOR OPERATOR'
        #USES SCHEMA AC_MASTER_SCHEMA
        operator_name = "FILE_READER"
        stage_name = f"{self.jobname}_{operator_name}"
        format_name = f"{self.jobname}_{operator_name}_FILEFORMAT"
        exec(f"""CREATE OR REPLACE FILE FORMAT {format_name} TYPE = 'CSV' FIELD_DELIMITER = '~' TRIM_SPACE = TRUE SKIP_HEADER = 0""")
        exec(f"""CREATE STAGE IF NOT EXISTS {self.jobname}_STAGE""")
        exec(f"""PUT file://{INPUTFILEPATH}/{INPUTTEXTFILE} @{stage_name} OVERWRITE = TRUE AUTO_COMPRESS = FALSE;""")
        temp_table_name = f"{self.jobname}_{operator_name}_TEMP"
        exec(f"""DROP TABLE IF EXISTS {temp_table_name}""")
        exec(f"""CREATE TEMPORARY TABLE {temp_table_name} {self.AC_MASTER_SCHEMA}""")
        exec(f"""COPY INTO {temp_table_name} FROM @{stage_name} FILE_FORMAT = (format_name = '{format_name}')""")
        return temp_table_name
Copy

Defina transformação de etapas

As etapas também são convertidas para funções python dentro da classe gerada para o trabalho; elas serão chamadas na função principal do código convertido.

Código-fonte da etapa

 STEP setup_tables
(
  APPLY
  ('DELETE FROM  &STAGE_DB_NAME.EMS_AC_MASTER_STG;')
   TO OPERATOR (DDL_OPERATOR() );
);

STEP stLOAD_FILE_NAME
(
  APPLY
  ('INSERT INTO CRASHDUMPS.EMP_NAME
  (EMP_NAME, EMP_YEARS, EMP_TEAM)
  VALUES
  (:EMP_NAME, :EMP_YEARS, :EMP_TEAM);')
  TO OPERATOR (ol_EMP_NAME() [1])
  SELECT * FROM OPERATOR(op_EMP_NAME);
);
Copy

Código convertido

 def setup_tables(self):
    self.DDL_OPERATOR()
    exec(f"""DELETE FROM DATABASE1.{STAGE_DB_NAME}.EMS_AC_MASTER_STG""")

def stLOAD_FILE_NAME(self):
    exec(f"""INSERT INTO DATABASE1.CRASHDUMPS.EMP_NAME (EMP_NAME, EMP_YEARS, EMP_TEAM)
SELECT EMP_NAME, EMP_YEARS, EMP_TEAM
FROM (
{self.ol_EMP_NAME('SELECT * FROM ' + self.op_EMP_NAME() )})""")
Copy

Função principal

A função principal é sempre gerada para qualquer linguagem de script; para TPT, a função principal contém uma instância da classe de trabalho e chamadas para as etapas do trabalho

Código de amostra da função principal

 def main():
  _LOADJOB = LOADJOB()
  _LOADJOB.setup_tables()
  _LOADJOB.stLOAD_FILE_NAME()
  snowconvert.helpers.quit_application()
Copy

MLOAD

O Teradata MultiLoad é um utilitário orientado por comandos para manutenção rápida e de alto volume em várias tabelas e visualizações no banco de dados Teradata.

Para simular a funcionalidade do MultiLoad do Teradata no Snowflake, os arquivos e comandos do MultiLoad são transformados em código Python, de forma semelhante às transformações realizadas nos scripts BTEQ e FastLoad. O código gerado usa o projeto Snowflake Python chamado snowconvert.helpers que contém as funções necessárias para simular as instruções do MultiLoad no Snowflake.

Conversão de comandos do MultiLoad

A maioria dos comandos do MultiLoad é considerada irrelevante no Snowflake, e esses comandos são comentados. Abaixo está a lista resumida dos comandos do MultiLoad e seu status de transformação no Snowflake:

CommandsTransformation StatusNote
ACCEPTCommented
BEGIN MLOADTransformed​​The node is commented out since the transformation occurs in other related statements instead.
BEGIN DELETE MLOADCommented
DATEFORMCommented
DELETEPartially transformedCheck known issues.​
DISPLAYCommented
DML LABELTransformed
END MLOADTransformed​​Commented out since is not necessary for the transformation of the BEGIN MLOAD.
EOCCommented
FIELDTransformed
FILLERTransformedThis command needs to be with a FIELD and LAYOUT command to be converted.
IF, ELSE, and ENDIFCommented
IMPORTTransformed
INSERTTransformedThis is taken as a Teradata Statement, so it doesn't appear in this chapter.
LAYOUTTransformedThis command needs to be with a FIELD and FILLER command to be converted.
LOGDATACommented
LOGMECHCommented
LOGOFFCommented
LOGONCommented
LOGTABLECommented
PAUSE ACQUISITIONCommented
RELEASE MLOADCommented
ROUTE MESSAGESCommented
RUN FILECommented
SETCommented
SYSTEMCommented
TABLECommented
UPDATETransformedThis is taken as a Teradata Statement, so it doesn't appear in this chapter.
VERSIONCommented

No entanto, há alguns comandos excepcionais que devem ser convertidos em código específico do Python para que funcionem como pretendido no Snowflake. Consulte esta seção.

Se você tiver outras dúvidas sobre esta documentação, pode nos enviar um e-mail para snowconvert-support@snowflake.com.

BEGIN MLOAD

A transformação para o comando .BEGIN MLOAD é uma transformação de várias partes que requer os comandos .LAYOUT, .FIELD, .FILLER,.DML LABEL e .IMPORT para simular seu comportamento corretamente.

Essa transformação é explicada detalhadamente nas subseções a seguir.

.LAYOUT, .FIELD e .FILLER

A transformação para os comandos .LAYOUT, .FIELD e .FILLER criará definições de variáveis a serem usadas em uma futura chamada de função do IMPORT desse layout.

Teradata (MultiLoad)

 .LAYOUT INFILE_LAYOUT;
.FIELD TABLE_ID        * INTEGER;
.FIELD TABLE_DESCR     * CHAR(8);
.FILLER COL1           * CHAR(1);
.FIELD TABLE_NBR       * SMALLINT;
.FIELD TABLE_SOMEFIELD * SMALLINT;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  INFILE_LAYOUT_TableName = "INFILE_LAYOUT_TEMP_TABLE"
  INFILE_LAYOUT_Columns = """TABLE_ID INTEGER, 
TABLE_DESCR CHAR(8), 
COL1 CHAR(1), 
TABLE_NBR SMALLINT, 
TABLE_SOMEFIELD SMALLINT"""
  INFILE_LAYOUT_Conditions = """TABLE_ID AS TABLE_ID, TABLE_DESCR AS TABLE_DESCR, COL1 AS COL1, TABLE_NBR AS TABLE_NBR, TABLE_SOMEFIELD AS TABLE_SOMEFIELD"""
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

.DML LABEL

A transformação para o comando .DML LABELcriará uma função contendo as instruções após a definição do rótulo. Observe que, após o comando .DML LABEL, geralmente há um comando Insert, Update ou Delete.

Teradata (MultiLoad)

 -- Example of .DML LABEL with INSERT:
.DML LABEL INSERT_TABLE;                                                                                    
INSERT INTO mydb.mytable( TABLE_ID,TABLE_DESCR,TABLE_NBR ) VALUES( :TABLE_ID,:TABLE_DESCR,:TABLE_NBR );

-- Example of .DML LABEL with DELETE:
.DML LABEL DELETE_TABLE;              
DELETE FROM Employee WHERE EmpNo  = :EmpNo;

-- Example of .DML LABEL with an UPDATE, followed by an INSERT:
.DML LABEL UPSERT_TABLE DO INSERT FOR MISSING UPDATE ROWS;
UPDATE   mydb.mytable SET TABLE_ID = :TABLE_ID WHERE TABLE_DESCR = :somedescription
INSERT INTO mydb.mytable(TABLE_ID, TABLE_DESCR, TABLE_NBR) VALUES(:TABLE_ID, :TABLE_DESCR, :TABLE_NBR );
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  def INSERT_TABLE(tempTableName, queryConditions = ""):
    exec(f"""INSERT INTO mydb.mytable (TABLE_ID, TABLE_DESCR, TABLE_NBR)
SELECT
   :TABLE_ID,
   :TABLE_DESCR,
   :TABLE_NBR
FROM {tempTableName} SRC {queryConditions}""")
  exec("""
    DELETE FROM
      Employee
    WHERE
      EmpNo = :EmpNo
    """)
  def UPSERT_TABLE(tempTableName, queryConditions = ""):
    exec(f"""MERGE INTO mydb.mytable TGT USING (SELECT * FROM {tempTableName} {queryConditions}) SRC ON TABLE_DESCR = :somedescription
WHEN MATCHED THEN UPDATE SET
   TABLE_ID = :TABLE_ID
WHEN NOT MATCHED THEN INSERT (TABLE_ID, TABLE_DESCR, TABLE_NBR)
VALUES (:TABLE_ID, :TABLE_DESCR, :TABLE_NBR)""")
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

.IMPORT

A transformação do comando .IMPORT criará uma chamada para o auxiliarimport_file_to_temptablepara carregar os dados do arquivo em uma tabela temporária. Em seguida, serão criadas as chamadas para todos os rótulosAPPLYusados na importação original. Por fim, as chamadas para um rótuloINSERTserão transformadas em um parâmetro de consulta e, opcionalmente, poderão ter uma condição de consulta.

Teradata (MultiLoad)

 .IMPORT INFILE INFILE_FILENAME
    LAYOUT INFILE_LAYOUT
    APPLY INSERT_TABLE
    APPLY UPSERT_TABLE
    Apply DELETE_TABLE;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #.IMPORT INFILE INFILE_FILENAME LAYOUT INFILE_LAYOUT APPLY INSERT_TABLE APPLY UPSERT_TABLE Apply DELETE_TABLE
   
  snowconvert.helpers.import_file_to_temptable(fr"INFILE_FILENAME", INFILE_LAYOUT_TableName, INFILE_LAYOUT_Columns, INFILE_LAYOUT_Conditions, ',')
  INSERT_TABLE(INFILE_LAYOUT_TableName)
  UPSERT_TABLE(INFILE_LAYOUT_TableName)
  DELETE_TABLE(INFILE_LAYOUT_TableName)
  exec(f"""DROP TABLE {INFILE_LAYOUT_TableName}""")
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

Exemplo grande

Dadas as transformações mostradas acima para uma variedade de comandos, considere o exemplo a seguir.

Com esses dados de entrada:

 id,name,age
1,John,25
2,Maria,29
3,Carlos,31
4,Mike,40
5,Laura,27
Copy

Teradata (MultiLoad)

 .begin import mload
        tables
	mySampleTable1
sessions 20
ampcheck none;

.layout myLayOut;
 .field ID * VARCHAR(2) NULLIF ID = '1';
 .field NAME * VARCHAR(25);
 .field AGE * VARCHAR(10);
.dml label insert_data;

INSERT INTO mySampleTable1
 ( 
    ID,
    NAME,
    AGE	
 )
VALUES
 (
    :ID,
    SUBSTRING(:NAME FROM 2),
    :AGE
 );

.import infile sampleData.txt
layout myLayOut
apply insert_data

.end mload;
.logoff;
Copy
ROWIDNAMEAGE
1NULLohn25
22aria29
33arlos31
44ike40
55aura27

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #.begin import mload tables mySampleTable1 sessions 20 ampcheck none
   
  myLayOut_TableName = "myLayOut_TEMP_TABLE"
  myLayOut_Columns = """ID VARCHAR(2), 
NAME VARCHAR(25), 
AGE VARCHAR(10)"""
  myLayOut_Conditions = """CASE
   WHEN ID = '1'
      THEN NULL
   ELSE ID
END AS ID, NAME AS NAME, AGE AS AGE"""
  def insert_data(tempTableName, queryConditions = ""):
    exec(f"""INSERT INTO mySampleTable1 (ID, NAME, AGE)
SELECT
   SRC.ID,
   SUBSTRING(SRC.NAME, 2),
   SRC.AGE
FROM {tempTableName} SRC {queryConditions}""")
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #.import infile sampleData.txt layout myLayOut apply insert_data
   
  snowconvert.helpers.import_file_to_temptable(fr"sampleData.txt", myLayOut_TableName, myLayOut_Columns, myLayOut_Conditions, ',')
  insert_data(myLayOut_TableName)
  exec(f"""DROP TABLE {myLayOut_TableName}""")

  if con is not None:
    con.close()
    con = None
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy
ROWIDNAMEAGE
1NULLohn25
22aria29
33arlos31
44ike40
55aura27

Problemas conhecidos

1. A instrução Delete é parcialmente suportada

A instrução DELETE é parcialmente compatível, pois as condições where, quando encontradas, não estão sendo convertidas corretamente se apontarem para uma coluna definida em LAYOUT.

No exemplo abaixo, :EmpNo está apontando para uma coluna definida em LAYOUT. No entanto, a transformação não leva isso em conta e, portanto, o código fará referência a uma coluna que não existe.

  exec("""
    DELETE FROM
      Employee
    WHERE
      EmpNo = :EmpNo
    """)

Copy

Se você tiver outras dúvidas sobre esta documentação, pode nos enviar um e-mail para snowconvert-support@snowflake.com.

Auxiliares de scripts do SnowConvert

O SnowConvert para Teradata pode receber qualquer Teradata SQL ou scripts (BTEQ, FastLoad, MultiLoad e TPump) e convertê-los em SQL, JavaScript incorporado ao Snowflake SQL e Python funcionalmente equivalentes no Snowflake. Qualquer código Python de saída do SnowConvert chamará as funções dessas classes auxiliares para concluir a conversão e criar uma saída funcionalmente equivalente no Snowflake.

O Snowflake Connector para Python também será chamado para se conectar à sua conta do Snowflake e executar o código Python de saída criado pelo SnowConvert.

As informações sobre a versão mais recente do pacote podem ser encontradas aqui.

Nota

O pacote Pythonsnowconvert-helpers é compatível com as versões 3.6, 3.7, 3.8 e 3.9 do Python.

Migração de scripts

Fonte

Suponha que você tenha o seguinte código BTEQ a ser migrado.

 insert into table1 values(1, 2);
insert into table1 values(3, 4);
insert into table1 values(5, 6);
Copy

Saída

Você deve obter um resultado como o mostrado abaixo.

The `log_on`function parameters ('user', 'password', 'account', 'database', 'warehouse', 'role', 'token') should be defined by the user.
Copy
 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  exec("""
    INSERT INTO table1
    VALUES (1, 2)
    """)
  exec("""
    INSERT INTO table1
    VALUES (3, 4)
    """)
  exec("""
    INSERT INTO table1
    VALUES (5, 6)
    """)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

Introdução

Para instalar o pacote, você deve executar o seguinte comando em seu ambiente python. Se você não estiver familiarizado com a instalação de pacotes em Python, visite a seguinte página sobre pacotes python (https://packaging.python.org/tutorials/installing-packages/).

 pip install snowconvert-helpers
Copy

Depois que o pacote estiver instalado, você poderá executar o código migrado do script no Python.

Execute o código

Para executar o código migrado, basta abrir o prompt de comando ou o terminal e executar o seguinte comando.

 python sample_BTEQ.py
Copy

Se o script não tiver erros, você obterá no console uma saída como a que está abaixo.

 Executing: INSERT INTO PUBLIC.table1 VALUES (1, 2).
Printing Result Set:
number of rows inserted
1

Executing: INSERT INTO PUBLIC.table1 VALUES (3, 4).
Printing Result Set:
number of rows inserted
1

Executing: INSERT INTO PUBLIC.table1 VALUES (5, 6).
Printing Result Set:
number of rows inserted
1

Error Code 0
Script done >>>>>>>>>>>>>>>>>>>>
Error Code 0
Copy

Passagem de parâmetros de conexão

Há várias maneiras de passar os parâmetros de conexão para a conexão do banco de dados:

  • Como parâmetros na função, chame snowconvert.helpers.log_on dentro do arquivo python.

  • Como parâmetros posicionais com a ordem específica de usuário, senha, conta, banco de dados, warehouse e função quando o python estiver sendo executado a partir da linha de comando.

  • Como parâmetros nomeados sem restrição de ordem de SNOW_USER, SNOW_PASSWORD, SNOW_ACCOUNT, SNOW_DATABASE, SNOW_WAREHOUSE, SNOW_ROLE, SNOW_QUERYTAG, SNOWAUTHENTICATOR e SNOWTOKEN quando o python estiver sendo executado a partir da linha de comando e qualquer um deles for passado como –param-VARNAME=VALUE.

  • Como variáveis de ambiente denominadas SNOW_USER, SNOW_PASSWORD, SNOW_ACCOUNT, SNOW_DATABASE, SNOW_WAREHOUSE, SNOW_ROLE, SNOW_QUERYTAG, SNOWAUTHENTICATOR e SNOWTOKEN antes da execução do python.

A ordem anterior especificada é a maneira de determinar a precedência.

Parâmetros na chamada de função

Eles podem ser definidos como parâmetros posicionais na chamada de função da seguinte forma.

    .....
   con = snowconvert.helpers.log_on(
     'myuser',
     'mypassword',
     'myaccount',
     'mydatabase',
     'mywarehouse',
     'myrole',
     5,
     'myauthenticator',
     'mytoken')
   .....
Copy

Ou podem ser definidos quaisquer dos parâmetros nomeados em qualquer ordem na chamada de função, da seguinte forma.

    .....
   con = snowconvert.helpers.log_on(
     account:'myaccount',
     password:'mypassword',
     user:'myuser',     
     warehouse:'mywarehouse',
     login_timeout:5,
     authenticator:'myauthenticator',
     toke:'mytoken')
   .....
Copy
Parâmetros posicionais

Eles precisam ser definidos na ordem específica na linha de comando, como segue.

 python sample_BTEQ.py myuser mypassword myaccount mydatabase mywarehouse myrole myauthenticator mytokenr
Copy

Ou podem ser definidos apenas alguns dos parâmetros, mas sempre começando com o parâmetro do usuário, como segue.

 python sample_BTEQ.py myuser mypassword myaccount
Copy
Parâmetros nomeados

Eles podem ser definidos com qualquer um dos parâmetros nomeados, em qualquer ordem, na linha de comando, da seguinte forma (use uma única linha, as linhas múltiplas são mostradas por motivos de legibilidade).

python sample_BTEQ.py --param-SNOW_WAREHOUSE=mywarehouse 
  --param-SNOW_ROLE=myrole 
  --param-SNOW_PASSWORD=mypassword 
  --param-SNOW_USER=myuser 
  --param-SNOW_QUERYTAG=mytag 
  --param-SNOW_ACCOUNT=myaccount
  --param-SNOW_DATABASE=mydatabase 
  --param-SNOW_AUTHENTICATOR=myauthenticator
  --param-SNOW_TOKEN=mytoken
  --param-PRIVATE_KEY_PATH=myprivatekey
  --param-PRIVATE_KEY_PASSWORD=myprivatekeypassword

Copy
Variáveis de ambiente

Antes de chamar o script python, qualquer uma das seguintes variáveis de ambiente pode ser definida:

  • SNOW_USER

  • SNOW_PASSWORD

  • SNOW_ACCOUNT

  • SNOW_DATABASE

  • SNOW_WAREHOUSE

  • SNOW_ROLE

  • SNOW_QUERYTAG

  • SNOW_AUTHENTICATOR

  • SNOW_TOKEN

  • PRIVATE_KEY_PATH

  • PRIVATE_KEY_PASSWORD

Autenticação por par de chaves

A função log_on também pode oferecer suporte ao processo de autenticação do par de chaves. Consulte a documentação do Snowflake a seguir para obter mais informações sobre a criação de chaves. Observe os parâmetros necessários:

log_on(

user='YOUR_USER',

account='YOUR_ACCOUNT',

role = 'YOUR_ROLE',

warehouse = 'YOUR_WAREHOUSE',

database = 'YOUR_DATABASE',

private_key_path='/YOUR_PATH/rsa_key.p8',

private_key_password='YOUR_PASSWORD')

Exemplo de passagem de variáveis de ambiente

Aqui está um exemplo de uso de SNOW_AUTHENTICATOR, SNOW_USER e SNOW_PASSWORD. Eles devem ser definidos antes de executar o arquivo python de saída e, em seguida, executar o arquivo gerado pelo python.

 SET SNOW_AUTHENTICATOR=VALUE
SET SNOW_USER=myuser
SET SNOW_PASSWORD=mypassword
python sample_BTEQ.py
Copy
 export SNOW_AUTHENTICATOR=VALUE
export SNOW_USER=myuser
export SNOW_PASSWORD=mypassword
python3 sample_BTEQ.py
Copy

Como ativar o registro em log

Para ativar logs, você deve ativar uma variável de ambiente chamada SNOW_LOGGING definida como true.

Em seguida, se quiser personalizar a configuração de registro, você pode passar um parâmetro para o método snowconvert.helpers.configure_log() desta forma:

 snowconvert.helpers.configure_log("SOMEPATH.conf")
Copy

O arquivo de configuração deve conter a seguinte estrutura. Para obter mais informações sobre o registro em python, clique aqui

 [loggers]
keys=root

[handlers]
keys=consoleHandler

[formatters]
keys=simpleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_simpleExample]
level=DEBUG
handlers=consoleHandler
qualname=simpleExample
propagate=0

[handler_consoleHandler]
class=FileHandler
level=DEBUG
formatter=simpleFormatter
args=('python2.log', 'w')

[formatter_simpleFormatter]
format=%(asctime)s -%(levelname)s - %(message)s
Copy

Snowflake

Depois de executar qualquer código migrado, você pode acessar o Snowflake e verificar suas alterações ou implementações.

 select * from PUBLIC.table1;
Copy

Você poderá ver as linhas que inseriu no exemplo acima.

Resultado da consulta

Documentação auxiliares locais

Antes de tudo, é necessário instalar o pacote python chamado pydoc (disponível desde a versão 2.0.2 do snowconvert-helpers).

 pip install pydoc
Copy

Em seguida, para exibir a documentação em python do pacote snowconvert-helpers, você deve ir para uma pasta em que tenha o código de saída convertido e uma saída em python.

D:\bteq\Output>dir

 Volume in drive D is Storage
 Volume Serial Number is 203C-168C

 Directory of D:\bteq\Output

05/25/2021  03:55 PM    <DIR>          .
05/25/2021  03:55 PM    <DIR>          ..
05/25/2021  03:55 PM               630 input_BTEQ.py
               1 File(s)            630 bytes
               2 Dir(s)  1,510,686,502,912 bytes free

Copy

Localizado nesse diretório, você precisa executar:

 python -m pydoc -b
Copy

O console abrirá o navegador de sua preferência com a ajuda de HTML da documentação de todos os pacotes instalados.

D:\bteq\Output>python -m pydoc -b
Server ready at http://localhost:61355/
Server commands: [b]rowser, [q]uit
server>

Copy

Isso abrirá o navegador com a documentação do seu código, como:

Página inicial da documentação local gerada

Role até o final da página para ver os pacotes instalados. E você verá algo semelhante a:

Índice da documentação dos pacotes locais instalados

Ao clicar em SnowConvert(pacote), você verá algo como:

Página inicial da documentação do snowconvert-helpers

Clicar nos auxiliares de módulo exibirá uma tela semelhante à seguinte:

Página inicial do módulo de auxiliares

Em seguida, você pode percorrer as funções e as classes do módulo.

Documentação de funções

Problemas conhecidos

Não foram encontrados problemas.

EWIs Relacionados

Sem EWIs relacionados.

Documentação técnica

Funções

Todas as funções definidas no projeto.

access

**`access`**`(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)`
Copy
Descrição:

Use o uid/gid real para testar o acesso a um caminho.

dir_fd, effective_ids e follow_symlinks podem não estar implementados em sua plataforma. Se eles não estiverem disponíveis, o uso deles gerará um NotImplementedError.

Observe que a maioria das operações usará o uid/gid efetivo, portanto, essa rotina pode ser usada em um ambiente suid/sgid para testar se o usuário que está invocando tem o acesso especificado ao caminho.

Parâmetros:
  • path, Caminho a ser testado; pode ser uma cadeia de caracteres, bytes ou um objeto semelhante a um caminho

  • mode, Campo de bits do modo do sistema operacional. Pode ser F_OK para testar a existência, ou o inclusive-OR de R_OK, W_OK e X_OK

  • dir_fd, Se não for None, deve ser um descritor de arquivo aberto em um diretório, e o caminho deve ser relativo; o caminho será relativo a esse diretório

  • effective_ids, Se True, o acesso usará o uid/gid efetivo em vez do uid/gid real

  • follow_symlinks, Se False e o último elemento do caminho for um link simbólico, access examinará o próprio link simbólico em vez do arquivo para o qual o link aponta

at_exit_helpers

**`at_exit_helpers`**`()`
Copy
Descrição:

Executado na saída da execução do script.

colored

**`colored`**`(text, color='blue')`
Copy
Descrição:

Imprime texto colorido a partir da cor especificada.

Parâmetros:
  • text , O texto a ser impresso

  • color="blue" , A cor a ser impressa

configure_log

**`configure_log`**`(configuration_path)`
Copy
Descrição:

Configura o registro que será realizado para qualquer execução relacionada a dados na conexão do snowflake. Por padrão, o arquivo de registro é denominado «snowflake_python_connector.log».

Parâmetros:

  • configuration_path , O caminho de configuração do arquivo que contém todas as configurações desejadas para o registro

drop_transient\_table

**`drop_transient_table`**`(tempTableName, con=None)`
Copy
Descrição:

Insere a tabela transitória com o nome especificado.

Parâmetros:

  • tempTableName , O nome da tabela temporária

  • con=None , A conexão a ser usada; se None for passado, será usada a última conexão realizada

exception_hook

**`exception_hook`**`(exctype, value, tback)`
Copy
Descrição:

Parâmetros:

  • exctype

  • value

  • tback

exec

**`exec`**`(sql_string, using=None, con=None)`
Copy
Descrição:

Executa uma cadeia de caracteres sql usando a última conexão; opcionalmente, usa argumentos ou uma conexão específica. Exemplos:

  • _ exec("SELECT * FROM USER")_

  • _ exec("SELECT * FROM USER", con)_

  • _ exec("SELECT * FROM CUSTOMER WHERE CUSTOMERID= %S", customer)_

Parâmetros:

  • sql_string , A definição do sql

  • using=None , O parâmetro opcional que pode ser usado no sql passado

  • con=None , A conexão a ser usada; se None for passado, será usada a última conexão realizada

exec_file

**`exec_file`**`(filename, con=None)`
Copy
Descrição:

Lê o conteúdo de um arquivo e executa as instruções sql contidas com a conexão especificada.

Parâmetros:

  • filename , O nome do arquivo a ser lido e executado

  • con=None , A conexão a ser usada; se None for passado, será usada a última conexão realizada

exec_os

**`exec_os`**`(command)`
Copy
Descrição:

Executa um comando no sistema operacional.

exec_sql\_statement

**`exec_sql_statement`**`(sql_string, con, using=None)`
Copy
Descrição:

Executa uma instrução sql na conexão passada, com os argumentos opcionais.

Parâmetros:

  • sql_string , O sql que contém a cadeia de caracteres a ser executada

  • con , A conexão a ser usada

  • using , Os parâmetros opcionais a serem usados na execução do sql

expands\using_params**

**`expands_using_params`**`(statement, params)`
Copy
Descrição:

Expande a instrução passada com os parâmetros.

Parâmetros:

  • statement , O sql que contém a cadeia de caracteres a ser executada

  • params , Os parâmetros da instrução sql

expandvar

**`expandvar`**`(str)`
Copy
Descrição:

Expande a variável a partir da cadeia de caracteres passada.

Parâmetros:

  • str , A cadeia de caracteres a ser expandida com as variáveis

expandvars

**`expandvars`**`(path, params, skip_escaped=False)`
Copy
Descrição:

Expanda as variáveis de ambiente do formato $var e ${var}. Se o parâmetro “skip_escaped” for True, todas as referências de variáveis com escape (ou seja, precedidas por barras invertidas) serão ignoradas. As variáveis desconhecidas são definidas como «padrão». Se “default” for None, eles não serão alterados.

Parâmetros:

  • path ,

  • params ,

  • skip_escaped=False ,

FAST LOAD

**`fast_load`**`(target_schema, filepath, stagename, target_table_name, con=None)`
Copy
Descrição:

Executa o carregamento rápido com os parâmetros passados target_schema, filepath, stagename e target_table_name.

Parâmetros:

  • target_schema , O nome do esquema a ser usado no carregamento rápido

  • filepath , O caminho do nome do arquivo a ser carregado na tabela

  • target_table_name , O nome da tabela que terá os dados carregados

  • con=None , A conexão a ser usada; se None for passado, será usada a última conexão realizada

file\exists\_and\_readable**

**`file_exists_and_readable`**`(filename)`
Copy
Descrição:

Parâmetros:

  • filename ,

get\argkey**

**`get_argkey`**`(astr)`
Copy
Descrição:

Obtém o valor da chave do argumento a partir da cadeia de caracteres passada. Ele deve começar com a cadeia de caracteres “–param-”

Parâmetros:

  • astr , A cadeia de caracteres de argumento a ser usada. A cadeia de caracteres deve ter um valor semelhante a –param-column=32 e a cadeia retornada será “32

get\error_position**

**`get_error_position`**`()`
Copy
Descrição:

Obtém a posição do erro do arquivo usando as informações da pilha do erro produzido.

get\from_vars_or_args_or_environment**

**`get_from_vars_or_args_or_environment`**`(arg_pos, variable_name, vars, args)`
Copy
Descrição:

Obtém o argumento da posição especificada ou obtém o valor da tabela vars ou obtém o nome da variável de ambiente passada.

Parâmetros:

  • arg_pos , A posição do argumento a ser usada a partir do parâmetro arguments

  • variable_name , O nome da variável a ser obtida

  • vars , O hash com os nomes e valores das variáveis

  • args , O parâmetro da matriz de argumentos

import\data_to_temptable**

**`import_data_to_temptable`**`(tempTableName, inputDataPlaceholder, con)`
Copy
Descrição:

Importa dados para uma tabela temporária usando um espaço reservado de dados de entrada.

Parâmetros:

  • tempTableName, O nome da tabela temporária.

  • inputDataPlaceholder, O espaço reservado de entrada usado que é um estágio no banco de dados snowflake

  • con, A conexão a ser usada

import\file**

**`import_file`**`(filename, separator=' ')`
Copy
Descrição:

Importa o nome de arquivo passado com o separador opcional.

Parâmetros:

  • filename, O caminho do nome do arquivo a ser importado

  • separator=' ', O separador opcional

import\file_to_temptable**

**`import_file_to_temptable`**`(filename, tempTableName, columnDefinition)`
Copy
Descrição:

Importa o arquivo passado para uma tabela temporária. Ele usará um estágio público nomeado como tabela temporária com o prefixo Stage_. Ao final do carregamento para a tabela temporária, ele excluirá o estágio que foi usado no processo.

Parâmetros:

  • filename, O nome do arquivo a ser lido

  • tempTableName, O nome da tabela temporária

  • columnDefinition, A definição de todos os campos que terão a tabela temporária

import\reset**

**`import_reset`**`()`
Copy
Descrição:

log

**`log`**`(*msg, level=20, writter=None)`
Copy
Descrição:

Imprime uma mensagem no console (saída padrão) ou no arquivo de registro, dependendo se o registro estiver ativado

Parâmetros:

  • *msg, A mensagem a ser impressa ou registrada

  • level=20,

  • writter=None,

log\on**

**`log_on`**`(user=None, password=None, account=None, database=None, warehouse=None, role=None, login_timeout=10, authenticator=None)`
Copy
Descrição:

Faz logon no banco de dados do snowflake com os parâmetros passados de credenciais, banco de dados, warehouse, função, login_timeout e autenticador.

Parâmetros:

  • user, O usuário do banco de dados

  • password A senha do usuário do banco de dados

  • database, O banco de dados a ser conectado

  • warehouse, O warehouse do banco de dados a ser conectado

  • role, A função a ser conectada

  • login_timeout, O tempo limite máximo antes de emitir um erro se a conexão estiver demorando muito para se conectar

  • authenticator, O valor suportado do autenticador a ser usado, como SNOWFLAKE, EXTERNALBROWSER, SNOWFLAKE_JWT ou OAUTH

  • token, O token OAUTH ou JWT

os

**`os`**`(args)`
Copy
Descrição:

Parâmetros:

  • args,

quit\application**

**`quit_application`**`(code=None)`
Copy
Descrição:

Encerra o aplicativo e, opcionalmente, retorna o código passado.

Parâmetros:

  • code=None, O código a ser retornado após o encerramento

read\params\_args**

**`read_param_args`**`(args)`
Copy
Descrição:

Lê os argumentos dos parâmetros da matriz passada.

Parâmetros:

  • args, Os argumentos a serem usados

readrun

**readrun**(line, skip=0)
Copy
Descrição:

Lê as linhas do nome de arquivo fornecido e, opcionalmente, pula algumas linhas no início do arquivo.

Parâmetros:

  • line, O nome do arquivo a ser lido

  • skip=0, As linhas a serem puladas

remark

**remark**(arg)
Copy
Descrição:

Imprime o argumento.

Parâmetros:

  • arg, O argumento a ser impresso

repeat\previous_sql_statement**

**`repeat_previous_sql_statement`**`(con=None, n=1)`
Copy
Descrição:

Repete a(s) instrução(ões) sql executada(s) anteriormente.

Parâmetros:

  • con=None, Conexão se especificada. Se isso não for passado, será usada a última conexão realizada

  • n=1, O número de instruções anteriores a serem executadas novamente

set\default\_error\_level**

**`set_default_error_level`**`(severity_value)`
Copy
Descrição:

Parâmetros:

  • severity_value,

set\error_level**

**`set_error_level`**`(arg, severity_value)`
Copy
Descrição:

Parâmetros:

  • arg,

  • severity_value,

simple\fast_load**

**`simple_fast_load`**`(con, target_schema, filepath, stagename, target_table_name)`
Copy
Descrição:

Executa um carregamento rápido simples na conexão e o parâmetro passado target_schema, filepath, stagename e nome da tabela de destino.

Parâmetros:

  • arg, A conexão a ser usada

  • target_schema, O nome do esquema a ser usado no carregamento rápido

  • filepath, O caminho do nome do arquivo a ser carregado na tabela

  • target_table_name, O nome da tabela que terá os dados carregados

stat

**`stat`**`(path, *, dir_fd=None, follow_symlinks=True)`
Copy
Descrição:

Execute uma chamada de sistema stat no caminho fornecido. dir_fd e follow_symlinks podem não estar implementados em sua plataforma. Se eles não estiverem disponíveis, o uso deles gerará um NotImplementedError. É um erro usar dir_fd ou follow_symlinks ao especificar o caminho como um descritor de arquivo aberto

Parâmetros:

  • path, Caminho a ser examinado; pode ser uma cadeia de caracteres, bytes, um objeto semelhante a um caminho ou\ open-file-descriptor int

  • dir_fd, Se não for None, deve ser um descritor de arquivo aberto em um diretório, e o caminho deve ser uma cadeia de caracteres relativa; o caminho será então relativo a esse diretório

  • follow_symlinks, Se for False e o último elemento do caminho for um link simbólico, stat examinará o próprio link simbólico em vez do arquivo para o qual o link aponta

system

**`system`**`(command)`
Copy
Descrição:

Execute o comando em um subshell.

Parâmetros:

  • _ command_ ,

usando

**`using`**`(*argv)`
Copy
Descrição:

Parâmetros:

  • _ *argv_ ,

Classes

Todas as classes definidas no projeto

Classe BeginLoading

Essa classe contém a função estática import_file_to_tab que oferece suporte para os comandos BEGIN LOADING e comandos associados em FastLoad.

import_file_to_tab()

Parâmetros:

  1. target_schema_table

    • o esquema de destino (opcional) e o nome da tabela

  2. define_file

    • O nome do arquivo a ser lido

  3. define_columns

    • A definição de todas as colunas da tabela temporária

  4. begin_loading_columns

    • Os nomes das colunas a serem inseridas. Determina a ordem em que os valores são inseridos

  5. begin_loading_values

    • A lista de valores de inserção brutos a serem convertidos

  6. field_delimiter

    • O delimitador de campo

  7. (opcional) skip_header

    • O número de linhas a serem ignoradas

  8. (opcional) input_data_place_holder

    • A localização do arquivo em um provedor de nuvem compatível. Defina o parâmetro quando o arquivo não estiver armazenado localmente

  9. (opcional) con

    • A conexão a ser usada

Classe de exportação

Métodos estáticos na classe

  • defaults()

  • null(value=None)

  • record_mode(value=None)

  • report(file, separator=' ')

  • reset()

  • separator_string(value=None)

  • separator_width(value=None)

  • side_titles(value=None)

  • title_dashes(value=None, withValue=None)

  • title_dashes_with(value=None)

  • width(value=None)

\ Dados e outros atributos definidos aqui

  • expandedfilename = None

  • separator = '' \

Classe de importação

Métodos na classe

  • reset()

Métodos estáticos na classe

  • file(file, separator=' ')

  • using(globals, *argv)

Dados e outros atributos definidos na classe

  • expandedfilename = None

  • no_more_rows = False

  • read_obj = None

  • reader = None

  • separator = ' '

Classe Parameters

Dados e outros atributos definidos na classe

  • passed_variables = {}

BTEQ

O Basic Teradata Query (BTEQ) é um programa de uso geral, baseado em comandos, que permite que os usuários de uma estação de trabalho se comuniquem com um ou mais sistemas de banco de dados Teradata e formatem relatórios para impressão e saída na tela.

Para simular a funcionalidade do BTEQ do Teradata no Snowflake, os arquivos e comandos do BTEQ são transformados em código Python, de forma semelhante às transformações realizadas nos scripts MultiLoad e FastLoad. O código gerado usa o projeto Snowflake Python chamado snowconvert.helpers que contém as funções necessárias para simular as instruções do BTEQ no Snowflake.

Conversão de comandos do BTEQ

A tabela a seguir apresenta a conversão dos comandos do BTEQ para o Snowflake.

Teradata

Snowflake

Notas

ERRORCODE != 0

snowconvert.helpers.error_code != 0

.EXPORT DATA FILE=fileName

Export.report(«fileName», «,»)

A função não tem funcionalidade

.EXPORT INDICDATA FILE=fileName

Export.report(«fileName», «,»)

A função não tem funcionalidade

.EXPORT REPORT FILE=fileName

Export.report(«fileName», «,»)

A função não tem funcionalidade

.EXPORT DIF FILE=fileName

Export.report(«fileName», «,»)

A função não tem funcionalidade

.EXPORT RESET

Export.reset()

A função não tem funcionalidade

.IF ERRORCODE! = 0 THEN.QUIT ERRORCODE

If snowconvert.helpers.error_code != 0: snowconvert.helpers.quit_application (snowconvert.helpers.error_code)

.IMPORT RESET

snowconvert.helpers.import_reset()

A função não tem funcionalidade

.LABEL newLabel

def NEWLABEL():
snowconvert.helpers.quit_application()

.LOGOFF

A instrução é comentada

.LOGON

A instrução é comentada

.LOGMECH

A instrução é comentada

.OS /fs/fs01/bin/filename.sh “load”

snowconvert.helpers.os(«»/fs/fs01/bin/filename.sh “load” «»)

.RUN FILE=newFile

for statement in snowconvert.helpers.readrun(«newFile»): eval(statement)

.SET DEFAULTS

Export.defaults()

A função não tem funcionalidade

.SET ERRORLEVEL 3807 SEVERITY 0

snowconvert.helpers.set_error_level(3807, 0)

.SET RECORMODE OFF

Export.record_mode(False)

.SET RECORMODE ON

Export.record_mode(True)

.SET SEPARATOR “|”

Export.separator_string(“|”)

A função não tem funcionalidade

.SET WIDTH 120

Export.width(120)

A função não tem funcionalidade

.Remark «»Hello world!»»»

snowconvert.helpers.remark(r»»»»»»Hello world!»»»»»»)

.QUIT ERRORCODE

snowconvert.helpers.quit_application(

snowconvert.helpers.error_code

)

.QUIT

snowconvert.helpers.quit_application()

Instruções SQL

exec(statement)

$(<$INPUT_SQL_FILE)

exec_file(«$INPUT_SQL_FILE»)

= (Repetir o comando anterior)

snowconvert.helpers.repeat_previous\_sql_statement(con)

Para instruções mais complicadas apresentadas na tabela anterior, são explicadas subseções com exemplos mais elaborados.

Conversão .GOTO

Como estamos convertendo os scripts do BTEQ para Python, algumas estruturas válidas no BTEQ não são inerentemente compatíveis com o Python. Esse é o caso do comando .GOTO usando os comandos .Label.

Por esse motivo, foi desenvolvida uma alternativa para que a funcionalidade desses comandos possa ser emulada, transformando os comandos .Label em funções com instruções de chamada subsequentes.

Verifique o código a seguir:

 .LABEL FIRSTLABEL
SELECT * FROM MyTable1;
.LABEL SECONDLABEL
SELECT * FROM MyTable2;
SELECT * FROM MyTable3;
Copy

No exemplo acima, havia cinco comandos. Dois deles eram comandos.Label. O comandoFIRSTLABELfoi transformado em uma função com a(s) instrução(ões) que o segue(m) abaixo até que outro comando.LABELseja encontrado. Quando outro rótulo é chamado (nesse caso, SECONDLABEL), essa chamada encerra a primeira função e inicia uma nova.

Se fôssemos migrar o exemplo anterior, o resultado seria o seguinte:

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  FIRSTLABEL()
  snowconvert.helpers.quit_application()
def FIRSTLABEL():
  exec("""
    SELECT
      *
    FROM
      MyTable1
    """)
  SECONDLABEL()
def SECONDLABEL():
  exec("""
    SELECT
      *
    FROM
      MyTable2
    """)
  exec("""
    SELECT
      *
    FROM
      MyTable3
    """)

if __name__ == "__main__":
  main()
Copy

Observe que há uma chamada para a função_ FIRSTLABEL, essa função tem apenas uma instrução, que seria o único comando sem rótulo que segueFIRSTLABELno código original. Antes de a funçãoFIRSTLABELterminar, ela chama SECONDLABEL_, com as instruções que a seguiram.

Notas:

  • Criando uma variável de conector con = None e preenchendo-a na função main(): con = snowconvert.helpers.log_on().

  • Configuração de um registro: snowconvert.helpers.configure_log().

Execução de instruções de consulta

Cada instrução SQL encontrada em um arquivo BTEQ será executada por meio da funçãoexecfornecida pelo snowconvert.helpers. Veja, por exemplo, o código a seguir:

 CREATE TABLE aTable (aColumn BYTEINT);
Copy

Isso é convertido para:

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  exec("""
    CREATE OR REPLACE TABLE aTable (
      aColumn BYTEINT
    )
    """)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

Execução de arquivos de script

Os arquivos que contêm os comandos do BTEQ de um usuário e as instruções do Teradata SQL são chamados de scripts, arquivos de execução, macros ou procedimentos armazenados. Por exemplo, crie um arquivo chamado SAMPFILE e digite o seguinte script do BTEQ:

    .LOGON tdpid/userid,password 
   SELECT * FROM department;
   .LOGOFF
Copy

Para executar o arquivo de execução, digite qualquer uma das formas do comando BTEQ RUN:

.RUN FILE=sampfile

Copy

Se você converter o segundo código, o resultado será o seguinte:

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()

  for statement in snowconvert.helpers.readrun(fr"sampfile"):
    eval(statement)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

O snowconvert.helpers.readrun("sampfile") retornará cada linha do SAMPFILE e, na instruçãoFOR, cada uma das linhas será passada para a função eval, um método que analisa a expressão passada para ele e executa a expressão python (o SAMPFILE deve ser convertido para funcionar) dentro do programa.

Execução de arquivos SQL

Em alguns casos, durante a execução de um arquivo BTEQ, um arquivo SQL pode ser encontrado, por exemplo, o arquivo SQL chamado NEWSQL:

 CREATE TABLE aTable (aColumn BYTEINT);
Copy

Isso pode ser executado durante um script com a seguinte linha:

 $(<$NEWSQL)
Copy

E após a conversão do script, o resultado é:

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  exec("""
    CREATE OR REPLACE TABLE aTable (
      aColumn BYTEINT
    )
    """)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

A função auxiliar exec_file lerá cada linha do arquivo NEWSQL e, em seguida, usará a função exec, conforme explicado na seção Execução de instruções de consulta.

Problemas conhecidos

Não foram encontrados problemas.

EWIs Relacionados

Não foram encontrados problemas.

REPEAT

Nota

Algumas partes do código de saída foram omitidas por motivos de clareza.

De acordo com a documentação do Teradata, a instrução REPEAT permite que os usuários especifiquem o número máximo de vezes que a próxima solicitação SQL deve ser enviada. Observe que uma solicitação SQL pode ser uma solicitação de instrução única ou múltipla. Isso é definido pela posição dos pontos-e-vírgulas para cada instrução após a instrução REPEAT.

Sintaxe

REPEAT [ n [ PACK p [ REQBUFLEN b ] ] | * | RECS r]
<sql_request>

Copy

Amostra de padrões da origem

Com esses dados de entrada:

A B C
D E F
G H I

Copy
* [
] *

Copy

Teradata:

 .IMPORT DATA FILE = inputData.dat;
.REPEAT *
USING var_1 (CHARACTER), var_2 (CHARACTER), var_3 (CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1)
;INSERT INTO testtabu (c1) VALUES (:var_2) 
;INSERT INTO testtabu (c1) VALUES (:var_3) 
;UPDATE testtabu 
   SET c2 = 'X'
   WHERE c1 = :var_1 
;UPDATE testtabu 
   SET c2 = 'Y' 
   WHERE c1 = :var_2 
;UPDATE testtabu 
   SET c2 = 'Z'
   WHERE c1 = :var_3
;INSERT INTO TESTTABU (c1, c2) VALUES ('?','_');

.REPEAT 10
INSERT INTO TESTTABU2 VALUES ('John Doe', 23);

.REPEAT RECS 5
INSERT INTO TESTTABU2 VALUES ('Bob Alice', 21);

.IMPORT DATA FILE = inputData2.dat;
USING (var_1 CHARACTER, var_2 CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1) 
;INSERT INTO testtabu (c1) VALUES (:var_2);
Copy
C1C2
AX
DX
GX
BY
EY
HY
CZ
FZ
IZ
?_
?_
?_
*null
[null
MY_NAMEMY_AGE
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21

Snowflake:

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  snowconvert.helpers.import_file(fr"inputData.dat")
  ssc_repeat_value = '*'
  ssc_max_iterations = 1

  for ssc_repeat_position in range(0, ssc_max_iterations):

    if ssc_repeat_position == 0:
      using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", "var_3", "CHARACTER", rows_to_read = ssc_repeat_value)
      exec("""
        INSERT INTO testtabu (c1)
        VALUES (:var_1)
        """, using = using)
      exec("""
        INSERT INTO testtabu (c1)
        VALUES (:var_2)
        """, using = using)
      exec("""
        INSERT INTO testtabu (c1)
        VALUES (:var_3)
        """, using = using)
      exec("""
        UPDATE testtabu
          SET
            c2 = 'X'
          WHERE
            c1 = :var_1
        """, using = using)
      exec("""
        UPDATE testtabu
          SET
            c2 = 'Y'
          WHERE
            c1 = :var_2
        """, using = using)
      exec("""
        UPDATE testtabu
          SET
            c2 = 'Z'
          WHERE
            c1 = :var_3
        """, using = using)
      exec("""
        INSERT INTO TESTTABU (c1, c2)
        VALUES ('?', '_')
        """, using = using)

  ssc_repeat_value = 10
  ssc_max_iterations = 10

  for ssc_repeat_position in range(0, ssc_max_iterations):
    exec("""
      INSERT INTO TESTTABU2
      VALUES ('John Doe', 23)
      """)
  ssc_repeat_value = 5
  ssc_max_iterations = 5

  for ssc_repeat_position in range(0, ssc_max_iterations):
    exec("""
      INSERT INTO TESTTABU2
      VALUES ('Bob Alice', 21)
      """)
  snowconvert.helpers.import_file(fr"inputData2.dat")
  using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", rows_to_read = 1)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_1)
    """, using = using)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_2)
    """, using = using)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy
C1C2
AX
DX
GX
BY
EY
HY
CZ
FZ
IZ
?_
?_
?_
*null
[null
MY_NAMEMY_AGE
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21

Problemas conhecidos

Não foram encontrados problemas.

EWIs Relacionados

Sem EWIs relacionados.

USING REQUEST MODIFIER

Some parts in the output code are omitted for clarity reasons.
Copy

De acordo com a documentação do Teradata, USING REQUEST MODIFIER define um ou mais nomes de parâmetros variáveis a serem usados nas instruções subsequentes SELECT, INSERT, UPDATE ou DELETE para importar ou exportar dados.

A sintaxe dessa instrução é a seguinte:

 USING ( <using_spec> [,...] ) SQL_request

<using_spec> ::= using_variable_name data_type [ data_type_attribute [...] ]
  [ AS { DEFERRED [BY NAME] | LOCATOR } ]
Copy

Conforme declarado na documentação do Teradata, USING REQUEST MODIFIER precisa ser precedido por uma instrução .IMPORT para carregar os dados nos parâmetros definidos.

Portanto, a transformação para essa instrução segue as seguintes etapas:

  1. Chame a função import_file() dos auxiliares do SnowConvert. Isso carrega os dados em um arquivo temporário.

  2. Chame a função using() dos auxiliares do SnowConvert para criar um dicionário com os dados carregados.

  3. Para cada consulta, execute a função exec() dos auxiliares do SnowConvert e passe o dicionário definido anteriormente. Isso usará os recursos de vinculação de dados do Snowflake Connector Python.

Com esses dados de entrada:

 A,B,C
Copy

Teradata (MultiLoad)

 .IMPORT DATA FILE = inputData.dat;
USING var_1 (CHARACTER), var_2 (CHARACTER), var_3 (CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1)
;INSERT INTO testtabu (c1) VALUES (:var_2) 
;INSERT INTO testtabu (c1) VALUES (:var_3) 
;UPDATE testtabu 
   SET c2 = 'X'
   WHERE c1 = :var_1 
;UPDATE testtabu 
   SET c2 = 'Y' 
   WHERE c1 = :var_2 
;UPDATE testtabu 
   SET c2 = 'Z'
   WHERE c1 = :var_3;
Copy
ROWC1C2
1AX
2BY
3CZ

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  snowconvert.helpers.import_file(fr"inputData.dat")
  using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", "var_3", "CHARACTER", rows_to_read = 1)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_1)
    """, using = using)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_2)
    """, using = using)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_3)
    """, using = using)
  exec("""
    UPDATE testtabu
      SET
        c2 = 'X'
      WHERE
        c1 = :var_1
    """, using = using)
  exec("""
    UPDATE testtabu
      SET
        c2 = 'Y'
      WHERE
        c1 = :var_2
    """, using = using)
  exec("""
    UPDATE testtabu
      SET
        c2 = 'Z'
      WHERE
        c1 = :var_3
    """, using = using)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy
ROWC1C2
1AX
2BY
3CZ

Problemas conhecidos

1. O comando .REPEAT ainda não é suportado

O comando .REPEAT ainda não é suportado. Isso significa que o USING REQUEST MODIFIER usará apenas os dados carregados da primeira linha do arquivo de entrada. Assim, as consultas serão executadas apenas uma vez.

Esse problema deverá ser corrigido quando o comando .REPEAT receber o suporte adequado para transformação.

Se você tiver outras dúvidas sobre esta documentação, pode nos enviar um e-mail para snowconvert-support@snowflake.com.

EWIs Relacionados

Sem EWIs relacionados.

FLOAD

O Teradata FastLoad é um utilitário orientado por comandos para carregar rapidamente grandes quantidades de dados em uma tabela vazia em um banco de dados Teradata.

Para simular a funcionalidade do FastLoad do Teradata no Snowflake, os arquivos e comandos do FastLoad são transformados em código Python, de forma semelhante às transformações realizadas nos scripts BTEQ e MultiLoad. O código gerado usa o projeto Snowflake Python chamado snowconvert.helpers que contém as funções necessárias para simular as instruções do FastLoad no Snowflake.

Conversão de comandos do FastLoad

A maioria dos comandos do FastLoad é considerada irrelevante no Snowflake, e esses comandos são comentados. Abaixo está a lista resumida dos comandos do FastLoad e seu status de transformação no Snowflake:

Comando do Teradata FastLoad

Status de transformação

Observação

AXSMOD

Comentado

BEGIN LOADING

Transformado

​O nó é comentado, pois a transformação ocorre na instrução INSERT relacionada.

CLEAR

Comentado

DATEFORM

Comentado

DEFINE

Transformado

END LOADING

Transformado

​Comentado, pois não é necessário para a transformação de BEGIN LOADING.

ERRLIMIT

Comentado

HELP

Comentado

HELP TABLE

Comentado

INSERT

Transformado

Transformado como parte de BEGIN LOADING.

LOGDATA

Comentado

LOGMECH

Comentado

LOGOFF

Comentado

LOGON

Comentado

NOTIFY

Comentado

OS

Comentado

QUIT

Comentado

RECORD

Comentado

RUN

Comentado

SESSIONS

Comentado

SET RECORD

Transformado

SET SESSION CHARSET

Comentado

SHOW

Comentado

SHOW VERSIONS

Comentado

SLEEP

Comentado

TENACITY

Comentado

Transformação padrão

O comportamento padrão da ConversionTool para essas instruções é comentá-las. Por exemplo:

Teradata (FastLoad)

 SESSIONS 4;
ERRLIMIT 25;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #SESSIONS 4
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #ERRLIMIT 25
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

No entanto, há algumas exceções que devem ser convertidas em instruções Python específicas para que funcionem como pretendido no Snowflake.

SQL Incorporado

Scripts do FastLoad suportam instruções do Teradata dentro do mesmo arquivo. A maioria dessas instruções é convertida como se estivesse em um arquivo BTEQ, com algumas exceções.

A eliminação de uma tabela de erros é comentada se estiver dentro de um arquivo FastLoad.

Teradata (FastLoad)

 DROP TABLE Error1;
DROP TABLE Error2;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  exec("""
    DROP TABLE Error1
    """)
  exec("""
    DROP TABLE Error2
    """)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

Exemplo grande

Dadas as transformações mostradas acima para uma variedade de comandos, considere o exemplo a seguir.

Teradata (FastLoad)

 SESSIONS 4;
ERRLIMIT 25;
DROP TABLE FastTable;
DROP TABLE Error1;
DROP TABLE Error2;
CREATE TABLE FastTable, NO FALLBACK
   ( ID INTEGER, UFACTOR INTEGER, MISC CHAR(42))
   PRIMARY INDEX(ID);
DEFINE ID (INTEGER), UFACTOR (INTEGER), MISC (CHAR(42))
   FILE=FileName;
SHOW;
BEGIN LOADING FastTable ERRORFILES Error1,Error2
   CHECKPOINT 10000;
INSERT INTO FastTable (ID, UFACTOR, MISC) VALUES
   (:ID, :MISC);
END LOADING;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
#** SSC-FDM-0007 - MISSING DEPENDENT OBJECTS "Error1", "Error2" **
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #SESSIONS 4
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #ERRLIMIT 25
   
  exec("""
    DROP TABLE FastTable
    """)
  exec("""
    CREATE OR REPLACE TABLE FastTable (
      ID INTEGER,
      UFACTOR INTEGER,
      MISC CHAR(42)
    )
    """)
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE ID (INTEGER), UFACTOR (INTEGER), MISC (CHAR(42)) FILE = FileName
   
  ssc_define_columns = "ID (INTEGER), UFACTOR (INTEGER), MISC (CHAR(42))"
  #Set file name manually if empty
  ssc_define_file = f"""FileName"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #SHOW
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #BEGIN LOADING FastTable ERRORFILES Error1, Error2 CHECKPOINT 10000
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS PART OF THE BEGIN LOADING TRANSLATION **
  #INSERT INTO FastTable (ID, UFACTOR, MISC) VALUES (:ID, :MISC)
   
  ssc_begin_loading_columns = "(ID, UFACTOR, MISC)"
  ssc_begin_loading_values = [":ID", ":MISC"]
  BeginLoading.import_file_to_table(f"""FastTable""", ssc_define_columns, ssc_define_file, ssc_begin_loading_columns, ssc_begin_loading_values, ",")
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. END LOADING **
  #END LOADING
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

Se você tiver outras dúvidas sobre esta documentação, pode nos enviar um e-mail para snowconvert-support@snowflake.com.

Problemas conhecidos

Não foram encontrados problemas.

EWIs relacionados

  1. SSC-FDM-0007: Elemento com dependências ausentes.

  2. SSC-FDM-0027: Removida a próxima instrução, não aplicável no SnowFlake.

BEGIN LOADING

A transformação para o comando BEGIN LOADING é uma transformação de várias partes que requer os comandos DEFINE, INSERT e (opcionalmente) SET RECORD para simular seu comportamento corretamente.

Essa transformação é explicada detalhadamente nas subseções a seguir.

SET RECORD

Conforme mencionado acima, esse comando não é necessário para a transformação de BEGIN LOADING. Se não for encontrado, o delimitador padrão será definido como “,” (vírgula). Caso contrário, será usado o delimitador definido. Esse valor é armazenado na variável ssc_set_record.

Até o momento, apenas SET RECORD VARTEXT, SET RECORD FORMATTED e SET RECORD UNFORMATTED são compatíveis. Para a especificação das palavras-chave BINARY e TEXT, um erro EWI é colocado em seu lugar.

Teradata (FastLoad)

 SET RECORD VARTEXT DELIMITER 'c' DISPLAY ERRORS 'efilename';
SET RECORD VARTEXT 'l' 'c' NOSTOP;
SET RECORD VARTEXT 'l' TRIM NONE LEADING 'p';
SET RECORD VARTEXT 'l' TRIM NONE TRAILING 'p';
SET RECORD VARTEXT 'l' TRIM NONE BOTH 'p';
SET RECORD FORMATTED TRIM NONE BOTH;
SET RECORD UNFORMATTED QUOTE NO OPTIONAL;
SET RECORD BINARY QUOTE NO YES 'q';
SET RECORD TEXT QUOTE OPTIONAL;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT DELIMITER 'c' DISPLAY ERRORS 'efilename'
   
  ssc_set_record = ""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' 'c' NOSTOP
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' TRIM NONE LEADING 'p'
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' TRIM NONE TRAILING 'p'
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' TRIM NONE BOTH 'p'
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD FORMATTED TRIM NONE BOTH
   
  ssc_set_record = ","
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD UNFORMATTED QUOTE NO OPTIONAL
   
  ssc_set_record = "UNFORMATTED"
  #** SSC-EWI-0021 - 'BINARY' KEYWORD SPECIFICATION FOR SET RECORD NOT SUPPORTED IN SNOWFLAKE **
  #SET RECORD BINARY QUOTE NO YES 'q'
   
  #** SSC-EWI-0021 - 'TEXT' KEYWORD SPECIFICATION FOR SET RECORD NOT SUPPORTED IN SNOWFLAKE **
  #SET RECORD TEXT QUOTE OPTIONAL
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

DEFINE

A transformação para o comando DEFINE define as variáveis ssc_define_columns e ssc_define_file com o valor da definição de colunas e o caminho do arquivo a ser usado na transformação BEGIN LOADING, respectivamente.

Teradata (FastLoad)

 DEFINE
    id (INTEGER),
    first_name (VARCHAR(50)),
    last_name (VARCHAR(50)),
    salary (FLOAT)
FILE=/tmp/inputData.txt;

DEFINE
    id (INTEGER),
    first_name (VARCHAR(50)),
    last_name (VARCHAR(50)),
    salary (FLOAT)

DEFINE
FILE=/tmp/inputData.txt;

DEFINE;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT) FILE = /tmp/inputData.txt
   
  ssc_define_columns = "id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)"
  #Set file name manually if empty
  ssc_define_file = f"""/tmp/inputData.txt"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)
   
  ssc_define_columns = "id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)"
  #Set file name manually if empty
  ssc_define_file = f""""""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE FILE = /tmp/inputData.txt
   
  ssc_define_columns = ""
  #Set file name manually if empty
  ssc_define_file = f"""/tmp/inputData.txt"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE
   
  ssc_define_columns = ""
  #Set file name manually if empty
  ssc_define_file = f""""""
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

BEGIN LOADING

O comando BEGIN LOADING é comentado, pois as informações relevantes para a transformação são encontradas na instrução INSERT associada.

ERRORFILES NODROP, CHECKPOINT, INDICATORS e DATAENCRYPTION não são necessárias para a transformação e, portanto, foram comentadas.

Teradata (FastLoad)

 BEGIN LOADING FastTable ERRORFILES Error1,Error2
   CHECKPOINT 10000;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #BEGIN LOADING FastTable ERRORFILES Error1, Error2 CHECKPOINT 10000
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

INSERT

A transformação da instrução INSERT associada define o valor das variáveis ssc_begin_loading_columns e ssc_begin_loading_values, usadas para determinar a ordem de inserção dos valores a serem carregados.

Por fim, essas variáveis e as descritas nas seções acima são usadas para chamar a parte da função BeginLoading.import_file_to_table do módulo SnowConvert.Helpers. Essa função simula o comportamento de todo o processo FastLoad BEGIN LOADING. Para saber mais sobre essa função, consulte aqui.

Teradata (FastLoad)

 SET RECORD VARTEXT """";
DEFINE
    _col1 (CHAR(10)),
    _col2 (CHAR(7)),
    _col3 (CHAR(2, NULLIF = 'V5'))
FILE=inputDataNoDel.txt;
BEGIN LOADING TESTS.EmpLoad4
ERRORFILES ${CPRDBName}.ET_${LOADTABLE},${CPRDBName}.UV_${LOADTABLE}
CHECKPOINT 1000;
INSERT INTO TESTS.EmpLoad4 (col2, col3, col1, col4)	
VALUES
(
    :_col2,
    :_col3,
    :_col1,
    CURRENT_DATE
);
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
#** SSC-FDM-0007 - MISSING DEPENDENT OBJECT "TESTS.EmpLoad4" **
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
#** SSC-FDM-TD0022 - SHELL VARIABLES FOUND, RUNNING THIS CODE IN A SHELL SCRIPT IS REQUIRED **
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT "" ""
   
  ssc_set_record = ""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE _col1 (CHAR(10)), _col2 (CHAR(7)), _col3 (CHAR(2, NULLIF = 'V5')) FILE = inputDataNoDel.txt
   
  ssc_define_columns = "_col1 (CHAR(10)), _col2 (CHAR(7)), _col3 (CHAR(2, NULLIF = 'V5'))"
  #Set file name manually if empty
  ssc_define_file = f"""inputDataNoDel.txt"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #BEGIN LOADING TESTS.EmpLoad4 ERRORFILES ${CPRDBName}.ET_${LOADTABLE}, ${CPRDBName}.UV_${LOADTABLE} CHECKPOINT 1000
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS PART OF THE BEGIN LOADING TRANSLATION **
  #INSERT INTO TESTS.EmpLoad4 (col2, col3, col1, col4) VALUES (:_col2, :_col3, :_col1, CURRENT_DATE)
   
  ssc_begin_loading_columns = "(col2, col3, col1, col4)"
  ssc_begin_loading_values = [":_col2", ":_col3", ":_col1", "CURRENT_DATE()"]
  BeginLoading.import_file_to_table(f"""TESTS.EmpLoad4""", ssc_define_columns, ssc_define_file, ssc_begin_loading_columns, ssc_begin_loading_values, ssc_set_record)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

Internamente, a função import_file_to_table cria um estágio temporário e coloca o arquivo local no estágio para ser carregado na tabela especificada. No entanto, o arquivo pode já estar armazenado em um dos provedores de nuvem suportados pelo Snowflake:

StageInput Data Place Holder
StageInput Data Place Holder
Internal stage@my_int_stage
External stage@my_int_stage/path/file.csv
Amazon S3 buckets3://mybucket/data/files
Google Cloud Storagegcs://mybucket/data/files
Microsoft Azureazure://myaccount.blob.core.windows.net/mycontainer/data/files

Se esse for o caso, adicione manualmente o parâmetro adicional input_data_place_holder="<cloud_provider_path>" na função import_file_to_table. Por exemplo:

 BeginLoading.import_file_to_table(
  f"""TESTS.EmpLoad4""", 
  ssc_define_columns, 
  ssc_define_file, 
  ssc_begin_loading_columns, 
  ssc_begin_loading_values, 
  ssc_set_record,
  input_data_place_holder="s3://mybucket/data/files")
Copy

END LOADING

O comando END LOADING é comentado, pois não é necessário para a transformação de BEGIN LOADING.

Teradata (FastLoad)

 END LOADING;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. END LOADING **
  #END LOADING
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

Problemas conhecidos

1. A especificação de palavras-chave BINARY e TEXT não é suportada

Ainda não há suporte para a especificação das palavras-chave BINARY e TEXT para o comando SET RECORD.

2. Somente a especificação básica para VARTEXT é suportada

Especificações extras para SET RECORD VARTEXT, como TRIM ou QUOTE, ainda não são compatíveis.

EWIs relacionados

  1. SSC-FDM-0007: Elemento com dependências ausentes.

  2. SSC-FDM-0027: Removida a próxima instrução, não aplicável no SnowFlake.

  3. SSC-EWI-0021: Não suportado.

  4. SSC-FDM-TD0022: Variáveis de shell encontradas, é necessário executar esse código em um script de shell.