SQL: ¿Cómo selecciono solo las filas con un valor único en cierta columna?

Question

Gracias a todos por la respuesta de todos. Lamentablemente, ninguna de las soluciones parece estar funcionando por mi parte, y creo que el ejemplo que he proporcionado está mal.

Así que permítanme intentarlo de nuevo.

Mi mesa se parece a esto:

contract project activity 
row1 1000 8000 10 
row2 1000 8000 20 
row3 1000 8001 10 
row4 2000 9000 49 
row5 2000 9001 49 
row6 3000 9000 79 
row7 3000 9000 78 

Básicamente, la consulta Busco volvería "2000,49" por "contrato, la actividad" porque sólo contrato # 2000 tiene uno, y sólo uno , valor de actividad único.

Una vez más, un millón de gracias por adelantado, boroatel

Answer 1

actualizado para utilizar sus datos recientemente proporcionados:

las soluciones utilizando los datos originales se pueden encontrar al final de esta respuesta.

Usando su nuevos datos:

DECLARE @T TABLE([contract] INT, project INT, activity INT) 
INSERT INTO @T VALUES(1000, 8000, 10) 
INSERT INTO @T VALUES(1000, 8000, 20) 
INSERT INTO @T VALUES(1000, 8001, 10) 
INSERT INTO @T VALUES(2000, 9000, 49) 
INSERT INTO @T VALUES(2000, 9001, 49) 
INSERT INTO @T VALUES(3000, 9000, 79) 
INSERT INTO @T VALUES(3000, 9000, 78) 

SELECT DISTINCT [contract], activity FROM @T AS A WHERE 
    (SELECT COUNT(DISTINCT activity) 
    FROM @T AS B WHERE B.[contract] = A.[contract]) = 1 

devuelve: 2000, 49

soluciones utilizando los datos originales

ADVERTENCIA: Las siguientes soluciones utilizan los datos previamente dados en la pregunta y puede no tener sentido para la pregunta actual. Los dejé adjuntos solo para completarlos.

SELECT Col1, Count(col1) AS count FROM table 
GROUP BY col1 
HAVING count > 1 

Esto debería obtener una lista de todos los valores en col1 que no son distintos. Puede colocar esto en una mesa var o tabla temporal y unirse contra ella.

Aquí hay un ejemplo usando un sub-consulta:

DECLARE @t TABLE(col1 VARCHAR(1), col2 VARCHAR(1), col3 VARCHAR(1)) 

INSERT INTO @t VALUES('A', 'B', 'C'); 
INSERT INTO @t VALUES('D', 'E', 'F'); 
INSERT INTO @t VALUES('A', 'J', 'K'); 
INSERT INTO @t VALUES('G', 'H', 'H'); 

SELECT * FROM @t 

SELECT col1, col2 FROM @t WHERE col1 NOT IN 
    (SELECT col1 FROM @t AS t GROUP BY col1 HAVING COUNT(col1) > 1) 

Esto devuelve:

D E 
G H 

Y otro método que los usuarios de una tabla temporal y se unen:

DECLARE @t TABLE(col1 VARCHAR(1), col2 VARCHAR(1), col3 VARCHAR(1)) 

INSERT INTO @t VALUES('A', 'B', 'C'); 
INSERT INTO @t VALUES('D', 'E', 'F'); 
INSERT INTO @t VALUES('A', 'J', 'K'); 
INSERT INTO @t VALUES('G', 'H', 'H'); 

SELECT * FROM @t 

DROP TABLE #temp_table 
SELECT col1 INTO #temp_table 
    FROM @t AS t GROUP BY col1 HAVING COUNT(col1) = 1 

SELECT t.col1, t.col2 FROM @t AS t 
    INNER JOIN #temp_table AS tt ON t.col1 = tt.col1 

también devoluciones:

D E 
G H 

Answer 2

Para MySQL:

SELECT contract, activity 
FROM table 
GROUP BY contract 
HAVING COUNT(DISTINCT activity) = 1 

Answer 3

Modificado!

SELECT distinct contract, activity from @t a 
WHERE (SELECT COUNT(DISTINCT activity) FROM @t b WHERE b.contract = a.contract) = 1 

Y aquí hay otro - más corto/más limpio y sin subconsulta

select contract, max(activity) from @t 
group by contract 
having count(distinct activity) = 1 

Answer 4

Prueba esto:

select 
     contract, 
     max (activity) 
from 
     mytable 
group by 
     contract 
having 
     count (activity) = 1 

Answer 5

Asumiendo que su tabla de datos se llama ProjectInfo:

SELECT DISTINCT Contract, Activity 
    FROM ProjectInfo 
    WHERE Contract = (SELECT Contract 
          FROM (SELECT DISTINCT Contract, Activity 
            FROM ProjectInfo) AS ContractActivities 
          GROUP BY Contract 
          HAVING COUNT(*) = 1); 

La consulta más interna identifica th e los contratos y las actividades. El siguiente nivel de la consulta (el medio) identifica los contratos en los que solo hay una actividad. La consulta externa extrae el contrato y la actividad de la tabla ProjectInfo para los contratos que tienen una sola actividad.

Probado con IBM Informix Dynamic Server 11.50: debería funcionar también en otros lugares.

Answer 6

Aquí es otra opción utilizando servidores SQL recuento diferente:

DECLARE @T TABLE([contract] INT, project INT, activity INT) 
INSERT INTO @T VALUES(1000, 8000, 10) 
INSERT INTO @T VALUES(1000, 8000, 20) 
INSERT INTO @T VALUES(1000, 8001, 10) 
INSERT INTO @T VALUES(2000, 9000, 49) 
INSERT INTO @T VALUES(2000, 9001, 49) 
INSERT INTO @T VALUES(3000, 9000, 79) 
INSERT INTO @T VALUES(3000, 9000, 78) 



SELECT DISTINCT [contract], activity FROM @T AS A WHERE 
    (SELECT COUNT(DISTINCT activity) 
    FROM @T AS B WHERE B.[contract] = A.[contract]) = 1 

Answer 7

SELECT DISTINCT Contract, Activity 
FROM Contract WHERE Contract IN (
SELECT Contract 
FROM Contract 
GROUP BY Contract 
HAVING COUNT(DISTINCT Activity) = 1) 

Answer 8

La utilización de la capacidad "tabla dinámica" en SQL Server (consulta contra una consulta paréntesis rodeado), puede devolver 2000, 49 w/lo siguiente. Si su plataforma no ofrece un equivalente a la extensión ANSI de "tabla dinámica", siempre puede utilizar una tabla temporal en instrucción de dos pasos insertando los resultados dentro de la "tabla dinámica" en una tabla temporal, y luego realizar una selección posterior en la tabla temporal.

DECLARE @T TABLE(
    [contract] INT, 
    project INT, 
    activity INT 
) 

INSERT INTO @T VALUES(1000, 8000, 10) 
INSERT INTO @T VALUES(1000, 8000, 20) 
INSERT INTO @T VALUES(1000, 8001, 10) 
INSERT INTO @T VALUES(2000, 9000, 49) 
INSERT INTO @T VALUES(2000, 9001, 49) 
INSERT INTO @T VALUES(3000, 9000, 79) 
INSERT INTO @T VALUES(3000, 9000, 78) 

SELECT 
    [contract], 
    [Activity] = max (activity) 
FROM 
    (
    SELECT 
     [contract], 
     [Activity] 
    FROM 
     @T 
    GROUP BY 
     [contract], 
     [Activity] 
    ) t 
GROUP BY 
    [contract] 
HAVING count (*) = 1 

Answer 9

En este momento no se está usando PostgreSQL ...

SELECT DISTINCT en el contrato, la actividad * DE thetable ORDER BY contrato, la actividad

http://www.postgresql.org/docs/8.3/static/sql-select.html#SQL-DISTINCT

Oh, espera. Desea que los valores con exactamente un ...

contrato SELECT, la actividad, el recuento () DE GRUPO POR thetable contrato, actividad que tenga recuento () = 1

Answer 10

Soy un fan de NO EXISTE

SELECT DISTINCT contract, activity FROM table t1 
WHERE NOT EXISTS (
    SELECT * FROM table t2 
    WHERE t2.contract = t1.contract AND t2.activity != t1.activity 
) 

Answer 11

lo sentimos antiguo puesto sé, pero tuve el mismo problema, no podía conseguir cualquiera de los anteriores a trabajar para mí, sin embargo lo he descubierto.

Esto funcionó para mí:..

SELECT DISTINCT [columna] Como UniqueValues ​​ DE [db] [dbo] [Tabla]

Answer 12

SELECT DISTINCT Col1, Col2 DE Tabla GROUP BY Col1 CUENTA QUE TIENE (DISTINCT Col1) = 1