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
Código convertido
## Some comments on the job
class LOADJOB:
# DESCRIPTION 'LOAD AC_SCHEMA TABLE FROM A FILE'
JobBody
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
);
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,
);"""
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']
);
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')
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'
);
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
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'
);
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
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);
);
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() )})""")
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()
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:
Commands | Transformation Status | Note |
---|---|---|
ACCEPT | Commented | |
BEGIN MLOAD | Transformed | The node is commented out since the transformation occurs in other related statements instead. |
BEGIN DELETE MLOAD | Commented | |
DATEFORM | Commented | |
DELETE | Partially transformed | Check known issues. |
DISPLAY | Commented | |
DML LABEL | Transformed | |
END MLOAD | Transformed | Commented out since is not necessary for the transformation of the BEGIN MLOAD. |
EOC | Commented | |
FIELD | Transformed | |
FILLER | Transformed | This command needs to be with a FIELD and LAYOUT command to be converted. |
IF, ELSE, and ENDIF | Commented | |
IMPORT | Transformed | |
INSERT | Transformed | This is taken as a Teradata Statement, so it doesn't appear in this chapter. |
LAYOUT | Transformed | This command needs to be with a FIELD and FILLER command to be converted. |
LOGDATA | Commented | |
LOGMECH | Commented | |
LOGOFF | Commented | |
LOGON | Commented | |
LOGTABLE | Commented | |
PAUSE ACQUISITION | Commented | |
RELEASE MLOAD | Commented | |
ROUTE MESSAGES | Commented | |
RUN FILE | Commented | |
SET | Commented | |
SYSTEM | Commented | |
TABLE | Commented | |
UPDATE | Transformed | This is taken as a Teradata Statement, so it doesn't appear in this chapter. |
VERSION | Commented | |
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;
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()
.DML LABEL¶
A transformação para o comando .DML LABEL
criará 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 );
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()
.IMPORT¶
A transformação do comando .IMPORT
criará uma chamada para o auxiliarimport_file_to_temptable
para carregar os dados do arquivo em uma tabela temporária. Em seguida, serão criadas as chamadas para todos os rótulosAPPLY
usados na importação original. Por fim, as chamadas para um rótuloINSERT
serã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;
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()
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
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;
ROW | ID | NAME | AGE |
---|---|---|---|
1 | NULL | ohn | 25 |
2 | 2 | aria | 29 |
3 | 3 | arlos | 31 |
4 | 4 | ike | 40 |
5 | 5 | aura | 27 |
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()
ROW | ID | NAME | AGE |
---|---|---|---|
1 | NULL | ohn | 25 |
2 | 2 | aria | 29 |
3 | 3 | arlos | 31 |
4 | 4 | ike | 40 |
5 | 5 | aura | 27 |
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
""")
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);
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.
#*** 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()
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
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
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
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')
.....
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')
.....
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
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
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
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
export SNOW_AUTHENTICATOR=VALUE
export SNOW_USER=myuser
export SNOW_PASSWORD=mypassword
python3 sample_BTEQ.py
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")
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
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;
Você poderá ver as linhas que inseriu no exemplo acima.
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
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
Localizado nesse diretório, você precisa executar:
python -m pydoc -b
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>
Isso abrirá o navegador com a documentação do seu código, como:
Role até o final da página para ver os pacotes instalados. E você verá algo semelhante a:
Ao clicar em SnowConvert(pacote), você verá algo como:
Clicar nos auxiliares de módulo exibirá uma tela semelhante à seguinte:
Em seguida, você pode percorrer as funções e as classes do módulo.
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)`
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 caminhomode,
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_OKdir_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órioeffective_ids,
Se True, o acesso usará o uid/gid efetivo em vez do uid/gid realfollow_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`**`()`
Descrição:¶
Executado na saída da execução do script.
colored¶
**`colored`**`(text, color='blue')`
Descrição:¶
Imprime texto colorido a partir da cor especificada.
Parâmetros:¶
text
,
O texto a ser impressocolor="blue"
,
A cor a ser impressa
configure_log¶
**`configure_log`**`(configuration_path)`
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)`
Descrição:¶
Insere a tabela transitória com o nome especificado.
Parâmetros:
tempTableName
,
O nome da tabela temporáriacon=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)`
Descrição:¶
Parâmetros:
exctype
value
tback
exec¶
**`exec`**`(sql_string, using=None, con=None)`
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 sqlusing=None
,
O parâmetro opcional que pode ser usado no sql passadocon=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)`
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 executadocon=None
,
A conexão a ser usada; se None for passado, será usada a última conexão realizada
exec_os¶
**`exec_os`**`(command)`
Descrição:¶
Executa um comando no sistema operacional.
exec_sql\_statement¶
**`exec_sql_statement`**`(sql_string, con, using=None)`
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 executadacon
,
A conexão a ser usadausing
,
Os parâmetros opcionais a serem usados na execução do sql
expands\using_params**¶
**`expands_using_params`**`(statement, params)`
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 executadaparams
,
Os parâmetros da instrução sql
expandvar¶
**`expandvar`**`(str)`
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)`
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)`
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ápidofilepath
,
O caminho do nome do arquivo a ser carregado na tabelatarget_table_name
,
O nome da tabela que terá os dados carregadoscon=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)`
Descrição:¶
Parâmetros:
filename
,
get\argkey**¶
**`get_argkey`**`(astr)`
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`**`()`
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)`
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 argumentsvariable_name
,
O nome da variável a ser obtidavars
,
O hash com os nomes e valores das variáveisargs
,
O parâmetro da matriz de argumentos
import\data_to_temptable**¶
**`import_data_to_temptable`**`(tempTableName, inputDataPlaceholder, con)`
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 snowflakecon,
A conexão a ser usada
import\file**¶
**`import_file`**`(filename, separator=' ')`
Descrição:¶
Importa o nome de arquivo passado com o separador opcional.
Parâmetros:
filename,
O caminho do nome do arquivo a ser importadoseparator=' ',
O separador opcional
import\file_to_temptable**¶
**`import_file_to_temptable`**`(filename, tempTableName, columnDefinition)`
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 lidotempTableName,
O nome da tabela temporáriacolumnDefinition,
A definição de todos os campos que terão a tabela temporária
import\reset**¶
**`import_reset`**`()`
Descrição:¶
log¶
**`log`**`(*msg, level=20, writter=None)`
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 registradalevel=20,
writter=None,
log\on**¶
**`log_on`**`(user=None, password=None, account=None, database=None, warehouse=None, role=None, login_timeout=10, authenticator=None)`
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 dadospassword
A senha do usuário do banco de dadosdatabase,
O banco de dados a ser conectadowarehouse,
O warehouse do banco de dados a ser conectadorole,
A função a ser conectadalogin_timeout,
O tempo limite máximo antes de emitir um erro se a conexão estiver demorando muito para se conectarauthenticator,
O valor suportado do autenticador a ser usado, como SNOWFLAKE, EXTERNALBROWSER, SNOWFLAKE_JWT ou OAUTHtoken,
O token OAUTH ou JWT
os¶
**`os`**`(args)`
Descrição:¶
Parâmetros:
args,
print\table**¶
**`print_table`**`(dictionary)`
Descrição:¶
Imprime o dicionário sem expor os valores de usuário e senha.
Parâmetros:
dictionary,
quit\application**¶
**`quit_application`**`(code=None)`
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)`
Descrição:¶
Lê os argumentos dos parâmetros da matriz passada.
Parâmetros:
args,
Os argumentos a serem usados
readrun¶
**readrun**(line, skip=0)
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 lidoskip=0,
As linhas a serem puladas
remark¶
**remark**(arg)
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)`
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 realizadan=1,
O número de instruções anteriores a serem executadas novamente
set\default\_error\_level**¶
**`set_default_error_level`**`(severity_value)`
Descrição:¶
Parâmetros:
severity_value,
set\error_level**¶
**`set_error_level`**`(arg, severity_value)`
Descrição:¶
Parâmetros:
arg,
severity_value,
simple\fast_load**¶
**`simple_fast_load`**`(con, target_schema, filepath, stagename, target_table_name)`
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 usadatarget_schema,
O nome do esquema a ser usado no carregamento rápidofilepath,
O caminho do nome do arquivo a ser carregado na tabelatarget_table_name,
O nome da tabela que terá os dados carregados
stat¶
**`stat`**`(path, *, dir_fd=None, follow_symlinks=True)`
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 intdir_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óriofollow_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)`
Descrição:¶
Execute o comando em um subshell.
Parâmetros:
_
command
_,
usando¶
**`using`**`(*argv)`
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:
target_schema_table
o esquema de destino (opcional) e o nome da tabela
define_file
O nome do arquivo a ser lido
define_columns
A definição de todas as colunas da tabela temporária
begin_loading_columns
Os nomes das colunas a serem inseridas. Determina a ordem em que os valores são inseridos
begin_loading_values
A lista de valores de inserção brutos a serem convertidos
field_delimiter
O delimitador de campo
(opcional)
skip_header
O número de linhas a serem ignoradas
(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
(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(): |
|
.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;
No exemplo acima, havia cinco comandos. Dois deles eram comandos.Label
. O comandoFIRSTLABEL
foi transformado em uma função com a(s) instrução(ões) que o segue(m) abaixo até que outro comando.LABEL
seja 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()
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 segueFIRSTLABEL
no código original. Antes de a funçãoFIRSTLABEL
terminar, ela chama SECONDLABEL
_, com as instruções que a seguiram.
Notas:
Criando uma variável de conector
con = None
e preenchendo-a na funçãomain()
: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çãoexec
fornecida pelo snowconvert.helpers. Veja, por exemplo, o código a seguir:
CREATE TABLE aTable (aColumn BYTEINT);
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()
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
Para executar o arquivo de execução, digite qualquer uma das formas do comando BTEQ RUN:
.RUN FILE=sampfile
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()
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);
Isso pode ser executado durante um script com a seguinte linha:
$(<$NEWSQL)
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()
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>
Amostra de padrões da origem¶
Com esses dados de entrada:
A B C
D E F
G H I
* [
] *
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);
C1 | C2 |
---|---|
A | X |
D | X |
G | X |
B | Y |
E | Y |
H | Y |
C | Z |
F | Z |
I | Z |
? | _ |
? | _ |
? | _ |
* | null |
[ | null |
MY_NAME | MY_AGE |
---|---|
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
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()
C1 | C2 |
---|---|
A | X |
D | X |
G | X |
B | Y |
E | Y |
H | Y |
C | Z |
F | Z |
I | Z |
? | _ |
? | _ |
? | _ |
* | null |
[ | null |
MY_NAME | MY_AGE |
---|---|
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
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.
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 } ]
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:
Chame a função
import_file()
dos auxiliares do SnowConvert. Isso carrega os dados em um arquivo temporário.Chame a função
using()
dos auxiliares do SnowConvert para criar um dicionário com os dados carregados.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
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;
ROW | C1 | C2 |
---|---|---|
1 | A | X |
2 | B | Y |
3 | C | Z |
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()
ROW | C1 | C2 |
---|---|---|
1 | A | X |
2 | B | Y |
3 | C | Z |
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 |
|
Transformado |
O nó é comentado, pois a transformação ocorre na instrução INSERT relacionada. |
|
CLEAR |
Comentado |
|
DATEFORM |
Comentado |
|
Transformado |
|
|
Transformado |
Comentado, pois não é necessário para a transformação de BEGIN LOADING. |
|
ERRLIMIT |
Comentado |
|
HELP |
Comentado |
|
HELP TABLE |
Comentado |
|
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 |
|
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;
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()
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;
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()
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;
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()
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¶
SSC-FDM-0007: Elemento com dependências ausentes.
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;
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()
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;
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()
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;
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()
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
);
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()
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:
Stage | Input Data Place Holder |
---|---|
Stage | Input Data Place Holder |
Internal stage | @my_int_stage |
External stage | @my_int_stage/path/file.csv |
Amazon S3 bucket | s3://mybucket/data/files |
Google Cloud Storage | gcs://mybucket/data/files |
Microsoft Azure | azure://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")
END LOADING¶
O comando END LOADING
é comentado, pois não é necessário para a transformação de BEGIN LOADING
.
Teradata (FastLoad)
END LOADING;
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()
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¶
SSC-FDM-0007: Elemento com dependências ausentes.
SSC-FDM-0027: Removida a próxima instrução, não aplicável no SnowFlake.
SSC-EWI-0021: Não suportado.
SSC-FDM-TD0022: Variáveis de shell encontradas, é necessário executar esse código em um script de shell.