Sélectionner la sélection en fonction d'une priorité

Question

Quelqu'un change mon titre pour mieux refléter ce que j'essaie de lui demander.

J'ai une table comme

Table (id, value, value_type, data) 

ID est pas unique. Il n'y a pas de clé unique.

value_type a deux valeurs possibles, disons A et B.

type B est meilleur que A, mais souvent pas disponible.

Pour chaque id si un enregistrement avec EXISTE value_type B, je veux tous les enregistrements avec cet identifiant et value_type B.

Si aucun enregistrement pour cet identifiant avec value_type B existe, je veux tous les enregistrements avec cet identifiant et value_type A.

Notez que si B existe pour cet ID, je ne veux pas d'enregistrements de type A.

Je fais actuellement cela avec une série de tables temporaires. Y a-t-il une seule instruction select (sous-requêtes OK) qui peut faire le travail?

Merci beaucoup!

Détails supplémentaires:

SQL Server 2005

Answer 1

RANK, plutôt que ROW_NUMBER, parce que vous voulez des liens (ceux qui ont la même valeur B) pour avoir la même valeur de classement:

WITH summary AS (
    SELECT t.*, 
     RANK() OVER (PARTITION BY t.id 
          ORDER BY t.value_type DESC) AS rank 
    FROM TABLE t 
    WHERE t.value_type IN ('A', 'B')) 
SELECT s.id, 
     s.value, 
     s.value_type, 
     s.data 
    FROM summary s 
WHERE s.rank = 1 

Version non CTE:

SELECT s.id, 
     s.value, 
     s.value_type, 
     s.data 
    FROM (SELECT t.*, 
       RANK() OVER (PARTITION BY t.id 
           ORDER BY t.value_type DESC) AS rank 
      FROM TABLE t 
     WHERE t.value_type IN ('A', 'B')) s 
WHERE s.rank = 1 

---

WITH test AS (
    SELECT 1 AS id, 'B' AS value_type 
    UNION ALL 
    SELECT 1, 'B' 
    UNION ALL 
    SELECT 1, 'A' 
    UNION ALL 
    SELECT 2, 'A' 
    UNION ALL 
    SELECT 2, 'A'), 
    summary AS (
    SELECT t.*, 
      RANK() OVER (PARTITION BY t.id 
          ORDER BY t.value_type DESC) AS rank 
    FROM test t) 
SELECT * 
    FROM summary 
WHERE rank = 1 

je reçois:

id value_type rank 
---------------------- 
1 B   1 
1 B   1 
2 A   1 
2 A   1 

Answer 2

Il utilise un syndicat, combinant tous les enregistrements de valeur B avec tous les enregistrements qui ont seulement les valeurs suivantes:

SELECT * 
FROM mainTable 
WHERE value_type = B 
GROUP BY value_type UNION SELECT * 
          FROM mainTable 
          WHERE value_type = A 
           AND id NOT IN(SELECT * 
              FROM mainTable 
              WHERE value_type = B); 

Answer 3

Essayez cette (MSSQL).

Select id, value_typeB, null 
from myTable 
where value_typeB is not null 
Union All 
Select id, null, value_typeA 
from myTable 
where value_typeB is null and value_typeA is not null 

Answer 4

SELECT * 
    FROM table 
WHERE value_type = B 
UNION ALL 
SELECT * 
    FROM table 
WHERE ID not in (SELECT distinct id 
        FROM table 
        WHERE value_type = B) 

Answer 5

declare @test as table(
id int , value [nvarchar](255),value_type [nvarchar](255),data int) 

INSERT INTO @test 
SELECT 1, 'X', 'A',1 UNION 
SELECT 1, 'X', 'A',2 UNION 
SELECT 1, 'X', 'A',3 UNION 
SELECT 1, 'X', 'A',4 UNION 
SELECT 2, 'X', 'A',5 UNION 
SELECT 2, 'X', 'B',6 UNION 
SELECT 2, 'X', 'B',7 UNION 
SELECT 2, 'X', 'A',8 UNION 
SELECT 2, 'X', 'A',9 


SELECT * FROM @test x 
INNER JOIN 
(SELECT id, MAX(value_type) as value_type FROM 
@test GROUP BY id) as y 
ON x.id = y.id AND x.value_type = y.value_type 

Answer 6

Peut-être quelque chose comme ceci:

select * from mytable 
where id in (select distinct id where value_type = "B") 
union 
select * from mytable 
where id in (select distinct id where value_type = "A" 
and id not in (select distinct id where value_type = "B")) 

Answer 7

La plus courte requête pour faire le travail que je peux penser:

SELECT TOP 1 WITH TIES * 
FROM #test 
ORDER BY Rank() OVER (PARTITION BY id ORDER BY value_type DESC) 

Il s'agit 50% pire sur CPU que les solutions OMG Ponies et Christoperous 5000, mais le même nombre de lectures . C'est le genre supplémentaire qui fait qu'il faut plus de CPU.

La plus performante requête originale que je suis venu avec à ce jour est:

SELECT * 
FROM #test 
WHERE value_type = 'B' 
UNION ALL 
SELECT * 
FROM #test T1 
WHERE NOT EXISTS (
    SELECT * 
    FROM #test T2 
    WHERE 
     T1.id = T2.id 
     AND T2.value_type = 'B' 
) 

Cela bat constamment tous les autres présentés sur le processeur d'environ 1/3 (les autres sont environ 50% de plus) mais a 3x le nombre de lectures. La durée de cette requête est souvent 2/3rds le temps de tous les autres. Je considère que c'est un bon concurrent.

Les index et les types de données peuvent tout changer.