Des méthodes SQL alternatives pour rechercher plusieurs éléments d'ID connus?

Est-il une meilleure solution au problème de la recherche de plusieurs Id dans un tableau:

SELECT * FROM some_table WHERE id='1001' OR id='2002' OR id='3003' OR ...

Je peux avoir plusieurs centaines d'éléments connus. Des idées?

source d'informationauteur AlexanderJohannesen

SELECT * FROM some_table WHERE ID IN ('1001', '1002', '1003')

et si votre Id sont à venir à partir d'un autre tableau

SELECT * FROM some_table WHERE ID IN (
    SELECT KnownID FROM some_other_table WHERE someCondition 
)

7

La première (naïve) option:
```
SELECT * FROM some_table WHERE id IN ('1001', '2002', '3003' ... )
```
Cependant, nous devrions être en mesure de faire mieux. IN est très mauvais quand vous avez beaucoup d'éléments, et vous avez mentionné des centaines de ces identifiants. Ce qui les crée? D'où viennent-ils? Pouvez-vous écrire une requête qui retourne cette liste? Si oui:
```
SELECT *
FROM some_table 
INNER JOIN ( your query here) filter ON some_table.id=filter.id
```
3

Voir Les tableaux et les Listes dans SQL Server 2005
2

Rup sont notoirement lent en SQL.

Votre question est courte sur les détails, mais en fonction de vos exigences et de contraintes je voudrais construire une table avec vos Identifiants et utiliser le EXISTE prédicat:
```
select t.id from some_table t 
where EXISTS (select * from lookup_table l where t.id = l.id)
```
0

Pour un ensemble fixe de Id vous pouvez faire:
```
SELECT * FROM some_table WHERE id IN (1001, 2002, 3003);
```
Pour un jeu qui change à chaque fois, vous pouvez créer une table de tenir et puis pour la requête:
```
SELECT * FROM some_table WHERE id IN 
  (SELECT id FROM selected_ids WHERE key=123);
```
Une autre approche consiste à utiliser des collections - la syntaxe de cette dépendra de votre SGBD.

Enfin, il y a toujours cette "encombrants":
```
SELECT * FROM some_table WHERE '|1001|2002|3003|' LIKE '%|' || id || '|%';
```
0

Dans Oracleje mets toujours l' id's dans un TEMPORARY TABLE pour effectuer massive SELECT's et DML opérations:
```
CREATE GLOBAL TEMPORARY TABLE t_temp (id INT)


SELECT  *
FROM    mytable
WHERE   mytable.id IN
        (
        SELECT  id
        FROM    t_temp
        )
```
Vous pouvez remplir la table temporaire dans un seul et unique client-serveur, aller à l'aide de Oracle types de collection.
0

Nous avons un problème similaire dans une application écrite pour MS SQL Server 7. Bien que je n'aime pas la solution utilisée, nous ne sommes pas au courant de quelque chose de mieux...

"Mieux" des solutions existent, en 2008, pour autant que je sais, mais nous avons des clients Zéro à l'aide 🙂

Nous avons créé une table défini par l'utilisateur fonction qui prend une chaîne délimitée par des virgules de l'IDs, et retourne un tableau d'Id. Le SQL puis se lit assez bien, et rien de tout cela est dynamique, mais il est toujours ennuyeux double surcharge:

1. Client concatène l'IDs dans la chaîne

2. SQL Server analyse de la chaîne pour créer un tableau d'Identifiants

Il y a beaucoup de façons de tourner '1,2,3,4,5" dans un tableau d'Id, mais la Procédure Stockée qui utilise la fonction finit par ressembler à...
```
CREATE PROCEDURE my_road_to_hell @IDs AS VARCHAR(8000)
AS
BEGIN

   SELECT
      *
   FROM
      myTable
   INNER JOIN
      dbo.fn_split_list(@IDs) AS [IDs]
         ON [IDs].id = myTable.id

END
```
0

Le plus rapide est de mettre l'id d'une autre table et REJOINDRE
```
SELECT some_table.* 
FROM some_table INNER JOIN some_other_table ON some_table.id = some_other_table.id
```
où some_other_table aurait juste un domaine (ids) et toutes les valeurs seraient unique

Vous devez vous connecter pour publier un commentaire.