SnowConvert: Teradata – Referenz zur Übersetzung von Skripten in Python¶
Weitere Informationen zu bestimmten Themen finden Sie auf den folgenden Seiten.
BTEQ, lesen Sie die Übersetzungsreferenz für Basic Teradata Query Syntax.
FastLoad, lesen Sie die Übersetzungsreferenz für die FastLoad-Syntax.
MultiLoad, lesen Sie die Übersetzungsreferenz für die MultiLoad-Syntax.
TPT, lesen Sie die Übersetzungsreferenz für die TPT-Syntax.
TPT¶
Transformation von TPT-Anweisungen¶
Alle TPT-Anweisungen werden, wie auch andere Teradata-Skriptsprachen, in Python-Code umgewandelt. Hier finden Sie einige Beispiele für bereits unterstützte Transformationen.
Transformation des „Define Job“-Header¶
Die JOB-Anweisung wird in eine Python-Klasse übersetzt, in der alle Anweisungen wie Operatoren, Schemadefinitionen und Schritte enthalten sind.
Quellcode
/* Some comments on the job */
DEFINE JOB LOADJOB
DESCRIPTION 'LOAD AC_SCHEMA TABLE FROM A FILE'
JobBody
Übersetzter Code
## Some comments on the job
class LOADJOB:
# DESCRIPTION 'LOAD AC_SCHEMA TABLE FROM A FILE'
JobBody
Transformation von „Define Schema“¶
Die SCHEMA-Anweisung wird in ein Attribut in der Klasse übersetzt, die für die JOB-Anweisung erstellt wurde.
Quellcode
DEFINE SCHEMA DCS_SCHEMA
DESCRIPTION 'DCS DATA'
(
PNRHEADER_ID PERIOD(DATE),
PNRLOCPERIOD PERIOD(TIMESTAMP(0)),
CRTDATE CLOB,
REQTYP JSON(100000),
seqno INTEGER,
resdata INTEGER
);
Übersetzter Code
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,
);"""
Transformation von „Define Operator“¶
Die Operatoren werden in der für den Auftrag erstellten Klasse in Python-Funktionen übersetzt. Die angegebenen Beispiele sind die Anbieter, die SnowConvert derzeit unterstützt
DDL-Operator¶
Quellcode für DDL-Operator
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']
);
Übersetzter Code
class JobName:
def DDL_OPERATOR(self):
#'TERADATA PARALLEL TRANSPORTER DDL OPERATOR'
global args
self.con = log_on(user = args.MyUserName, password = 'SomePassWord')
UPDATE-Operator¶
Quellcode für UPDATE-Operator
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'
);
Übersetzter Code
class JobName:
def LOAD_OPERATOR(self, query):
#'TERADATA PARALLEL TRANSPORTER LOAD OPERATOR'
#USES SCHEMA AC_MASTER_SCHEMA
operator_name = "LOAD_OPERATOR"
return query
DATACONNECTORPRODUCER-Operator¶
Quellcode für Data Connector Producer-Operator
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'
);
Übersetzter Code
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
Transformation von „Define Step“¶
Die Schritte werden ebenfalls in Python-Funktionen innerhalb der für den Auftrag generierten Klasse übersetzt. Sie werden in der Hauptfunktion des übersetzten Codes aufgerufen.
Quellcode für Step (Schritt)
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);
);
Übersetzter Code
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() )})""")
Hauptfunktion¶
Die Hauptfunktion wird immer für jede Skriptsprache generiert. Für TPT enthält die Hauptfunktion eine Instanz der Auftragsklasse und ruft die Schritte im Auftrag auf
Beispielcode für die Hauptfunktion
def main():
_LOADJOB = LOADJOB()
_LOADJOB.setup_tables()
_LOADJOB.stLOAD_FILE_NAME()
snowconvert.helpers.quit_application()
MLOAD¶
Teradata MultiLoad ist ein befehlsgesteuertes Dienstprogramm für die schnelle, umfangreiche Wartung mehrerer Tabellen und Ansichten in der Teradata-Datenbank.
Um die MultiLoad-Funktionalität für Teradata in Snowflake zu simulieren, werden MultiLoad-Dateien und -Befehle in Python-Code umgewandelt, ähnlich wie bei den Transformationen für BTEQ- und FastLoad-Skripte. Der generierte Code verwendet das Snowflake Python-Projekt namens snowconvert.helpers, das die erforderlichen Funktionen zur Simulation der MultiLoad-Anweisungen in Snowflake enthält.
Übersetzung von MultiLoad-Befehlen¶
Die meisten der MultiLoad-Befehle werden in Snowflake als nicht relevant angesehen, diese Befehle sind auskommentiert. Im Folgenden finden Sie eine zusammenfassende Liste der MultiLoad-Befehle und deren Transformationsstatus in 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 | |
Es gibt jedoch einige außergewöhnliche Befehle, die in Python-spezifischen Code umgewandelt werden müssen, damit sie in Snowflake wie vorgesehen funktionieren. Siehe Abschnitt BEGIN MLOAD.
Wenn Sie weitere Fragen zu dieser Dokumentation haben, können Sie uns eine E-Mail an snowconvert-support@snowflake.com senden.
BEGIN MLOAD¶
Die Transformation für den Befehl .BEGIN MLOAD
ist eine mehrteilige Transformation, die die Befehle .LAYOUT
, .FIELD
, .FILLER
,.DML LABEL
und .IMPORT
benötigt, um ihre Verhaltensweise korrekt zu simulieren.
Diese Transformation wird in den folgenden Unterabschnitten ausführlich erklärt.
.LAYOUT, .FIELD und .FILLER¶
Die Transformation für die Befehle .LAYOUT
, .FIELD
, und .FILLER
erstellt Variablendefinitionen, die in einem zukünftigen Funktionsaufruf von IMPORT dieses Layouts verwendet werden.
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¶
Die Transformation für den Befehl .DML LABEL
erstellt eine Funktion, die die Anweisungen nach der Definition des Labels enthält. Beachten Sie, dass nach dem Befehl .DML LABEL
normalerweise ein Insert
, Update
oder Delete
folgt.
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¶
Die Transformation des Befehls .IMPORT
erzeugt einen Aufruf des Hilfsmittelsimport_file_to_temptable
, um die Daten aus der Datei in eine temporäre Tabelle zu laden. Dann werden die Aufrufe allerAPPLY
-Labels, die im ursprünglichen Import verwendet wurden, erstellt. Schließlich werden die Aufrufe für einINSERT
-Label in einen Abfrageparameter umgewandelt und können optional eine Abfragebedingung enthalten.
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()
Großes Beispiel¶
Betrachten Sie anhand der oben gezeigten Transformationen für eine Vielzahl von Befehlen das folgende Beispiel.
Mit diesen Eingabedaten:
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 |
Bekannte Probleme¶
1. DELETE-Anweisung wird teilweise unterstützt
Die DELETE
-Anweisung wird nur teilweise unterstützt, da die Where-Bedingungen, wenn sie gefunden werden, nicht korrekt konvertiert werden, wenn sie auf eine mit LAYOUT
definierte Spalte verweisen.
In dem folgenden Beispiel verweist :EmpNo
auf eine LAYOUT
definierte Spalte. Die Transformation berücksichtigt dies jedoch nicht, so dass der Code auf eine Spalte verweist, die nicht existiert.
exec("""
DELETE FROM
Employee
WHERE
EmpNo = :EmpNo
""")
Wenn Sie weitere Fragen zu dieser Dokumentation haben, können Sie uns eine E-Mail an snowconvert-support@snowflake.com senden.
SnowConvert Skript-Hilfsfunktionen¶
SnowConvert für Teradata kann beliebige Teradata SQL oder Skripte (BTEQ, FastLoad, MultiLoad und TPump) übernehmen und sie in funktional äquivalente Snowflake SQL, JavaScript eingebettet in Snowflake SQL und Python konvertieren. Jeder ausgegebene Python-Code von SnowConvert ruft Funktionen aus diesen Hilfsklassen auf, um die Konvertierung abzuschließen und eine funktional gleichwertige Ausgabe in Snowflake zu erzeugen.
Der Snowflake Connector für Python wird ebenfalls aufgerufen, um eine Verbindung zu Ihrem Snowflake Konto herzustellen und den von SnowConvert erstellten Python-Code auszuführen.
Die neuesten Inforamationen zu den Versionen des Pakets finden Sie hier.
Bemerkung
Das Python-Paketsnowconvert-helpers
unterstützt die Python-Versionen 3.6, 3.7, 3.8 und 3.9.
Skript-Migration¶
Quelle¶
Nehmen wir an, Sie haben den folgenden BTEQ-Code, der migriert werden soll.
insert into table1 values(1, 2);
insert into table1 values(3, 4);
insert into table1 values(5, 6);
Ausgabe¶
Sie sollten eine Ausgabe wie die unten stehende erhalten.
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()
Erste Schritte¶
Um das Paket zu installieren, sollten Sie den folgenden Befehl in Ihrer Python-Umgebung ausführen. Wenn Sie mit der Installation von Paketen in Python nicht vertraut sind, besuchen Sie die folgende Seite über Python-Pakete (https://packaging.python.org/tutorials/installing-packages/).
pip install snowconvert-helpers
Sobald das Paket installiert ist, können Sie das Skript mit dem migrierten Code in Python ausführen.
Führen Sie den Code aus.¶
Um den migrierten Code auszuführen, müssen Sie nur Command Prompt
oder Terminal
öffnen und den folgenden Befehl ausführen.
python sample_BTEQ.py
Wenn das Skript keine Fehler aufweist, erhalten Sie in Ihrer Konsole eine Ausgabe wie die folgende.
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
Übergabe von Verbindungsparametern¶
Es gibt mehrere Möglichkeiten, die Verbindungsparameter an die Verbindung der Datenbank zu übergeben:
Als Parameter im Funktionsaufruf snowconvert.helpers.log_on innerhalb der Python-Datei.
Als Positionsparameter mit der spezifischen Reihenfolge von Benutzer, Kennwort, Konto, Datenbank, Warehouse und Rolle, wenn das Python-Programm von der Befehlszeile aus ausgeführt wird.
Als benannte Parameter ohne Einschränkung der Reihenfolge SNOW_USER, SNOW_PASSWORD, SNOW\_ACCOUNT, SNOW\_DATABASE, SNOW\_WAREHOUSE, SNOW_ROLE, SNOW_QUERYTAG, SNOWAUTHENTICATOR und SNOWTOKEN, wenn Python von der Kommandozeile aus ausgeführt wird und einer von ihnen wie –param-VARNAME=VALUE übergeben wird.
Als Umgebungsvariablen namens SNOW_USER, SNOW_PASSWORD, SNOW\_ACCOUNT, SNOW\_DATABASE, SNOW\_WAREHOUSE, SNOW_ROLE, SNOW\_QUERYTAG, SNOWAUTHENTICATOR und SNOWTOKEN vor der Ausführung von Python.
Die zuvor angegebene Reihenfolge ist die Art und Weise, wie Sie den Vorrang bestimmen.
Parameter im Funktionsaufruf¶
Sie können als Positionsparameter im Funktionsaufruf wie folgt festgelegt werden.
.....
con = snowconvert.helpers.log_on(
'myuser',
'mypassword',
'myaccount',
'mydatabase',
'mywarehouse',
'myrole',
5,
'myauthenticator',
'mytoken')
.....
Oder Sie können jeden der genannten Parameter in beliebiger Reihenfolge im Funktionsaufruf wie folgt setzen.
.....
con = snowconvert.helpers.log_on(
account:'myaccount',
password:'mypassword',
user:'myuser',
warehouse:'mywarehouse',
login_timeout:5,
authenticator:'myauthenticator',
toke:'mytoken')
.....
Positionsbezogene Parameter¶
Sie müssen in der Befehlszeile wie folgt in einer bestimmten Reihenfolge eingegeben werden.
python sample_BTEQ.py myuser mypassword myaccount mydatabase mywarehouse myrole myauthenticator mytokenr
Sie können auch nur einige der Parameter einstellen, aber immer beginnend mit dem Benutzer-Parameter wie folgt.
python sample_BTEQ.py myuser mypassword myaccount
Benannte Parameter¶
Sie können jeden der genannten Parameter in beliebiger Reihenfolge in der Befehlszeile wie folgt setzen (aus Gründen der Lesbarkeit einzeilig, mehrzeilig dargestellt).
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
Umgebungsvariablen¶
Bevor Sie das Python-Skript aufrufen, können Sie eine der folgenden Umgebungsvariablen setzen:
SNOW_USER
SNOW_PASSWORD
SNOW_ACCOUNT
SNOW_DATABASE
SNOW_WAREHOUSE
SNOW_ROLE
SNOW_QUERYTAG
SNOW_AUTHENTICATOR
SNOW_TOKEN
PRIVATE_KEY_PATH
PRIVATE_KEY_PASSWORD
Schlüsselpaar-Authentifizierung¶
Die Funktion log_on
kann auch den Authentifizierungsprozess des Schlüsselpaares unterstützen. In der folgenden Snowflake-Dokumentation finden Sie weitere Informationen zur Schlüsselerstellung. Bitte beachten Sie die erforderlichen Parameter:
log_on(
user='YOUR_USER',
account='YOUR_ACCOUNT',
role = 'YOUR_ROLE',
warehouse = 'YOUR_WAREHOUSE',
datenbank = 'YOUR_DATABASE',
private_key_path='/YOUR_PATH/rsa_key.p8',
private_key_password='YOUR_PASSWORD')
Beispiel für die Übergabe von Umgebungsvariablen¶
Hier ist ein Beispiel für die Verwendung von SNOW_AUTHENTICATOR, SNOW_USER und SNOW\_PASSWORD. Sie müssen vor der Ausführung der Python-Ausgabedatei definiert werden und dann die von Python generierte Datei ausführen.
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
Aktivieren der Protokollierung¶
Um die Protokollierung zu aktivieren, sollten Sie eine Umgebungsvariable namens SNOW_LOGGING auf „true“ setzen.
Wenn Sie dann die Konfiguration der Protokollierung anpassen möchten, können Sie der Methode snowconvert.helpers.configure_log()
einen Parameter wie den folgenden übergeben:
snowconvert.helpers.configure_log("SOMEPATH.conf")
Die Konfigurationsdatei sollte die folgende Struktur enthalten. Für weitere Informationen über Python-Protokollierung klicken Sie bitte hier
[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¶
Sobald der von Ihnen migrierte Code ausgeführt wurde, können Sie zu Snowflake gehen und Ihre Änderungen oder Bereitstellungen überprüfen.
select * from PUBLIC.table1;
Sie können die Zeilen sehen, die Sie im obigen Beispiel eingefügt haben.
Dokumentation zu lokalen Hilfsfunktionen¶
Zunächst einmal müssen Sie das Python-Paket pydoc installieren (verfügbar seit Version 2.0.2 von snowconvert-helpers).
pip install pydoc
Um die Python-Dokumentation des Pakets snowconvert-helpers anzuzeigen, sollten Sie dann in einen Ordner wechseln, in dem sich der konvertierte Ausgabecode befindet und Sie eine Python-Ausgabe haben.
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
In diesem Verzeichnis müssen Sie Folgendes ausführen:
python -m pydoc -b
Die Konsole öffnet Ihren bevorzugten Browser mit der HTML-Hilfe der Dokumentation für alle installierten Pakete.
D:\bteq\Output>python -m pydoc -b
Server ready at http://localhost:61355/
Server commands: [b]rowser, [q]uit
server>
Dadurch wird der Browser mit der Dokumentation Ihres Codes geöffnet:
Blättern Sie bis zum Ende der Seite, um die installierten Pakete zu sehen. Und Sie werden etwas Ähnliches sehen wie:
Wenn Sie auf SnowConvert (Paket) klicken, sehen Sie etwas wie:
Wenn Sie auf das Modul Hilfsfunktion klicken, wird ein Bildschirm angezeigt, der ungefähr so aussieht:
Dann können Sie durch die Funktionen und Klassen des Moduls blättern.
Bekannte Probleme ¶
Es wurden keine Probleme gefunden.
Zugehörige EWIs ¶
Keine zugehörigen EWIs.
Technische Dokumentation¶
Funktionen¶
Alle im Projekt definierten Funktionen.
Zugriff¶
**`access`**`(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)`
Beschreibung:¶
_Verwenden Sie die echte UID/GID, um den Zugriff auf einen Pfad zu testen
dir_fd, effective_ids und follow_symlinks sind auf Ihrer Plattform möglicherweise nicht implementiert. Wenn sie nicht verfügbar sind, wird bei ihrer Verwendung eine NotImplementedError angezeigt.
_Beachten Sie, dass die meisten Operationen die effektive UID/GID verwenden werden. Daher kann diese Routine in einer SUID/SGID-Umgebung verwendet werden, um zu testen, ob der aufrufende Benutzer den angegebenen Zugriff auf den Pfad hat
Parameter:¶
path,
Zu testender Pfad; kann eine Zeichenfolge, Bytes oder ein pfadähnliches Objekt seinmode,
Bitfeld für den Betriebssystemmodus. Kann F_OK sein, um die Existenz zu testen, oder das inklusive OR von R_OK, W_OK, und X_OKdir_fd,
Wenn es nicht None ist, sollte es ein Dateideskriptor sein, der für ein Verzeichnis geöffnet ist, und der Pfad sollte relativ sein; der Pfad ist dann relativ zu diesem Verzeichniseffective_ids,
Wenn „true“, verwendet der Zugriff die effektive UID/GID anstelle der realen UID/GIDfollow_symlinks,
Wenn „false“ und das letzte Element des Pfads ein symbolischer Link ist, überprüft „access“ den symbolischen Link selbst anstelle der Datei, auf die der Link verweist
at_exit_helfers¶
**`at_exit_helpers`**`()`
Beschreibung:¶
wird am Ende der Ausführung des Skripts ausgeführt
farbig¶
**`colored`**`(text, color='blue')`
Beschreibung:¶
Druckt farbigen Text in der angegebenen Farbe.
Parameter:¶
text
,
Der zu druckende Textcolor="blue"
,
Die zu druckende Farbe
configure_log¶
**`configure_log`**`(configuration_path)`
Beschreibung:¶
Konfiguriert die Protokollierung, die für jede datenbezogene Ausführung auf der Snowflake-Verbindung durchgeführt wird. Die Protokolldatei heißt standardmäßig ‚snowflake_python_connector.log‘.
Parameter:
configuration_path
,
Der Konfigurationspfad der Datei, die alle gewünschten Einstellungen für die Protokollierung enthält
drop_transient_table¶
**`drop_transient_table`**`(tempTableName, con=None)`
Beschreibung:¶
löscht die transiente Tabelle mit dem angegebenen Namen
Parameter:
tempTableName
,
Der Name der temporären Tabellecon=None
,
Die zu verwendende Verbindung, wenn None übergeben wird, wird die zuletzt durchgeführte Verbindung verwendet
exception_hook¶
**`exception_hook`**`(exctype, value, tback)`
Beschreibung:¶
Parameter:
exctype
Wert
tback
exec¶
**`exec`**`(sql_string, using=None, con=None)`
Beschreibung:¶
Führt eine SQL-Zeichenfolge unter Verwendung der letzten Verbindung aus, optional unter Verwendung von Argumenten oder einer bestimmten Verbindung. Beispiele:
_
exec("SELECT * FROM USER")
__
exec("SELECT * FROM USER", con)
__
exec("SELECT * FROM CUSTOMER WHERE CUSTOMERID= %S", customer)
_
Parameter:
sql_string
,
Die Definition der SQLusing=None
,
Der optionale Parameter, der in der übergebenen SQL verwendet werden kanncon=None
,
Die zu verwendende Verbindung, wenn None übergeben wird, wird die zuletzt durchgeführte Verbindung verwendet
exec_file¶
**`exec_file`**`(filename, con=None)`
Beschreibung:¶
liest den Inhalt einer Datei und führt die darin enthaltenen SQL-Anweisungen mit der angegebenen Verbindung aus
Parameter:
filename
,
Der Dateiname, der gelesen und ausgeführt werden sollcon=None
,
Die zu verwendende Verbindung, wenn None übergeben wird, wird die zuletzt durchgeführte Verbindung verwendet
exec_os¶
**`exec_os`**`(command)`
Beschreibung:¶
führt einen Befehl im operativen System aus
exec_sql_statement¶
**`exec_sql_statement`**`(sql_string, con, using=None)`
Beschreibung:¶
Führt eine SQL-Anweisung in der übergebenen Verbindung mit den optionalen Argumenten aus.
Parameter:
sql_string
,
Die SQL-Anweisung, die die auszuführende Zeichenfolge enthältcon
,
Die zu verwendende Verbindungusing
,
Die optionalen Parameter, die bei der SQL-Ausführung verwendet werden sollen
expands\using_params**¶
**`expands_using_params`**`(statement, params)`
Beschreibung:¶
Erweitert die mit den Parametern übergebene Anweisung.
Parameter:
statement
,
Die SQL-Anweisung mit der auszuführenden ZeichenfolgeParams
,
Die Parameter der SQL-Anweisung
expandvar¶
**`expandvar`**`(str)`
Beschreibung:¶
Erweitert die Variable anhand der übergebenen Zeichenfolge.
Parameter:
str
,
Die mit den Variablen zu erweiternde Zeichenfolge
expandvars¶
**`expandvars`**`(path, params, skip_escaped=False)`
Beschreibung:¶
Erweitern Sie die Umgebungsvariablen der Form $var und ${var}. Wenn der Parameter ‚skip_escaped‘ auf „true“ gesetzt ist, werden alle Variablenreferenzen mit Escape-Zeichen (d. h. denen ein Backslash vorangestellt ist) übersprungen. Unbekannte Variablen werden auf „default“ gesetzt. Wenn „default“ None ist, bleiben sie unverändert.
Parameter:
path
,
params
,
skip_escaped=False
,
FAST LOAD¶
**`fast_load`**`(target_schema, filepath, stagename, target_table_name, con=None)`
Beschreibung:¶
Führt das schnelle Laden mit den übergebenen Parametern target_schema, filepath, stagename und target_table_name aus.
Parameter:
target_schema
,
Der Name des Schemas, das beim schnellen Laden verwendet werden sollfilepath
,
Der Pfad des Dateinamens, der in die Tabelle geladen werden solltarget_table_name
,
Der Name der Tabelle, in die die Daten geladen werden sollencon=None
,
Die zu verwendende Verbindung, wenn None übergeben wird, wird die zuletzt durchgeführte Verbindung verwendet
file\exists_and_readable**¶
**`file_exists_and_readable`**`(filename)`
Beschreibung:¶
Parameter:
filename
,
get\argkey**¶
**`get_argkey`**`(astr)`
Beschreibung:¶
Holt das Argument Schlüsselwert aus der übergebenen Zeichenfolge. Sie muss mit der Zeichenfolge ‚–param-‘ beginnen
Parameter:
astr
,
Die zu verwendende Argumentzeichenfolge. Die Zeichenfolge sollte einen ähnlichen Wert haben wie –param-column=32 und die zurückgegebene Zeichenfolge lautet ‚32
get\error_position**¶
**`get_error_position`**`()`
Beschreibung:¶
-Holt die Fehlerposition aus der Datei anhand der Informationen des Stapels des erzeugten Fehlers._
get\from_vars_or_args_or_environment**¶
**`get_from_vars_or_args_or_environment`**`(arg_pos, variable_name, vars, args)`
Beschreibung:¶
Holt das Argument von der angegebenen Position oder holt den Wert aus der Tabelle vars oder holt den Namen der übergebenen Umgebungsvariablen.
Parameter:
arg_pos
,
Die zu verwendende Position des Arguments aus dem Parameter „Arguments“variable_name
,
Der Name der abzurufenden Variablevars
,
Der Hashwert mit den Namen und Werten der Variablenargs
,
Der Array-Parameter „Arguments“
import\data_to_temptable**¶
**`import_data_to_temptable`**`(tempTableName, inputDataPlaceholder, con)`
Beschreibung:¶
Importiert Daten in eine temporäre Tabelle unter Verwendung eines Platzhalters für Eingabedaten.
Parameter:
tempTableName,
Der Name der temporären Tabelle.inputDataPlaceholder,
Der verwendete Eingabeplatzhalter, der ein Stagingbereich in der Snowflake-Datenbank istcon,
Die zu verwendende Verbindung
import\file**¶
**`import_file`**`(filename, separator=' ')`
Beschreibung:¶
Importiert den übergebenen Dateinamen mit dem optionalen Trennzeichen.
Parameter:
filename,
Der Pfad des zu importierenden Dateinamensseparator=' ',
Das optionale Trennzeichen
import\file_to_temptable**¶
**`import_file_to_temptable`**`(filename, tempTableName, columnDefinition)`
Beschreibung:¶
Importiert die übergebene Datei in eine temporäre Tabelle. Verwendet einen öffentlichen Stagingbereich, der als temporäre Tabelle mit dem Präfix Stagingbereich_ benannt wird. Am Ende des Ladevorgangs in die temporäre Tabelle wird der Stagingbereich gelöscht, der in diesem Prozess verwendet wurde.
Parameter:
filename,
Der Name der zu lesenden DateitempTableName,
Der Name der temporären TabellecolumnDefinition,
Die Definition aller Felder, die die temporäre Tabelle haben wird
import\reset**¶
**`import_reset`**`()`
Beschreibung:¶
log¶
**`log`**`(*msg, level=20, writter=None)`
Beschreibung:¶
Druckt eine Meldung auf der Konsole (Standardausgabe) oder in der Protokolldatei, je nachdem, ob die Protokollierung aktiviert ist
Parameter:
*msg,
Die zu druckende oder zu protokollierende Nachrichtlevel=20,
writter=None,
log\on**¶
**`log_on`**`(user=None, password=None, account=None, database=None, warehouse=None, role=None, login_timeout=10, authenticator=None)`
Beschreibung:¶
Meldet sich bei der Snowflake-Datenbank mit den übergebenen Parametern user, password, database, warehouse, role, login_timeout and authenticator an.
Parameter:
user,
Der Benutzer der Datenbankpassword
Das Kennwort des Benutzers der Datenbankdatabase,
Die zu verbindende Datenbankwarehouse,
Das Warehouse der zu verbindenden Datenbankrole,
Die zu verbindende Rollelogin_timeout,
Der maximale Timeout, bevor eine Fehlermeldung ausgegeben wird, wenn die Verbindung zu lange dauertauthenticator,
Der vom Authentifikator unterstützte Wert, z. B. SNOWFLAKE, EXTERNALBROWSER, SNOWFLAKE_JWT oder OAUTHtoken,
Das OAUTH- oder JWT-Token
os¶
**`os`**`(args)`
Beschreibung:¶
Parameter:
args,
print\table**¶
**`print_table`**`(dictionary)`
Beschreibung:¶
Druckt das Wörterbuch, ohne die Werte von Benutzern und Kennwörtern preiszugeben.
Parameter:
dictionary,
quit\application**¶
**`quit_application`**`(code=None)`
Beschreibung:¶
Beendet die Anwendung und gibt optional den übergebenen Code zurück.
Parameter:
code=None,
Der Code, der nach dem Beenden zurückgegeben wird
read\params_args**¶
**`read_param_args`**`(args)`
Beschreibung:¶
Liest die Parameterargumente aus dem übergebenen Array.
Parameter:
args,
Die zu verwendenden Argumente
readrun¶
**readrun**(line, skip=0)
Beschreibung:¶
Liest die angegebenen Zeilen des Dateinamens und überspringt optional einige Zeilen am Anfang der Datei.
Parameter:
line,
Der zu lesende Dateinameskip=0,
Die zu überspringenden Zeilen
Bemerkung¶
**remark**(arg)
Beschreibung:¶
Druckt das Argument.
Parameter:
arg,
Das zu druckende Argument
repeat\previous_sql_statement**¶
**`repeat_previous_sql_statement`**`(con=None, n=1)`
Beschreibung:¶
Wiederholt die zuvor ausgeführte(n) SQL-Anweisung(en).
Parameter:
con=None,
Verbindung, falls angegeben. Wenn sie nicht übergeben wird, wird die zuletzt durchgeführte Verbindung verwendetn=1,
Die Anzahl der vorherigen Anweisungen, die erneut ausgeführt werden sollen
set\standard\_fehler\_level**¶
**`set_default_error_level`**`(severity_value)`
Beschreibung:¶
Parameter:
severity_value,
set\error_level**¶
**`set_error_level`**`(arg, severity_value)`
Beschreibung:¶
Parameter:
arg,
severity_value,
simple\fast_load**¶
**`simple_fast_load`**`(con, target_schema, filepath, stagename, target_table_name)`
Beschreibung:¶
Führt eine einfache Schnellladung in der Verbindung und den übergebenen Parametern target_schema, filepath, stagename und target table name aus.
Parameter:
arg,
Die zu verwendende Verbindungtarget_schema,
Der Name des Schemas, das beim schnellen Laden verwendet werden sollfilepath,
Der Pfad des Dateinamens, der in die Tabelle geladen werden solltarget_table_name,
Der Name der Tabelle, in die die Daten geladen werden sollen
stat¶
**`stat`**`(path, *, dir_fd=None, follow_symlinks=True)`
Beschreibung:¶
Führen Sie einen stat-Systemaufruf für den angegebenen Pfad durch. dir_fd und follow_symlinks sind auf Ihrer Plattform möglicherweise nicht implementiert. Wenn sie nicht verfügbar sind, wird bei ihrer Verwendung eine NotImplementedError-Meldung angezeigt. Es ist ein Fehler, dir_fd oder follow_symlinks zu verwenden, wenn der Pfad als offener Dateideskriptor angegeben wird
Parameter:
path,
Zu untersuchender Pfad; kann eine Zeichenfolge, Bytes, ein pfadähnliches Objekt oder\ open-file-descriptor int seindir_fd,
Falls nicht None, sollte es sich um einen Dateideskriptor handeln, der für ein Verzeichnis geöffnet ist, und „path“ sollte eine relative Zeichenfolge sein; „path“ ist dann relativ zu diesem Verzeichnisfollow_symlinks,
Wenn „false“, und das letzte Element des Pfades ein symbolischer Link ist, untersucht „stat“ den symbolischen Link selbst anstatt der Datei, auf die der Link zeigt
system¶
**`system`**`(command)`
Beschreibung:¶
Führen Sie den Befehl in einer Subshell aus.
Parameter:
_
command
_,
using¶
**`using`**`(*argv)`
Beschreibung:¶
Parameter:
_
*argv
_,
Klassen¶
Alle im Projekt definierten Klassen
BeginLoading-Klasse¶
Diese Klasse enthält die statische Funktion import_file_to_tab
, die Unterstützung für BEGIN LOADING und die damit verbundenen Befehle in FastLoad bietet.
import_file_to_tab()
¶
Parameter:
target_schema_table
Das Zielschema (optional) und den Tabellennamen
define_file
Der Name der zu lesenden Datei
definieren_Spalten
Die Definition aller Spalten für die temporäre Tabelle
begin_loading_columns
Die einzufügenden Spaltennamen. Legt die Reihenfolge fest, in der die Werte eingefügt werden
begin_loading_values
Die Liste der zu konvertierenden rohen Einfügewerte
field_delimiter
Das Feldtrennzeichen
(optional)
skip_header
Die Anzahl der zu überspringenden Zeilen
(optional)
input_data_place_holder
Der Speicherort der Datei bei einem unterstützten Cloud-Anbieter. Parameter setzen, wenn die Datei nicht lokal gespeichert ist
(optional)
con
Die zu verwendende Verbindung
Export-Klasse¶
Statische Methoden in der Klasse
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)
\ Daten und andere hier definierte Attribute
expandedfilename = None
separator = ''
\
Import-Klasse¶
Methoden in der Klasse
reset()
Statische Methoden in der Klasse
file(file, separator=' ')
using(globals, *argv)
Daten und andere in der Klasse definierte Attribute
expandedfilename = None
no_more_rows = False
read_obj = None
reader = None
separator = ' '
Parameters
-Klasse¶
Daten und andere in der Klasse definierte Attribute
passed_variables = {}
¶
BTEQ¶
Basic Teradata Query (BTEQ) ist ein allgemeines, befehlsbasiertes Programm, das es Benutzern auf einer Workstation ermöglicht, mit einem oder mehreren Teradata-Datenbanksystemen zu kommunizieren und Berichte sowohl für die Druck- als auch für die Bildschirmausgabe zu formatieren.
Um die BTEQ-Funktionalität für Teradata in Snowflake zu simulieren, werden BTEQ-Dateien und -Befehle in Python-Code umgewandelt, ähnlich wie bei den Transformationen für MultiLoad- und FastLoad-Skripte. Der generierte Code verwendet das Snowflake Python-Projekt namens snowconvert.helpers, das die erforderlichen Funktionen zur Simulation der BTEQ-Anweisungen in Snowflake enthält.
Übersetzung von BTEQ-Befehlen¶
Die folgende Tabelle zeigt die Konvertierung der BTEQ-Befehle in Snowflake.
Teradata |
Snowflake |
Anmerkungen |
---|---|---|
ERRORCODE != 0 |
snowconvert.helpers.error_code != 0 |
|
.EXPORT DATA FILE=fileName |
Export.report(„fileName“, „,“) |
Die Funktion hat keine Funktionalität |
.EXPORT INDICDATA FILE=fileName |
Export.report(„fileName“, „,“) |
Die Funktion hat keine Funktionalität |
.EXPORT REPORT FILE=fileName |
Export.report(„fileName“, „,“) |
Die Funktion hat keine Funktionalität |
.EXPORT DIF FILE=fileName |
Export.report(„fileName“, „,“) |
Die Funktion hat keine Funktionalität |
.EXPORT RESET |
Export.reset() |
Die Funktion hat keine Funktionalität |
.IF ERRORCODE! = 0 THEN.QUIT ERRORCODE |
Wenn snowconvert.helpers.error_code != 0: snowconvert.helpers.quit_application (snowconvert.helpers.error_code) |
|
.IMPORT RESET |
snowconvert.helpers.import_reset() |
Die Funktion hat keine Funktionalität |
.LABEL newLabel |
def NEWLABEL(): |
|
.LOGOFF |
Die Anweisung ist kommentiert |
|
.LOGON |
Die Anweisung ist kommentiert |
|
.LOGMECH |
Die Anweisung ist kommentiert |
|
.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() |
Die Funktion hat keine Funktionalität |
.SETERRORLEVEL 3807 SEVERITY 0 |
snowconvert.helpers.set_error_level(3807, 0) |
|
.SET RECORMODE OFF |
Export.record_mode(False) |
|
.SET RECORMODE ON |
Export.record_mode(True) |
|
.SETSEPARATOR ‚|‘ |
Export.separator_string(‚|‘) |
Die Funktion hat keine Funktionalität |
.SETWIDTH 120 |
Export.Breite(120) |
Die Funktion hat keine Funktionalität |
.Remark „“Hello world!“““ |
snowconvert.helpers.remark(r““““““Hello world!““““““) |
|
.QUIT ERRORCODE |
snowconvert.helpers.quit_application( snowconvert.helpers.error_code ) |
|
.QUIT |
snowconvert.helpers.quit_application() |
|
SQL-Anweisungen |
exec(statement) |
|
$(<$INPUT_SQL_FILE) |
exec_file(„$INPUT_SQL_FILE“) |
|
= (Repeat previous command) |
snowconvert.helpers.repeat_previous\_sql_statement(con) |
Für kompliziertere Anweisungen, die in der vorherigen Tabelle dargestellt sind, werden Unterabschnitte mit ausführlicheren Beispielen erläutert.
.GOTO-Konvertierung¶
Da wir BTEQ-Skripte nach Python konvertieren, werden bestimmte Strukturen, die in BTEQ gültig sind, in Python nicht unterstützt. Dies ist der Fall für den Befehl .GOTO
unter Verwendung der Befehle . Label
.
Aus diesem Grund wurde eine Alternative entwickelt, mit der die Funktionalität dieser Befehle emuliert werden kann, indem die Befehle . Label
in Funktionen mit nachfolgenden Aufrufanweisungen umgewandelt werden.
Prüfen Sie den folgenden Code:
.LABEL FIRSTLABEL
SELECT * FROM MyTable1;
.LABEL SECONDLABEL
SELECT * FROM MyTable2;
SELECT * FROM MyTable3;
In dem obigen Beispiel gab es fünf Befehle. Zwei davon waren. Label
-Befehle. Der BefehlFIRSTLABEL
wurde in eine Funktion mit den nachfolgenden Anweisungen umgewandelt, bis ein weiterer.LABEL
-Befehl gefunden wird. Wenn ein anderes Label aufgerufen wird (in diesem Fall SECONDLABEL
), beendet dieser Aufruf die erste Funktion und startet eine neue.
Wenn wir das vorherige Beispiel migrieren würden, würde das Ergebnis folgendermaßen lauten:
#*** 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()
Beachten Sie, dass es einen Aufruf der Funktion _ FIRSTLABEL
_ gibt. Diese Funktion hat nur eine Anweisung, die der einzige Nicht-Label-Befehl ist, der im Originalcode auf FIRSTLABEL
folgt. Bevor die Funktion FIRSTLABEL
endet, ruft sie_ SECONDLABEL
_ auf, mit den Anweisungen, die darauf folgten.
Anmerkungen:
Erstellen einer Konnektorvariable
con = None
, und Auffüllen in der Funktionmain()
:con = snowconvert.helpers.log_on()
.Einrichten eines Protokolls:
snowconvert.helpers.configure_log()
.
Abfrage ausführen (Anweisungen)¶
Jede SQL-Anweisung, die in einer BTEQ-Datei gefunden wird, wird über die Funktion exec
ausgeführt, die von snowconvert.helpers bereitgestellt wird. Nehmen Sie zum Beispiel den folgenden Code:
CREATE TABLE aTable (aColumn BYTEINT);
Dies wird umgerechnet in:
#*** 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()
Skript-Dateien ausführen¶
Dateien, die die BTEQ-Befehle eines Benutzers und Teradata SQL Anweisungen enthalten, werden Skripte, Ausführungsdateien, Makros oder gespeicherte Prozeduren genannt. Erstellen Sie beispielsweise eine Datei mit dem Namen SAMPFILE, und geben Sie das folgende Skript BTEQ ein:
.LOGON tdpid/userid,password
SELECT * FROM department;
.LOGOFF
Um die Ausführungsdatei auszuführen, geben Sie eine der beiden Formen des Befehls BTEQ RUN ein:
.RUN FILE=sampfile
Wenn Sie den zweiten Code umwandeln, erhalten Sie das folgende Ergebnis:
#*** 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()
snowconvert.helpers.readrun("sampfile")
gibt jede Zeile aus der SAMPFILE zurück und in derFOR
-Anweisung wird jede der Zeilen an die eval
-Funktion übergeben, eine Methode, die den ihr übergebenen Ausdruck parst und den Python-Ausdruck (die SAMPFILE sollte konvertiert werden, um zu funktionieren) innerhalb des Programms ausführt.
SQL-Dateien ausführen¶
In einigen Fällen kann während der Ausführung einer BTEQ-Datei eine SQL-Datei gefunden werden, z. B. die SQL-Datei mit dem Namen NEWSQL:
CREATE TABLE aTable (aColumn BYTEINT);
Dies kann während eines Skripts mit der folgenden Zeile ausgeführt werden:
$(<$NEWSQL)
Und nach der Konvertierung des Skripts lautet das Ergebnis:
#*** 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()
Die Hilfsfunktion exec_file
liest jede Zeile aus der Datei NEWSQL und verwendet dann die Funktion „exec“ wie im Abschnitt Abfrageanweisung ausführen beschrieben.
Bekannte Probleme ¶
Es wurden keine Probleme gefunden.
Zugehörige EWIs ¶
Es wurden keine Probleme gefunden.
REPEAT¶
Bemerkung
Einige Teile des Ausgabecodes wurden aus Gründen der Übersichtlichkeit weggelassen.
Wie in der Dokumentation von Teradata beschrieben, können Benutzer mit der REPEAT-Anweisung angeben, wie oft die nächste SQL-Anfrage maximal gestellt werden soll. Beachten Sie, dass es sich bei einer SQL-Anfrage um eine Einzel- oder Mehrfachanforderung handeln kann. Dies wird durch die Position der Semikolons für jede Anweisung nach der REPEAT-Anweisung definiert.
Syntax¶
REPEAT [ n [ PACK p [ REQBUFLEN b ] ] | * | RECS r]
<sql_request>
Beispielhafte Quellcode-Muster¶
Mit diesen Eingabedaten:
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 |
Bekannte Probleme ¶
Es wurden keine Probleme gefunden.
Zugehörige EWIs ¶
Keine zugehörigen EWIs.
USING REQUEST MODIFIER¶
Some parts in the output code are omitted for clarity reasons.
Wie in der Teradata-Dokumentation beschrieben, definiert USING REQUEST MODIFIER einen oder mehrere variable Parameternamen, die in den nachfolgenden SELECT
-, INSERT
-, UPDATE
- oder DELETE
-Anweisungen zum Importieren oder Exportieren von Daten verwendet werden.
Die Syntax für diese Anweisung lautet wie folgt:
USING ( <using_spec> [,...] ) SQL_request
<using_spec> ::= using_variable_name data_type [ data_type_attribute [...] ]
[ AS { DEFERRED [BY NAME] | LOCATOR } ]
Wie in der Dokumentation von Teradata angegeben, muss USING REQUEST MODIFIER eine .IMPORT-Anweisung vorangestellt werden, damit die Daten in die definierten Parameter geladen werden.
Die Transformation für diese Anweisung folgt also diesen Schritten:
Rufen Sie die Funktion
import_file()
aus den SnowConvert-Hilfsfunktionen auf. Dadurch werden die Daten in eine temporäre Datei geladen.Rufen Sie die Funktion
using()
aus den SnowConvert -Hilfsfunktionen auf, um ein Wörterbuch mit den geladenen Daten zu erstellen.Führen Sie für jede Abfrage die Funktion
exec()
aus den SnowConvert-Hilfsfunktionen aus und übergeben Sie das zuvor definierte Wörterbuch. Dabei werden die Datenbindungsfunktionen des Snowflake Python Connectors verwendet.
Mit diesen Eingabedaten:
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 |
Bekannte Probleme¶
1. Der Befehl .REPEAT wird noch nicht unterstützt
Der Befehl .REPEAT
wird noch nicht unterstützt. Das bedeutet, dass USING REQUEST MODIFIER nur die Daten verwendet, die aus der ersten Zeile der Eingabedatei geladen werden. Die Abfragen werden also nur einmal ausgeführt.
Dieses Problem sollte behoben werden, wenn der Befehl .REPEAT eine angemessene Unterstützung für die Transformation erhält.
Wenn Sie weitere Fragen zu dieser Dokumentation haben, können Sie uns eine E-Mail an snowconvert-support@snowflake.com senden.
Zugehörige EWIs ¶
Keine zugehörigen EWIs.
FLOAD¶
Teradata FastLoad ist ein befehlsgesteuertes Dienstprogramm zum schnellen Laden von Daten in eine leere Tabelle in einer Teradata-Datenbank.
Um die FastLoad-Funktionalität für Teradata in Snowflake zu simulieren, werden FastLoad-Dateien und -Befehle in Python-Code umgewandelt, ähnlich wie bei den Transformationen für BTEQ- und MultiLoad-Skripte. Der generierte Code verwendet das Snowflake Python-Projekt namens snowconvert.helpers, das die erforderlichen Funktionen zur Simulation der FastLoad-Anweisungen in Snowflake enthält.
Übersetzung von FastLoad-Befehlen¶
Die meisten der FastLoad-Befehle werden in Snowflake als nicht relevant angesehen, diese Befehle sind auskommentiert. Im Folgenden finden Sie eine zusammenfassende Liste der FastLoad-Befehle und deren Transformationsstatus in Snowflake:
Teradata FastLoad-Befehl |
Status der Transformation |
Hinweis |
---|---|---|
AXSMOD |
Kommentiert |
|
Transformiert |
Der Knoten wird auskommentiert, da die Transformation stattdessen in der zugehörigen Anweisung INSERT erfolgt. |
|
CLEAR |
Kommentiert |
|
DATEFORM |
Kommentiert |
|
Transformiert |
|
|
Transformiert |
Auskommentiert, da nicht notwendig für die BEGIN LOADING-Transformation. |
|
ERRLIMIT |
Kommentiert |
|
HELP |
Kommentiert |
|
HELP TABLE |
Kommentiert |
|
Transformiert |
Umgewandelt als Teil von BEGIN LOADING. |
|
LOGDATA |
Kommentiert |
|
LOGMECH |
Kommentiert |
|
LOGOFF |
Kommentiert |
|
LOGON |
Kommentiert |
|
NOTIFY |
Kommentiert |
|
OS |
Kommentiert |
|
QUIT |
Kommentiert |
|
RECORD |
Kommentiert |
|
RUN |
Kommentiert |
|
SESSIONS |
Kommentiert |
|
Transformiert |
|
|
SET SESSION CHARSET |
Kommentiert |
|
SHOW |
Kommentiert |
|
SHOW VERSIONS |
Kommentiert |
|
SLEEP |
Kommentiert |
|
TENACITY |
Kommentiert |
|
Standardtransformation¶
Das Standardverhalten von ConversionTool für diese Anweisungen ist, sie auszukommentieren. Beispiel:
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()
Dennoch gibt es einige Ausnahmen, die in spezifische Python-Anweisungen umgewandelt werden müssen, damit sie in Snowflake wie vorgesehen funktionieren.
Eingebettetes SQL¶
FastLoad-Skripte unterstützen Teradata-Anweisungen innerhalb der gleichen Datei. Die meisten dieser Anweisungen werden genauso konvertiert, als befänden sie sich in einer BTEQ-Datei, mit einigen Ausnahmen.
Das Löschen einer Fehlertabelle wird auskommentiert, wenn sie sich in einer FastLoad-Datei befindet.
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()
Großes Beispiel¶
Betrachten Sie anhand der oben gezeigten Transformationen für eine Vielzahl von Befehlen das folgende Beispiel.
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()
Wenn Sie weitere Fragen zu dieser Dokumentation haben, können Sie uns eine E-Mail an snowconvert-support@snowflake.com senden.
Bekannte Probleme¶
Es wurden keine Probleme gefunden.
Zugehörige EWIs¶
[SSC-FDM-0007](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0007): Element mit fehlenden Abhängigkeiten.
[SSC-FDM-0027](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0027): Die nächste Anweisung wurde entfernt, da sie in SnowFlake nicht anwendbar ist.
BEGIN LOADING¶
Die Transformation für den Befehl BEGIN LOADING
ist eine mehrteilige Transformation, die die Befehle DEFINE
, INSERT
und (optional) SET RECORD
benötigt, um ihre Verhaltensweise korrekt zu simulieren.
Diese Transformation wird in den folgenden Unterabschnitten ausführlich erklärt.
SET RECORD¶
Wie bereits erwähnt, ist dieser Befehl für die Transformation von BEGIN LOADING nicht erforderlich. Wenn er nicht gefunden wird, wird das Standardtrennzeichen auf ‚,‘ (Komma) gesetzt. Andernfalls wird das definierte Trennzeichen verwendet. Dieser Wert wird in der Variablen ssc_set_record
gespeichert.
Ab sofort werden nur noch SET RECORD VARTEXT
, SET RECORD FORMATTED
und SET RECORD UNFORMATTED
unterstützt. Bei den Schlüsselwortangaben BINARY
und TEXT
wird stattdessen eine Fehlermeldung EWI ausgegeben.
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¶
Die Transformation für den Befehl DEFINE
setzt die Variablen ssc_define_columns
und ssc_define_file
mit dem Wert der Spaltendefinition bzw. dem Dateipfad, der in der BEGIN LOADING
-Transformation verwendet werden soll.
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¶
Der Befehl BEGIN LOADING
ist auskommentiert, da die relevanten Informationen für die Transformation stattdessen in der zugehörigen INSERT
-Anweisung zu finden sind.
ERRORFILES
, NODROP
, CHECKPOINT
, INDICATORS
und DATAENCRYPTION
sind für die Transformation nicht notwendig und werden daher auskommentiert.
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¶
Die Transformation für die zugehörige INSERT
-Anweisung setzt den Wert für die Variablen ssc_begin_loading_columns
und ssc_begin_loading_values
, die verwendet werden, um die Reihenfolge zu bestimmen, in der die zu ladenden Werte eingefügt werden sollen.
Schließlich werden diese Variablen und die in den obigen Abschnitten beschriebenen Variablen verwendet, um die Funktion BeginLoading. import_file_to_table
des Moduls SnowConvert. Helpers
aufzurufen. Diese Funktion simuliert die Verhaltensweise des gesamten FastLoad BEGIN LOADING
-Prozesses. Um mehr über diese Funktion zu erfahren, klicken Sie hier.
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()
Intern erstellt die Funktion import_file_to_table
einen temporären Stagingbereich und legt die lokale Datei in diesem Stagingbereich ab, um sie in die angegebene Tabelle zu laden. Es kann jedoch sein, dass die Datei bereits bei einem der von Snowflake unterstützten Cloud-Anbieter gespeichert ist:
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 |
Sollte dies der Fall sein, fügen Sie bitte manuell den zusätzlichen Parameter input_data_place_holder="<cloud_provider_path>"
in der Funktion import_file_to_table
hinzu. Beispiel:
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¶
Der Befehl END LOADING
ist auskommentiert, da er für die Transformation von BEGIN LOADING
nicht notwendig ist.
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()
Bekannte Probleme¶
1. BINARY- und TEXT-Schlüsselwortangabe nicht unterstützt
Die Schlüsselwortangaben BINARY
und TEXT
für den Befehl SET RECORD
werden noch nicht unterstützt.
2. Nur die Basis-Spezifikation für VARTEXT wird unterstützt
Zusätzliche Angaben für SET RECORD VARTEXT
wie TRIM
oder QUOTE
werden noch nicht unterstützt.
Zugehörige EWIs¶
[SSC-FDM-0007](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0007): Element mit fehlenden Abhängigkeiten.
[SSC-FDM-0027](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0027): Die nächste Anweisung wurde entfernt, da sie in SnowFlake nicht anwendbar ist.
[SSC-EWI-0021](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0021): Nicht unterstützt.
[SSC-FDM-TD0022](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/teradataFDM. md#ssc-fdm-td0022): Shell-Variablen gefunden, die Ausführung dieses Codes in einem Shell-Skript ist erforderlich.