PreparedStatement IN句の代替？

のINインスタンスでSQL 句を使用するための最良の回避策は何ですか？これは、java.sql.PreparedStatementSQLインジェクション攻撃のセキュリティ問題のため、複数の値に対してサポートされていません。1つの?プレースホルダーは、値のリストではなく1つの値を表します。

次のSQLステートメントについて考えてみます。

SELECT my_column FROM my_table where search_column IN (?)

使用することpreparedStatement.setString( 1, "'A', 'B', 'C'" );は?、そもそも使用する理由の回避策での、実際には機能しない試みです。

どのような回避策がありますか？

利用可能なさまざまなオプションの分析、およびそれぞれの長所と短所はこちらから入手できます。

推奨されるオプションは次のとおりです。

• 準備しSELECT my_column FROM my_table WHERE search_column = ?、各値に対して実行し、結果をクライアント側でUNIONします。準備されたステートメントが1つだけ必要です。ゆっくりと痛みを伴う。
• 準備SELECT my_column FROM my_table WHERE search_column IN (?,?,?)して実行します。リストのサイズごとに1つの準備済みステートメントが必要です。速くて明白です。
• 準備SELECT my_column FROM my_table WHERE search_column = ? ; SELECT my_column FROM my_table WHERE search_column = ? ; ...して実行します。[またはUNION ALLそれらのセミコロンの代わりに使用します。--ed] size-of-IN-listごとに1つの準備済みステートメントが必要です。愚かなほど遅く、厳密にはよりも悪いWHERE search_column IN (?,?,?)ので、ブロガーがなぜそれを提案したのかさえわかりません。
• ストアドプロシージャを使用して結果セットを作成します。
• N個の異なるサイズリストのクエリを準備します。たとえば、2、10、50の値があるとします。6つの異なる値を持つINリストを検索するには、のようにサイズ10クエリを入力しますSELECT my_column FROM my_table WHERE search_column IN (1,2,3,4,5,6,6,6,6,6)。適切なサーバーは、クエリを実行する前に重複する値を最適化します。

ただし、これらのオプションはどれも優れたものではありません。

これらの場所では、同様に正気な代替案で重複する質問に答えていますが、それでも非常に優れた質問はありません。

• IN句のパラメーターのリストを持つPreparedStatement
• 準備済みステートメントのパラメーターのリストを設定する方法は？

正しい答えは、JDBC4とをサポートするサーバーx = ANY(y)を使用PreparedStatement.setArrayしている場合は、次の説明に従って使用することです。

• PreparedStatement IN句の代替？

setArrayただし、INリストを使用する方法はないようです。

時々、SQLステートメントは実行時にロードされます（たとえば、プロパティファイルから）が、可変数のパラメーターを必要とします。このような場合は、最初にクエリを定義します。

query=SELECT * FROM table t WHERE t.column IN (?)

次に、クエリを読み込みます。次に、実行する前にパラメーターの数を決定します。パラメータ数がわかったら、次を実行します。

sql = any( sql, count );

例えば：

/**
 * Converts a SQL statement containing exactly one IN clause to an IN clause
 * using multiple comma-delimited parameters.
 *
 * @param sql The SQL statement string with one IN clause.
 * @param params The number of parameters the SQL statement requires.
 * @return The SQL statement with (?) replaced with multiple parameter
 * placeholders.
 */
public static String any(String sql, final int params) {
    // Create a comma-delimited list based on the number of parameters.
    final StringBuilder sb = new StringBuilder(
            new String(new char[params]).replace("\0", "?,")
    );

    // Remove trailing comma.
    sb.setLength(Math.max(sb.length() - 1, 0));

    // For more than 1 parameter, replace the single parameter with
    // multiple parameter placeholders.
    if (sb.length() > 1) {
        sql = sql.replace("(?)", "(" + sb + ")");
    }

    // Return the modified comma-delimited list of parameters.
    return sql;
}

JDBC 4仕様を介した配列の受け渡しがサポートされていない特定のデータベースでは、このメソッドを使用すると、スロー= ?を高速なIN (?)句の条件に変換しやすくなり、anyメソッドを呼び出すことで拡張できます。

PostgreSQLのソリューション：

final PreparedStatement statement = connection.prepareStatement(
        "SELECT my_column FROM my_table where search_column = ANY (?)"
);
final String[] values = getValues();
statement.setArray(1, connection.createArrayOf("text", values));
final ResultSet rs = statement.executeQuery();
try {
    while(rs.next()) {
        // do some...
    }
} finally {
    rs.close();
}

または

final PreparedStatement statement = connection.prepareStatement(
        "SELECT my_column FROM my_table " + 
        "where search_column IN (SELECT * FROM unnest(?))"
);
final String[] values = getValues();
statement.setArray(1, connection.createArrayOf("text", values));
final ResultSet rs = statement.executeQuery();
try {
    while(rs.next()) {
        // do some...
    }
} finally {
    rs.close();
}

簡単な方法はありません。ターゲットがステートメントキャッシュ率を高く保つことである場合（つまり、すべてのパラメーターカウントごとにステートメントを作成しないこと）、次の操作を実行できます。

1. いくつかの（例：10）パラメータを使用してステートメントを作成します。

   ... WHERE A IN（？、？、？、？、？、？、？、？、？、？）...

2. すべての実際のパラメーターをバインドする

   setString（1、 "foo"）; setString（2、 "bar"）;

3. 残りをNULLとしてバインドする

   setNull（3、Types.VARCHAR）... setNull（10、Types.VARCHAR）

NULLは何にも一致しないため、SQLプランビルダーによって最適化されます。

リストをDAO関数に渡すと、ロジックを簡単に自動化できます。

while( i < param.size() ) {
  ps.setString(i+1,param.get(i));
  i++;
}

while( i < MAX_PARAMS ) {
  ps.setNull(i+1,Types.VARCHAR);
  i++;
}

不快な回避策ですが、ネストされたクエリを使用することは確かに可能です。列を含む一時テーブルMYVALUESを作成します。MYVALUESテーブルに値のリストを挿入します。次に実行します

select my_column from my_table where search_column in ( SELECT value FROM MYVALUES )

醜いが、値のリストが非常に大きい場合に実行可能な代替手段。

この手法には、データベースが準備されたステートメントをキャッシュしない場合、オプティマイザーからのクエリプラン（ページで複数の値をチェックする、テーブルスキャンを値ごとに1回だけにするなど）が潜在的に改善されるという追加の利点があります。「INSERTS」はバッチで実行する必要があり、MYVALUESテーブルを微調整して、ロックやその他のオーバーヘッドの高い保護を最小限に抑える必要がある場合があります。

in（）演算子の制限はすべての悪の根です。

これは些細な場合にも機能し、「準備済みステートメントの自動生成」で拡張できますが、常に制限があります。

• 可変数のパラメーターを持つステートメントを作成している場合、呼び出しごとにSQL解析オーバーヘッドが発生します
• 多くのプラットフォームでは、in（）演算子のパラメーターの数が制限されています
• すべてのプラットフォームで、SQLテキストの合計サイズが制限されているため、inパラメータの2000プレースホルダを送信できません。
• JDBCドライバーに制限があるため、1000から10kのバインド変数を送信することはできません。

in（）のアプローチは、場合によっては十分ですが、ロケットの証拠にはなりません:)

ロケットに対応するソリューションは、任意の数のパラメーターを個別の呼び出しで渡し（たとえば、パラメーターのCLOBを渡すことにより）、次にSQLでそれらを表すビュー（または他の方法）を使用して、whereで使用することです。基準。

ブルートフォースのバリアントはこちらhttp://tkyte.blogspot.hu/2006/06/varying-in-lists.html

ただし、PL / SQLを使用できる場合は、この混乱はかなりうまくいきます。

function getCustomers(in_customerIdList clob) return sys_refcursor is 
begin
    aux_in_list.parse(in_customerIdList);
    open res for
        select * 
        from   customer c,
               in_list v
        where  c.customer_id=v.token;
    return res;
end;

次に、パラメーターで任意の数のコンマ区切りの顧客IDを渡すことができます。

• selectのSQLは安定しているため、解析遅延は発生しません
• パイプライン化された関数の複雑さはありません-クエリは1つだけです
• SQLはIN演算子の代わりに単純な結合を使用しており、非常に高速です。
• すべての後に、それはの親指の良いルールではない、それは、Oracle、MySQLや類似したシンプルなデータベースエンジンよりも多くの申し出の光年であることから、任意のプレーンを選択またはDMLを使用してデータベースを打ちます。PL / SQLを使用すると、ストレージモデルをアプリケーションドメインモデルから効果的に隠すことができます。

ここでの秘訣は次のとおりです。

• 長い文字列を受け入れ、dbセッションがアクセスできる場所に格納する呼び出しが必要です（たとえば、単純なパッケージ変数、またはdbms_session.set_context）。
• 次に、これを行に解析できるビューが必要です
• 次に、クエリを実行しているIDを含むビューがあるので、必要なのは、クエリされたテーブルへの単純な結合だけです。

ビューは次のようになります。

create or replace view in_list
as
select
    trim( substr (txt,
          instr (txt, ',', 1, level  ) + 1,
          instr (txt, ',', 1, level+1)
             - instr (txt, ',', 1, level) -1 ) ) as token
    from (select ','||aux_in_list.getpayload||',' txt from dual)
connect by level <= length(aux_in_list.getpayload)-length(replace(aux_in_list.getpayload,',',''))+1

ここで、aux_in_list.getpayloadは元の入力文字列を参照します。

可能なアプローチはpl / sql配列を渡すことです（Oracleのみでサポートされています）。ただし、それらを純粋なSQLで使用することはできないため、変換ステップが常に必要です。SQLで変換を行うことはできないため、結局のところ、すべてのパラメーターを含むCLOBを文字列で渡し、ビューで変換することが最も効率的なソリューションです。

これが私が自分のアプリケーションでそれを解決した方法です。理想的には、文字列に+を使用する代わりに、StringBuilderを使用する必要があります。

    String inParenthesis = "(?";
    for(int i = 1;i < myList.size();i++) {
      inParenthesis += ", ?";
    }
    inParenthesis += ")";

    try(PreparedStatement statement = SQLite.connection.prepareStatement(
        String.format("UPDATE table SET value='WINNER' WHERE startTime=? AND name=? AND traderIdx=? AND someValue IN %s", inParenthesis))) {
      int x = 1;
      statement.setLong(x++, race.startTime);
      statement.setString(x++, race.name);
      statement.setInt(x++, traderIdx);

      for(String str : race.betFair.winners) {
        statement.setString(x++, str);
      }

      int effected = statement.executeUpdate();
    }

具体的な数値の代わりに上記のxのような変数を使用すると、後でクエリを変更する場合に非常に役立ちます。

私は試したことはありませんが、.setArray（）はあなたが探していることをしますか？

更新：明らかにそうではありません。setArrayは、前のクエリから取得したARRAY列、またはARRAY列を持つサブクエリからのjava.sql.Arrayでのみ機能するようです。

私の回避策は：

create or replace type split_tbl as table of varchar(32767);
/

create or replace function split
(
  p_list varchar2,
  p_del varchar2 := ','
) return split_tbl pipelined
is
  l_idx    pls_integer;
  l_list    varchar2(32767) := p_list;
  l_value    varchar2(32767);
begin
  loop
    l_idx := instr(l_list,p_del);
    if l_idx > 0 then
      pipe row(substr(l_list,1,l_idx-1));
      l_list := substr(l_list,l_idx+length(p_del));
    else
      pipe row(l_list);
      exit;
    end if;
  end loop;
  return;
end split;
/

これで、1つの変数を使用して、テーブル内のいくつかの値を取得できます。

select * from table(split('one,two,three'))
  one
  two
  three

select * from TABLE1 where COL1 in (select * from table(split('value1,value2')))
  value1 AAA
  value2 BBB

したがって、準備されたステートメントは次のようになります。

  "select * from TABLE where COL in (select * from table(split(?)))"

よろしく、

ハビエルアイバニーズ

（基本的な文字列操作を使用して）でクエリ文字列を生成PreparedStatementして、?し、リスト内のアイテム数と一致する数の。

もちろん、あなたがあなたがそれをしているならOR、あなたはクエリでチェインされた巨大なコードを生成することからほんの一歩です?が、クエリ文字列に正しい数がなければ、これを回避する方法が他にあるかわかりません。

このjavadocに記載されているように、setArrayメソッドを使用できます。

PreparedStatement statement = connection.prepareStatement("Select * from emp where field in (?)");
Array array = statement.getConnection().createArrayOf("VARCHAR", new Object[]{"E1", "E2","E3"});
statement.setArray(1, array);
ResultSet rs = statement.executeQuery();

を使用Collections.nCopiesして、プレースホルダのコレクションを生成し、次を使用してそれらを結合できますString.join。

List<String> params = getParams();
String placeHolders = String.join(",", Collections.nCopies(params.size(), "?"));
String sql = "select * from your_table where some_column in (" + placeHolders + ")";
try (   Connection connection = getConnection();
        PreparedStatement ps = connection.prepareStatement(sql)) {
    int i = 1;
    for (String param : params) {
        ps.setString(i++, param);
    }
    /*
     * Execute query/do stuff
     */
}

以下に、Javaでの準備済みステートメントを作成するための完全なソリューションを示します。

/*usage:

Util u = new Util(500); //500 items per bracket. 
String sqlBefore  = "select * from myTable where (";
List<Integer> values = new ArrayList<Integer>(Arrays.asList(1,2,4,5)); 
string sqlAfter = ") and foo = 'bar'"; 

PreparedStatement ps = u.prepareStatements(sqlBefore, values, sqlAfter, connection, "someId");
*/



import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class Util {

    private int numValuesInClause;

    public Util(int numValuesInClause) {
        super();
        this.numValuesInClause = numValuesInClause;
    }

    public int getNumValuesInClause() {
        return numValuesInClause;
    }

    public void setNumValuesInClause(int numValuesInClause) {
        this.numValuesInClause = numValuesInClause;
    }

    /** Split a given list into a list of lists for the given size of numValuesInClause*/
    public List<List<Integer>> splitList(
            List<Integer> values) {


        List<List<Integer>> newList = new ArrayList<List<Integer>>(); 
        while (values.size() > numValuesInClause) {
            List<Integer> sublist = values.subList(0,numValuesInClause);
            List<Integer> values2 = values.subList(numValuesInClause, values.size());   
            values = values2; 

            newList.add( sublist);
        }
        newList.add(values);

        return newList;
    }

    /**
     * Generates a series of split out in clause statements. 
     * @param sqlBefore ""select * from dual where ("
     * @param values [1,2,3,4,5,6,7,8,9,10]
     * @param "sqlAfter ) and id = 5"
     * @return "select * from dual where (id in (1,2,3) or id in (4,5,6) or id in (7,8,9) or id in (10)"
     */
    public String genInClauseSql(String sqlBefore, List<Integer> values,
            String sqlAfter, String identifier) 
    {
        List<List<Integer>> newLists = splitList(values);
        String stmt = sqlBefore;

        /* now generate the in clause for each list */
        int j = 0; /* keep track of list:newLists index */
        for (List<Integer> list : newLists) {
            stmt = stmt + identifier +" in (";
            StringBuilder innerBuilder = new StringBuilder();

            for (int i = 0; i < list.size(); i++) {
                innerBuilder.append("?,");
            }



            String inClause = innerBuilder.deleteCharAt(
                    innerBuilder.length() - 1).toString();

            stmt = stmt + inClause;
            stmt = stmt + ")";


            if (++j < newLists.size()) {
                stmt = stmt + " OR ";
            }

        }

        stmt = stmt + sqlAfter;
        return stmt;
    }

    /**
     * Method to convert your SQL and a list of ID into a safe prepared
     * statements
     * 
     * @throws SQLException
     */
    public PreparedStatement prepareStatements(String sqlBefore,
            ArrayList<Integer> values, String sqlAfter, Connection c, String identifier)
            throws SQLException {

        /* First split our potentially big list into lots of lists */
        String stmt = genInClauseSql(sqlBefore, values, sqlAfter, identifier);
        PreparedStatement ps = c.prepareStatement(stmt);

        int i = 1;
        for (int val : values)
        {

            ps.setInt(i++, val);

        }
        return ps;

    }

}

Springでは、java.util.ListsをNamedParameterJdbcTemplateに渡すことができます。にます。これにより、引数の数に応じて（？、？、？、...、？）の生成が自動化されます。

Oracleの場合、このブログ投稿ではoracle.sql.ARRAYの使用について説明しています（Connection.createArrayOfはOracleでは機能しません）。このためには、SQLステートメントを変更する必要があります。

SELECT my_column FROM my_table where search_column IN (select COLUMN_VALUE from table(?))

Oracleテーブル関数は、の値を使用できるようにテーブルに渡された配列を変換INステートメント。

instr関数を使用してみますか？

select my_column from my_table where  instr(?, ','||search_column||',') > 0

その後

ps.setString(1, ",A,B,C,"); 

確かに、これはちょっと汚いハックですが、SQLインジェクションの機会を減らします。とにかくオラクルで動作します。

Sormulaは、java.util.Collectionオブジェクトをパラメーターとして指定できるようにすることで、SQL IN演算子をサポートしています。それは？各要素のコレクション。例4を参照してください（例の SQLは、何が作成されるかを明確にするためのコメントですが、Sormulaでは使用されていません）。

使用する代わりに

SELECT my_column FROM my_table where search_column IN (?)

次のようにSQLステートメントを使用する

select id, name from users where id in (?, ?, ?)

そして

preparedStatement.setString( 1, 'A');
preparedStatement.setString( 2,'B');
preparedStatement.setString( 3, 'C');

または、ストアドプロシージャを使用します。これは、SQLステートメントがデータベースサーバーにコンパイルおよび保存されるため、最良のソリューションです。

準備されたステートメントに関連するいくつかの制限に遭遇しました：

1. 準備されたステートメントは同じセッション（Postgres）内でのみキャッシュされるため、実際には接続プールでのみ機能します
2. @BalusCによって提案されたさまざまな準備されたステートメントの多くにより、キャッシュがいっぱいになり、以前にキャッシュされたステートメントが削除されます。
3. クエリは最適化され、インデックスを使用する必要があります。当たり前のように聞こえますが、たとえば、@ Borisが提案したANY（ARRAY ...）ステートメントは、トップの回答の1つでインデックスを使用できず、キャッシュにもかかわらずクエリが遅くなります
4. 準備されたステートメントはクエリプランもキャッシュし、ステートメントで指定されたパラメーターの実際の値は使用できません。

提案されたソリューションの中から、クエリのパフォーマンスを低下させず、クエリの数を少なくするソリューションを選択します。これは、@ Donリンクからの＃4（いくつかのクエリのバッチ処理）または不要な '？'にNULL値を指定することになります。@Vladimir Dyuzhevによって提案されたマーク

私はこれのためにPostgreSQL固有のオプションを考え出しました。これは少しハックであり、独自の長所と短所と制限がありますが、機能するようで、特定の開発言語、プラットフォーム、またはPGドライバーに限定されません。

もちろん、秘訣は、任意の長さの値のコレクションを単一のパラメーターとして渡し、dbにそれを複数の値として認識させる方法を見つけることです。私が取り組んでいる解決策は、コレクション内の値から区切られた文字列を作成し、その文字列を単一のパラメーターとして渡し、PostgreSQLに必要なキャストでstring_to_array（）を使用して適切に使用することです。

したがって、「foo」、「blah」、「abc」を検索する場合は、「foo、blah、abc」のように、それらを1つの文字列に連結することができます。これが単純なSQLです。

select column from table
where search_column = any (string_to_array('foo,blah,abc', ',')::text[]);

明示的なキャストを、結果の値の配列にしたいもの（int、text、uuidなど）に明らかに変更します。また、関数は単一の文字列値（または、区切り文字をカスタマイズする場合は2つ）を取るので同様に）、それを準備されたステートメントのパラメーターとして渡すことができます：

select column from table
where search_column = any (string_to_array($1, ',')::text[]);

これは、LIKE比較のようなものをサポートするのに十分なほど柔軟です。

select column from table
where search_column like any (string_to_array('foo%,blah%,abc%', ',')::text[]);

繰り返しますが、これはハックですが、機能し、*コンパイル済み*のプリコンパイル済みステートメントを引き続き使用できます。個別のパラメーターを、付随するセキュリティと（おそらく）パフォーマンス上の利点があります。それは賢明で、実際にパフォーマンスがありますか？当然ですが、クエリが実行される前に文字列の解析とキャストが行われる可能性があるためです。3、5、数十の値を送信することを期待している場合、確かにそれはおそらく問題ありません。数千？ええ、多分それほどではないでしょう。YMMV、制限および除外が適用され、明示または黙示の保証はありません。

しかし、それは機能します。

完全を期すために：値のセットが大きすぎない限り、次のようなステートメントを単純に文字列構成することもできます。

... WHERE tab.col = ? OR tab.col = ? OR tab.col = ?

これをprepare（）に渡し、ループでsetXXX（）を使用してすべての値を設定できます。これは不自然に見えますが、多くの「大きな」商用システムは、Oracleのステートメントに対して32 KB（そうだと思います）などのDB固有の制限に達するまで、この種のことを日常的に行っています。

もちろん、セットが不当に大きくならないようにする必要があります。そうでない場合は、エラートラップを実行する必要があります。

アダムのアイデアに従う。準備されたステートメントをmy_tableからselect my_columnのようなものにします（＃）のsearch_columnを作成します文字列xを作成し、それに「？、？、？」の数を入力します 値のリストに応じて、新しいString x a Populateのクエリの＃を変更するだけです

リスト内の項目の数と一致する？の数が含まれるように、PreparedStatementでクエリ文字列を生成します。次に例を示します。

public void myQuery(List<String> items, int other) {
  ...
  String q4in = generateQsForIn(items.size());
  String sql = "select * from stuff where foo in ( " + q4in + " ) and bar = ?";
  PreparedStatement ps = connection.prepareStatement(sql);
  int i = 1;
  for (String item : items) {
    ps.setString(i++, item);
  }
  ps.setInt(i++, other);
  ResultSet rs = ps.executeQuery();
  ...
}

private String generateQsForIn(int numQs) {
    String items = "";
    for (int i = 0; i < numQs; i++) {
        if (i != 0) items += ", ";
        items += "?";
    }
    return items;
}

PreparedStatementのIN句に使用できる別の方法があります。

1. 単一クエリの使用-パフォーマンスが最も低く、リソースを大量に消費します
2. StoredProcedureの使用-最速ですがデータベース固有
3. PreparedStatementの動的クエリの作成-良好なパフォーマンスが得られますが、キャッシュのメリットは得られず、PreparedStatementは毎回再コンパイルされます。

4. PreparedStatementクエリでのNULLの使用-最適なパフォーマンス。IN句の引数の制限がわかっている場合に最適です。制限がない場合は、クエリをバッチで実行できます。サンプルコードスニペットは次のとおりです。

       int i = 1;
       for(; i <=ids.length; i++){
           ps.setInt(i, ids[i-1]);
       }
   
       //set null for remaining ones
       for(; i<=PARAM_SIZE;i++){
           ps.setNull(i, java.sql.Types.INTEGER);
       }

これらの代替アプローチの詳細については、こちらで確認できます。

状況によっては、正規表現が役立つ場合があります。Oracleで確認した例は次のとおりです。

select * from my_table where REGEXP_LIKE (search_column, 'value1|value2')

しかし、それにはいくつかの欠点があります。

1. 適用した列は、少なくとも暗黙的にvarchar / charに変換する必要があります。
2. 特殊文字には注意が必要です。
3. パフォーマンスが低下する可能性があります。私の場合、INバージョンはインデックスと範囲スキャンを使用し、REGEXPバージョンはフルスキャンを実行します。

さまざまなフォーラムでさまざまな解決策を検討しても良い解決策が見つからなかった後、私が思いついた以下のハックは、追跡およびコーディングが最も簡単だと感じています。

例： 'IN'句で渡す複数のパラメーターがあるとします。「IN」句の中にダミーの文字列を挿入するだけです。たとえば、「PARAM」は、このダミーの文字列の代わりに来るパラメータのリストを示します。

    select * from TABLE_A where ATTR IN (PARAM);

Javaコードでは、すべてのパラメーターを1つのString変数に収集できます。これは次のように実行できます。

    String param1 = "X";
    String param2 = "Y";
    String param1 = param1.append(",").append(param2);

この場合は、すべてのパラメーターをコンマで区切って単一のストリング変数「param1」に追加できます。

すべてのパラメータを1つの文字列に収集した後、クエリ内のダミーテキスト（この場合は「PARAM」）をパラメータ文字列、つまりparam1に置き換えるだけです。これはあなたがする必要があることです：

    String query = query.replaceFirst("PARAM",param1); where we have the value of query as 

    query = "select * from TABLE_A where ATTR IN (PARAM)";

これで、executeQuery（）メソッドを使用してクエリを実行できます。クエリのどこにも「PARAM」という単語が含まれていないことを確認してください。「PARAM」という単語の代わりに特殊文字とアルファベットの組み合わせを使用して、そのような単語がクエリに含まれる可能性がないことを確認できます。あなたが解決策を得たことを願っています。

注：これは準備済みのクエリではありませんが、コードで実行したい作業を実行します。

完全を期すために、そして他の誰かがそれを提案するのを見なかったので

上記の複雑な提案を実装する前に、SQLインジェクションが実際にシナリオの問題であるかどうかを検討してください。

多くの場合、IN（...）に提供される値は、インジェクションが不可能であることを確認できる方法で生成されたIDのリストです（例：some_tableからの以前のselect some_idの結果some_condition。）

その場合は、この値を連結するだけで、サービスや準備されたステートメントを使用したり、このクエリの他のパラメーターに使用したりしないでください。

query="select f1,f2 from t1 where f3=? and f2 in (" + sListOfIds + ");";

PreparedStatementは、SQL IN句を処理するための適切な方法を提供していません。パーhttp://www.javaranch.com/journal/200510/Journal200510.jsp#a2「あなたは、SQL文の一部になることを意味しているものを代用することはできません。SQL自体は変更することができますので、この場合は必要であり、ドライバはステートメントをプリコンパイルできません。また、SQLインジェクション攻撃を防ぐというすばらしい副作用もあります。」私は次のアプローチを使用してしまいました：

String query = "SELECT my_column FROM my_table where search_column IN ($searchColumns)";
query = query.replace("$searchColumns", "'A', 'B', 'C'");
Statement stmt = connection.createStatement();
boolean hasResults = stmt.execute(query);
do {
    if (hasResults)
        return stmt.getResultSet();

    hasResults = stmt.getMoreResults();

} while (hasResults || stmt.getUpdateCount() != -1);

SetArrayは最良のソリューションですが、多くの古いドライバーでは使用できません。次の回避策はjava8で使用できます。

String baseQuery ="SELECT my_column FROM my_table where search_column IN (%s)"

String markersString = inputArray.stream().map(e -> "?").collect(joining(","));
String sqlQuery = String.format(baseSQL, markersString);

//Now create Prepared Statement and use loop to Set entries
int index=1;

for (String input : inputArray) {
     preparedStatement.setString(index++, input);
}

このソリューションは、クエリ文字列が手動の反復によって構築される他の醜いwhileループソリューションよりも優れています

これは私のために働きました（疑似コード）：

public class SqlHelper
{
    public static final ArrayList<String>platformList = new ArrayList<>(Arrays.asList("iOS","Android","Windows","Mac"));

    public static final String testQuery = "select * from devices where platform_nm in (:PLATFORM_NAME)";
}

バインドを指定：

public class Test extends NamedParameterJdbcDaoSupport
public List<SampleModelClass> runQuery()
{
    //define rowMapper to insert in object of SampleClass
    final Map<String,Object> map = new HashMap<>();
    map.put("PLATFORM_LIST",DeviceDataSyncQueryConstants.platformList);
    return getNamedParameterJdbcTemplate().query(SqlHelper.testQuery, map, rowMapper)
}

SQLiteおよびOracleデータベースの私の例。

最初のForループは、PreparedStatementオブジェクトを作成するためのものです。

2番目のForループは、PreparedStatementパラメータの値を提供するためのものです。

List<String> roles = Arrays.asList("role1","role2","role3");
Map<String, String> menu = getMenu(conn, roles);

public static Map<String, String> getMenu(Connection conn, List<String> roles ) {
    Map<String, String> menu = new LinkedHashMap<String, String>();

    PreparedStatement stmt;
    ResultSet rset;
    String sql;
    try {
        if (roles == null) {
            throw new Exception();
        }
        int size = roles.size();
        if (size == 0) {
            throw new Exception("empty list");
        }
        StringBuilder sb = new StringBuilder();
        sb.append("select page_controller, page_name from pages "
                + " where page_controller in (");
        for (int i = 0; i < size; i++) {
            sb.append("?,");
        }
        sb.setLength(sb.length() - 1);
        sb.append(") order by page_id");
        sql = sb.toString();
        stmt = conn.prepareStatement(sql);
        for (int i = 0; i < size; i++) {
            stmt.setString(i + 1, roles.get(i));
        }
        rset = stmt.executeQuery();
        while (rset.next()) {
            menu.put(rset.getString(1), rset.getString(2));
        }

        conn.close();
    } catch (Exception ex) {
        logger.info(ex.toString());
        try {
            conn.close();
        } catch (SQLException e) {
        }
        return menu;
    }
    return menu;
}

私の回避策（JavaScript）

    var s1 = " SELECT "

 + "FROM   table t "

 + "  where t.field in ";

  var s3 = '(';

  for(var i =0;i<searchTerms.length;i++)
  {
    if(i+1 == searchTerms.length)
    {
     s3  = s3+'?)';
    }
    else
    {
        s3  = s3+'?, ' ;
    }
   }
    var query = s1+s3;

    var pstmt = connection.prepareStatement(query);

     for(var i =0;i<searchTerms.length;i++)
    {
        pstmt.setString(i+1, searchTerms[i]);
    }

SearchTerms 入力/キー/フィールドなどを含む配列です