SnowConvert AI – Teradata – BTEQ

Referências de tradução para converter arquivos Teradata BTEQ para Python

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.

To simulate the BTEQ functionality for Teradata in Snowflake, BTEQ files and commands are transformed to Python code, similar to the transformations performed for MultiLoad and FastLoad scripts. The generated code uses the Snowflake Python project called snowconvert.helpers which contains the required functions to simulate the BTEQ statements in 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)

For more complicated statements presented in the previous table, subsections with detailed examples are provided below.

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 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 AI 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()

Aviso que há uma chamada para a funçãoFIRSTLABEL. Esta função tem apenas uma instrução, que seria o único comando não rótulo que segueFIRSTLABELno código original. Antes que a função FIRSTLABELtermine, ela chama SECONDLABEL, com as instruções que o seguiram.

  • Notes:

    • 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

Every SQL statement found in a BTEQ file will be executed through theexecfunction provided by the snowconvert.helpers. Take for example the following code:

 CREATE TABLE aTable (aColumn BYTEINT);

Isso é convertido para:

 #*** Generated code is based on the SnowConvert AI 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 AI 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 AI 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.

REPEAT

Especificação de tradução para a instrução 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:

inputData.dat

A B C
D E F
G H I
inputData2.dat
* [
] *

Teradata:

Consulta
 .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);
Resultado TESTTABU
C1C2
AX
DX
GX
BY
EY
HY
CZ
FZ
IZ
?_
?_
?_
*null
[null
Resultado TESTTABU2
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:

Consulta
 #*** Generated code is based on the SnowConvert AI 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()
Resultado TESTTABU
C1C2
AX
DX
GX
BY
EY
HY
CZ
FZ
IZ
?_
?_
?_
*null
[null
Resultado TESTTABU2
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

Especificação de tradução para a consulta USING REQUEST MODIFIER.

Nota

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

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:

  1. Chamada da função import_file() dos SnowConvert AI Helpers. Isso carrega os dados em um arquivo temporário.

  2. Chamada da função using() de SnowConvert AI Helpers para criar um dicionário com os dados carregados.

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

Com esses dados de entrada:

 A,B,C

Teradata (MultiLoad)

Consulta

 .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;

Resultado

ROWC1C2
1AX
2BY
3CZ

Snowflake (Python)

Consulta
 #*** Generated code is based on the SnowConvert AI 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()
Resultado
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 alguma dúvida adicional sobre esta documentação, envie um e-mail para snowconvert-support@snowflake.com.

EWIs Relacionados

Sem EWIs relacionados.