Verwenden des Node.js-Treibers

.

Verwandte Themen

Der typische Workflow für die Verwendung des Treibers ist wie folgt:

  1. Stellen Sie eine Verbindung zu Snowflake her.

  2. Führen Sie Anweisungen aus, z. B. Abfragen und DDL/DML-Befehle.

  3. Verwenden Sie die Ergebnisse.

  4. Beenden Sie die Verbindung.

Wichtig

Der Treiber unterstützt derzeit nicht die Befehle PUT und GET und kann daher nicht zum Hoch- oder Herunterladen von Dateien für das Laden/Entladen von Daten verwendet werden. Verwenden Sie stattdessen SnowSQL (CLI-Client) oder JDBC-Treiber.

Unter diesem Thema:

Herstellen einer Verbindung

Um Anweisungen in Snowflake auszuführen, müssen Sie zunächst eine Verbindung herstellen:

  1. Rufen Sie snowflake.createConnection auf, um ein neues Connection-Objekt zu erstellen, und übergeben Sie ein JavaScript-Objekt, das die Verbindungsoptionen angibt.

  2. Rufen Sie mit dem Connection-Objekt die Methode connect auf, um eine Verbindung herzustellen.

    Bemerkung

    Wenn Sie die Option authenticator auf EXTERNALBROWSER einstellen (um browserbasiertes SSO zu verwenden), rufen Sie die Methode connectAsync und nicht die Methode connect auf.

    Um Verbindungsfehler zu behandeln, übergeben Sie eine Callback-Funktion, die folgende Signatur hat:

    function(err, conn)

    Wobei:

    • err ist ein JavaScript-Error-Objekt.

    • conn ist das aktuelle Connection-Objekt.

    Wenn bei der Verbindung ein Fehler auftritt, übergibt die Methode connect ein Error-Objekt an Ihre Callback-Funktion. Sie können dieses Objekt in Ihrer Callback-Funktion verwenden, um Details über den Fehler abzurufen. Wenn Sie Informationen über das aktuelle Connection-Objekt benötigen, können Sie das an Ihre Callback-Funktion übergebene conn-Argument verwenden.

Das folgende Beispiel baut eine Verbindung auf und verwendet ein Kennwort zur Authentifizierung. Informationen zu weiteren Authentifizierungsmethoden finden Sie unter Authentifizierungsoptionen.

// Load the Snowflake Node.js driver.
var snowflake = require('snowflake-sdk');

// Create a Connection object that we can use later to connect.
var connection = snowflake.createConnection( {
    account: account,
    username: user,
    password: password
    }
    );

// Try to connect to Snowflake, and check whether the connection was successful.
connection.connect( 
    function(err, conn) {
        if (err) {
            console.error('Unable to connect: ' + err.message);
            } 
        else {
            console.log('Successfully connected to Snowflake.');
            // Optional: store the connection ID.
            connection_ID = conn.getId();
            }
        }
    );

Beim Herstellen einer Verbindung können Sie die im folgenden Abschnitt beschriebenen Optionen festlegen.

Verbindungsoptionen einstellen

Beim Konstruieren eines neuen Connection-Objekts übergeben Sie ein JavaScript-Objekt, das die Optionen für die Verbindung angibt (z. B. Ihr Konto, Ihren Benutzernamen usw.). In den folgenden Abschnitten beschreiben die Optionen, die Sie einstellen können. Um eine Option einzustellen, geben Sie den Optionsnamen als Eigenschaftsnamen im JavaScript-Objekte an.

Erforderliche Verbindungsoptionen

account

Der volle Name Ihres Kontos (bereitgestellt von Snowflake). Beachten Sie, dass Ihr vollständiger Kontoname möglicherweise zusätzliche Segmente enthält, die die Region und die Cloudplattform angeben, wo Ihr Konto gehostet wird.

Beispiele für Kontonamen nach Region

Wenn Ihr Konto-Locator xy12345 ist:

Cloudplattform/ . Region

Konto-Locator . (mit zusätzlichen Segmenten, falls erforderlich)

Amazon Web Services (AWS)
US West (Oregon)

xy12345
US East (Ohio)

xy12345.us-east-2.aws
US East (N. Virginia)

xy12345.us-east-1
US East (Commercial Gov - N. Virginia)

xy12345.us-east-1-gov.aws
Canada (Central)

xy12345.ca-central-1.aws
EU (Irland)

xy12345.eu-west-1
Europe (London)

xy12345.eu-west-2.aws
EU (Frankfurt)

xy12345.eu-central-1
Asia Pacific (Tokio)

xy12345.ap-northeast-1.aws
Asia Pacific (Mumbai)

xy12345.ap-south-1.aws
Asia Pacific (Singapur)

xy12345.ap-southeast-1
Asia Pacific (Sydney)

xy12345.ap-southeast-2

Google Cloud Platform (GCP)
US Central1 (Iowa)

xy12345.us-central1.gcp
Europe West2 (London)

xy12345.europe-west2.gcp
Europe West4 (Niederlande)

xy12345.europe-west4.gcp

Microsoft Azure
West US 2 (Washington)

xy12345.west-us-2.azure
East US 2 (Virginia)

xy12345.east-us-2.azure
US Gov Virginia

xy12345.us-gov-virginia.azure
Canada Central (Toronto)

xy12345.canada-central.azure
West Europe (Niederlande)

xy12345.west-europe.azure
Switzerland North (Zürich)

xy12345.switzerland-north.azure
Southeast Asia (Singapur)

xy12345.southeast-asia.azure
Australia East (New South Wales)

xy12345.australia-east.azure

Wichtig

Wenn eine der folgenden Bedingungen zutrifft, unterscheidet sich Ihr Konto-Locator von der im obigen Beispiel beschriebenen Struktur:

username

Snowflake-Benutzeranmeldename, mit dem die Verbindung erfolgen soll.

region – Veraltet

ID der Region, in der sich Ihr Konto befindet.

Diese Option wird nicht mehr verwendet, da die Regionsinformationen, falls erforderlich, Teil des vollständigen Kontonamens sind. Sie ist hier nur aus Gründen der Abwärtskompatibilität dokumentiert.

Zusätzlich müssen Sie die Optionen für die Authentifizierung am Server angeben.

Authentifizierungsoptionen

authenticator

Gibt den Authentifikator an, der für die Überprüfung der Anmeldeinformationen des Benutzers verwendet werden soll. Sie können dies auf einen der folgenden Werte einstellen:

Wert

Beschreibung

SNOWFLAKE

Verwenden des internen Snowflake-Authentifikators. Sie müssen auch die Option password einstellen.

EXTERNALBROWSER

Verwenden Ihres Webbrowsers zur Authentifizierung mit Okta, ADFS oder einem anderen SAML 2.0-kompatiblen Identitätsanbieter (IdP).

OAUTH

Verwenden Sie OAuth für die Authentifizierung. Sie müssen auch die Option token auf das OAuth-Token setzen (siehe unten).

SNOWFLAKE_JWT

Verwenden der Schlüsselpaar-Authentifizierung Siehe Verwenden von Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation.

Der Standardwert ist SNOWFLAKE.

Weitere Informationen zur Authentifizierung finden Sie unter Verwenden und Verwalten der Verbundauthentifizierung und OAuth mit Clients, Treibern und Konnektoren.

password

Kennwort für den Benutzer. Legen Sie diese Option fest, wenn Sie die Option authenticator auf SNOWFLAKE gesetzt haben oder wenn Sie die Option authenticator nicht gesetzt haben.

token

Gibt das OAuth-Token an, das für die Authentifizierung verwendet werden soll. Legen Sie diese Option fest, wenn Sie die Option authenticator auf OAUTH gesetzt haben.

privateKey

Privater Schlüssel (im PEM-Format) für die Schlüsselpaar-Authentifizierung. Weitere Details dazu finden Sie unter Verwenden von Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation.

privateKeyPath

Gibt den lokalen Pfad zu der erstellten Datei mit dem privaten Schlüssel an (z. B rsa_key.p8). Weitere Details dazu finden Sie unter Verwenden von Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation.

privateKeyPass

Gibt die Kennung zum Entschlüsseln der privaten Schlüsseldatei an, wenn die Datei verschlüsselt ist. Weitere Details dazu finden Sie unter Verwenden von Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation.

Zusätzliche Verbindungsoptionen

database

Die Standarddatenbank, die nach dem Verbinden für die Sitzung verwendet werden soll.

schema

Das Standardschema, das nach dem Verbinden für die Sitzung verwendet werden soll.

warehouse

Das standardmäßige virtuelle Warehouse, das nach dem Verbinden für die Sitzung verwendet werden soll. Wird zum Ausführen von Abfragen, Laden von Daten usw. verwendet.

role

Die Standardsicherheitsrolle, die nach dem Verbinden für die Sitzung verwendet werden soll.

clientSessionKeepAlive

Standardmäßig kommt es bei Clientverbindungen ca. 3–4 Stunden nach der Ausführung der letzten Abfrage zu einem Timeout.

Wenn die Option clientSessionKeepAlive auf true gesetzt ist, bleibt die Verbindung des Clients zum Server auf unbestimmte Zeit bestehen, auch wenn keine Abfragen ausgeführt werden.

Die Standardeinstellung dieser Option lautet „false“.

Wenn Sie die Option auf true setzen, müssen Sie sicherstellen, dass Ihr Programm die Verbindung zum Server explizit trennt, sobald das Programm abgeschlossen ist. Trennen Sie erst die Verbindung, bevor Sie das Programm beenden.

clientSessionKeepAliveHeartbeatFrequency

(Gilt nur, wenn clientSessionKeepAlive den Wert „true“ hat)

Mit dieser Option wird die Häufigkeit (das Wiederholungsintervall in Sekunden) zwischen Taktmeldungen festgelegt.

Sie können sich die Taktmeldung einer Verbindung wie einen Ersatz für eine Abfrage mit Neustart des Timeout-Countdowns der Verbindung vorstellen. Anders ausgedrückt: Wenn die Verbindung nach mindestens 4 Stunden Inaktivität abbrechen würde, setzt der Takt den Timer zurück, sodass das Timeout frühestens 4 Stunden nach dem letzten Takt (oder der letzten Abfrage) stattfindet.

Der Standardwert ist 3.600 Sekunden (eine Stunde). Der gültige Wertebereich liegt zwischen 900 und 3.600. Da Timeouts normalerweise nach frühestens 4 Stunden auftreten, reicht normalerweise ein Takt von einmal pro Stunde, damit die Verbindung aufrechterhalten bleibt. Taktintervalle von weniger als 3.600 Sekunden sind selten notwendig oder nützlich.

Bei einigen Verbindungsoptionen wird davon ausgegangen, dass das angegebene Datenbankobjekt (Datenbank, Schema, Warehouse oder Rolle) bereits im System vorhanden ist. Wenn das angegebene Objekt nicht vorhanden ist, wird während der Verbindung kein Standard festgelegt.

Nach dem Verbinden können alle optionalen Verbindungsoptionen auch über den Befehl USE <Objekt> eingestellt oder überschrieben werden.

Authentifizierung mit Snowflake

Für die Authentifizierung bei Snowflake können Sie eine der folgenden Optionen verwenden:

Verwenden von Single Sign-On (SSO)

Wenn Sie Snowflake für die Verwendung von Single Sign-On (SSO) konfiguriert haben, können Sie Ihre Clientanwendung so konfigurieren, dass browserbasiertes SSO für die Authentifizierung verwendet wird.

In Ihrem Anwendungscode:

  1. Setzen Sie die Option authenticator auf EXTERNALBROWSER.

  2. Rufen Sie zum Herstellen einer Verbindung die Methode connectAsync und nicht die Methode connect auf.

Beispiel:

// Use a browser to authenticate via SSO.
var connection = snowflake.createConnection({
  ...,
  authenticator: "EXTERNALBROWSER"
});
// Establish a connection. Use connectAsync, rather than connect.
connection.connectAsync(
  function (err, conn)
  {
    ... // Handle any errors.
  }
).then(() =>
{
  // Execute SQL statements.
  var statement = connection.execute({...});
});

Weitere Informationen zur Verwendung von browserbasiertem SSO für die Authentifizierung finden Sie unter Browser-basiertes SSO.

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

Der Treiber unterstützt Schlüsselpaar-Authentifizierung und Schlüsselrotation. Für die Verwendung müssen Sie Folgendes tun:

  1. Konfigurieren Sie die Schlüsselpaar-Authentifizierung, wie unter Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation erläutert.

  2. In Ihrem Anwendungscode:

    1. Setzen Sie die Option authenticator auf SNOWFLAKE_JWT.

    2. Verwenden Sie den privaten Schlüssel zur Authentifizierung auf eine der folgenden Arten:

      • Setzen Sie die Option privateKey auf den privaten Schlüssel.

      • Setzen Sie die Option privateKeyPath auf den Pfad zur Datei des privaten Schlüssels.

        Wenn die Datei verschlüsselt ist, müssen Sie auch die Option privateKeyPass auf die Passphrase setzen, um den privaten Schlüssel zu entschlüsseln.

Im folgenden Beispiel wird der private Schlüssel aus einer Datei geladen und die Option privateKey auf den privaten Schlüssel gesetzt:

// Read the private key file from the filesystem.
var crypto = require('crypto');
var fs = require('fs');
var privateKeyFile = fs.readFileSync('<path_to_private_key_file>/rsa_key.p8');

// Get the private key from the file as an object.
const privateKeyObject = crypto.createPrivateKey({
  key: privateKeyFile,
  format: 'pem',
  passphrase: 'passphrase'
});

// Extract the private key from the object as a PEM-encoded string.
var privateKey = privateKeyObject.export({
  format: 'pem',
  type: 'pkcs8'
});

// Use the private key for authentication.
var connection = snowflake.createConnection({
  ...
  authenticator: "SNOWFLAKE_JWT",
  privateKey: privateKey
});

// Establish a connection.
connection.connect(
  function (err, conn)
  {
    ... // Handle any errors.
  }
);

// Execute SQL statements.
var statement = connection.execute({...});

Im folgenden Beispiel wird die Option privateKeyPath auf eine verschlüsselte Datei mit privatem Schlüssel gesetzt und die Option privateKeyPass auf die Passphrase gesetzt, die zum Entschlüsseln des privaten Schlüssels verwendet wird:

// Use an encrypted private key file for authentication.
// Specify the passphrase for decrypting the key.
var connection = snowflake.createConnection({
  ...
  authenticator: "SNOWFLAKE_JWT",
  privateKeyFile: "<path-to-privatekey>/privatekey.p8",
  privateKeyPass: '<passphrase_to_decrypt_the_private_key>'
});

// Establish a connection.
connection.connect(
  function (err, conn)
  {
    ... // Handle any errors.
  }
);

// Execute SQL statements.
var statement = connection.execute({...});

Verwenden von OAuth

Um eine Verbindung mit OAuth herzustellen, setzen Sie die Option authenticator auf OAUTH und die Option token auf das OAuth-Zugriffstoken. Beispiel:

// Use OAuth for authentication.
var connection = snowflake.createConnection({
  ...
  authenticator: "OAUTH",
  token: "<your_oauth_token>"
});

// Establish a connection.
connection.connect(
  function (err, conn)
  {
    ... // Handle any errors.
  }
);

// Execute SQL statements.
var statement = connection.execute({...});

Weitere Informationen dazu finden Sie unter OAuth mit Clients, Treibern und Konnektoren.

Überprüfen der Netzwerkverbindung zu Snowflake mit SnowCD

Nach der Konfiguration des Treibers können Sie die Netzwerkkonnektivität zu Snowflake mit SnowCD testen und Probleme beheben.

Sie können während der Erstkonfiguration und bei Bedarf jederzeit SnowCD verwenden, um Ihre Netzwerkverbindung zu Snowflake zu testen und Probleme zu beheben.

OCSP (Online Certificate Status Protocol)

Wenn der Treiber eine Verbindung herstellt, sendet Snowflake ein Zertifikat, um zu bestätigen, dass die Verbindung zu Snowflake und nicht zu einem Host besteht, der sich als Snowflake ausgibt. Der Treiber sendet dieses Zertifikat an einen OCSP (Online Certificate Status Protocol)-Server, um zu überprüfen, ob das Zertifikat widerrufen wurde.

Wenn der Treiber den OCSP-Server nicht erreichen kann, um das Zertifikat zu überprüfen, kann beim Treiber „Fail-open“ oder „Fail-close“ auftreten.

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

Bei Node.js-Treiberversionen vor 1.2.0 findet standardmäßig „Fail-close“ statt. Bei Versionen ab 1.2.0 findet standardmäßig „Fail-open“ statt. Sie können das Standardverhalten überschreiben, indem Sie den globalen Parameter ocspFailOpen festlegen, bevor Sie die Methode snowflake.createConnection() aufrufen. Sie können den Parameter auf „true“ oder „false“ setzen.

snowflake.configure( {ocspFailOpen: false} );
const connection = snowflake.createConnection(
    {
    account: <account>,
    ...
    }
);

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

Weitere Informationen zu Version, Konfiguration und OCSP-Verhalten von Treiber oder Konnektor finden Sie unter OCSP-Konfiguration.

Ausführen von Anweisungen

Anweisungen können durch Aufruf der Methode connection.execute() ausgeführt werden. Die execute()-Methode akzeptiert ein options-Objekt, mit dem der SQL-Text und ein complete-Callback angegeben werden können. Der complete-Callback wird aufgerufen, wenn eine Anweisung die Ausführung beendet hat und das Ergebnis zur Weiterverarbeitung bereit steht:

var statement = connection.execute({
  sqlText: 'create database testdb',
  complete: function(err, stmt, rows) {
    if (err) {
      console.error('Failed to execute statement due to the following error: ' + err.message);
    } else {
      console.log('Successfully executed statement: ' + stmt.getSqlText());
    }
  }
});

Datenbindung in Anweisungsparametern

Gelegentlich kann es sinnvoll sein, Daten in einer Anweisung mit einem Platzhalter zu verknüpfen. Die Ausführung von Anweisungen auf diese Weise ist nützlich, um Angriffe durch Einschleusung von SQL-Befehlen zu verhindern. Verwenden Sie ggf. die folgende Anweisung:

connection.execute({
  sqlText: 'select c1 from (select 1 as c1 union all select 2 as c1) where c1 = 1;'
});

Das gleiche Ergebnis erzielen Sie mit den folgenden Bindungen:

connection.execute({
  sqlText: 'select c1 from (select :1 as c1 union all select :2 as c1) where c1 = :1;',
  binds: [1, 2]
});

Die ?-Syntax für Bindungen wird ebenfalls unterstützt:

connection.execute({
  sqlText: 'select c1 from (select ? as c1 union all select ? as c1) where c1 = ?;',
  binds: [1, 2, 1]
});

Bemerkung

Es gibt eine Obergrenze für die Datengröße, die Sie binden oder in einem Batch kombinieren können. Weitere Details dazu finden Sie unter Begrenzung der Abfragetextgröße.

Binden eines Array für Masseneinfügen

Das Binden eines Arrays von Daten wird für INSERT-Massenoperationen unterstützt. Übergeben Sie ein Array von Arrays wie folgt:

connection.execute({
  sqlText: 'insert into t(c1, c2, c3) values(?, ?, ?)',
  binds: [[1, 'string1', 2.0], [2, 'string2', 4.0], [3, 'string3', 6.0]]
});

Bemerkung

Das Binden eines großen Arrays wirkt sich auf die Leistung aus und kann abgelehnt werden, wenn die Datenmenge zu groß ist, um vom Server verarbeitet zu werden.

Abbrechen von Anweisungen

Eine Anweisung kann durch Aufruf der Methode statement.cancel() abgebrochen werden:

statement.cancel(function(err, stmt) {
  if (err) {
    console.error('Unable to abort statement due to the following error: ' + err.message);
  } else {
    console.log('Successfully aborted statement');
  }
});

Verwenden von Ergebnissen

Inline-Rückgabe von Ergebnissen

Die gebräuchlichste Art, Ergebnisse zu verwenden, ist die Übergabe eines complete-Callbacks an connection.execute(). Wenn die Ausführung der Anweisung beendet und das Ergebnis zur Verwendung bereit ist, wird der complete-Callback gestartet, und die Ergebniszeilen werden inline zurückgegeben:

connection.execute({
  sqlText: 'select * from sometable',
  complete: function(err, stmt, rows) {
    if (err) {
      console.error('Failed to execute statement due to the following error: ' + err.message);
    } else {
      console.log('Number of rows produced: ' + rows.length);
    }
  }
});

Streamen von Ergebnissen

Es ist auch möglich, ein Ergebnis in Form eines Zeilenstream zu verarbeiten. Dies kann durch Aufruf der statement.streamRows()-Methode erfolgen. Dabei wird ein Readable-Node.js-Stream zurückgegeben, der verwendet werden kann, um Zeilen direkt beim Empfangen weiterzuverarbeiten. Weitere Informationen zum Readable-Stream finden Sie in der Dokumentation zu Node.js.

Beispiel:

var statement = connection.execute({
  sqlText: 'select * from sometable'
});

var stream = statement.streamRows();

stream.on('error', function(err) {
  console.error('Unable to consume all rows');
});

stream.on('data', function(row) {
  // consume result row...
});

stream.on('end', function() {
  console.log('All rows consumed');
});

Stapelverarbeitung von Ergebnissen

Standardmäßig wird mit der statement.streamRows()-Methode ein Stream produziert, der jede Zeile im Ergebnis enthält. Wenn Sie jedoch nur eine Teilmenge des Ergebnisses weiterverwenden möchten oder wenn Ergebniszeilen in Batches verwendet werden sollen, können Sie streamRows() mit start- und end-Argumenten aufrufen. Bei Angabe dieser zusätzlichen Optionen werden nur Zeilen im geforderten Bereich gestreamt:

connection.execute({
  sqlText: 'select * from sometable',
  streamResult: true, // prevent rows from being returned inline in the complete callback
  complete: function(err, stmt, rows) {
    // no rows returned inline because streamResult was set to true
    console.log('rows: ' + rows); // 'rows: undefined'

    // only consume at most the last 5 rows in the result
    rows = [];
    stmt.streamRows({
      start: Math.max(0, stmt.getNumRows() - 5),
      end: stmt.getNumRows() - 1,
    })
    .on('error', function(err) {
      console.error('Unable to consume requested rows');
    })
    .on('data', function(row) {
      rows.push(row);
    })
    .on('end', function() {
      console.log('Number of rows consumed: ' + rows.length);
    });
  }
})

Umwandeln des Datentyps

Wenn Ergebniszeilen erzeugt werden, ordnet der Treiber SQL-Datentypen automatisch den entsprechenden JavaScript-Äquivalenten zu. Beispielsweise werden Werte der Typen TIMESTAMP und DATE als JavaScript Date-Objekte zurückgegeben.

Die vollständige Zuordnung von JavaScript zu SQL-Datentypen finden Sie in der folgenden Tabelle:

SQL-Datentyp

JavaScript-Datentyp

Anmerkungen

VARCHAR, CHAR, CHARACTER, STRING, TEXT

String

INT, INTEGER, BIGINT, SMALLINT

Number

Dies ist die Standardzuordnung. Verwenden Sie den Sitzungsparameter JS_TREAT_INTEGER_AS_BIGINT, um eine Zuordnung zu JavaScript Bigint vorzunehmen.

NUMBER(Genauigkeit, Skalierung), DECIMAL(p, s), NUMERIC(p, s), wobei scale = 0

Number

Dies ist die Standardzuordnung. Verwenden Sie den Sitzungsparameter JS_TREAT_INTEGER_AS_BIGINT, um eine Zuordnung zu JavaScript Bigint vorzunehmen.

NUMBER(Genauigkeit, Skalierung), DECIMAL(p, s), NUMERIC(p, s) wobei scale > 0

Number

FLOAT, FLOAT4, FLOAT8, DOUBLE, DOUBLE PRECISION, REAL

Number

TIMESTAMP, TIMESTAMP_LTZ, TIMESTAMP_NTZ, TIMESTAMP_TZ

Date

TIMESTAMP_NTZ Werte werden in UTC zurückgegeben.

DATE

Date

TIME

String

Beachten Sie, dass der TIME-Datentyp in SQL kein Äquivalent in JavaScript hat, sodass er auf eine JavaScript-Zeichenfolge (String) abgebildet wird.

BOOLEAN

Boolean

VARIANT, ARRAY, OBJECT

JSON

Abrufen von Ganzahl-Datentypen als Bigint

Standardmäßig werden die INTEGER-Spalten von Snowflake (einschließlich BIGINT, NUMBER(p, 0) usw.) in den JavaScript-Datentyp Number konvertiert. Die größten zulässigen Snowflake-Ganzzahlwerte sind jedoch größer als die größten zulässigen JavaScript-Zahlenwerte. Um Snowflake-INTEGER-Spalten in JavaScript Bigint zu konvertieren, in denen größere Werte als JavaScript Number gespeichert werden können, legen Sie den Sitzungsparameter JS_TREAT_INTEGER_AS_BIGINT fest.

Es gibt zwei Möglichkeiten, diesen Parameter festzulegen:

  • Verwenden Sie die ALTER SESSION-Anweisung wie folgt:

    connection.execute( {
                    sqlText: 'ALTER SESSION SET JS_TREAT_INTEGER_AS_BIGINT = TRUE',
                    complete: function ...
                    }
                  );

  • Geben Sie den Parameter in den Verbindungskonfigurationsinformationen an:

    var connection = snowflake.createConnection(
      {
      accessUrl: 'http://xy12345.snowflakecomputing.com',
      username: 'fakeusername',
      password: 'fakepassword',
      account: 'fakeaccount',
      jsTreatIntegerAsBigInt: true
      }
    );

Abrufen von Datentypen als Zeichenfolgen (String)

Wenn connection.execute() aufgerufen wird, kann die Option fetchAsString so eingestellt werden, dass alle Zahlen oder Daten als Zeichenfolge zurückgegeben werden. Dies kann verwendet werden, um zu Folgendes zu erhalten:

  • Formatierte Versionen von Werten des Typs DATE und TIMESTAMP (oder deren Varianten).

  • Zeichenfolgeversionen von numerischen SQL-Typen, die nicht ohne Genauigkeitsverlust in JavaScript-Zahlen umgewandelt werden können.

Beispiel:

connection.execute({
  sqlText: 'select 1.123456789123456789123456789 as "c1"',
  fetchAsString: ['Number'],
  complete: function(err, stmt, rows) {
    if (err) {
      console.error('Failed to execute statement due to the following error: ' + err.message);
    } else {
      console.log('c1: ' + rows[0].c1); // c1: 1.123456789123456789123456789
    }
  }
});

Beenden einer Verbindung

Eine Verbindung kann durch Aufruf der Methode connection.destroy() beendet werden. Dadurch wird die Verbindung zur Sitzung sofort beendet, ohne darauf zu warten, dass die in Ausführung befindlichen Anweisungen abgeschlossen werden:

connection.destroy(function(err, conn) {
  if (err) {
    console.error('Unable to disconnect: ' + err.message);
  } else {
    console.log('Disconnected connection with id: ' + connection.getId());
  }
});