Exécution d’instructions¶

Paramètres d’instruction de liaison¶

Il peut arriver que vous souhaitiez lier des données dans une instruction avec un caractère de remplacement. Exécuter des instructions de cette manière est utile car cela aide à prévenir les attaques par injection de commandes SQL. Considérez l’énoncé suivant :

connection.execute({
  sqlText: 'SELECT c1 FROM (SELECT 1 AS c1 UNION ALL SELECT 2 AS c1) WHERE c1 = 1;'
});

Copy

Vous pouvez obtenir le même résultat en utilisant les liaisons suivantes :

connection.execute({
  sqlText: 'SELECT c1 FROM (SELECT :1 AS c1 UNION ALL SELECT :2 AS c1) WHERE c1 = :1;',
  binds: [1, 2]
});

Copy

La syntaxe ? pour les liaisons est également prise en charge :

connection.execute({
p
  sqlText: 'SELECT c1 FROM (SELECT ? AS c1 UNION ALL SELECT ? AS c1) WHERE c1 = ?;',
  binds: [1, 2, 1]
});

Copy

Exécution d’un lot d’instructions SQL (prise en charge des multi-instructions)¶

Dans les versions 1.6.18 et ultérieures du connecteur Node.js, vous pouvez envoyer un lot d’instructions SQL séparées par des points-virgules à exécuter en une seule requête.

Vous pouvez exécuter plusieurs instructions en tant que lot de la même manière que vous exécutez des requêtes avec des instructions uniques, sauf que la chaîne de requête contient plusieurs instructions séparées par des points-virgules. Notez que les instructions multiples s’exécutent de manière séquentielle, et non en parallèle. Le paramètre MULTI_STATEMENT_COUNT indique le nombre exact d’instructions que le lot contient.

Par exemple, si vous définissez MULTI_STATEMENT_COUNT=3, une instruction par lot doit comprendre exactement trois instructions. Si vous soumettez une instruction par lot avec un autre nombre d’instructions, le pilote Node.js rejette la demande. Vous pouvez définir MULTI_STATEMENT_COUNT=0 pour permettre aux requêtes par lots de contenir n’importe quel nombre d’instructions. Cependant, il faut savoir que l’utilisation de cette valeur réduit la protection contre les attaques par injection de SQL.

Vous pouvez définir ce paramètre au niveau de la session à l’aide de la commande suivante, ou vous pouvez définir la valeur séparément à chaque fois que vous soumettez une requête.

ALTER SESSION SET multi_statement_count = <n>

En définissant la valeur au niveau de la session, vous n’avez pas besoin de la définir à chaque fois que vous exécutez une instruction par lot. L’exemple suivant définit le nombre d’instructions au niveau de la session sur trois, puis exécute trois instructions SQL :

var statement = connection.execute({
    sqlText: "ALTER SESSION SET multi_statement_count=0",
    complete: function (err, stmt, rows) {
      if (err) {
        console.error('1 Failed to execute statement due to the following error: ' + err.message);
      } else {
        testMulti();
      }
    }
  });
function testMulti() {
  console.log('select bind execute.');
  var selectStatement = connection.execute({
    sqlText: "create or replace table test(n int); insert into test values(1), (2); select * from test order by n",
    complete: function (err, stmt, rows) {
      if (err) {
        console.error('1 Failed to execute statement due to the following error: ' + err.message);
      }
      else {
        console.log('==== complete');
        console.log('==== sqlText=' + stmt.getSqlText());
        if(stmt.hasNext())
        {
          stmt.NextResult();
        }
        else {
          // do something else, e.g. close the connection
        }
      }
    }
  });
}

Copy

Vous pouvez également définir le nombre d’instructions dans un lot chaque fois que vous exécutez une requête à plusieurs instructions en définissant MULTI_STATEMENT_COUNT comme paramètre de la fonction connection.execute. L’exemple suivant fixe le nombre d’instructions à trois pour le lot et inclut trois instructions SQL dans la requête de lot :

var selectStatement = connection.execute({
    sqlText: "CREATE OR REPLACE TABLE test(n int); INSERT INTO test values(1), (2); SELECT * FROM test ORDER BY n",
    parameters: { MULTI_STATEMENT_COUNT: 3 },
    complete: function (err, stmt, rows) {
      if (err) {
        console.error('1 Failed to execute statement due to the following error: ' + err.message);
      }
      else {
        console.log('==== complete');
        console.log('==== sqlText=' + stmt.getSqlText());
        if(stmt.hasNext())
        {
          stmt.NextResult();
        }
        else {
          // do something else, e.g. close the connection
        }
      }
    }
  });

Copy

Liaison d’un tableau pour les insertions en masse¶

La liaison d’un tableau de données est prise en charge pour le fonctionnement en masse INSERT. Transmettez un tableau de tableaux comme suit :

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

Copy

Annulation d’instructions¶

Une instruction peut être annulée en utilisant la méthode statement.cancel() :

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');
  }
});

Copy

Nouvelle soumission de requêtes¶

Si vous n’avez pas la certitude que Snowflake a exécuté avec succès une instruction SQL, peut-être en raison d’une erreur de réseau ou d’un dépassement de délai, vous pouvez soumettre à nouveau la même instruction en utilisant son ID de requête. Par exemple, supposons que vous soumettiez une commande INSERT pour ajouter des données, mais que vous n’ayez pas reçu d’accusé de réception en temps voulu, de sorte que vous ne savez pas comme s’est déroulée la commande. Dans ce scénario, vous ne voulez pas simplement exécuter la même commande en tant que nouvelle commande, car cela pourrait entraîner une double exécution de la commande, produisant ainsi une duplication des données.

En incluant l’ID de requête dans l’instruction SQL, vous pouvez éviter le risque de duplication des données. La nouvelle soumission de la requête avec l’ID de requête d’origine garantit que la commande resoumise n’est exécutée que si la requête d’origine a échoué. Pour plus d’informations, reportez-vous à Nouvelle soumission d’une requête d’exécution d’instructions SQL.

Les exemples de code suivants montrent comment vous pouvez enregistrer et utiliser l’ID de requête pour soumettre à nouveau une instruction. Lorsque vous exécutez une instruction, vous pouvez utiliser la fonction getRequestId() pour récupérer les ID de la requête soumise. Vous pouvez ensuite utiliser cet ID pour exécuter la même instruction à un moment ultérieur. L’exemple suivant exécute une instruction INSERT et enregistre son ID de requête dans la variable requestId.

var requestId;
connection.execute({
  sqlText: 'INSERT INTO testTable VALUES (1);',
    complete: function (err, stmt, rows)
    {
      var stream = stmt.streamRows();
      requestId = stmt.getRequestId();   // Retrieves the request ID
      stream.on('data', function (row)
      {
        console.log(row);
      });
      stream.on('end', function (row)
      {
        console.log('done');
      });
    }
});

Copy

Si vous ne recevez pas d’accusé de réception indiquant que la commande a été exécutée avec succès, vous pouvez soumettre à nouveau la requête en utilisant l’ID de requête enregistré comme indiqué ci-dessous.

connection.execute({
  sqlText: 'INSERT INTO testTable VALUES (1);',  // optional
    requestId: requestId,  // Uses the request ID from before
    complete: function (err, stmt, rows)
    {
      var stream = stmt.streamRows();
      stream.on('data', function (row)
      {
        console.log(row);
      });
      stream.on('end', function (row)
      {
        console.log('done');
      });
  }
});

Copy

Si vous choisissez de soumettre à nouveau une requête avec un requestId et un sqlText, tenez compte des interactions suivantes :

• Si le requestId existe déjà, c’est-à-dire qu’il correspond à une requête précédente, la commande ignore la requête sqlText et soumet à nouveau la requête de la commande d’origine.

• Si la requête requestId n’existe pas, c’est-à-dire qu’elle ne correspond pas à une requête précédente, la commande exécute la requête sqlText.