SnowConvert : Référence de la traduction des scripts Teradata vers Python

Parcourez les pages suivantes pour trouver plus d’informations sur des sujets spécifiques.

  • BTEQ, pour explorer la référence de traduction pour la syntaxe de base de Teradata Query.

  • FastLoad, pour explorer la référence de la traduction pour la syntaxe de FastLoad.

  • MultiLoad, pour explorer la référence de la traduction pour connaître la syntaxe de MultiLoad.

  • TPT, pour explorer la référence de traduction pour la syntaxe TPT.

TPT

Transformation des instructions TPT

Toutes les instructions TPT, comme les autres langues de script de Teradata, sont converties en code python. Voici quelques exemples de transformations déjà prises en charge.

Définir la transformation de l’en-tête de la tâche

L’instruction de tâche est traduite en une classe Python contenant toutes les instructions telles que les opérateurs, les définitions de schéma et les étapes.

Code source

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

Code traduit

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

Définir la transformation du schéma

L’instruction de schéma est traduite en attribut dans la classe créée pour l’instruction de tâche.

Code source

 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

Code traduit

 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

Définir la transformation de l’opérateur

Les opérateurs sont traduits en fonctions Python dans la classe générée pour la tâche. Les exemples fournis sont ceux des opérateurs actuellement pris en charge par SnowConvert

Opérateur DDL

Code source pour l’opérateur 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

Code traduit

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

Code source pour l’opérateur 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

Code traduit

 class JobName:
    def LOAD_OPERATOR(self, query):
        #'TERADATA PARALLEL TRANSPORTER LOAD OPERATOR'
        #USES SCHEMA AC_MASTER_SCHEMA
        operator_name = "LOAD_OPERATOR"
        return query
Copy
Opérateur DATACONNECTORPRODUCER

Code source pour l’opérateur 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

Code traduit

 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

Définir la transformation par étapes

Les étapes sont également traduites en fonctions Python à l’intérieur de la classe générée pour le travail, elles seront appelées dans la fonction principale du code traduit.

Code source de l’étape

 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

Code traduit

 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

Fonction principale

La fonction principale est toujours générée pour n’importe quelle langue de script, pour TPT la fonction principale contient une instance de la classe de fonctionnalité et des appels aux étapes de la fonctionnalité

Échantillon de code de la fonction principale

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

MLOAD

Teradata MultiLoad est un utilitaire piloté par des commandes qui permet d’effectuer une maintenance rapide et en grande quantité sur plusieurs tables et vues de la base de données Teradata.

Afin de simuler la fonctionnalité MultiLoad pour Teradata dans Snowflake, les fichiers et commandes MultiLoad sont transformés en code Python, de manière similaire aux performances réalisées pour les scripts BTEQ et FastLoad. Le code généré utilise le projet Snowflake Python appelé snowconvert.helpers qui contient les fonctions requises pour simuler les instructions MultiLoad dans Snowflake.

Traduction des commandes MultiLoad

La plupart des commandes MultiLoad sont considérées comme non pertinentes dans Snowflake, ces commandes sont donc commentées. Vous trouverez ci-dessous la liste récapitulative des commandes MultiLoad et leur statut de transformation dans 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

Cependant, certaines commandes exceptionnelles doivent être converties en code spécifique à Python pour qu’elles fonctionnent comme prévu dans Snowflake. Voir cette section.

Si vous avez d’autres questions concernant cette documentation, vous pouvez nous envoyer un e-mail à l’adresse suivante : snowconvert-support@snowflake.com.

BEGIN MLOAD

La transformation de la commande .BEGIN MLOAD est une transformation en plusieurs parties qui nécessite les commandes .LAYOUT, .FIELD, .FILLER,.DML LABEL et .IMPORT pour simuler correctement son comportement.

Cette transformation est expliquée en détail dans les sous-sections suivantes.

.LAYOUT, .FIELD et .FILLER

La transformation des commandes .LAYOUT, .FIELD et .FILLER créera des définitions de variables qui seront utilisées dans un futur appel de fonction de l’IMPORT de cette présentation.

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

La transformation pour la commande .DML LABELcréera une fonction contenant les instructions après la définition de l’étiquette. Notez qu’après la commande .DML LABEL, il y a généralement une commande 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

La transformation de la commande .IMPORT créera un appel à l’assistant import_file_to_temptablepour charger les données du fichier dans une table temporaire. Ensuite, les appels à toutes les étiquettesAPPLYutilisées dans l’importation originale seront créés. Enfin, les appels à une étiquetteINSERTseront transformés en paramètre de requête et pourront éventuellement être assortis d’une condition de requête.

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

Large exemple

Compte tenu des transformations présentées ci-dessus pour diverses commandes, considérez l’exemple suivant.

Avec ces données d’entrée :

 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

Problèmes connus

1. L’instruction delete est partiellement prise en charge

L’instruction DELETE est partiellement prise en charge car les conditions where, lorsqu’elles sont trouvées, ne sont pas converties correctement si elles pointent vers une colonne définie par LAYOUT.

Dans l’exemple ci-dessous,  :EmpNo pointe vers une colonne définie par LAYOUT. Cependant, la transformation n’en tient pas compte et le code fera donc référence à une colonne qui n’existe pas.

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

Copy

Si vous avez d’autres questions concernant cette documentation, vous pouvez nous envoyer un e-mail à l’adresse suivante : snowconvert-support@snowflake.com.

Assistants des scripts SnowConvert

SnowConvert pour Teradata peut prendre en charge n’importe quel script ou SQL Teradata (BTEQ, FastLoad, MultiLoad et TPump) et les convertir en équivalents Snowflake fonctionnels SQL, JavaScript intégrés dans Snowflake SQL et Python. Tout code Python sortant de SnowConvert appellera les fonctions de ces classes d’aide pour achever la conversion et créer une sortie fonctionnellement équivalente dans Snowflake.

Snowflake Connector for Python sera également appelé afin de se connecter à votre compte Snowflake et d’exécuter le code Python de sortie créé par SnowConvert.

Les dernières informations sur la version du paquet sont disponibles ici.

Note

Le paquet Pythonsnowconvert-helpers prend en charge les versions 3.6, 3.7, 3.8 et 3.9 de Python.

Migration des scripts

Source

Supposons que vous ayez le code BTEQ suivant à migrer.

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

Sortie

Vous devriez obtenir une sortie comme celle ci-dessous.

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

Prise en main

Pour installer le paquet, vous devez exécuter la commande suivante dans votre environnement Python. Si vous n’êtes pas familiarisé avec l’installation de paquets dans Python, consultez la page suivante sur les paquets python (https://packaging.python.org/tutorials/installing-packages/).

 pip install snowconvert-helpers
Copy

Une fois votre paquet installé, vous pourrez exécuter le code migré par script en Python.

Exécuter le code

Pour exécuter le code migré, il vous suffit d’ouvrir le Command Prompt ou le Terminal et d’exécuter la commande suivante.

 python sample_BTEQ.py
Copy

Si le script ne contient pas d’erreurs, vous obtiendrez dans votre console une sortie comme celle ci-dessous.

 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

Transmission des paramètres de connexion

Il existe plusieurs façons de transmettre les paramètres de connexion à la connexion de la base de données :

  • En tant que paramètres dans l’appel de fonction snowconvert.helpers.log_on à l’intérieur du fichier Python.

  • En tant que paramètres positionnels avec l’ordre spécifique de l’utilisateur, du mot de passe, du compte, de la base de données, de l’entrepôt et du rôle lorsque le Python est exécuté à partir de la ligne de commande.

  • En tant que paramètres nommés sans restriction d’ordre de SNOW_USER, SNOW_PASSWORD, SNOW_ACCOUNT, SNOW_DATABASE, SNOW_WAREHOUSE, SNOW_ROLE, SNOW_QUERYTAG, SNOWAUTHENTICATOR et SNOWTOKEN lorsque le Python est exécuté à partir de la ligne de commande et que l’un d’entre eux est transmis comme –param-VARNAME=VALUE.

  • En tant que variables d’environnement nommées SNOW_USER, SNOW_PASSWORD, SNOW_ACCOUNT, SNOW_DATABASE, SNOW_WAREHOUSE, SNOW_ROLE, SNOW_QUERYTAG, SNOWAUTHENTICATOR et SNOWTOKEN avant l’exécution de Python.

L’ordre précédent spécifié permet de déterminer la priorité.

Paramètres dans l’appel de la fonction

Ils peuvent être définis en tant que paramètres de position dans l’appel de la fonction comme suit.

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

Ou bien ils peuvent être définis avec n’importe lequel des paramètres nommés, dans n’importe quel ordre, dans l’appel de la fonction, comme suit.

    .....
   con = snowconvert.helpers.log_on(
     account:'myaccount',
     password:'mypassword',
     user:'myuser',     
     warehouse:'mywarehouse',
     login_timeout:5,
     authenticator:'myauthenticator',
     toke:'mytoken')
   .....
Copy
Paramètres de position

Ils doivent être définis dans l’ordre spécifique de la ligne de commande, comme suit.

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

Il est également possible de ne définir que certains des paramètres, en commençant toujours par le paramètre utilisateur, comme suit.

 python sample_BTEQ.py myuser mypassword myaccount
Copy
Paramètres nommés

L’ensemble des paramètres nommés peut être défini dans n’importe quel ordre dans la ligne de commande, comme suit (utilisez une seule ligne, les lignes multiples étant indiquées pour des raisons de lisibilité).

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
Variables d’environnement

Avant d’appeler le script Python, l’une des variables d’environnement suivantes peut être définie :

  • SNOW_USER

  • SNOW_PASSWORD

  • SNOW_ACCOUNT

  • SNOW_DATABASE

  • SNOW_WAREHOUSE

  • SNOW_ROLE

  • SNOW_QUERYTAG

  • SNOW_AUTHENTICATOR

  • SNOW_TOKEN

  • PRIVATE_KEY_PATH

  • PRIVATE_KEY_PASSWORD

Authentification par paire de clés

La fonction log_on peut également prendre en charge le processus d’authentification de la paire de clés. Consultez la documentation Snowflake suivante pour plus d’informations sur la création de clés . Veuillez noter les paramètres requis :

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')

Exemple de transmission de variables d’environnement

Voici un exemple d’utilisation de SNOW_AUTHENTICATOR, SNOW_USER et SNOW_PASSWORD. Ils doivent être définis avant d’exécuter le fichier Python de sortie, puis d’exécuter le fichier généré par 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

Activation de la journalisation

Pour activer la journalisation, vous devez activer une variable d’environnement appelée SNOW_LOGGING et lui donner la valeur true.

Ensuite, si vous souhaitez personnaliser la configuration de la journalisation, vous pouvez passer un paramètre à la méthode snowconvert.helpers.configure_log() comme ceci :

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

Le fichier de configuration doit contenir la structure suivante. Pour plus d’informations sur la connexion en Python, cliquez ici

 [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

Une fois que le code migré a été exécuté, vous pouvez aller sur Snowflake et vérifier vos changements ou déploiements.

 select * from PUBLIC.table1;
Copy

Vous pourrez voir les lignes que vous avez insérées dans l’exemple ci-dessus.

Résultat de la requête

Documentation sur les assistants locaux

Tout d’abord, il est exigé d’installer le paquet Python nommé pydoc (Disponible depuis la version 2.0.2 de snowconvert-helpers).

 pip install pydoc
Copy

Ensuite, pour afficher la documentation python du paquet snowconvert-helpers, vous devez aller dans un dossier où vous avez le code de sortie converti et où vous avez une sortie 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

Dans ce répertoire, vous devez exécuter :

 python -m pydoc -b
Copy

La console ouvrira votre navigateur préféré avec l’aide HTML de la documentation pour tous les paquets installés.

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

Copy

Cela ouvrira le navigateur avec la documentation de votre code, de la façon suivante :

Page d'accueil pour la documentation locale générée

Faites défiler la page jusqu’à la fin pour voir les paquets installés. Et vous verrez quelque chose de similaire à :

Index de la documentation sur les paquets installés localement

En cliquant sur SnowConvert(paquet), vous verrez quelque chose comme :

Page d'accueil de la documentation snowconvert-helpers

En cliquant sur les assistants de modules, vous obtiendrez un écran similaire à celui-ci :

Page d'accueil du module des assistants

Vous pouvez ensuite faire défiler les fonctions et les classes du module.

Documentation des fonctions

Problèmes connus

Aucun problème n’a été constaté.

EWIs connexes

Pas d’EWIs connexes.

Documentation technique

Fonctions

Toutes les fonctions définies dans le projet.

access

**`access`**`(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)`
Copy
Description :

Utilisez le vrai uid/gid pour tester l’accès à un chemin.

_Les fonctions suivantes peuvent ne pas être mises en œuvre sur votre plateforme : dir_fd, effective_ids, et follow_symlinks. Si elles ne sont pas disponibles, leur utilisation provoquera un NotImplementedError.

Notez que la plupart des opérations utiliseront l’uid/gid effectif, cette routine peut donc être utilisée dans un environnement suid/sgid pour tester si l’utilisateur qui l’invoque a l’accès spécifié au chemin.

Paramètres :
  • path, Chemin à tester ; peut être une chaîne, des octets ou un objet de type chemin

  • mode, Champ de bits du mode du système d’opération. Il peut s’agir de F_OK pour tester l’existence, ou de l’inclusion deOR de R_OK, W_OK et X_OK

  • dir_fd, Si non défini sur None, il doit s’agir d’un descripteur de fichier ouvert sur un répertoire, et le chemin doit être relatif ; le chemin sera alors relatif à ce répertoire

  • effective_ids, Si True, l’accès utilisera l’uid/gid effectif au lieu de l’uid/gid réel

  • follow_symlinks, Si False, et que le dernier élément du chemin est un lien symbolique, l’accès examinera le lien symbolique lui-même au lieu du fichier vers lequel pointe le lien

at_exit_helpers

**`at_exit_helpers`**`()`
Copy
Description :

S’exécute à la fin de l’exécution du script.

coloré

**`colored`**`(text, color='blue')`
Copy
Description :

Imprime un texte coloré à partir de la couleur spécifiée.

Paramètres :
  • texte , Le texte à imprimer

  • color="blue" , La couleur à imprimer

configure_log

**`configure_log`**`(configuration_path)`
Copy
Description :

Configure la connectivité qui sera effectuée pour toute exécution liée aux données sur la connexion Snowflake. Le fichier journal est nommé par défaut « Snowflake\Npython\Nconnector.log ».

Paramètres :

  • configuration_path , Le chemin de configuration du fichier qui contient l’ensemble des paramètres souhaités pour la connexion

drop_transient_table

**`drop_transient_table`**`(tempTableName, con=None)`
Copy
Description :

Supprime la table transitoire portant le nom spécifié.

Paramètres :

  • tempTableName , Le nom de la table temporaire

  • con=None , La connexion à utiliser, si None est passé, la dernière connexion effectuée sera utilisée

exception à la règle

**`exception_hook`**`(exctype, value, tback)`
Copy
Description :

Paramètres :

  • exctype

  • valeur

  • tback

exec

**`exec`**`(sql_string, using=None, con=None)`
Copy
Description :

Exécute une chaîne SQL en utilisant la dernière connexion, en utilisant éventuellement des arguments ou une connexion spécifique. Exemples :

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

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

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

Paramètres :

  • sql_string , La définition de la chaîne sql

  • using=None , Le paramètre optionnel qui peut être utilisé dans la requête sql transmise

  • con=None , La connexion à utiliser, si None est passé, la dernière connexion effectuée sera utilisée

exec_file

**`exec_file`**`(filename, con=None)`
Copy
Description :

Lit le contenu d’un fichier et exécute les instructions sql contenues avec la connexion spécifiée.

Paramètres :

  • filename , Nom du fichier à lire et à exécuter

  • con=None , La connexion à utiliser, si None est passé, la dernière connexion effectuée sera utilisée

exec_os

**`exec_os`**`(command)`
Copy
Description :

Exécute une commande dans le système d’exploitation.

exec_sql_statement

**`exec_sql_statement`**`(sql_string, con, using=None)`
Copy
Description :

Exécute une instruction SQL dans la connexion transmise, avec les arguments optionnels.

Paramètres :

  • sql_string , Le sql contenant la chaîne à exécuter

  • con , La connexion à utiliser

  • using , Les paramètres optionnels à utiliser dans l’exécution sql

expands\using_params**

**`expands_using_params`**`(statement, params)`
Copy
Description :

Développe l’instruction transmise avec les paramètres.

Paramètres :

  • statement , Le sql contenant la chaîne à exécuter

  • params , Les paramètres de l’instruction sql

expandvar

**`expandvar`**`(str)`
Copy
Description :

Développe la variable à partir de la chaîne passée.

Paramètres :

  • str , La chaîne à développer à l’aide des variables

expandvars

**`expandvars`**`(path, params, skip_escaped=False)`
Copy
Description :

_Expansion des variables d’environnement de la forme $var et ${var}. Si le paramètre « skip_escaped » vaut True, toutes les références de variables échappées (c’est-à-dire précédées de barres obliques inverses) sont ignorées. Les variables inconnues sont définies sur « default ». Si « default » est None, ils sont laissés inchangés

Paramètres :

  • path ,

  • params ,

  • skip_escaped=False ,

FAST LOAD

**`fast_load`**`(target_schema, filepath, stagename, target_table_name, con=None)`
Copy
Description :

Exécute le chargement rapide avec les paramètres transmis : target_schema, filepath, stagename et target_table_name.

Paramètres :

  • target_schema , Nom du schéma à utiliser pour le chargement rapide

  • filepath , Chemin du nom de fichier à charger dans la table

  • target_table_name , Nom de la table dont les données seront chargées

  • con=None , La connexion à utiliser, si None est passé, la dernière connexion effectuée sera utilisée

file\exists_and_readable**

**`file_exists_and_readable`**`(filename)`
Copy
Description :

Paramètres :

  • filename ,

get\argkey**

**`get_argkey`**`(astr)`
Copy
Description :

Récupère la valeur de la clé de l’argument à partir de la chaîne transmise. Elle doit commencer par la chaîne « –param- »

Paramètres :

  • astr , Chaîne de l’argument à utiliser. La chaîne doit avoir une valeur similaire à –param-column=32 et la chaîne retournée sera 32

get\error_position**

**`get_error_position`**`()`
Copy
Description :

Récupère la position de l’erreur dans le fichier en utilisant les informations de la pile de l’erreur produite.

get\from_vars_or_args_or_environment**

**`get_from_vars_or_args_or_environment`**`(arg_pos, variable_name, vars, args)`
Copy
Description :

Récupère l’argument à la position spécifiée ou la valeur de la table vars ou le nom de la variable d’environnement passée.

Paramètres :

  • arg_pos , Position de l’argument à utiliser à partir du paramètre arguments

  • variable_name , Nom de la variable à obtenir

  • vars , Le hachage avec les noms et les valeurs des variables

  • args , Le paramètre du tableau des arguments

import\data_to_temptable**

**`import_data_to_temptable`**`(tempTableName, inputDataPlaceholder, con)`
Copy
Description :

Importe les données dans une table temporaire à l’aide d’un espace réservé de données d’entrée.

Paramètres :

  • tempTableName, Nom de la table temporaire.

  • inputDataPlaceholder, Le marqueur d’entrée utilisé qui est une zone de préparation de la base de données Snowflake

  • con, La connexion à utiliser

import\file**

**`import_file`**`(filename, separator=' ')`
Copy
Description :

Importe le nom de fichier passé avec le séparateur optionnel.

Paramètres :

  • filename, Le chemin du fichier à importer

  • separator=' ', Le séparateur optionnel

import\file_to_temptable**

**`import_file_to_temptable`**`(filename, tempTableName, columnDefinition)`
Copy
Description :

Importe le fichier passé dans une table temporaire. Il utilisera une zone de préparation publique nommée comme table temporaire avec le préfixe Stage_. À la fin du chargement de la table temporaire, il supprimera la zone de préparation utilisée dans le processus.

Paramètres :

  • filename, Le nom du fichier à lire

  • tempTableName, Le nom de la table temporaire

  • columnDefinition, La définition de tous les champs qui composeront la table temporaire

import\reset**

**`import_reset`**`()`
Copy
Description :

log

**`log`**`(*msg, level=20, writter=None)`
Copy
Description :

Imprime un message sur la console (sortie standard) ou dans le fichier journal, selon que la fonction de connexion est activée ou non.

Paramètres :

  • *msg, Le message à imprimer ou à journaliser

  • 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
Description :

Se connecte à la base de données Snowflake avec les identifiants, la base de données, l’entrepôt, le rôle, login_timeout et l’authentificateur transmis comme paramètres.

Paramètres :

  • user, L’utilisateur de la base de données

  • password Le mot de passe de l’utilisateur de la base de données

  • database, La base de données à connecter

  • warehouse, L’entrepôt de la base de données à connecter

  • role, Le rôle à connecter

  • login_timeout, Le délai d’expiration maximum avant d’émettre une erreur si la connexion prend trop de temps

  • authentificator, Valeur de l’authentificateur à utiliser comme SNOWFLAKE, EXTERNALBROWSER, SNOWFLAKE_JWT ou OAUTH

  • token, Le jeton OAUTH ou JWT

os

**`os`**`(args)`
Copy
Description :

Paramètres :

  • args,

quit\application**

**`quit_application`**`(code=None)`
Copy
Description :

Quitte l’application et renvoie éventuellement le code transmis.

Paramètres :

  • code=None, Le code à renvoyer après l’arrêt de l’application

read\params_args**

**`read_param_args`**`(args)`
Copy
Description :

Lit les arguments des paramètres à partir du tableau passé.

Paramètres :

  • args, Les arguments à utiliser

readrun

**readrun**(line, skip=0)
Copy
Description :

Lit les lignes du nom de fichier donné et, éventuellement, saute certaines lignes au début du fichier.

Paramètres :

  • ligne, Nom du fichier à lire

  • skip=0, Les lignes à sauter

remark

**remark**(arg)
Copy
Description :

Imprime l’argument.

Paramètres :

  • arg, L’argument à imprimer

repeat\previous_sql_statement**

**`repeat_previous_sql_statement`**`(con=None, n=1)`
Copy
Description :

Répète la ou les instructions sql exécutées précédemment.

Paramètres :

  • con=None, Connexion si spécifiée. Si ce n’est pas le cas, la dernière connexion établie sera utilisée

  • n=1, Le nombre d’instructions précédentes à exécuter à nouveau

set\default_error_level**

**`set_default_error_level`**`(severity_value)`
Copy
Description :

Paramètres :

  • severity_value,

set\error_level**

**`set_error_level`**`(arg, severity_value)`
Copy
Description :

Paramètres :

  • arg,

  • severity_value,

simple\fast_load**

**`simple_fast_load`**`(con, target_schema, filepath, stagename, target_table_name)`
Copy
Description :

Exécute un simple chargement rapide dans la connexion et le paramètre transmis target_schema, chemin de fichier, nom de zone de préparation et le nom de la table cible.

Paramètres :

  • arg, La connexion à utiliser

  • target_schema, Nom du schéma à utiliser pour le chargement rapide

  • filepath, Chemin du nom de fichier à charger dans la table

  • target_table_name, Nom de la table dont les données seront chargées

stat

**`stat`**`(path, *, dir_fd=None, follow_symlinks=True)`
Copy
Description :

Effectue un appel système stat sur le chemin donné. dir_fd et follow_symlinks peuvent ne pas être implémentés sur votre plateforme. S’ils ne sont pas disponibles, leur utilisation entraînera NotImplementedError. C’est une erreur d’utiliser dir_fd ou follow_symlinks lorsque le chemin est spécifié comme descripteur de fichier ouvert

Paramètres :

  • path, Chemin à examiner ; il peut s’agir d’une chaîne, d’octets, d’un objet semblable à un chemin ou de \ open-file-descriptor int

  • dir_fd, Si non défini sur None, il doit s’agir d’un descripteur de fichier ouvert sur un répertoire, et le chemin doit être une chaîne relative ; le chemin sera alors relatif à ce répertoire

  • follow_symlinks, Si False, et que le dernier élément du chemin est un lien symbolique, stat examinera le lien symbolique lui-même au lieu du fichier vers lequel le lien pointe

system

**`system`**`(command)`
Copy
Description :

Exécute la commande dans un sous-shell.

Paramètres :

  • _ command_ ,

using

**`using`**`(*argv)`
Copy
Description :

Paramètres :

  • _ *argv_ ,

Classes

Toutes les classes définies dans le projet

Classe BeginLoading

Cette classe contient la fonction statique import_file_to_tab qui fournit un support pour BEGIN LOADING et les commandes associées dans FastLoad.

import_file_to_tab()

Paramètres :

  1. target_schema_table

    • le schéma cible (facultatif) et le nom de la table

  2. define_file

    • Le nom du fichier à lire

  3. define_columns

    • La définition de toutes les colonnes de la table temporaire

  4. begin_loading_columns

    • Les noms des colonnes à insérer. Détermine l’ordre dans lequel les valeurs sont insérées

  5. begin_loading_values

    • La liste des valeurs brutes d’insertion à convertir

  6. field_delimiter

    • Le délimiteur de champ

  7. (facultatif) skip_header

    • Le nombre de lignes à sauter

  8. (facultatif) input_data_place_holder

    • L’emplacement du fichier dans un fournisseur de Cloud pris en charge. Paramètre d’ensemble lorsque le fichier n’est pas stocké localement

  9. (facultatif) con

    • La connexion à utiliser

Classe d’exportation

Méthodes statiques dans la 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)

\ Données et autres attributs définis ici

  • expandedfilename = None

  • separator = '' \

Classe d’importation

Méthodes de la classe

  • reset()

Méthodes statiques dans la classe

  • file(file, separator=' ')

  • using(globals, *argv)

Données et autres attributs définis dans la classe

  • expandedfilename = None

  • no_more_rows = False

  • read_obj = None

  • reader = None

  • separator = ' '

Classe Parameters

Données et autres attributs définis dans la classe

  • passed_variables = {}

BTEQ

Basic Teradata Query (BTEQ) est un programme général à base de commandes qui permet aux utilisateurs d’une station de travail de communiquer avec un ou plusieurs systèmes de bases de données Teradata et de formater des rapports pour une sortie sur papier ou à l’écran.

Afin de simuler la fonctionnalité BTEQ pour Teradata dans Snowflake, les fichiers et commandes BTEQ sont transformés en code Python, de manière similaire aux performances réalisées pour les scripts MultiLoad et FastLoad. Le code généré utilise le projet Snowflake Python appelé snowconvert.helpers qui contient les fonctions requises pour simuler les instructions BTEQ dans Snowflake.

Traduction des commandes BTEQ

La table suivante présente la conversion des commandes BTEQ vers Snowflake.

Teradata

Snowflake

Remarques

ERRORCODE != 0

snowconvert.helpers.error_code != 0

.EXPORT DATA FILE=fileName

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

La fonction n’a pas de fonctionnalité

.EXPORT INDICDATA FILE=fileName

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

La fonction n’a pas de fonctionnalité

.EXPORT REPORT FILE=fileName

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

La fonction n’a pas de fonctionnalité

.EXPORT DIF FILE=fileName

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

La fonction n’a pas de fonctionnalité

.EXPORT RESET

Export.reset()

La fonction n’a pas de fonctionnalité

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

La fonction n’a pas de fonctionnalité

.LABEL newLabel

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

.LOGOFF

L’instruction est commentée

.LOGON

L’instruction est commentée

.LOGMECH

L’instruction est commentée

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

La fonction n’a pas de fonctionnalité

.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(“|”)

La fonction n’a pas de fonctionnalité

.SET WIDTH 120

Export.width(120)

La fonction n’a pas de fonctionnalité

.Remark « « Hello world! » » »

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

.QUIT ERRORCODE

snowconvert.helpers.quit_application(

snowconvert.helpers.error_code

)

.QUIT

snowconvert.helpers.quit_application()

Instructions SQL

exec(statement)

$(<$INPUT_SQL_FILE)

exec_file(« $INPUT_SQL_FILE »)

= (Repeat previous command)

snowconvert.helpers.repeat_previous_sql_statement(con)

Pour les instructions plus compliquées présentées dans la table précédente, des sous-sections avec des exemples plus élaborés sont expliquées.

Conversion en valeur .GOTO

Étant donné que nous convertissons les scripts BTEQ en Python, certaines structures valables dans BTEQ ne sont pas intrinsèquement prises en charge dans Python. C’est le cas de la commande .GOTO utilisant les commandes . Label.

C’est pourquoi une alternative a été développée afin d’émuler la fonctionnalité de ces commandes, en transformant les commandes . Label en fonctions avec des instructions d’appel ultérieures.

Regardez le code suivant :

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

Dans l’exemple ci-dessus, il y avait cinq commandes. Deux d’entre elles étaient des commandes. Label. La commandeFIRSTLABELa été transformée en une fonction avec la ou les instructions qui la suivent ci-dessous jusqu’à ce qu’une autre commande.LABELsoit trouvée. Lorsqu’une autre étiquette est appelée (dans le cas présent, SECONDLABEL), cet appel met fin à la première fonction et en démarre une nouvelle.

Si nous devions migrer l’exemple précédent, le résultat serait le suivant :

 #*** 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

Remarquez qu’il y a un appel à la fonction_ FIRSTLABEL, cette fonction n’a qu’une seule instruction, qui serait la seule commande non étiquetée qui suitFIRSTLABELdans le code original. Avant que la fonctionFIRSTLABELne se termine, elle appelle SECONDLABEL_, avec les instructions qui l’ont suivie.

Remarques :

  • Création d’une variable connecteur con = None, et alimentation de cette variable dans la fonction main(): con = snowconvert.helpers.log_on().

  • Définition d’un journal : snowconvert.helpers.configure_log().

Exécution des instructions de requête

Chaque instruction SQL trouvée dans un fichier BTEQ sera exécutée par le biais de la fonctionexecfournie par snowconvert.helpers. Prenez par exemple le code suivant :

 CREATE TABLE aTable (aColumn BYTEINT);
Copy

Il est converti en :

 #*** 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

Exécution des fichiers de script

Les fichiers contenant les commandes BTEQ et les instructions Teradata SQL d’un utilisateur sont appelés scripts, fichiers d’exécution, macros ou procédures stockées. Par exemple, créez un fichier appelé SAMPFILE, et entrez le script BTEQ suivant :

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

Pour exécuter le fichier d’exécution, entrez l’une ou l’autre forme de la commande BTEQ RUN :

.RUN FILE=sampfile

Copy

Si vous convertissez le deuxième code, le résultat est le suivant :

 #*** 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

L’instruction snowconvert.helpers.readrun("sampfile") renverra chaque ligne de l’instruction SAMPFILE et dans l’instructionFOR, chacune des lignes sera transmise à la fonction eval, une fonction qui analyse l’expression qui lui est transmise et exécute l’expression Python (l’instruction SAMPFILE doit être convertie en travail) au sein du programme.

Exécuter les fichiers SQL

Dans certaines instances, lors de l’exécution d’un fichier BTEQ, un fichier SQL peut être trouvé, par exemple le fichier SQL appelé NEWSQL :

 CREATE TABLE aTable (aColumn BYTEINT);
Copy

Ceci peut être exécuté au cours d’un script avec la ligne suivante :

 $(<$NEWSQL)
Copy

Après la conversion du script, le résultat est le suivant :

 #*** 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

La fonction d’assistance exec_file lira chaque ligne du fichier NEWSQL et utilisera ensuite la fonction exec comme expliqué dans la section Exécution des instructions de requête.

Problèmes connus

Aucun problème n’a été constaté.

EWIs connexes

Aucun problème n’a été constaté.

REPEAT

Note

Certaines parties du code de sortie sont omises pour des raisons de clarté.

Selon la documentation Teradata, l’instruction REPEAT permet aux utilisateurs de spécifier le nombre maximum de fois que la prochaine requête SQL doit être soumise. Notez qu’une requête SQL peut être une requête à une ou plusieurs instructions. Ce mécanisme est défini par la position des points-virgules pour chaque instruction suivant l’instruction REPEAT.

Syntaxe

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

Copy

Modèles d’échantillons de sources

Avec ces données d’entrée :

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

Problèmes connus

Aucun problème n’a été constaté.

EWIs connexes

Pas d’EWIs connexes.

USING REQUEST MODIFIER

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

Conformément à la documentation Teradata, l’instruction USING REQUEST MODIFIER définit un ou plusieurs noms de paramètres variables à utiliser dans les instructions suivantes SELECT, INSERT, UPDATE ou DELETE pour importer ou exporter des données.

La syntaxe de cette instruction est la suivante :

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

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

Comme indiqué dans la documentation de Teradata, USING REQUEST MODIFIER doit être précédé d’une instruction .IMPORT pour charger les données dans les paramètres définis.

Ainsi, la transformation de cette instruction suit les étapes suivantes :

  1. Appelez la fonction import_file() à partir des assistants SnowConvert. Cette opération charge les données dans un fichier temporaire.

  2. Appelez la fonction using() des assistants SnowConvert pour créer un dictionnaire avec les données chargées.

  3. Pour chaque requête, exécutez la fonction exec() à partir des assistants SnowConvert et transmettez le dictionnaire défini précédemment. Ceci utilisera les capacités de liaison de données du connecteur Snowflake Python.

Avec ces données d’entrée :

 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

Problèmes connus

1. La commande .REPEAT n’est pas encore prise en charge

La commande .REPEAT n’est pas encore prise en charge. Cela signifie que USING REQUEST MODIFIER n’utilisera que les données chargées à partir de la première ligne du fichier d’entrée. Ainsi, les requêtes ne seront exécutées qu’une seule fois.

Ce problème devrait être corrigé lorsque la commande .REPEAT bénéficiera de la prise en charge adéquate des transformations.

Si vous avez d’autres questions concernant cette documentation, vous pouvez nous envoyer un e-mail à l’adresse suivante : snowconvert-support@snowflake.com.

EWIs connexes

Pas d’EWIs connexes.

FLOAD

Teradata FastLoad est un utilitaire piloté par commande qui permet de charger rapidement de grandes quantités de données dans une table vide d’une base de données Teradata.

Afin de simuler la fonctionnalité FastLoad pour Teradata dans Snowflake, les fichiers et commandes FastLoad sont transformés en code Python, de manière similaire aux performances réalisées pour les scripts BTEQ et MultiLoad. Le code généré utilise le projet Snowflake Python appelé snowconvert.helpers qui contient les fonctions requises pour simuler les instructions FastLoad dans Snowflake.

Traduction des commandes FastLoad

La plupart des commandes FastLoad sont considérées comme non pertinentes dans Snowflake, ces commandes sont donc commentées. Vous trouverez ci-dessous la liste récapitulative des commandes FastLoad et leur statut de transformation dans Snowflake :

Commande Teradata FastLoad

Statut de la transformation

Remarque

AXSMOD

Commenté

BEGIN LOADING

Transformé

​Le nœud est commenté car la transformation a lieu dans l’instruction INSERT correspondante.

CLEAR

Commenté

DATEFORM

Commenté

DEFINE

Transformé

END LOADING

Transformé

​Commenté car non nécessaire pour la transformation de BEGIN LOADING.

ERRLIMIT

Commenté

HELP

Commenté

HELP TABLE

Commenté

INSERT

Transformé

Transformé dans le cadre de BEGIN LOADING.

LOGDATA

Commenté

LOGMECH

Commenté

LOGOFF

Commenté

LOGON

Commenté

NOTIFY

Commenté

OS

Commenté

QUIT

Commenté

RECORD

Commenté

RUN

Commenté

SESSIONS

Commenté

SET RECORD

Transformé

SET SESSION CHARSET

Commenté

SHOW

Commenté

SHOW VERSIONS

Commenté

SLEEP

Commenté

TENACITY

Commenté

Transformation par défaut

Le comportement par défaut de ConversionTool pour ces instructions est de les commenter. Par exemple :

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

Néanmoins, certaines exceptions doivent être converties en instructions Python spécifiques afin de fonctionner comme prévu dans Snowflake.

SQL intégré

Les scripts FastLoad prennent en charge les instructions Teradata dans le même fichier. La majorité de ces instructions sont converties comme si elles se trouvaient dans un fichier BTEQ, à quelques exceptions près.

La suppression d’une table d’erreurs est commentée si elle se trouve à l’intérieur d’un fichier 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

Large exemple

Compte tenu des transformations présentées ci-dessus pour diverses commandes, considérez l’exemple suivant.

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

Si vous avez d’autres questions concernant cette documentation, vous pouvez nous envoyer un e-mail à l’adresse suivante : snowconvert-support@snowflake.com.

Problèmes connus

Aucun problème n’a été constaté.

EWIs connexes

  1. SSC-FDM-0007 : Élément avec des dépendances manquantes.

  2. SSC-FDM-0027 : Suppression de l’instruction suivante, sans application dans SnowFlake.

BEGIN LOADING

La transformation de la commande BEGIN LOADING est une transformation en plusieurs parties qui nécessite les commandes DEFINE, INSERT et (éventuellement) SET RECORD pour simuler correctement son comportement.

Cette transformation est expliquée en détail dans les sous-sections suivantes.

SET RECORD

Comme indiqué plus haut, cette commande n’est pas nécessaire pour la transformation de BEGIN LOADING. Si introuvable, le paramètre de délimiteur par défaut sera « , » (virgule). Dans le cas contraire, le délimiteur défini sera utilisé. Cette valeur est stockée dans la variable ssc_set_record.

Pour l’instant, seuls SET RECORD VARTEXT, SET RECORD FORMATTED et SET RECORD UNFORMATTED sont pris en charge. Pour la spécification des mots-clés BINARY et TEXT, une erreur EWI est placée à la place.

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

La transformation pour la commande DEFINE établit les variables ssc_define_columns et ssc_define_file avec la valeur de la définition des colonnes et le chemin du fichier à utiliser dans la transformation BEGIN LOADING respectivement.

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

La commande BEGIN LOADING est commentée car les informations nécessaires à la transformation se trouvent dans l’instruction INSERT qui lui est associée.

ERRORFILES, NODROP, CHECKPOINT, INDICATORS et DATAENCRYPTION ne sont pas nécessaires à la transformation et sont donc commentées.

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

La transformation de l’instruction INSERT associée définit les valeurs des variables ssc_begin_loading_columns et ssc_begin_loading_values, utilisées pour déterminer l’ordre dans lequel les valeurs à charger doivent être insérées.

Enfin, ces variables et celles décrites dans les sections précédentes sont utilisées pour appeler la fonction BeginLoading. import_file_to_table qui fait partie du module SnowConvert. Helpers. Cette fonction simule le comportement de l’ensemble du processus FastLoad BEGIN LOADING. Pour en savoir plus sur cette fonction, cliquez ici.

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

En interne, la fonction import_file_to_table crée une zone de préparation temporaire et place le fichier local dans la zone de préparation pour le charger dans la table spécifiée. Cependant, il se peut que le fichier soit déjà stocké chez l’un des fournisseurs de Cloud pris en charge par 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

Si tel est le cas, veuillez ajouter manuellement le paramètre supplémentaire input_data_place_holder="<cloud_provider_path>" dans la fonction import_file_to_table. Par exemple :

 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

La commande END LOADING est commentée car elle n’est pas nécessaire à la transformation 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

Problèmes connus

1. La spécification des mots-clés BINARY et TEXT n’est pas prise en charge

La spécification des mots-clés BINARY et TEXT pour la commande SET RECORD n’est pas encore prise en charge.

2. Seule la spécification de base pour VARTEXT est prise en charge

Les spécifications supplémentaires pour SET RECORD VARTEXT, telles que TRIM ou QUOTE, ne sont pas encore prises en charge.

EWIs connexes

  1. SSC-FDM-0007 : Élément avec des dépendances manquantes.

  2. SSC-FDM-0027 : Suppression de l’instruction suivante, sans application dans SnowFlake.

  3. SSC-EWI-0021 : Non pris en charge.

  4. SSC-FDM-TD0022 : Variables shell trouvées, l’exécution de ce code dans un script shell est exigée.