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
Copy

Übersetzter Code

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

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
);
Copy

Ü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,
    );"""
Copy

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']
);
Copy

Übersetzter Code

 class JobName:
    def DDL_OPERATOR(self):
        #'TERADATA PARALLEL TRANSPORTER DDL OPERATOR'
        global args
        self.con = log_on(user = args.MyUserName, password = 'SomePassWord')
Copy
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'
);
Copy

Ü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
Copy
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'
);
Copy

Ü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
Copy

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);
);
Copy

Ü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() )})""")
Copy

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

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:

CommandsTransformation StatusNote
ACCEPTCommented
BEGIN MLOADTransformed​​The node is commented out since the transformation occurs in other related statements instead.
BEGIN DELETE MLOADCommented
DATEFORMCommented
DELETEPartially transformedCheck known issues.​
DISPLAYCommented
DML LABELTransformed
END MLOADTransformed​​Commented out since is not necessary for the transformation of the BEGIN MLOAD.
EOCCommented
FIELDTransformed
FILLERTransformedThis command needs to be with a FIELD and LAYOUT command to be converted.
IF, ELSE, and ENDIFCommented
IMPORTTransformed
INSERTTransformedThis is taken as a Teradata Statement, so it doesn't appear in this chapter.
LAYOUTTransformedThis command needs to be with a FIELD and FILLER command to be converted.
LOGDATACommented
LOGMECHCommented
LOGOFFCommented
LOGONCommented
LOGTABLECommented
PAUSE ACQUISITIONCommented
RELEASE MLOADCommented
ROUTE MESSAGESCommented
RUN FILECommented
SETCommented
SYSTEMCommented
TABLECommented
UPDATETransformedThis is taken as a Teradata Statement, so it doesn't appear in this chapter.
VERSIONCommented

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

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  INFILE_LAYOUT_TableName = "INFILE_LAYOUT_TEMP_TABLE"
  INFILE_LAYOUT_Columns = """TABLE_ID INTEGER, 
TABLE_DESCR CHAR(8), 
COL1 CHAR(1), 
TABLE_NBR SMALLINT, 
TABLE_SOMEFIELD SMALLINT"""
  INFILE_LAYOUT_Conditions = """TABLE_ID AS TABLE_ID, TABLE_DESCR AS TABLE_DESCR, COL1 AS COL1, TABLE_NBR AS TABLE_NBR, TABLE_SOMEFIELD AS TABLE_SOMEFIELD"""
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

.DML LABEL

Die Transformation für den Befehl .DML LABELerstellt 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 );
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  def INSERT_TABLE(tempTableName, queryConditions = ""):
    exec(f"""INSERT INTO mydb.mytable (TABLE_ID, TABLE_DESCR, TABLE_NBR)
SELECT
   :TABLE_ID,
   :TABLE_DESCR,
   :TABLE_NBR
FROM {tempTableName} SRC {queryConditions}""")
  exec("""
    DELETE FROM
      Employee
    WHERE
      EmpNo = :EmpNo
    """)
  def UPSERT_TABLE(tempTableName, queryConditions = ""):
    exec(f"""MERGE INTO mydb.mytable TGT USING (SELECT * FROM {tempTableName} {queryConditions}) SRC ON TABLE_DESCR = :somedescription
WHEN MATCHED THEN UPDATE SET
   TABLE_ID = :TABLE_ID
WHEN NOT MATCHED THEN INSERT (TABLE_ID, TABLE_DESCR, TABLE_NBR)
VALUES (:TABLE_ID, :TABLE_DESCR, :TABLE_NBR)""")
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

.IMPORT

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

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #.IMPORT INFILE INFILE_FILENAME LAYOUT INFILE_LAYOUT APPLY INSERT_TABLE APPLY UPSERT_TABLE Apply DELETE_TABLE
   
  snowconvert.helpers.import_file_to_temptable(fr"INFILE_FILENAME", INFILE_LAYOUT_TableName, INFILE_LAYOUT_Columns, INFILE_LAYOUT_Conditions, ',')
  INSERT_TABLE(INFILE_LAYOUT_TableName)
  UPSERT_TABLE(INFILE_LAYOUT_TableName)
  DELETE_TABLE(INFILE_LAYOUT_TableName)
  exec(f"""DROP TABLE {INFILE_LAYOUT_TableName}""")
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

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
Copy

Teradata (MultiLoad)

 .begin import mload
        tables
	mySampleTable1
sessions 20
ampcheck none;

.layout myLayOut;
 .field ID * VARCHAR(2) NULLIF ID = '1';
 .field NAME * VARCHAR(25);
 .field AGE * VARCHAR(10);
.dml label insert_data;

INSERT INTO mySampleTable1
 ( 
    ID,
    NAME,
    AGE	
 )
VALUES
 (
    :ID,
    SUBSTRING(:NAME FROM 2),
    :AGE
 );

.import infile sampleData.txt
layout myLayOut
apply insert_data

.end mload;
.logoff;
Copy
ROWIDNAMEAGE
1NULLohn25
22aria29
33arlos31
44ike40
55aura27

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #.begin import mload tables mySampleTable1 sessions 20 ampcheck none
   
  myLayOut_TableName = "myLayOut_TEMP_TABLE"
  myLayOut_Columns = """ID VARCHAR(2), 
NAME VARCHAR(25), 
AGE VARCHAR(10)"""
  myLayOut_Conditions = """CASE
   WHEN ID = '1'
      THEN NULL
   ELSE ID
END AS ID, NAME AS NAME, AGE AS AGE"""
  def insert_data(tempTableName, queryConditions = ""):
    exec(f"""INSERT INTO mySampleTable1 (ID, NAME, AGE)
SELECT
   SRC.ID,
   SUBSTRING(SRC.NAME, 2),
   SRC.AGE
FROM {tempTableName} SRC {queryConditions}""")
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #.import infile sampleData.txt layout myLayOut apply insert_data
   
  snowconvert.helpers.import_file_to_temptable(fr"sampleData.txt", myLayOut_TableName, myLayOut_Columns, myLayOut_Conditions, ',')
  insert_data(myLayOut_TableName)
  exec(f"""DROP TABLE {myLayOut_TableName}""")

  if con is not None:
    con.close()
    con = None
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy
ROWIDNAMEAGE
1NULLohn25
22aria29
33arlos31
44ike40
55aura27

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

Copy

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);
Copy

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.
Copy
 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  exec("""
    INSERT INTO table1
    VALUES (1, 2)
    """)
  exec("""
    INSERT INTO table1
    VALUES (3, 4)
    """)
  exec("""
    INSERT INTO table1
    VALUES (5, 6)
    """)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

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
Copy

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
Copy

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
Copy

Ü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')
   .....
Copy

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

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
Copy
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

Copy
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
Copy
 export SNOW_AUTHENTICATOR=VALUE
export SNOW_USER=myuser
export SNOW_PASSWORD=mypassword
python3 sample_BTEQ.py
Copy

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")
Copy

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
Copy

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

Sie können die Zeilen sehen, die Sie im obigen Beispiel eingefügt haben.

Abfrageergebnis

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
Copy

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

Copy

In diesem Verzeichnis müssen Sie Folgendes ausführen:

 python -m pydoc -b
Copy

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>

Copy

Dadurch wird der Browser mit der Dokumentation Ihres Codes geöffnet:

Startseite für die generierte lokale Dokumentation

Blättern Sie bis zum Ende der Seite, um die installierten Pakete zu sehen. Und Sie werden etwas Ähnliches sehen wie:

Index der Dokumentation zu lokal installierten Pakete

Wenn Sie auf SnowConvert (Paket) klicken, sehen Sie etwas wie:

Startseite für die Dokumentation zu snowconvert-helpers

Wenn Sie auf das Modul Hilfsfunktion klicken, wird ein Bildschirm angezeigt, der ungefähr so aussieht:

Startseite für das Modul Hilfsfunktionen

Dann können Sie durch die Funktionen und Klassen des Moduls blättern.

Funktionen Dokumentation

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)`
Copy
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 sein

  • mode, 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_OK

  • dir_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 Verzeichnis

  • effective_ids, Wenn „true“, verwendet der Zugriff die effektive UID/GID anstelle der realen UID/GID

  • follow_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`**`()`
Copy
Beschreibung:

wird am Ende der Ausführung des Skripts ausgeführt

farbig

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

Druckt farbigen Text in der angegebenen Farbe.

Parameter:
  • text , Der zu druckende Text

  • color="blue" , Die zu druckende Farbe

configure_log

**`configure_log`**`(configuration_path)`
Copy
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)`
Copy
Beschreibung:

löscht die transiente Tabelle mit dem angegebenen Namen

Parameter:

  • tempTableName , Der Name der temporären Tabelle

  • con=None , Die zu verwendende Verbindung, wenn None übergeben wird, wird die zuletzt durchgeführte Verbindung verwendet

exception_hook

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

Parameter:

  • exctype

  • Wert

  • tback

exec

**`exec`**`(sql_string, using=None, con=None)`
Copy
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 SQL

  • using=None , Der optionale Parameter, der in der übergebenen SQL verwendet werden kann

  • con=None , Die zu verwendende Verbindung, wenn None übergeben wird, wird die zuletzt durchgeführte Verbindung verwendet

exec_file

**`exec_file`**`(filename, con=None)`
Copy
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 soll

  • con=None , Die zu verwendende Verbindung, wenn None übergeben wird, wird die zuletzt durchgeführte Verbindung verwendet

exec_os

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

führt einen Befehl im operativen System aus

exec_sql_statement

**`exec_sql_statement`**`(sql_string, con, using=None)`
Copy
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ält

  • con , Die zu verwendende Verbindung

  • using , Die optionalen Parameter, die bei der SQL-Ausführung verwendet werden sollen

expands\using_params**

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

Erweitert die mit den Parametern übergebene Anweisung.

Parameter:

  • statement , Die SQL-Anweisung mit der auszuführenden Zeichenfolge

  • Params , Die Parameter der SQL-Anweisung

expandvar

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

Erweitert die Variable anhand der übergebenen Zeichenfolge.

Parameter:

  • str , Die mit den Variablen zu erweiternde Zeichenfolge

expandvars

**`expandvars`**`(path, params, skip_escaped=False)`
Copy
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)`
Copy
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 soll

  • filepath , Der Pfad des Dateinamens, der in die Tabelle geladen werden soll

  • target_table_name , Der Name der Tabelle, in die die Daten geladen werden sollen

  • con=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)`
Copy
Beschreibung:

Parameter:

  • filename ,

get\argkey**

**`get_argkey`**`(astr)`
Copy
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`**`()`
Copy
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)`
Copy
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 Variable

  • vars , Der Hashwert mit den Namen und Werten der Variablen

  • args , Der Array-Parameter „Arguments“

import\data_to_temptable**

**`import_data_to_temptable`**`(tempTableName, inputDataPlaceholder, con)`
Copy
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 ist

  • con, Die zu verwendende Verbindung

import\file**

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

Importiert den übergebenen Dateinamen mit dem optionalen Trennzeichen.

Parameter:

  • filename, Der Pfad des zu importierenden Dateinamens

  • separator=' ', Das optionale Trennzeichen

import\file_to_temptable**

**`import_file_to_temptable`**`(filename, tempTableName, columnDefinition)`
Copy
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 Datei

  • tempTableName, Der Name der temporären Tabelle

  • columnDefinition, Die Definition aller Felder, die die temporäre Tabelle haben wird

import\reset**

**`import_reset`**`()`
Copy
Beschreibung:

log

**`log`**`(*msg, level=20, writter=None)`
Copy
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 Nachricht

  • level=20,

  • writter=None,

log\on**

**`log_on`**`(user=None, password=None, account=None, database=None, warehouse=None, role=None, login_timeout=10, authenticator=None)`
Copy
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 Datenbank

  • password Das Kennwort des Benutzers der Datenbank

  • database, Die zu verbindende Datenbank

  • warehouse, Das Warehouse der zu verbindenden Datenbank

  • role, Die zu verbindende Rolle

  • login_timeout, Der maximale Timeout, bevor eine Fehlermeldung ausgegeben wird, wenn die Verbindung zu lange dauert

  • authenticator, Der vom Authentifikator unterstützte Wert, z. B. SNOWFLAKE, EXTERNALBROWSER, SNOWFLAKE_JWT oder OAUTH

  • token, Das OAUTH- oder JWT-Token

os

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

Parameter:

  • args,

quit\application**

**`quit_application`**`(code=None)`
Copy
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)`
Copy
Beschreibung:

Liest die Parameterargumente aus dem übergebenen Array.

Parameter:

  • args, Die zu verwendenden Argumente

readrun

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

Liest die angegebenen Zeilen des Dateinamens und überspringt optional einige Zeilen am Anfang der Datei.

Parameter:

  • line, Der zu lesende Dateiname

  • skip=0, Die zu überspringenden Zeilen

Bemerkung

**remark**(arg)
Copy
Beschreibung:

Druckt das Argument.

Parameter:

  • arg, Das zu druckende Argument

repeat\previous_sql_statement**

**`repeat_previous_sql_statement`**`(con=None, n=1)`
Copy
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 verwendet

  • n=1, Die Anzahl der vorherigen Anweisungen, die erneut ausgeführt werden sollen

set\standard\_fehler\_level**

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

Parameter:

  • severity_value,

set\error_level**

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

Parameter:

  • arg,

  • severity_value,

simple\fast_load**

**`simple_fast_load`**`(con, target_schema, filepath, stagename, target_table_name)`
Copy
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 Verbindung

  • target_schema, Der Name des Schemas, das beim schnellen Laden verwendet werden soll

  • filepath, Der Pfad des Dateinamens, der in die Tabelle geladen werden soll

  • target_table_name, Der Name der Tabelle, in die die Daten geladen werden sollen

stat

**`stat`**`(path, *, dir_fd=None, follow_symlinks=True)`
Copy
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 sein

  • dir_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 Verzeichnis

  • follow_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)`
Copy
Beschreibung:

Führen Sie den Befehl in einer Subshell aus.

Parameter:

  • _ command_ ,

using

**`using`**`(*argv)`
Copy
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:

  1. target_schema_table

    • Das Zielschema (optional) und den Tabellennamen

  2. define_file

    • Der Name der zu lesenden Datei

  3. definieren_Spalten

    • Die Definition aller Spalten für die temporäre Tabelle

  4. begin_loading_columns

    • Die einzufügenden Spaltennamen. Legt die Reihenfolge fest, in der die Werte eingefügt werden

  5. begin_loading_values

    • Die Liste der zu konvertierenden rohen Einfügewerte

  6. field_delimiter

    • Das Feldtrennzeichen

  7. (optional) skip_header

    • Die Anzahl der zu überspringenden Zeilen

  8. (optional) input_data_place_holder

    • Der Speicherort der Datei bei einem unterstützten Cloud-Anbieter. Parameter setzen, wenn die Datei nicht lokal gespeichert ist

  9. (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():
snowconvert.helpers.quit_application()

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

In dem obigen Beispiel gab es fünf Befehle. Zwei davon waren. Label-Befehle. Der BefehlFIRSTLABELwurde 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()
Copy

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 FIRSTLABELfolgt. Bevor die Funktion FIRSTLABELendet, ruft sie_ SECONDLABEL_ auf, mit den Anweisungen, die darauf folgten.

Anmerkungen:

  • Erstellen einer Konnektorvariable con = None, und Auffüllen in der Funktion main(): 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);
Copy

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

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
Copy

Um die Ausführungsdatei auszuführen, geben Sie eine der beiden Formen des Befehls BTEQ RUN ein:

.RUN FILE=sampfile

Copy

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

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);
Copy

Dies kann während eines Skripts mit der folgenden Zeile ausgeführt werden:

 $(<$NEWSQL)
Copy

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

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>

Copy

Beispielhafte Quellcode-Muster

Mit diesen Eingabedaten:

A B C
D E F
G H I

Copy
* [
] *

Copy

Teradata:

 .IMPORT DATA FILE = inputData.dat;
.REPEAT *
USING var_1 (CHARACTER), var_2 (CHARACTER), var_3 (CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1)
;INSERT INTO testtabu (c1) VALUES (:var_2) 
;INSERT INTO testtabu (c1) VALUES (:var_3) 
;UPDATE testtabu 
   SET c2 = 'X'
   WHERE c1 = :var_1 
;UPDATE testtabu 
   SET c2 = 'Y' 
   WHERE c1 = :var_2 
;UPDATE testtabu 
   SET c2 = 'Z'
   WHERE c1 = :var_3
;INSERT INTO TESTTABU (c1, c2) VALUES ('?','_');

.REPEAT 10
INSERT INTO TESTTABU2 VALUES ('John Doe', 23);

.REPEAT RECS 5
INSERT INTO TESTTABU2 VALUES ('Bob Alice', 21);

.IMPORT DATA FILE = inputData2.dat;
USING (var_1 CHARACTER, var_2 CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1) 
;INSERT INTO testtabu (c1) VALUES (:var_2);
Copy
C1C2
AX
DX
GX
BY
EY
HY
CZ
FZ
IZ
?_
?_
?_
*null
[null
MY_NAMEMY_AGE
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21

Snowflake:

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  snowconvert.helpers.import_file(fr"inputData.dat")
  ssc_repeat_value = '*'
  ssc_max_iterations = 1

  for ssc_repeat_position in range(0, ssc_max_iterations):

    if ssc_repeat_position == 0:
      using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", "var_3", "CHARACTER", rows_to_read = ssc_repeat_value)
      exec("""
        INSERT INTO testtabu (c1)
        VALUES (:var_1)
        """, using = using)
      exec("""
        INSERT INTO testtabu (c1)
        VALUES (:var_2)
        """, using = using)
      exec("""
        INSERT INTO testtabu (c1)
        VALUES (:var_3)
        """, using = using)
      exec("""
        UPDATE testtabu
          SET
            c2 = 'X'
          WHERE
            c1 = :var_1
        """, using = using)
      exec("""
        UPDATE testtabu
          SET
            c2 = 'Y'
          WHERE
            c1 = :var_2
        """, using = using)
      exec("""
        UPDATE testtabu
          SET
            c2 = 'Z'
          WHERE
            c1 = :var_3
        """, using = using)
      exec("""
        INSERT INTO TESTTABU (c1, c2)
        VALUES ('?', '_')
        """, using = using)

  ssc_repeat_value = 10
  ssc_max_iterations = 10

  for ssc_repeat_position in range(0, ssc_max_iterations):
    exec("""
      INSERT INTO TESTTABU2
      VALUES ('John Doe', 23)
      """)
  ssc_repeat_value = 5
  ssc_max_iterations = 5

  for ssc_repeat_position in range(0, ssc_max_iterations):
    exec("""
      INSERT INTO TESTTABU2
      VALUES ('Bob Alice', 21)
      """)
  snowconvert.helpers.import_file(fr"inputData2.dat")
  using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", rows_to_read = 1)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_1)
    """, using = using)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_2)
    """, using = using)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy
C1C2
AX
DX
GX
BY
EY
HY
CZ
FZ
IZ
?_
?_
?_
*null
[null
MY_NAMEMY_AGE
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
John Doe23
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21
Bob Alice21

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

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 } ]
Copy

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:

  1. Rufen Sie die Funktion import_file() aus den SnowConvert-Hilfsfunktionen auf. Dadurch werden die Daten in eine temporäre Datei geladen.

  2. Rufen Sie die Funktion using() aus den SnowConvert -Hilfsfunktionen auf, um ein Wörterbuch mit den geladenen Daten zu erstellen.

  3. 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
Copy

Teradata (MultiLoad)

 .IMPORT DATA FILE = inputData.dat;
USING var_1 (CHARACTER), var_2 (CHARACTER), var_3 (CHARACTER)
INSERT INTO testtabu (c1) VALUES (:var_1)
;INSERT INTO testtabu (c1) VALUES (:var_2) 
;INSERT INTO testtabu (c1) VALUES (:var_3) 
;UPDATE testtabu 
   SET c2 = 'X'
   WHERE c1 = :var_1 
;UPDATE testtabu 
   SET c2 = 'Y' 
   WHERE c1 = :var_2 
;UPDATE testtabu 
   SET c2 = 'Z'
   WHERE c1 = :var_3;
Copy
ROWC1C2
1AX
2BY
3CZ

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  snowconvert.helpers.import_file(fr"inputData.dat")
  using = snowconvert.helpers.using("var_1", "CHARACTER", "var_2", "CHARACTER", "var_3", "CHARACTER", rows_to_read = 1)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_1)
    """, using = using)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_2)
    """, using = using)
  exec("""
    INSERT INTO testtabu (c1)
    VALUES (:var_3)
    """, using = using)
  exec("""
    UPDATE testtabu
      SET
        c2 = 'X'
      WHERE
        c1 = :var_1
    """, using = using)
  exec("""
    UPDATE testtabu
      SET
        c2 = 'Y'
      WHERE
        c1 = :var_2
    """, using = using)
  exec("""
    UPDATE testtabu
      SET
        c2 = 'Z'
      WHERE
        c1 = :var_3
    """, using = using)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy
ROWC1C2
1AX
2BY
3CZ

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

BEGIN LOADING

Transformiert

​Der Knoten wird auskommentiert, da die Transformation stattdessen in der zugehörigen Anweisung INSERT erfolgt.

CLEAR

Kommentiert

DATEFORM

Kommentiert

DEFINE

Transformiert

END LOADING

Transformiert

​Auskommentiert, da nicht notwendig für die BEGIN LOADING-Transformation.

ERRLIMIT

Kommentiert

HELP

Kommentiert

HELP TABLE

Kommentiert

INSERT

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

SET RECORD

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

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #SESSIONS 4
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #ERRLIMIT 25
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

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

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  exec("""
    DROP TABLE Error1
    """)
  exec("""
    DROP TABLE Error2
    """)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

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

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
#** SSC-FDM-0007 - MISSING DEPENDENT OBJECTS "Error1", "Error2" **
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #SESSIONS 4
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #ERRLIMIT 25
   
  exec("""
    DROP TABLE FastTable
    """)
  exec("""
    CREATE OR REPLACE TABLE FastTable (
      ID INTEGER,
      UFACTOR INTEGER,
      MISC CHAR(42)
    )
    """)
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE ID (INTEGER), UFACTOR (INTEGER), MISC (CHAR(42)) FILE = FileName
   
  ssc_define_columns = "ID (INTEGER), UFACTOR (INTEGER), MISC (CHAR(42))"
  #Set file name manually if empty
  ssc_define_file = f"""FileName"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE.  **
  #SHOW
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #BEGIN LOADING FastTable ERRORFILES Error1, Error2 CHECKPOINT 10000
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS PART OF THE BEGIN LOADING TRANSLATION **
  #INSERT INTO FastTable (ID, UFACTOR, MISC) VALUES (:ID, :MISC)
   
  ssc_begin_loading_columns = "(ID, UFACTOR, MISC)"
  ssc_begin_loading_values = [":ID", ":MISC"]
  BeginLoading.import_file_to_table(f"""FastTable""", ssc_define_columns, ssc_define_file, ssc_begin_loading_columns, ssc_begin_loading_values, ",")
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. END LOADING **
  #END LOADING
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

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

  1. [SSC-FDM-0007](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0007): Element mit fehlenden Abhängigkeiten.

  2. [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;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT DELIMITER 'c' DISPLAY ERRORS 'efilename'
   
  ssc_set_record = ""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' 'c' NOSTOP
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' TRIM NONE LEADING 'p'
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' TRIM NONE TRAILING 'p'
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT 'l' TRIM NONE BOTH 'p'
   
  ssc_set_record = "'l'"
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD FORMATTED TRIM NONE BOTH
   
  ssc_set_record = ","
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD UNFORMATTED QUOTE NO OPTIONAL
   
  ssc_set_record = "UNFORMATTED"
  #** SSC-EWI-0021 - 'BINARY' KEYWORD SPECIFICATION FOR SET RECORD NOT SUPPORTED IN SNOWFLAKE **
  #SET RECORD BINARY QUOTE NO YES 'q'
   
  #** SSC-EWI-0021 - 'TEXT' KEYWORD SPECIFICATION FOR SET RECORD NOT SUPPORTED IN SNOWFLAKE **
  #SET RECORD TEXT QUOTE OPTIONAL
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

DEFINE

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

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT) FILE = /tmp/inputData.txt
   
  ssc_define_columns = "id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)"
  #Set file name manually if empty
  ssc_define_file = f"""/tmp/inputData.txt"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)
   
  ssc_define_columns = "id (INTEGER), first_name (VARCHAR(50)), last_name (VARCHAR(50)), salary (FLOAT)"
  #Set file name manually if empty
  ssc_define_file = f""""""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE FILE = /tmp/inputData.txt
   
  ssc_define_columns = ""
  #Set file name manually if empty
  ssc_define_file = f"""/tmp/inputData.txt"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE
   
  ssc_define_columns = ""
  #Set file name manually if empty
  ssc_define_file = f""""""
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

BEGIN LOADING

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

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #BEGIN LOADING FastTable ERRORFILES Error1, Error2 CHECKPOINT 10000
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

INSERT

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
);
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
#** SSC-FDM-0007 - MISSING DEPENDENT OBJECT "TESTS.EmpLoad4" **
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
#** SSC-FDM-TD0022 - SHELL VARIABLES FOUND, RUNNING THIS CODE IN A SHELL SCRIPT IS REQUIRED **
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS AN ASSIGNMENT STATEMENT **
  #SET RECORD VARTEXT "" ""
   
  ssc_set_record = ""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS ASSIGNMENT STATEMENTS **
  #DEFINE _col1 (CHAR(10)), _col2 (CHAR(7)), _col3 (CHAR(2, NULLIF = 'V5')) FILE = inputDataNoDel.txt
   
  ssc_define_columns = "_col1 (CHAR(10)), _col2 (CHAR(7)), _col3 (CHAR(2, NULLIF = 'V5'))"
  #Set file name manually if empty
  ssc_define_file = f"""inputDataNoDel.txt"""
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW **
  #BEGIN LOADING TESTS.EmpLoad4 ERRORFILES ${CPRDBName}.ET_${LOADTABLE}, ${CPRDBName}.UV_${LOADTABLE} CHECKPOINT 1000
   
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. TRANSLATED BELOW AS PART OF THE BEGIN LOADING TRANSLATION **
  #INSERT INTO TESTS.EmpLoad4 (col2, col3, col1, col4) VALUES (:_col2, :_col3, :_col1, CURRENT_DATE)
   
  ssc_begin_loading_columns = "(col2, col3, col1, col4)"
  ssc_begin_loading_values = [":_col2", ":_col3", ":_col1", "CURRENT_DATE()"]
  BeginLoading.import_file_to_table(f"""TESTS.EmpLoad4""", ssc_define_columns, ssc_define_file, ssc_begin_loading_columns, ssc_begin_loading_values, ssc_set_record)
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

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:

StageInput Data Place Holder
StageInput Data Place Holder
Internal stage@my_int_stage
External stage@my_int_stage/path/file.csv
Amazon S3 buckets3://mybucket/data/files
Google Cloud Storagegcs://mybucket/data/files
Microsoft Azureazure://myaccount.blob.core.windows.net/mycontainer/data/files

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")
Copy

END LOADING

Der Befehl END LOADING ist auskommentiert, da er für die Transformation von BEGIN LOADING nicht notwendig ist.

Teradata (FastLoad)

 END LOADING;
Copy

Snowflake (Python)

 #*** Generated code is based on the SnowConvert Python Helpers version 2.0.6 ***
 
import os
import sys
import snowconvert.helpers
from snowconvert.helpers import Export
from snowconvert.helpers import exec
from snowconvert.helpers import BeginLoading
con = None
def main():
  snowconvert.helpers.configure_log()
  con = snowconvert.helpers.log_on()
  #** SSC-FDM-0027 - REMOVED NEXT STATEMENT, NOT APPLICABLE IN SNOWFLAKE. END LOADING **
  #END LOADING
   
  snowconvert.helpers.quit_application()

if __name__ == "__main__":
  main()
Copy

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

  1. [SSC-FDM-0007](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0007): Element mit fehlenden Abhängigkeiten.

  2. [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.

  3. [SSC-EWI-0021](../../general/technical-documentation/issues-and-troubleshooting/conversion-issues/generalEWI. md#ssc-ewi-0021): Nicht unterstützt.

  4. [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.