sql-server - multiple - sql oracle convertir columnas en filas

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 déjame intentarlo de nuevo.

Mi mesa se ve así:

 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 que estoy buscando devolvería "2000,49" para "contrato, actividad" porque solo el contrato # 2000 tiene uno, y SOLO uno, valor de actividad único.

De nuevo, gracias un millón por adelantado, boroatel

Answer 1

Utilizando la capacidad de "tabla dinámica" en SQL Server (consulta en una consulta rodeada de paréntesis), puede devolver 2000, 49 w / lo siguiente. Si su plataforma no ofrece un equivalente a la extensión ANSI "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 realizando 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 2

¡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 sin subconsulta

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

Answer 3

Aquí hay otra opción que usa servidores SQL distintos:

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 4

Para MySQL:

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

Answer 5

Prueba esto:

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

Answer 6

Suponiendo 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 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 7

Actualizado para usar sus datos recién provistos:

Las soluciones que usan los datos originales se pueden encontrar al final de esta respuesta.

Usando tus 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

devoluciones: 2000, 49

Soluciones que usan datos originales

ADVERTENCIA: las siguientes soluciones usan los datos que se dieron anteriormente en la pregunta y pueden 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 proporcionarle 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 una 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 una tabla temporal y unirse:

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 regresa:

D E
G H

Answer 8

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

Answer 9

Lamento que no estés usando PostgreSQL ...

SELECCIONE DISTINCT ON contract, actividad * FROMtabletable ORDER BY contract, actividad

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

Oh espera. Solo quieres valores con exactamente uno ...

SELECCIONAR contrato, actividad, recuento ( ) FROM tabletable GROUP BY contrato, actividad HAVING count ( ) = 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

Disculpa la publicación anterior Lo sé, pero tuve el mismo problema, no pude hacer nada de lo anterior para trabajar para mí, sin embargo, lo descubrí.

Esto funcionó para mí:

SELECCIONE DISTINCT [columna] Como UniqueValues ​​FROM [db]. [Dbo]. [Table]

Answer 12

SELECCIONAR DISTINCT Col1, Col2 FROM Tabla GROUP BY Col1 TENER COUNT (DISTINCT Col1) = 1