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
Code traduit
## Some comments on the job
class LOADJOB:
# DESCRIPTION 'LOAD AC_SCHEMA TABLE FROM A FILE'
JobBody
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
);
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,
);"""
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']
);
Code traduit
class JobName:
def DDL_OPERATOR(self):
#'TERADATA PARALLEL TRANSPORTER DDL OPERATOR'
global args
self.con = log_on(user = args.MyUserName, password = 'SomePassWord')
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'
);
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
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'
);
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
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);
);
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() )})""")
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()
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 :
Commands | Transformation Status | Note |
---|---|---|
ACCEPT | Commented | |
BEGIN MLOAD | Transformed | The node is commented out since the transformation occurs in other related statements instead. |
BEGIN DELETE MLOAD | Commented | |
DATEFORM | Commented | |
DELETE | Partially transformed | Check known issues. |
DISPLAY | Commented | |
DML LABEL | Transformed | |
END MLOAD | Transformed | Commented out since is not necessary for the transformation of the BEGIN MLOAD. |
EOC | Commented | |
FIELD | Transformed | |
FILLER | Transformed | This command needs to be with a FIELD and LAYOUT command to be converted. |
IF, ELSE, and ENDIF | Commented | |
IMPORT | Transformed | |
INSERT | Transformed | This is taken as a Teradata Statement, so it doesn't appear in this chapter. |
LAYOUT | Transformed | This command needs to be with a FIELD and FILLER command to be converted. |
LOGDATA | Commented | |
LOGMECH | Commented | |
LOGOFF | Commented | |
LOGON | Commented | |
LOGTABLE | Commented | |
PAUSE ACQUISITION | Commented | |
RELEASE MLOAD | Commented | |
ROUTE MESSAGES | Commented | |
RUN FILE | Commented | |
SET | Commented | |
SYSTEM | Commented | |
TABLE | Commented | |
UPDATE | Transformed | This is taken as a Teradata Statement, so it doesn't appear in this chapter. |
VERSION | Commented | |
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;
Snowflake (Python)
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
INFILE_LAYOUT_TableName = "INFILE_LAYOUT_TEMP_TABLE"
INFILE_LAYOUT_Columns = """TABLE_ID INTEGER,
TABLE_DESCR CHAR(8),
COL1 CHAR(1),
TABLE_NBR SMALLINT,
TABLE_SOMEFIELD SMALLINT"""
INFILE_LAYOUT_Conditions = """TABLE_ID AS TABLE_ID, TABLE_DESCR AS TABLE_DESCR, COL1 AS COL1, TABLE_NBR AS TABLE_NBR, TABLE_SOMEFIELD AS TABLE_SOMEFIELD"""
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
.DML LABEL¶
La transformation pour la commande .DML LABEL
cré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 );
Snowflake (Python)
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
def INSERT_TABLE(tempTableName, queryConditions = ""):
exec(f"""INSERT INTO mydb.mytable (TABLE_ID, TABLE_DESCR, TABLE_NBR)
SELECT
:TABLE_ID,
:TABLE_DESCR,
:TABLE_NBR
FROM {tempTableName} SRC {queryConditions}""")
exec("""
DELETE FROM
Employee
WHERE
EmpNo = :EmpNo
""")
def UPSERT_TABLE(tempTableName, queryConditions = ""):
exec(f"""MERGE INTO mydb.mytable TGT USING (SELECT * FROM {tempTableName} {queryConditions}) SRC ON TABLE_DESCR = :somedescription
WHEN MATCHED THEN UPDATE SET
TABLE_ID = :TABLE_ID
WHEN NOT MATCHED THEN INSERT (TABLE_ID, TABLE_DESCR, TABLE_NBR)
VALUES (:TABLE_ID, :TABLE_DESCR, :TABLE_NBR)""")
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
.IMPORT¶
La transformation de la commande .IMPORT
créera un appel à l’assistant import_file_to_temptable
pour charger les données du fichier dans une table temporaire. Ensuite, les appels à toutes les étiquettesAPPLY
utilisées dans l’importation originale seront créés. Enfin, les appels à une étiquetteINSERT
seront 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;
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()
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
Teradata (MultiLoad)
.begin import mload
tables
mySampleTable1
sessions 20
ampcheck none;
.layout myLayOut;
.field ID * VARCHAR(2) NULLIF ID = '1';
.field NAME * VARCHAR(25);
.field AGE * VARCHAR(10);
.dml label insert_data;
INSERT INTO mySampleTable1
(
ID,
NAME,
AGE
)
VALUES
(
:ID,
SUBSTRING(:NAME FROM 2),
:AGE
);
.import infile sampleData.txt
layout myLayOut
apply insert_data
.end mload;
.logoff;
ROW | ID | NAME | AGE |
---|---|---|---|
1 | NULL | ohn | 25 |
2 | 2 | aria | 29 |
3 | 3 | arlos | 31 |
4 | 4 | ike | 40 |
5 | 5 | aura | 27 |
Snowflake (Python)
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. **
#.begin import mload tables mySampleTable1 sessions 20 ampcheck none
myLayOut_TableName = "myLayOut_TEMP_TABLE"
myLayOut_Columns = """ID VARCHAR(2),
NAME VARCHAR(25),
AGE VARCHAR(10)"""
myLayOut_Conditions = """CASE
WHEN ID = '1'
THEN NULL
ELSE ID
END AS ID, NAME AS NAME, AGE AS AGE"""
def insert_data(tempTableName, queryConditions = ""):
exec(f"""INSERT INTO mySampleTable1 (ID, NAME, AGE)
SELECT
SRC.ID,
SUBSTRING(SRC.NAME, 2),
SRC.AGE
FROM {tempTableName} SRC {queryConditions}""")
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
#.import infile sampleData.txt layout myLayOut apply insert_data
snowconvert.helpers.import_file_to_temptable(fr"sampleData.txt", myLayOut_TableName, myLayOut_Columns, myLayOut_Conditions, ',')
insert_data(myLayOut_TableName)
exec(f"""DROP TABLE {myLayOut_TableName}""")
if con is not None:
con.close()
con = None
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
ROW | ID | NAME | AGE |
---|---|---|---|
1 | NULL | ohn | 25 |
2 | 2 | aria | 29 |
3 | 3 | arlos | 31 |
4 | 4 | ike | 40 |
5 | 5 | aura | 27 |
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
""")
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);
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.
#*** 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()
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
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
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
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')
.....
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')
.....
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
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
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
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
export SNOW_AUTHENTICATOR=VALUE
export SNOW_USER=myuser
export SNOW_PASSWORD=mypassword
python3 sample_BTEQ.py
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")
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
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;
Vous pourrez voir les lignes que vous avez insérées dans l’exemple ci-dessus.
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
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
Dans ce répertoire, vous devez exécuter :
python -m pydoc -b
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>
Cela ouvrira le navigateur avec la documentation de votre code, de la façon suivante :
Faites défiler la page jusqu’à la fin pour voir les paquets installés. Et vous verrez quelque chose de similaire à :
En cliquant sur SnowConvert(paquet), vous verrez quelque chose comme :
En cliquant sur les assistants de modules, vous obtiendrez un écran similaire à celui-ci :
Vous pouvez ensuite faire défiler les fonctions et les classes du module.
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)`
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 cheminmode,
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_OKdir_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épertoireeffective_ids,
Si True, l’accès utilisera l’uid/gid effectif au lieu de l’uid/gid réelfollow_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`**`()`
Description :¶
S’exécute à la fin de l’exécution du script.
coloré¶
**`colored`**`(text, color='blue')`
Description :¶
Imprime un texte coloré à partir de la couleur spécifiée.
Paramètres :¶
texte
,
Le texte à imprimercolor="blue"
,
La couleur à imprimer
configure_log¶
**`configure_log`**`(configuration_path)`
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)`
Description :¶
Supprime la table transitoire portant le nom spécifié.
Paramètres :
tempTableName
,
Le nom de la table temporairecon=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)`
Description :¶
Paramètres :
exctype
valeur
tback
exec¶
**`exec`**`(sql_string, using=None, con=None)`
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 sqlusing=None
,
Le paramètre optionnel qui peut être utilisé dans la requête sql transmisecon=None
,
La connexion à utiliser, si None est passé, la dernière connexion effectuée sera utilisée
exec_file¶
**`exec_file`**`(filename, con=None)`
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écutercon=None
,
La connexion à utiliser, si None est passé, la dernière connexion effectuée sera utilisée
exec_os¶
**`exec_os`**`(command)`
Description :¶
Exécute une commande dans le système d’exploitation.
exec_sql_statement¶
**`exec_sql_statement`**`(sql_string, con, using=None)`
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écutercon
,
La connexion à utiliserusing
,
Les paramètres optionnels à utiliser dans l’exécution sql
expands\using_params**¶
**`expands_using_params`**`(statement, params)`
Description :¶
Développe l’instruction transmise avec les paramètres.
Paramètres :
statement
,
Le sql contenant la chaîne à exécuterparams
,
Les paramètres de l’instruction sql
expandvar¶
**`expandvar`**`(str)`
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)`
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)`
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 rapidefilepath
,
Chemin du nom de fichier à charger dans la tabletarget_table_name
,
Nom de la table dont les données seront chargéescon=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)`
Description :¶
Paramètres :
filename
,
get\argkey**¶
**`get_argkey`**`(astr)`
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`**`()`
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)`
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 argumentsvariable_name
,
Nom de la variable à obtenirvars
,
Le hachage avec les noms et les valeurs des variablesargs
,
Le paramètre du tableau des arguments
import\data_to_temptable**¶
**`import_data_to_temptable`**`(tempTableName, inputDataPlaceholder, con)`
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 Snowflakecon,
La connexion à utiliser
import\file**¶
**`import_file`**`(filename, separator=' ')`
Description :¶
Importe le nom de fichier passé avec le séparateur optionnel.
Paramètres :
filename,
Le chemin du fichier à importerseparator=' ',
Le séparateur optionnel
import\file_to_temptable**¶
**`import_file_to_temptable`**`(filename, tempTableName, columnDefinition)`
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 à liretempTableName,
Le nom de la table temporairecolumnDefinition,
La définition de tous les champs qui composeront la table temporaire
import\reset**¶
**`import_reset`**`()`
Description :¶
log¶
**`log`**`(*msg, level=20, writter=None)`
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 à journaliserlevel=20,
writter=None,
log\on**¶
**`log_on`**`(user=None, password=None, account=None, database=None, warehouse=None, role=None, login_timeout=10, authenticator=None)`
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éespassword
Le mot de passe de l’utilisateur de la base de donnéesdatabase,
La base de données à connecterwarehouse,
L’entrepôt de la base de données à connecterrole,
Le rôle à connecterlogin_timeout,
Le délai d’expiration maximum avant d’émettre une erreur si la connexion prend trop de tempsauthentificator,
Valeur de l’authentificateur à utiliser comme SNOWFLAKE, EXTERNALBROWSER, SNOWFLAKE_JWT ou OAUTHtoken,
Le jeton OAUTH ou JWT
os¶
**`os`**`(args)`
Description :¶
Paramètres :
args,
print\table**¶
**`print_table`**`(dictionary)`
Description :¶
Imprime le dictionnaire sans exposer les valeurs de l’utilisateur et du mot de passe.
Paramètres :
dictionary,
quit\application**¶
**`quit_application`**`(code=None)`
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)`
Description :¶
Lit les arguments des paramètres à partir du tableau passé.
Paramètres :
args,
Les arguments à utiliser
readrun¶
**readrun**(line, skip=0)
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 à lireskip=0,
Les lignes à sauter
remark¶
**remark**(arg)
Description :¶
Imprime l’argument.
Paramètres :
arg,
L’argument à imprimer
repeat\previous_sql_statement**¶
**`repeat_previous_sql_statement`**`(con=None, n=1)`
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éen=1,
Le nombre d’instructions précédentes à exécuter à nouveau
set\default_error_level**¶
**`set_default_error_level`**`(severity_value)`
Description :¶
Paramètres :
severity_value,
set\error_level**¶
**`set_error_level`**`(arg, severity_value)`
Description :¶
Paramètres :
arg,
severity_value,
simple\fast_load**¶
**`simple_fast_load`**`(con, target_schema, filepath, stagename, target_table_name)`
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 à utilisertarget_schema,
Nom du schéma à utiliser pour le chargement rapidefilepath,
Chemin du nom de fichier à charger dans la tabletarget_table_name,
Nom de la table dont les données seront chargées
stat¶
**`stat`**`(path, *, dir_fd=None, follow_symlinks=True)`
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 intdir_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épertoirefollow_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)`
Description :¶
Exécute la commande dans un sous-shell.
Paramètres :
_
command
_,
using¶
**`using`**`(*argv)`
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 :
target_schema_table
le schéma cible (facultatif) et le nom de la table
define_file
Le nom du fichier à lire
define_columns
La définition de toutes les colonnes de la table temporaire
begin_loading_columns
Les noms des colonnes à insérer. Détermine l’ordre dans lequel les valeurs sont insérées
begin_loading_values
La liste des valeurs brutes d’insertion à convertir
field_delimiter
Le délimiteur de champ
(facultatif)
skip_header
Le nombre de lignes à sauter
(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
(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(): |
|
.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;
Dans l’exemple ci-dessus, il y avait cinq commandes. Deux d’entre elles étaient des commandes. Label
. La commandeFIRSTLABEL
a été transformée en une fonction avec la ou les instructions qui la suivent ci-dessous jusqu’à ce qu’une autre commande.LABEL
soit 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()
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 suitFIRSTLABEL
dans le code original. Avant que la fonctionFIRSTLABEL
ne 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 fonctionmain()
: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 fonctionexec
fournie par snowconvert.helpers. Prenez par exemple le code suivant :
CREATE TABLE aTable (aColumn BYTEINT);
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()
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
Pour exécuter le fichier d’exécution, entrez l’une ou l’autre forme de la commande BTEQ RUN :
.RUN FILE=sampfile
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()
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);
Ceci peut être exécuté au cours d’un script avec la ligne suivante :
$(<$NEWSQL)
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()
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>
Modèles d’échantillons de sources¶
Avec ces données d’entrée :
A B C
D E F
G H I
* [
] *
Teradata :¶
.IMPORT DATA FILE = inputData.dat;
.REPEAT *
USING var_1 (CHARACTER), var_2 (CHARACTER), var_3 (CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1)
;INSERT INTO testtabu (c1) VALUES (:var_2)
;INSERT INTO testtabu (c1) VALUES (:var_3)
;UPDATE testtabu
SET c2 = 'X'
WHERE c1 = :var_1
;UPDATE testtabu
SET c2 = 'Y'
WHERE c1 = :var_2
;UPDATE testtabu
SET c2 = 'Z'
WHERE c1 = :var_3
;INSERT INTO TESTTABU (c1, c2) VALUES ('?','_');
.REPEAT 10
INSERT INTO TESTTABU2 VALUES ('John Doe', 23);
.REPEAT RECS 5
INSERT INTO TESTTABU2 VALUES ('Bob Alice', 21);
.IMPORT DATA FILE = inputData2.dat;
USING (var_1 CHARACTER, var_2 CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1)
;INSERT INTO testtabu (c1) VALUES (:var_2);
C1 | C2 |
---|---|
A | X |
D | X |
G | X |
B | Y |
E | Y |
H | Y |
C | Z |
F | Z |
I | Z |
? | _ |
? | _ |
? | _ |
* | null |
[ | null |
MY_NAME | MY_AGE |
---|---|
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Snowflake :¶
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
snowconvert.helpers.import_file(fr"inputData.dat")
ssc_repeat_value = '*'
ssc_max_iterations = 1
for ssc_repeat_position in range(0, ssc_max_iterations):
if ssc_repeat_position == 0:
using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", "var_3", "CHARACTER", rows_to_read = ssc_repeat_value)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_1)
""", using = using)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_2)
""", using = using)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_3)
""", using = using)
exec("""
UPDATE testtabu
SET
c2 = 'X'
WHERE
c1 = :var_1
""", using = using)
exec("""
UPDATE testtabu
SET
c2 = 'Y'
WHERE
c1 = :var_2
""", using = using)
exec("""
UPDATE testtabu
SET
c2 = 'Z'
WHERE
c1 = :var_3
""", using = using)
exec("""
INSERT INTO TESTTABU (c1, c2)
VALUES ('?', '_')
""", using = using)
ssc_repeat_value = 10
ssc_max_iterations = 10
for ssc_repeat_position in range(0, ssc_max_iterations):
exec("""
INSERT INTO TESTTABU2
VALUES ('John Doe', 23)
""")
ssc_repeat_value = 5
ssc_max_iterations = 5
for ssc_repeat_position in range(0, ssc_max_iterations):
exec("""
INSERT INTO TESTTABU2
VALUES ('Bob Alice', 21)
""")
snowconvert.helpers.import_file(fr"inputData2.dat")
using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", rows_to_read = 1)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_1)
""", using = using)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_2)
""", using = using)
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
C1 | C2 |
---|---|
A | X |
D | X |
G | X |
B | Y |
E | Y |
H | Y |
C | Z |
F | Z |
I | Z |
? | _ |
? | _ |
? | _ |
* | null |
[ | null |
MY_NAME | MY_AGE |
---|---|
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
John Doe | 23 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
Bob Alice | 21 |
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.
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 } ]
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 :
Appelez la fonction
import_file()
à partir des assistants SnowConvert. Cette opération charge les données dans un fichier temporaire.Appelez la fonction
using()
des assistants SnowConvert pour créer un dictionnaire avec les données chargées.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
Teradata (MultiLoad)
.IMPORT DATA FILE = inputData.dat;
USING var_1 (CHARACTER), var_2 (CHARACTER), var_3 (CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1)
;INSERT INTO testtabu (c1) VALUES (:var_2)
;INSERT INTO testtabu (c1) VALUES (:var_3)
;UPDATE testtabu
SET c2 = 'X'
WHERE c1 = :var_1
;UPDATE testtabu
SET c2 = 'Y'
WHERE c1 = :var_2
;UPDATE testtabu
SET c2 = 'Z'
WHERE c1 = :var_3;
ROW | C1 | C2 |
---|---|---|
1 | A | X |
2 | B | Y |
3 | C | Z |
Snowflake (Python)
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
snowconvert.helpers.import_file(fr"inputData.dat")
using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", "var_3", "CHARACTER", rows_to_read = 1)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_1)
""", using = using)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_2)
""", using = using)
exec("""
INSERT INTO testtabu (c1)
VALUES (:var_3)
""", using = using)
exec("""
UPDATE testtabu
SET
c2 = 'X'
WHERE
c1 = :var_1
""", using = using)
exec("""
UPDATE testtabu
SET
c2 = 'Y'
WHERE
c1 = :var_2
""", using = using)
exec("""
UPDATE testtabu
SET
c2 = 'Z'
WHERE
c1 = :var_3
""", using = using)
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
ROW | C1 | C2 |
---|---|---|
1 | A | X |
2 | B | Y |
3 | C | Z |
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é |
|
Transformé |
Le nœud est commenté car la transformation a lieu dans l’instruction INSERT correspondante. |
|
CLEAR |
Commenté |
|
DATEFORM |
Commenté |
|
Transformé |
|
|
Transformé |
Commenté car non nécessaire pour la transformation de BEGIN LOADING. |
|
ERRLIMIT |
Commenté |
|
HELP |
Commenté |
|
HELP TABLE |
Commenté |
|
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é |
|
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;
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()
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;
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()
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;
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()
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¶
SSC-FDM-0007 : Élément avec des dépendances manquantes.
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;
Snowflake (Python)
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
#SET RECORD VARTEXT DELIMITER 'c' DISPLAY ERRORS 'efilename'
ssc_set_record = ""
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
#SET RECORD VARTEXT 'l' 'c' NOSTOP
ssc_set_record = "'l'"
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
#SET RECORD VARTEXT 'l' TRIM NONE LEADING 'p'
ssc_set_record = "'l'"
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
#SET RECORD VARTEXT 'l' TRIM NONE TRAILING 'p'
ssc_set_record = "'l'"
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
#SET RECORD VARTEXT 'l' TRIM NONE BOTH 'p'
ssc_set_record = "'l'"
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
#SET RECORD FORMATTED TRIM NONE BOTH
ssc_set_record = ","
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
#SET RECORD UNFORMATTED QUOTE NO OPTIONAL
ssc_set_record = "UNFORMATTED"
#** SSC-EWI-0021 - 'BINARY' KEYWORD SPECIFICATION FOR SET RECORD NOT SUPPORTED IN SNOWFLAKE **
#SET RECORD BINARY QUOTE NO YES 'q'
#** SSC-EWI-0021 - 'TEXT' KEYWORD SPECIFICATION FOR SET RECORD NOT SUPPORTED IN SNOWFLAKE **
#SET RECORD TEXT QUOTE OPTIONAL
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
DEFINE¶
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;
Snowflake (Python)
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
#DEFINE id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT) FILE = /tmp/inputData.txt
ssc_define_columns = "id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)"
#Set file name manually if empty
ssc_define_file = f"""/tmp/inputData.txt"""
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
#DEFINE id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)
ssc_define_columns = "id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)"
#Set file name manually if empty
ssc_define_file = f""""""
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
#DEFINE FILE = /tmp/inputData.txt
ssc_define_columns = ""
#Set file name manually if empty
ssc_define_file = f"""/tmp/inputData.txt"""
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
#DEFINE
ssc_define_columns = ""
#Set file name manually if empty
ssc_define_file = f""""""
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
BEGIN LOADING¶
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;
Snowflake (Python)
#*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
snowconvert.helpers.configure_log()
con = snowconvert.helpers.log_on()
#** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
#BEGIN LOADING FastTable ERRORFILES Error1, Error2 CHECKPOINT 10000
snowconvert.helpers.quit_application()
if __name__ == "__main__":
main()
INSERT¶
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
);
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()
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 :
Stage | Input Data Place Holder |
---|---|
Stage | Input Data Place Holder |
Internal stage | @my_int_stage |
External stage | @my_int_stage/path/file.csv |
Amazon S3 bucket | s3://mybucket/data/files |
Google Cloud Storage | gcs://mybucket/data/files |
Microsoft Azure | azure://myaccount.blob.core.windows.net/mycontainer/data/files |
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")
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;
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()
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¶
SSC-FDM-0007 : Élément avec des dépendances manquantes.
SSC-FDM-0027 : Suppression de l’instruction suivante, sans application dans SnowFlake.
SSC-EWI-0021 : Non pris en charge.
SSC-FDM-TD0022 : Variables shell trouvées, l’exécution de ce code dans un script shell est exigée.