OÙ col1,col2 EN (...) [sous-requête SQL à l'aide de clé primaire composite]

Donné un tableau foo avec une clé primaire composite (a,b), est-il légal de syntaxe pour écrire une requête telle que:

SELECT ... FROM foo WHERE a,b IN (SELECT ...many tuples of a/b values...);
UPDATE foo SET ... WHERE a,b IN (SELECT ...many tuples of a/b values...);

Si ce n'est pas possible, et on ne pouvait pas modifier le schéma, comment pouvez-vous effectuer l'équivalent de ce qui précède?

Je vais aussi mettre les termes "composé de clé primaire", "sélectionner", "sous-select" et "sous-requête" ici pour les résultats de recherche sur ces alias.

Modifier: je suis intéressé par les réponses pour le standard SQL ainsi que ceux qui pourraient travailler avec PostgreSQL et SQLite 3.

InformationsquelleAutor Phrogz | 2011-01-07

26
```
sqlite> create table foo (a,b,c);
sqlite> create table bar (x,y);
sqlite> select * from foo where exists (select 1 from bar where foo.a = bar.x and foo.b = bar.y);
```
Remplacer le select 1 from bar avec votre select ... many tuples of a/b values ....

Ou de créer une table temporaire de votre select ... many tuples of a/b values ... et l'utiliser à la place de bar..

InformationsquelleAutor Doug Currie
19

Votre syntaxe est très proche du Standard SQL!

Ce qui suit est valable COMPLÈTE de SQL-92 (comme l'a confirmé le Mimer SQL-92 Validateur)
```
SELECT * 
  FROM foo 
  WHERE (a, b) IN (
                   SELECT a, b 
                      FROM bar
                  );
```
Bien sûr, pas tous les SQL produit prend en charge complète de SQL-92 (la honte!) Si quelqu'un souhaite voir cette syntaxe pris en charge dans Microsoft SQL Server, ils peuvent voter pour elle ici.

Un autre SQL-92 construire que ce qui est largement pris en charge (par exemple par Microsoft SQL Server et Oracle) est INTERSECT par exemple
```
SELECT a, b
  FROM Foo
INTERSECT
SELECT a, b
  FROM Bar;
```
Noter que ces constructions gérer correctement la NULL valeur, contrairement à d'autres suggestions ici, par exemple, ceux qui utilisent EXISTS (<equality predicates>), valeurs concaténées, etc.
- C'est pris en charge dans PostgreSql. SELECT * FROM foo WHERE (a,b) IN ((1,2),(3,4))
- Pour information, le contraire de INTERSECT est EXCEPT
InformationsquelleAutor onedaywhen
9

Vous avez fait une très petite erreur.
Vous devez mettre a,b entre parenthèses.
```
SELECT ... FROM foo WHERE (a,b) IN (SELECT f,d FROM ...);
```
Qui fonctionne!

InformationsquelleAutor Ostin
4

La syntaxe vous l'avez suggéré, n'est pas valide SQL. Une solution EXISTE devraient travailler dans tous raisonnablement compatible SQL RDBMSes:
```
 UPDATE foo SET x = y WHERE EXISTS
    (SELECT * FROM bar WHERE bar.c1 = foo.c1 AND bar.c2 = foo.c2)
```
Être conscient que ce n'est souvent pas particulièrement performant.
- Et devrait donner le même plan parce qu'ils sont sémantiquement identiques. Au moins dans SQL Server, vous obtenez le même plan de toute façon.
InformationsquelleAutor Larry Lustig
3
```
    SELECT ...
      FROM foo
INNER JOIN (SELECT ...many tuples of a/b values...) AS results
        ON results.a = foo.a
       AND results.b = foo.b
```
Que ce que vous recherchez?
- Ça a l'air bon, sauf qu'il ne fonctionne pas dans le cas de UPDATE sur SQLite3, qui ne prend pas en charge les jointures dans la mise à JOUR les requêtes. J'essaie en partie à savoir si le noyau multi-touches EN est légal (je viens de lire qu'il n'est pas dans SQLite), mais aussi pour aider les répondre à cette question.
- Ah, bien pour la mise à jour, je ne suis pas certain. Je vais continuer à cogner ma tête contre ce...
- Cela a fonctionné pour moi. Merci beaucoup!!
InformationsquelleAutor Stefan H
2

Avec la concaténation, cela fonctionne avec PostgreSQL:
```
SELECT a,b FROM foo WHERE a||b IN (SELECT a||b FROM bar WHERE condition);

UPDATE foo SET x=y WHERE a||b IN (SELECT a||b FROM bar WHERE condition);
```
- C'est une mauvaise idée, selon les valeurs de a et b. Votre concaténation ne sera pas toujours unique. Vous pouvez avoir un enregistrement avec a=22 et b=1, un autre record avec a=2 et b=21. Votre concaténation serait 221 pour les deux! Un peu plus de concaténation serait une||'-'||b, pour éviter ce problème. Un autre problème est que, avec la concaténation, la requête sera lente car la base de données ne peut pas utiliser l'index de façon optimale.
InformationsquelleAutor Toto
0

Si vous avez besoin d'une solution qui ne nécessite pas les n-uplets de valeurs déjà existantes dans une table, vous pouvez concaténer le tableau des valeurs et des éléments de votre liste, puis utilisez le 'DANS' la commande.

Dans postgres ce serait ressembler à ceci:

SELECT * FROM foo WHERE a || '_' || b in ('Hi_there', 'Me_here', 'Test_test');

Tandis que dans SQL j'imagine qu'il pourrait ressembler à quelque chose comme ceci:

SELECT * FROM foo WHERE CONCAT(a, "_", b) in ('Hi_there', 'Me_here', 'Test_test');

InformationsquelleAutor mobeetsatwork
0

JOINS et INTERSECTS fonctionner comme un substitut pour IN, mais ils ne sont pas si évidentes comme un substitut pour NOT IN, par exemple: l'insertion de lignes de TableA en TableB où ils n'existent pas déjà dans TableB où la PK sur les deux tableaux est un composite.

Je suis actuellement en utilisant la méthode de concaténation ci-dessus dans SQL Server, mais elle n'est pas très élégant.
- Vous suggère de regarder à MERGE..USING..WHEN NOT MATCHED THEN INSERT...
InformationsquelleAutor Simon
0

Firebird utilise cette formule de concaténation:

SÉLECTIONNEZ a,b DE foo OÙ a||b IN (SELECT a||b à PARTIR de la barre OÙ
condition);

InformationsquelleAutor muaddibx

Vous devez vous connecter pour publier un commentaire.