Knex: 1回の実行で複数のクエリを実行するにはどうすればよいですか？

いいえ、2つのステートメントとして実行する必要があります。

まあ、これは少し制限のある解決策です

クエリでtoString()を呼び出して実行することもできますが、実際にはお勧めしません。

knex.raw(knex.raw(query, bindings) + '').exec(function(err, result) {
  assert.isNotError(err);
});

さて、それをどうするかを見ていきます。基本的には、プリペアドステートメントをオフにして、クエリ文字列とバインディングを持つ機能を維持したいのですが、それが可能かどうかはわかりません。これらに関連するドキュメントは見つかりませんでした。

とにかくやってみた

knex.raw(query, bindings) + ''

しかし、それはスローします-オブジェクトオブジェクトにはメソッド 'clone'がありません。

0.6.0ブランチを試してみたい場合は、そこで機能することはわかっています。いくつかのテストを終えたら、リリースする必要があります。

しかし、なぜそのような単一の文字列を使用して2つのクエリステートメントを実行する必要があるのでしょうか。 パッケージを使用する目的を損なうようなものではありませんか？

個人的には、一度に複数のINSERT ... ON DUPLICATE KEY UPDATEを作成する必要があります。 複数の値で挿入を実行できないため、どの行が更新され、どの行が作成されたかを知りたい（影響を受ける行の値を確認する）。

Knexの制限を見つけた後、私はnode.jsのさまざまなクエリビルダーで遊んでいます（これは基本的にほとんどの場合生のクエリを使用する結果になりました）。 結局、私は自分でsqlbuilderをコーディングしました-QSqlDemo 。 完全ではなく、本番環境にも対応していませんが、基本的に私が考えている方法を要約しています。

非常にクールなデモです。次のリリースの後にそのようなものを追加することを計画していました-不思議なことに、0.6ブランチを試してみましたか？

ここにコラボレーションの余地があるのではないかと思います。QSQLはより堅牢なクエリビルダーの必要性を満たすことができ、Knexは接続プールと異なる方言間の疣贅の平滑化を扱います。

とにかく、いい仕事、私は見ていきます！

いいえ、0.6を試しませんでした。ある場所でknexを使用し、別の場所で生のクエリを実行するコードがたくさんあったからです。 いくつかの調査の結果、スタック全体を、保守が可能で、機能を即座に追加できるものに置き換えることにしました。

まあ、確かにコラボレーションの余地はあると思いますが、最初にQSqlを安定させるには少し時間がかかります。 99％のニーズとユースケースに一致する優れたAPIを定義し（一部の構成はまだ少し醜いことがわかります）、他のバックエンドを追加できるように適切な抽象化を実装することを意味します。

クエリの配列を渡す機能があり、結果も配列になりますか？ このような単純なものはかっこいいでしょう、それを行うためにasync.parallelのようなものを使用することができます

@niftylettuce Bluebirdには、すぐに使用できる「async.parallel」機能がすでに付属しています。 しかし、これは問題ではありません。 1回の実行でコマ分離クエリを実行する方法が本当に必要です。

マークするだけでは不可能です

    multipleStatements: true

自分の構成の接続ブロック内：
例えば

    connection: {
        host: 'localhost',
        user: 'superSecret',
        password: 'notGonnaTell',
         port: 8889,
        database: 'babelverse_core',
        multipleStatements: true
    }

さて、ここの誰かが興味を持っているなら-私はこれを可能にするために次のリファクタリングでいくつかの新しいことに取り組んでいます。

これに理想的なAPIは何でしょうか...単一のチェーンが必要ですか？

knex
  .update('records_raw')
  .set({title: x}).where({id: 1})
  .end()
  .update('records_raw')
  .set({title: y}).where({id: 2})
  .spread((resultA, resultB) => {

  })

またはもっと似たようなもの：

knex.multiQuery([
  knex.update('records_raw').set({title: x}).where({id: 1})
  knex.update('records_raw').set({title: y}).where({id: 2})
]).spread((resultA, resultB) => {

})

また、セミコロンで分割することにより、 knex.rawケースを自動的に機能させる可能性を検討しています。

生のクエリでセミコロンを分割することは素晴らしいスタートです。

現在、挿入前に削除が完了しないという問題が発生しているため、重複キーエラーがスローされます。

私は次のようなことをしています

knex("mytable")
.where({
  id: 32423
})
.del()
.then( ->
  knex("mytable")
  .insert()
 ..... 

あなたは要点を理解します。

デルは時間内に完了しません。

@tgriesser私の投票はknex.multiQueryです

@tgriesser単一のクエリで複数のステートメントを実行する機能に関する更新はありますか？ を好む：

.update（ 'records_raw'）
.set（{title：x}）。where（{id：1}）
。終わり（）
.update（ 'records_raw'）
.set（{title：y}）。where（{id：2}）
.then（function（result）{
result [0] //結果1
result [1] //結果2
}）
.catch（function（err）{
console.log（err）;
}）;

+1

セミコロンで適切な分割を行うには、方言固有のパーサーを使用して生のクエリ全体を解析する必要があります。 具体的には、文字列に;が含まれている場合、それらは無視する必要があります。 解析するのが簡単ではない有効なSQLの2つの例を次に示します。

-- generic SQL
SELECT * FROM book WHERE title = 'Lord of the Rings; The Fellowship of the Ring';

-- MySQL specific
CREATE PROCEDURE dorepeat(p1 INT)
  BEGIN
    SET <strong i="9">@x</strong> = 0;
    REPEAT SET <strong i="10">@x</strong> = <strong i="11">@x</strong> + 1; UNTIL <strong i="12">@x</strong> > p1 END REPEAT;
  END

また、最初のケースでは2つのステートメントが作成されるため、コードは分割の空の結果を考慮する必要があることに注意してください。

正直なところ、全体として、これは悪い考えだと思います。 SQLインジェクションが発生し、クエリが正しく分割されない可能性が非常に高くなります。

また、複数のステートメントを実行する場合、ほとんどの場合、同じトランザクションでそれを実行する必要があります。 Knexは、 .transacting(function(transaction) { /* code */ })構文を使用して、この問題をすでに非常にうまく解決しています。 トランザクションが不要なまれなケースでは、bluebirdを使用してknexステートメントを結合し、結果を取得できます。

したがって、これらの問題のために、これは起こらないはずだと私の意見です。

：-1：

また、複数のステートメントを実行する場合、ほとんどの場合、同じトランザクションでそれを実行する必要があります。 Knexは、 .transacting(function(transaction) { /* code */ })構文を使用して、この問題をすでに非常にうまく解決しています。 トランザクションが不要なまれなケースでは、bluebirdを使用してknexステートメントを結合し、結果を取得できます。

経験から、特定のケースでは、これら2つのアプローチと、1つのコマンドとしてサーバーに複数の値をバッチ処理することの間に_巨大な_パフォーマンスの違いがあることがわかります。

クリーンに実装するのは非常に難しいことを理解しています。そのため、まだ実装されていませんが、この問題により、プロジェクトでのknexの使用が大幅に制限されています。

私も同様の問題を抱えていて、それを解決することができました。 こちらをご覧ください。 https://github.com/tgriesser/knex/issues/1075

この機能のユースケースが見当たりません。 修正されないので、このチケットを閉じたいと思います。 同じ接続で実行されているクエリの順序に依存している場合は、トランザクションを使用することをお勧めします。

この「複数のクエリ」の使用法を私たちが望んでいるものにしたことの1つは、場合によってはパフォーマンスが向上する可能性があるということです。 サーバーとの間ですべてのクエリと結果を通信するために必要なラウンドトリップが少なくて済みます。

しかし、測定可能なユースケースが利用できるわけではありません。 過去の経験/記憶からのみ話す...

@ jurko-gospodnetic接続プールがない場合があります。 プールを使用すると、複数のクエリを送信することは、基本的に、作成済みのTCPソケットにデータを配置するだけです。 また、パフォーマンスがTCPバッファーが十分に満たされていないことに依存している場合は、knexはすでに遅すぎます:)その場合は、ドライバーを直接使用することをお勧めします。

@ jurko-gospodneticが5月20日にコメントしました

この「複数のクエリ」の使用法を私たちが望んでいるものにしたことの1つは、場合によってはパフォーマンスが向上する可能性があるということです。 サーバーとの間ですべてのクエリと結果を通信するために必要なラウンドトリップが少なくて済みます。

この特定の理由から、エンタープライズグレードのプロジェクトでnode-mysql（mysqljs）を使用してい

node-mysql（mysqljs）ドライバーの複数ステートメントのクエリ機能を利用することで、このような操作のパフォーマンスが大幅に向上します。

Knexがこれをサポートしていない場合、それは私にとってショートッパーになるかもしれません。 だから私はこのスレッドを復活させてそれだけを尋ねます。

Knex.jsでは、1つのステートメントでの複数のクエリがサポートされるようになりましたか？

@nicholaswminは、「大幅なパフォーマンスの向上」とはどういう意味ですか？ この方法で複数のクエリを送信する方が、同じ接続を介して複数のクエリを送信するよりもはるかに効率的ですか？ ベンチマークはありますか？

@elhiguベンチマークはありませんが、すぐに私はこれを言うことができます：

DBへの1回の呼び出し（すべてのステートメントが含まれている）により、server-dbネットワークのラウンドトリップが排除されます。

一方、同じ接続を介して複数のクエリを送信することは特効薬ではありません。 このソリューションは、非トランザクションフローでのみ機能します。この問題を参照してください

@nicholaswmin大量の小さなクエリを送信していて、ほとんど無視されているか、小さな結果ですか？ その場合、ドライバーが各TCPパケットに複数のクエリをパックできるため、違いが目立つ可能性があると思います。そうしないと、各TCPパケットのほとんどがヘッダーになり、ペイロードが非常に少なくなります。

このようなパフォーマンスの違いは、ネットワークトラフィックの量からでも簡単に測定できるはずです。

ドライバーが、前の呼び出しの結果を最初に待たずに、別々のconnection.query呼び出しからDBへの複数のクエリの送信をサポートしているかどうかはわかりません。 もしそうなら、複数のconnection.query送信するか、mysqlドライバーでサポートされている単一のマルチクエリを送信するかでTCPトラフィックに大きな違いはないはずです。

@elhiguこれらは確かに小さなクエリですが、トランザクション/クエリチェーンのさらに下流で使用できるように結果が必要です。

デバッグまたは同様のオプションを介して送信されているTCPパケットを確認する方法はありますか？ 送信されるクエリ自体ではなく、実際のパケット。

ユースケース：

システム内のユーザーのデータを更新するときに、そのユーザーの監査証跡（何が変更されたか）を計算したいと思います。

// # PSEUDOCODE

// get current data of user
getUserData();
// set data of user
setUserData()
// get new data of user
getUserData()
// compute the audit trail by comparing the difference between before-set/after-set datums
computeAuditTrail(previousData, newData);

上記の各呼び出しは複数のDB呼び出しを行うため、ご想像のとおり、これらは多くのネットワークラウンドトリップです。

＃1806で述べたように、シーケンシャルである必要のないクエリにPromise.all()を使用することで、これを回避できます（ほとんどの場合、 getData/setDataのDB呼び出しはシーケンシャルである必要はありません）。

クエリはプールからのさまざまな接続で送信できるため、これは非トランザクションフローで機能します。 トランザクションを使用して上記のフローを実行するとすぐに、クエリが単一の接続で送信されるため、速度が低下します（約4倍）。

補足として、私はMSSQLを使用しています。

Wiresharkは、ネットワークトラフィックの分析に使用される非常に一般的なクロスプラットフォームツールです。

ノードでそのレベルを確認する方法はないと思います。

1つの方法は、iptrafなどを使用して、1つのクエリにパックされた、またはドライバーに個別に渡された同じ量のクエリを送信するときに、送受信されたデータの量を測定することです。

multiQuery構文を見たいです。

すべてのアップデート ？
multiQueryを作成することは可能ですか？
もしそうなら、どの構文を使用しますか？

var knex = require("knex");
var _ = require("lodash");
var Promise = require("bluebird");

var knex = require('knex')({
    client: 'sqlite3',
    connection: {
        filename: "./data.sqlite"
    }
});

// Create Schema
let createScript = `

CREATE TABLE Class ( 
    Id                   integer NOT NULL  ,
    Name                 varchar(100)   ,
    CONSTRAINT Pk_Classes_Id PRIMARY KEY ( Id )
 );

CREATE TABLE Material ( 
    Id                   integer NOT NULL  ,
    Description          varchar(500)   ,
    CONSTRAINT Pk_Material_Id PRIMARY KEY ( Id )
 )

-- ... and so on (leave off the last semi or remove it later) ... 

`;

let statementPromises = _.map(createScript.split(';'), (statement) => {
    return knex.raw(statement);
});

Promise.all(statementPromises).then(function() {
    console.log('Schema generated. Populating...');

     // ...

これは単なるループであり、複数のリクエストを1つにまとめたものではなく、低速です。

@mscheffer質問は：

';'で区切られた複数のクエリを実行したいという問題に直面しています。 一人の幹部によって、それは可能ですか？

私の答えはどれを解決しますか。 あなたがより速くより良い解決策を持っているならば、それを提供してください。

@VictorioBerra ;からの分割は、文字列リテラルとコメント内に;が存在する可能性があるため、通常は機能しません。 データダンプを読み込んでいる場合、SQLダンプコードをsqliteシェルにパイプするのが簡単な方法だと思います。 残念ながら、インメモリデータベースは単一の接続であるため、これは機能しません。

また、テンプレート文字列内でSQL文字列を作成し、それを分割する場合も、 knex.schema.*ビルダーを使用すると、実質的に同じことができますが、より安全になります。

私の知る限り、すべての方言ドライバーに対して1つのコマンドで複数のクエリを実行するというこの機能を実現する方法はありません。 そのサポートがあったのはmysqlとoracledbまたはmssqlだったと思いますが、mysqlを使用すると、最後のクエリの結果だけが応答として返されます（ただし、問題ない可能性があります）。

複数のクエリを使用してデータを変更する場合は、トランザクションを使用して、それらが連続して実行されることを確認できるようにしてください。

RAWSQLを使用した複数のクエリ実行
私は、knex移行の1つがCREATE DATABASE連続して複数回実行する必要がある同様の状況に遭遇しました。 クエリをセミコロンで区切ることを望みましたが、knexは構文エラーをスローしました。 その解決策は、接続オブジェクトに"multipleStatements": trueを含めることです。そのため、その最終結果は次のようになります。

"host": "192.168.x.x",
"user": "userLogin",
"password": "userPassword",
"database": "schemaToUse",
"multipleStatements": true

その後、次のような生のステートメントを使用できます。

return knex.raw("CREATE DATABASE schema0; CREATE DATABASE schema1; CREATE DATABASE schema2")
   .then((result) => {
   })
   .catch((error) => {
   });

KNEXクエリビルダーを使用した複数のクエリ実行
生のSQLを自分で作成する代わりに、knexクエリビルダーを使用する必要がある場合は、 Knex.QueryBuilderの結果を文字列に変換してから、複数のクエリを結合する必要があります。 これが1つの例です：

// Suppose that we wanted to add 100 currency for all players in multiple games
const addCurrency = 100;
const updateCurrency = { currency: "currency + " + addCurrency };
const queries = [
   knex.table("game0.stats").update(updateCurrency),
   knex.table("game1.stats").update(updateCurrency),
   knex.table("game2.stats").update(updateCurrency),
];
const multiQuery = queries.join(";");
console.log(multiQuery);
return knex.raw(multiQuery)
   .then((result) => {
   })
   .catch((error) => {
   });

これは、連続して実行する必要のある冗長なクエリを作成する際の人的エラーを減らすのにも役立ちます。 繰り返しますが、このようなものでは、トランザクションでラップすることをお勧めします。

これはほとんどdbドライバーによって制限されているので、これを閉じることができると思います。 少なくとも適切な機能要求が必要です。

@AksharaKarikalan複数のサブクエリを実行し、それらの間で減算を行ったとしても、クエリは1つだけです。 そこで、この問題に関係のないコメントを削除しました。 Stackoverflowは、knexの使用リクエストに適した場所です。