Verwenden des Python-Konnektors¶

Einstellen der Sitzungsparameter¶

Es gibt mehrere Möglichkeiten, Sitzungsparameter festzulegen, z. B. QUERY_TAG, wenn Sie den Python-Konnektor verwenden.

Sie können Parameter auf Sitzungsebene festlegen, wenn Sie eine Verbindung zu Snowflake herstellen. Übergeben Sie dazu den optionalen Verbindungsparameter „session_parameters“ wie unten gezeigt:

con = snowflake.connector.connect(
    user='XXXX',
    password='XXXX',
    account='XXXX',
    session_parameters={
        'QUERY_TAG': 'EndOfMonthFinancials',
    }
)

Das an die connect()-Methode übergebene „session_parameters“-Wörterbuch kann einen oder mehrere Parameter auf Sitzungsebene enthalten.

Sie können Sitzungsparameter auch festlegen, indem Sie nach dem Herstellen der Verbindung die SQL-Anweisung ALTER SESSION SET ... ausführen:

con.cursor().execute("ALTER SESSION SET QUERY_TAG = 'EndOfMonthFinancials'")

Weitere Informationen zu Sitzungsparametern finden Sie in den Beschreibungen der einzelnen Parameter auf der allgemeinen Seite Parameters.

Verbinden mit dem Standardauthentifikator¶

Stellen Sie eine Verbindung zu Snowflake unter Verwendung der erforderlichen Anmeldeparameter her:

conn = snowflake.connector.connect(
    user=USER,
    password=PASSWORD,
    account=ACCOUNT,
    warehouse=WAREHOUSE,
    database=DATABASE,
    schema=SCHEMA
    )

Copy

Möglicherweise müssen Sie dies mit anderen Informationen erweitern.

Verwenden von Single Sign-On (SSO) zur Authentifizierung¶

Wenn Sie Snowflake für die Verwendung von Single Sign-On (SSO) konfiguriert haben, können Sie Ihre Clientanwendung so konfigurieren, dass SSO für die Authentifizierung verwendet wird. Weitere Informationen dazu finden Sie unter Verwenden von SSO bei Clientanwendungen, die sich mit Snowflake verbinden.

Verwenden der mehrstufige Authentifizierung (MFA)¶

Snowflake unterstützt das Caching von MFA-Token, einschließlich der Kombination der von MFA-Token-Caching mit SSO.

Weitere Informationen dazu finden Sie unter Verwenden von MFA-Token-Caching zur Minimierung der Anzahl von Eingabeaufforderungen bei der Authentifizierung – Optional.

Verwenden von Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation¶

Der Python-Konnektor unterstützt Schlüsselpaar-Authentifizierung und Schlüsselrotation.

Weitere Informationen zur Konfiguration der Schlüsselpaar-Authentifizierung und der Schlüsselrotation finden Sie unter Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation.

Nachdem Sie die Konfiguration der Schlüsselpaar-Authentifizierung abgeschlossen haben, setzen Sie den Parameter private_key in der Funktion connect auf den Pfad zur Datei des privaten Schlüssels.

1. Ändern Sie den unten stehenden Beispielcode, und führen Sie ihn aus. Der Code entschlüsselt die Datei, die den privaten Schlüssel enthält, und übergibt sie an den Snowflake-Treiber, um eine Verbindung herzustellen:

• Aktualisieren Sie die Sicherheitsparameter:

  • path: Gibt den lokalen Pfad zu der von Ihnen erstellten Datei mit dem privaten Schlüssel an.

• Aktualisieren Sie die Verbindungsparameter:

  • user: Gibt Ihren Snowflake-Anmeldenamen an.

  • account_identifier: Gibt Ihren Kontobezeichner an.

    Weitere Details dazu finden Sie unter Nutzungshinweise für die Verwendung des account-Parameters (für die connect-Methode).

Beispielcode

import snowflake.connector
import os
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives.asymmetric import dsa
from cryptography.hazmat.primitives import serialization
with open("<path>/rsa_key.p8", "rb") as key:
    p_key= serialization.load_pem_private_key(
        key.read(),
        password=os.environ['PRIVATE_KEY_PASSPHRASE'].encode(),
        backend=default_backend()
    )

pkb = p_key.private_bytes(
    encoding=serialization.Encoding.DER,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption())

ctx = snowflake.connector.connect(
    user='<user>',
    account='<account_identifier>',
    private_key=pkb,
    warehouse=WAREHOUSE,
    database=DATABASE,
    schema=SCHEMA
    )

cs = ctx.cursor()

Copy

Verwenden eines Proxyservers¶

Um einen Proxyserver zu verwenden, konfigurieren Sie die folgenden Umgebungsvariablen:

• HTTP_PROXY

• HTTPS_PROXY

• NO_PROXY

Beispiel:

Linux oder macOS

export HTTP_PROXY='http://username:password@proxyserver.company.com:80'
export HTTPS_PROXY='http://username:password@proxyserver.company.com:80'

Copy

Windows

set HTTP_PROXY=http://username:password@proxyserver.company.com:80
set HTTPS_PROXY=http://username:password@proxyserver.company.com:80

Copy

Verbinden mit OAuth¶

Um eine Verbindung mit OAuth herzustellen, muss die Verbindungszeichenfolge den Parameter authenticator mit dem Wert oauth und den Parameter token mit dem Wert oauth_access_token enthalten. Weitere Informationen dazu finden Sie unter Clients, Treiber und Konnektoren.

ctx = snowflake.connector.connect(
    user="<username>",
    host="<hostname>",
    account="<account_identifier>",
    authenticator="oauth",
    token="<oauth_access_token>",
    warehouse="test_warehouse",
    database="test_db",
    schema="test_schema"
)

Auswahl des Fail-open- oder Fail-close-Modus¶

Versionen des Snowflake-Konnektors für Python vor 1.8.0 verwenden standardmäßig den Fail-close-Modus. Bei Versionen ab 1.8.0 wird standardmäßig der Fail-open-Modus verwendet. Sie können das Standardverhalten überschreiben, indem Sie beim Aufrufen der connect() -Methode den optionalen Verbindungsparameter ocsp_fail_open einstellen. Beispiel:

con = snowflake.connector.connect(
    account=<account_identifier>,
    user=<user>,
    ...,
    ocsp_fail_open=False,
    ...);

Überprüfen der Version von OCSP-Konnektor oder -Treiber¶

The driver or connector version and its configuration both determine the OCSP behavior. For more information about the driver or connector version, their configuration, and OCSP behavior, see OCSP-Konfiguration.

Zwischenspeichern von OCSP-Antworten¶

Um die Sicherheit der gesamten Kommunikation zu gewährleisten, verwendet der Snowflake-Konnektor für Python das HTTPS-Protokoll für die Verbindung zu Snowflake und zu allen anderen Services (z. B. Amazon S3 für das Staging von Datendateien und Okta für die Verbundauthentifizierung). Zusätzlich zum regulären HTTPS-Protokoll überprüft der Konnektor bei jeder Verbindung über OCSP (Online Certificate Status Protocol) auch den Status der TLS/SSL-Zertifikatssperre und bricht die Verbindung ab, wenn er feststellt, dass das Zertifikat gesperrt wurde oder der OCSP-Status nicht zuverlässig ist.

Da jede Snowflake-Verbindung bis zu drei Roundtrips mit dem OCSP-Server auslöst, wurden mehrere Ebenen des Cache für OCSP-Antworten eingeführt, um die zusätzliche Netzwerklast der Verbindung zu reduzieren:

• Speichercache, der während der gesamten Lebensdauer des Prozesses beibehalten wird.

• Dateicache, der so lange beibehalten wird, bis das Cacheverzeichnis (z. B. ~/.cache/snowflake) gelöscht ist.

• OCSP-Antwort-Servercache.

Das Caching behebt auch Verfügbarkeitsprobleme für OCSP-Server (d. h. für den Fall, dass der eigentliche OCSP-Server ausfällt). Solange der Cache gültig ist, kann der Konnektor den Status der Zertifikatssperre noch überprüfen.

Wenn keine der Cacheschichten die OCSP-Antwort enthält, versucht der Client, den Validierungsstatus direkt vom OCSP-Server der CA abzurufen.

Kopieren von Daten von einem internen Speicherort¶

Um Daten aus Dateien auf Ihrem Hostcomputer in eine Tabelle zu laden, verwenden Sie zunächst den Befehl PUT für das Staging der Datei an einem internen Speicherort. Verwenden Sie dann den Befehl COPY INTO <Tabelle>, um die Daten aus den Dateien in die Tabelle zu kopieren.

Beispiel:

# Putting Data
con.cursor().execute("PUT file:///tmp/data/file* @%testtable")
con.cursor().execute("COPY INTO testtable")

Copy

Hier werden die CSV-Daten in einem lokalen Verzeichnis namens /tmp/data in einer Linux- oder macOS-Umgebung gespeichert. Das Verzeichnis enthält dann Dateien mit den Namen file0, file1, … file100.

Kopieren von Daten von einem externen Speicherort¶

Um Daten aus Dateien, die bereits in einem externen Stagingbereich (z. B. Ihr S3-Bucket) bereitgestellt wurden, in eine Tabelle zu laden, verwenden Sie den Befehl COPY INTO <Tabelle>.

Beispiel:

# Copying Data
con.cursor().execute("""
COPY INTO testtable FROM s3://<s3_bucket>/data/
    STORAGE_INTEGRATION = myint
    FILE_FORMAT=(field_delimiter=',')
""".format(
    aws_access_key_id=AWS_ACCESS_KEY_ID,
    aws_secret_access_key=AWS_SECRET_ACCESS_KEY))

Copy

Wobei:

• s3://<S3-Bucket>/data/ gibt den Namen Ihres S3-Buckets an.

• Den Dateien im Bucket wird data vorangestellt.

• Der Zugriff auf den Bucket erfolgt über eine Speicherintegration, die mit CREATE STORAGE INTEGRATION von einem Kontoadministrator (d. h. einem Benutzer mit der Rolle ACCOUNTADMIN) oder einer Rolle mit der globalen Berechtigung CREATE INTEGRATION erstellt wurde. Bei Verwendung einer Speicherintegration benötigen Benutzer für den Zugriff auf einen privaten Speicherort keine Anmeldeinformationen mehr.

Ausführen einer synchronen Abfrage¶

Um eine synchrone Abfrage auszuführen, rufen Sie die Methode execute() im Cursor-Objekt auf. Beispiel:

conn = snowflake.connector.connect( ... )
cur = conn.cursor()
cur.execute('select * from products')

Verwenden Sie das Cursor-Objekt, um die Werte in den Ergebnissen abzurufen, wie unter Verwenden von cursor zum Abrufen von Werten erläutert.

Ausführen einer asynchronen Abfrage¶

Der Snowflake-Konnektor für Python unterstützt asynchrone Abfragen (d. h. Abfragen, die dem Benutzer die Kontrolle zurückgeben, bevor die Abfrage abgeschlossen ist). Sie können eine asynchrone Abfrage übermitteln und mithilfe von Abrufen (Polling) feststellen, wann die Abfrage abgeschlossen ist. Nachdem die Abfrage abgeschlossen ist, können Sie die Ergebnisse abrufen.

Mit dieser Funktion können Sie mehrere Abfragen parallel übermitteln, ohne auf den Abschluss jeder Abfrage warten zu müssen. Sie können innerhalb derselben Sitzung auch Kombinationen von synchronen und asynchronen Abfragen ausführen.

Schließlich können Sie eine asynchrone Abfrage über eine Verbindung übermitteln und die Ergebnisse über eine andere Verbindung abrufen. Beispielsweise kann ein Benutzer eine Abfrage mit langer Laufzeit über Ihre Anwendung initiieren, die Anwendung beenden und die Anwendung zu einem späteren Zeitpunkt erneut starten, um die Ergebnisse zu überprüfen.

conn = snowflake.connector.connect( ... )
cur = conn.cursor()
# Submit an asynchronous query for execution.
cur.execute_async('select count(*) from table(generator(timeLimit => 25))')

Abrufen der Snowflake-Abfrage-ID¶

Eine Abfrage-ID kennzeichnet jede von Snowflake ausgeführte Abfrage. Wenn Sie den Snowflake-Konnektor für Python zum Ausführen einer Abfrage verwenden, können Sie auf die Abfrage-ID über das Attribut sfqid im Cursor-Objekt zugreifen:

# Retrieving a Snowflake Query ID
cur = con.cursor()
cur.execute("SELECT * FROM testtable")
print(cur.sfqid)

Copy

Sie können die Abfrage-ID für Folgendes verwenden:

• Überprüfen des Status von Abfragen über die Weboberfläche.

  Auf der klassischen Weboberfläche werden die Abfrage-IDs auf der Seite History angezeigt. Siehe Verwenden der Verlaufsseite zum Überwachen von Abfragen.

• Programmgesteuertes Prüfen des Status einer Abfrage (z. B. um festzustellen, ob eine asynchrone Abfrage abgeschlossen ist).

  Siehe Überprüfen des Status einer Abfrage.

• Abrufen der Ergebnisse einer asynchronen Abfrage oder einer zuvor übermittelten synchronen Abfrage.

  Siehe Verwenden der Abfrage-ID zum Abrufen von Abfrageergebnissen.

• Abbrechen einer in Ausführung befindlichen Abfrage.

  Siehe Verwenden der Abfrage-ID zum Abbrechen einer Abfrage.

Überprüfen des Status einer Abfrage¶

So überprüfen Sie den Status einer Abfrage:

1. Rufen Sie die Abfrage-ID aus dem Feld sfqid im Objekt Cursor ab.

2. Übergeben Sie die Abfrage-ID an die Methode get_query_status() des Connection-Objekts, um die Enumerationskonstante QueryStatus zurückzugeben, die den Status der Abfrage darstellt.

   Standardmäßig löst get_query_status() keinen Fehler aus, wenn die Abfrage zu einem Fehler geführt hat. Wenn Sie möchten, dass ein Fehler ausgelöst wird, rufen Sie stattdessen get_query_status_throw_if_error() auf.

3. Verwenden Sie die Enumerationskonstante QueryStatus, um den Status der Abfrage zu überprüfen.

   • Um festzustellen, ob die Abfrage noch ausgeführt wird (z. B. wenn es sich um eine asynchrone Abfrage handelt), übergeben Sie die Konstante an die Methode is_still_running() des Connection-Objekts.

   • Um festzustellen, ob ein Fehler aufgetreten ist, übergeben Sie die Konstante an die Methode is_an_error().

   Eine vollständige Liste der Enumerationskonstanten erhalten Sie mit QueryStatus.

Im folgenden Beispiel wird eine asynchrone Abfrage ausgeführt und der Status der Abfrage überprüft:

import time
...
# Execute a long-running query asynchronously.
cur.execute_async('select count(*) from table(generator(timeLimit => 25))')
...
# Wait for the query to finish running.
query_id = cur.sfqid
while conn.is_still_running(conn.get_query_status(query_id)):
  time.sleep(1)

Im folgenden Beispiel wird ein Fehler ausgelöst, wenn die Abfrage zu einem Fehler geführt hat:

from snowflake.connector import ProgrammingError
import time
...
# Wait for the query to finish running and raise an error
# if a problem occurred with the execution of the query.
try:
  query_id = cur.sfqid
  while conn.is_still_running(conn.get_query_status_throw_if_error(query_id)):
    time.sleep(1)
except ProgrammingError as err:
  print('Programming Error: {0}'.format(err))

Verwenden der Abfrage-ID zum Abrufen von Abfrageergebnissen¶

Wenn Sie die Ergebnisse einer asynchronen Abfrage oder einer zuvor übermittelten synchronen Abfrage abrufen möchten, führen Sie die folgenden Schritte aus:

1. Rufen Sie die Abfrage-ID der Abfrage ab. Siehe Abrufen der Snowflake-Abfrage-ID.

2. Rufen Sie die Methode get_results_from_sfqid() im Cursor-Objekt auf, um die Ergebnisse abzurufen.

3. Verwenden Sie das Cursor-Objekt, um die Werte in den Ergebnissen abzurufen, wie unter Verwenden von cursor zum Abrufen von Werten erläutert.

Falls die Abfrage noch ausgeführt wird, müssen Sie beachten, dass die Fetch-Methoden (fetchone(), fetchmany(), fetchall() usw.) auf den Abschluss der Abfrage warten.

Beispiel:

# Get the results from a query.
cur.get_results_from_sfqid(query_id)
results = cur.fetchall()
print(f'{results[0]}')

Verwenden von cursor zum Abrufen von Werten¶

Rufen Sie Werte aus einer Tabelle mit der Cursorobjektiterator-Methode ab.

Um beispielsweise Spalten mit dem Namen „col1“ und „col2“ aus der zuvor mit testtable erstellten Tabelle (siehe Erstellen von Tabellen und Einfügen von Daten) abzurufen, verwenden Sie Code, der dem folgenden ähnelt:

cur = conn.cursor()
try:
    cur.execute("SELECT col1, col2 FROM test_table ORDER BY col1")
    for (col1, col2) in cur:
        print('{0}, {1}'.format(col1, col2))
finally:
    cur.close()

Copy

Alternativ bietet der Snowflake-Konnektor für Python ein abgekürztes Verfahren:

for (col1, col2) in con.cursor().execute("SELECT col1, col2 FROM testtable"):
    print('{0}, {1}'.format(col1, col2))

Copy

Wenn Sie ein einzelnes Ergebnis (d. h. eine einzelnen Zeile) erhalten möchten, verwenden Sie die Methode fetchone:

col1, col2 = con.cursor().execute("SELECT col1, col2 FROM testtable").fetchone()
print('{0}, {1}'.format(col1, col2))

Copy

Wenn Sie die angegebene Anzahl von Zeilen auf einmal erhalten möchten, verwenden Sie die Methode fetchmany mit der Anzahl der Zeilen:

cur = con.cursor().execute("SELECT col1, col2 FROM testtable")
ret = cur.fetchmany(3)
print(ret)
while len(ret) > 0:
    ret = cur.fetchmany(3)
    print(ret)

Copy

Bemerkung

Verwenden Sie fetchone oder fetchmany, wenn das Resultset zu groß für den verfügbaren Speicher ist.

Wenn Sie alle Ergebnisse auf einmal erhalten müssen:

results = con.cursor().execute("SELECT col1, col2 FROM testtable").fetchall()
for rec in results:
    print('%s, %s' % (rec[0], rec[1]))

Copy

Um ein Zeitlimit (Timeout) für eine Abfrage festzulegen, führen Sie einen „begin“-Befehl aus, und fügen Sie einen Timeout-Parameter in die Abfrage ein. Wenn die Abfrage die Zeitdauer des Parameterwertes überschreitet, wird ein Fehler generiert und ein Rollback durchgeführt.

Im folgenden Code bedeutet der Fehler 604, dass die Abfrage abgebrochen wurde. Der Timeout-Parameter startet Timer() und bricht ab, wenn die Abfrage nicht innerhalb der angegebenen Zeit beendet wird.

conn.cursor().execute("create or replace table testtbl(a int, b string)")

conn.cursor().execute("begin")
try:
   conn.cursor().execute("insert into testtbl(a,b) values(3, 'test3'), (4,'test4')", timeout=10) # long query

except ProgrammingError as e:
   if e.errno == 604:
      print("timeout")
      conn.cursor().execute("rollback")
   else:
      raise e
else:
   conn.cursor().execute("commit")

Copy

Verwenden von DictCursor zum Abrufen von Werten nach Spaltenname¶

Wenn Sie einen Wert anhand des Spaltennamens abrufen möchten, erstellen Sie ein cursor-Objekt vom Typ DictCursor.

Beispiel:

# Querying data by DictCursor
from snowflake.connector import DictCursor
cur = con.cursor(DictCursor)
try:
    cur.execute("SELECT col1, col2 FROM testtable")
    for rec in cur:
        print('{0}, {1}'.format(rec['COL1'], rec['COL2']))
finally:
    cur.close()

Copy

Beispiele für asynchrone Abfragen¶

Im Folgenden finden Sie ein einfaches Beispiel für eine asynchrone Abfrage:

from snowflake.connector import ProgrammingError
import time

conn = snowflake.connector.connect( ... )
cur = conn.cursor()

# Submit an asynchronous query for execution.
cur.execute_async('select count(*) from table(generator(timeLimit => 25))')

# Retrieve the results.
cur.get_results_from_sfqid(query_id)
results = cur.fetchall()
print(f'{results[0]}')

Im nächsten Beispiel wird eine asynchrone Abfrage von einer Verbindung aus übermittelt und das Ergebnis von einer anderen Verbindung aus abgerufen:

from snowflake.connector import ProgrammingError
import time

conn = snowflake.connector.connect( ... )
cur = conn.cursor()

# Submit an asynchronous query for execution.
cur.execute_async('select count(*) from table(generator(timeLimit => 25))')

# Get the query ID for the asynchronous query.
query_id = cur.sfqid

# Close the cursor and the connection.
cur.close()
conn.close()

# Open a new connection.
new_conn = snowflake.connector.connect( ... )

# Create a new cursor.
new_cur = new_conn.cursor()

# Retrieve the results.
new_cur.get_results_from_sfqid(query_id)
results = new_cur.fetchall()
print(f'{results[0]}')

Verwenden der Abfrage-ID zum Abbrechen einer Abfrage¶

So brechen Sie eine Abfrage über die Abfrage-ID ab:

cur = cn.cursor()

try:
  cur.execute(r"SELECT SYSTEM$CANCEL_QUERY('queryID')")
  result = cur.fetchall()
  print(len(result))
  print(result[0])
finally:
  cur.close()

Copy

Ersetzen Sie die Zeichenfolge „queryID“ durch die tatsächliche Abfrage-ID. Um die ID für eine Abfrage zu erhalten, siehe Abrufen der Snowflake-Abfrage-ID.

Verbessern der Abfrageleistung durch Umgehen der Datenkonvertierung¶

Verwenden Sie zur Verbesserung der Abfrageleistung die Klasse SnowflakeNoConverterToPython im Modul snowflake.connector.converter_null, um die Datenkonvertierung vom internen Snowflake-Datentyp in den systemeigenen Python-Datentyp zu umgehen, z. B.:

from snowflake.connector.converter_null import SnowflakeNoConverterToPython

con = snowflake.connector.connect(
    ...
    converter_class=SnowflakeNoConverterToPython
)
for rec in con.cursor().execute("SELECT * FROM large_table"):
    # rec includes raw Snowflake data

Copy

Im Ergebnis werden alle Daten als Zeichenfolgen dargestellt, sodass die Anwendung für die Konvertierung in die systemeigenen Python-Datentypen verantwortlich ist. Beispielsweise sind TIMESTAMP_NTZ- und TIMESTAMP_LTZ-Daten die als Zeichenfolgen dargestellte Epochenzeit, und TIMESTAMP_TZ-Daten sind die Epochenzeit, gefolgt von einem Leerzeichen, gefolgt vom Offset zu UTC in Minuten, dargestellt als Zeichenfolge.

Das Binden der Daten wird nicht beeinflusst. Python-native Daten können weiterhin für Updates gebunden werden.

pyformat- oder format-Bindung¶

Sowohl die pyformat-Bindung als auch die format-Bindung binden Daten auf der Clientseite und nicht auf der Serverseite.

Standardmäßig unterstützt der Snowflake-Konnektor für Python sowohl pyformat als auch format, sodass Sie %(name)s oder %s als Platzhalter verwenden können. Beispiel:

• Verwenden von %(name)s als Platzhalter:

  conn.cursor().execute(
      "INSERT INTO test_table(col1, col2) "
      "VALUES(%(col1)s, %(col2)s)", {
          'col1': 789,
          'col2': 'test string3',
          })
  

  Copy

• Verwenden von %s als Platzhalter:

  con.cursor().execute(
      "INSERT INTO testtable(col1, col2) "
      "VALUES(%s, %s)", (
          789,
          'test string3'
      ))
  

  Copy

Mit pyformat und format können Sie auch ein Listenobjekt verwenden, um Daten für den IN-Operator zu binden:

# Binding data for IN operator
con.cursor().execute(
    "SELECT col1, col2 FROM testtable"
    " WHERE col2 IN (%s)", (
        ['test string1', 'test string3'],
    ))

Copy

Das Prozentzeichen („%“) ist sowohl ein Platzhalterzeichen für SQL LIKE als auch ein Formatbindungszeichen für Python. Wenn Sie die Formatbindung verwenden und Ihr SQL-Befehl das Prozentzeichen enthält, müssen Sie möglicherweise das Prozentzeichen maskieren. Wenn Ihre SQL-Anweisung beispielsweise wie folgt lautet:

SELECT col1, col2
    FROM test_table
    WHERE col2 ILIKE '%York' LIMIT 1;  -- Find York, New York, etc.

Copy

Dann sollte Ihr Python-Code wie folgt aussehen (beachten Sie das zusätzliche Prozentzeichen, um das ursprüngliche Prozentzeichen zu umgehen):

sql_command = "select col1, col2 from test_table "
sql_command += " where col2 like '%%York' limit %(lim)s"
parameter_dictionary = {'lim': 1 }
cur.execute(sql_command, parameter_dictionary)

Copy

qmark- oder numeric-Bindung¶

Sowohl die qmark-Bindung als auch die numeric-Bindung binden Daten eher auf der Serverseite als auf der Clientseite:

• Verwenden Sie für die qmark-Bindung ein Fragezeichenzeichen (?), um anzugeben, an welcher Stelle in der Zeichenfolge der Wert einer Variablen eingefügt werden soll.

• Verwenden Sie für die numeric-Bindung einen Doppelpunkt (:), gefolgt von einer Zahl, mit der die Position der Variablen angegeben wird, die an dieser Position ersetzt werden soll. So gibt beispielsweise :2 die zweite Variable an.

  Verwenden Sie die numerische Bindung, um denselben Wert mehr als einmal in derselben Abfrage zu binden. Wenn Sie z. B. einen langen VARCHAR- oder BINARY- oder semistrukturierten Wert haben, den Sie mehr als einmal verwenden möchten, dann können Sie mit der numeric-Bindung den Wert einmal an den Server senden und ihn mehrfach verwenden.

In den nächsten Abschnitten wird erklärt, wie Sie qmark- und numeric-Bindung verwenden:

• Verwenden von qmark- oder numeric-Bindung

• Verwenden von qmark- oder numeric-Bindung mit datetime-Objekten

• Verwenden von Bindungsvariablen mit dem IN-Operator

Binden von Parametern an Variablen für Batcheinfügungen¶

In Ihrem Anwendungscode können Sie mehrere Zeilen in einen einzelnen Batch einfügen. Verwenden Sie dazu Parameter für Werte in einer INSERT-Anweisung. In der folgenden Anweisung werden z. B. Platzhalter für qmark-Bindungen in einer INSERT-Anweisung verwendet:

insert into grocery (item, quantity) values (?, ?)

Copy

Zum Spezifizieren der einzufügenden Daten definieren Sie dann eine Variable, die eine Sequenz von Sequenzen ist (z. B. eine Liste von Tupeln):

rows_to_insert = [('milk', 2), ('apple', 3), ('egg', 2)]

Copy

Wie im obigen Beispiel gezeigt, ist jedes Element in der Liste ein Tupel, das die Spaltenwerte für eine einzufügende Zeile enthält.

Um die Bindung durchzuführen, rufen Sie die Methode executemany() auf und übergeben die Variable als zweites Argument. Beispiel:

conn = snowflake.connector.connect( ... )
rows_to_insert = [('milk', 2), ('apple', 3), ('egg', 2)]
conn.cursor().executemany(
    "insert into grocery (item, quantity) values (?, ?)",
    rows_to_insert)

Copy

Durch Binden von Daten auf dem Server (d. h. mittels qmark- oder numeric-Bindung) kann der Konnektor die Leistung von Batcheinfügungen optimieren.

Wenn Sie dieses Verfahren verwenden, um eine große Anzahl von Werten einzufügen, kann die Treiberleistung verbessert werden, indem die Daten (ohne Erstellen von Dateien auf dem lokalen Computer) an einen temporären Stagingbereich gestreamt werden. Der Treiber führt dies automatisch durch, wenn die Anzahl der Werte einen Schwellenwert überschreitet.

Außerdem müssen die aktuelle Datenbank und das aktuelle Schema für die Sitzung festgelegt sein. Wenn diese nicht festgelegt sind, kann der vom Treiber ausgeführte CREATE TEMPORARY STAGE-Befehl folgenden Fehler generieren:

CREATE TEMPORARY STAGE SYSTEM$BIND file_format=(type=csv field_optionally_enclosed_by='"')
Cannot perform CREATE STAGE. This session does not have a current schema. Call 'USE SCHEMA', or use a qualified name.

Angriffe durch Einschleusung von SQL-Befehlen verhindern¶

Binden Sie Daten nicht mit der Formatierungsfunktion von Python, da Sie eine Einschleusung von SQL-Befehlen riskieren. Beispiel:

# Binding data (UNSAFE EXAMPLE)
con.cursor().execute(
    "INSERT INTO testtable(col1, col2) "
    "VALUES(%(col1)d, '%(col2)s')" % {
        'col1': 789,
        'col2': 'test string3'
    })

Copy

# Binding data (UNSAFE EXAMPLE)
con.cursor().execute(
    "INSERT INTO testtable(col1, col2) "
    "VALUES(%d, '%s')" % (
        789,
        'test string3'
    ))

Copy

# Binding data (UNSAFE EXAMPLE)
con.cursor().execute(
    "INSERT INTO testtable(col1, col2) "
    "VALUES({col1}, '{col2}')".format(
        col1=789,
        col2='test string3')
    )

Copy

Speichern Sie stattdessen die Werte in Variablen, und binden Sie diese Variablen dann mit qmark oder einem numerischen Bindungsformat ein.