Sélectionnez des valeurs distinctes parmi plusieurs colonnes dans la même table

Je suis en train de construire une seule instruction SQL qui renvoie unique, les valeurs non null de plusieurs colonnes, toutes situées dans la même table.

 SELECT distinct tbl_data.code_1 FROM tbl_data
      WHERE tbl_data.code_1 is not null
 UNION
 SELECT tbl_data.code_2 FROM tbl_data
      WHERE tbl_data.code_2 is not null;

Par exemple, tbl_data est comme suit:

 id   code_1    code_2
 ---  --------  ----------
 1    AB        BC
 2    BC        
 3    DE        EF
 4              BC

Du tableau ci-dessus, la requête SQL doit retourner tous les unique des valeurs non nulles de deux colonnes, à savoir: AB, BC, DE, EF.

Je suis assez nouveau dans SQL. Ma déclaration ci-dessus fonctionne, mais est-il une manière plus propre d'écrire cette instruction SQL, depuis les colonnes sont de la même table?

source d'informationauteur regulus

18

Il est préférable d'inclure le code dans votre question, et non ambiguë de texte, de données, de sorte que nous travaillons tous avec les mêmes données. Voici un exemple de schéma et les données que j'ai pris en charge:
```
CREATE TABLE tbl_data (
  id INT NOT NULL,
  code_1 CHAR(2),
  code_2 CHAR(2)
);

INSERT INTO tbl_data (
  id,
  code_1,
  code_2
)
VALUES
  (1, 'AB', 'BC'),
  (2, 'BC', NULL),
  (3, 'DE', 'EF'),
  (4, NULL, 'BC');
```
Comme Blorgbeard commenté, le DISTINCT clause dans votre solution est inutile parce que la UNION opérateur élimine les doublons. Il y a un UNION ALL opérateur qui n'est pas elimiate les doublons, mais il n'est pas approprié ici.

La réécriture de votre requête sans la DISTINCT clause est une belle solution à ce problème:
```
SELECT code_1
FROM tbl_data
WHERE code_1 IS NOT NULL
UNION
SELECT code_2
FROM tbl_data
WHERE code_2 IS NOT NULL;
```
Il n'est pas question que les deux colonnes sont dans le même tableau. La solution serait la même, même si les colonnes ont été dans des tables différentes.

Si vous n'aimez pas la redondance de la spécification de la même clause de filtre deux fois, vous pouvez encapsuler l'union requête dans une table virtuelle avant de filtrage:
```
SELECT code
FROM (
  SELECT code_1
  FROM tbl_data
  UNION
  SELECT code_2
  FROM tbl_data
) AS DistinctCodes (code)
WHERE code IS NOT NULL;
```
Je trouve la syntaxe de la deuxième plus laid, mais il est logiquement plus soignée. Mais celui qui fonctionne mieux?

J'ai créé un sqlfiddle qui démontre que l'optimiseur de requête de SQL Server 2005 produit le même plan d'exécution pour les deux requêtes différentes:

Si SQL Server génère le même plan d'exécution pour les deux requêtes, alors qu'ils sont pratiquement aussi bien que logiquement équivalentes.

Comparer ci-dessus pour le plan d'exécution de la requête dans votre question:

La DISTINCT clause rend SQL Server 2005 réaliser une redondance de l'opération de tri, car l'optimiseur de requête ne sait pas que tous les doublons filtrés par la DISTINCT dans la première requête serait filtré par la UNION plus tard de toute façon.

Cette requête est logiquement équivalent pour les deux autres, mais redondant opération le rend moins efficace. Sur un grand ensemble de données, je m'attendrais à votre requête de prendre plus de temps pour revenir un ensemble de résultats que les deux ici. Ne prenez pas mon mot pour lui; expérience dans votre propre environnement, pour être sûr de!

essayer quelque chose comme SubQuery:

SELECT derivedtable.NewColumn
FROM
(
    SELECT code_1 as NewColumn FROM tbl_data 
    UNION
    SELECT code_2 as NewColumn FROM tbl_data 
) derivedtable
WHERE derivedtable.NewColumn IS NOT NULL

La UNION retourne déjà DISTINCTES les valeurs de la requête combinée.

Vous devez vous connecter pour publier un commentaire.