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