SQL Server: Seule la dernière entrée dans le GROUPE PAR

J'ai le tableau suivant en MSSQL2005

id | business_key | result
1 | 1 | 0
2 | 1 | 1
3 | 2 | 1
4 | 3 | 1
5 | 4 | 1
6 | 4 | 0

Et maintenant je veux le groupe sur la base des business_key retour de la saisie complète avec les id les plus élevés.
Donc mon résultat attendu est:

business_key | result
1 | 1
2 | 1
3 | 1
4 | 0

Je parie qu'il y a un moyen de le réaliser, j'ai juste ne peux pas le voir à l'instant.

OriginalL'auteur computhomas | 2009-01-13

  1. 11

    Une solution alternative, qui peut vous donner une meilleure performance (test à la fois des moyens et de vérifier les plans d'exécution):

    SELECT
     T1.id,
     T1.business_key,
     T1.result
FROM
     dbo.My_Table T1
LEFT OUTER JOIN dbo.My_Table T2 ON
     T2.business_key = T1.business_key AND
     T2.id > T1.id
WHERE
     T2.id IS NULL

    Cette question suppose que l'ID est une valeur unique (au moins pour tout business_key) et que la valeur est NON NULLE.

    wow, vous avez raison. Coûts de requête 44% au lieu de 56%. Merci beaucoup!
    C'est ce que je cherchais ici : stackoverflow.com/questions/20934092/...

    OriginalL'auteur Tom H

  2. 4
    select
  drv.business_key,
  mytable.result
from mytable
  inner join
  (
    select 
      business_key, 
      max(id) as max_id
    from mytable
    group by
      business_key
  ) as drv on
    mytable.id = drv.max_id

    OriginalL'auteur Chris Simpson

  3. 2

    Essayer cette

    select  business_key, 
        result
from    myTable
where   id in 
        (select max(id)
        from    myTable
        group by business_key)

    EDIT: j'ai créé la table pour tester mon code. Je l'inclus ci-dessous dans le cas où quelqu'un d'autre veut le tester.

    SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [dbo].[myTable](
    [id] [int] NOT NULL,
    [business_key] [int] NOT NULL,
    [result] [int] NOT NULL
) ON [PRIMARY]
go

insert into myTable values(1,1,0);
insert into myTable values(2,1,1);
insert into myTable values(3,2,1);
insert into myTable values(4,3,1);
insert into myTable values(5,4,1);
insert into myTable values(6,4,0);

select  * from mytable
    Cette requête n'afficher qu'une ligne de données, et non pas quatre. Vous avez besoin de faire de la sous-requête en corrélation - et vous avez besoin d'alias pour les deux instances de MyTable (les appeler "premier" et "second"); ajouter en premier.id = seconde.id
    Jonathan-Vous avez raison, il y avait une faute de frappe dans la clause where. Il devrait être 'dans le' non '='. Mais les alias ne sont pas nécessaires. Merci d'avoir signalé mon erreur.

    OriginalL'auteur John MacIntyre

  4. 2
    select business_key, 
       result
    from 
    (select id, 
        business_key, 
        result, 
        max(id) over (partition by business_key) as max_id
    from mytable) x
where id = max_id
    Ce doit être la accepté de répondre, parce que cette requête est BEAUCOUP plus efficace que d'être acceptées.
    Ce n'est guère le cas. J'ai couru les deux requêtes à travers MSSQL 2012 R2 en une seule fois, et ce que j'ai trouvé dans le plan d'exécution a été que la sous-requête de la partie 68% du temps écoulé. La très partition utilisée 77% de l'ensemble de la deuxième requête.

    OriginalL'auteur

  5. 1

    C'est un vieux post, mais était pertinent pour quelque chose que j'était en train de faire actuellement (2013). Si vous obtenez un plus grand ensemble de données (typique dans la plupart des DBs), les résultats des différentes requêtes (en regardant les plans d'exécution) en dit beaucoup. Nous avons d'abord créer un "tableau de POINTAGE" pour générer aléatoirement des numéros, puis utiliser une formule arbitraire pour créer des données pour le "Matable": 

    CREATE TABLE #myTable(
    [id] [int] NOT NULL,
    [business_key] [int] NOT NULL,
    [result] [int] NOT NULL,
    PRIMARY KEY (Id)
) ON [PRIMARY];

; WITH
    -- Tally table Gen            Tally Rows:     X2                X3
t1 AS (SELECT 1 N UNION ALL SELECT 1 N),    -- 4            ,    8
t2 AS (SELECT 1 N FROM t1 x, t1 y),            -- 16            ,    64
t3 AS (SELECT 1 N FROM t2 x, t2 y),            -- 256            ,    4096
t4 AS (SELECT 1 N FROM t3 x, t3 y),            -- 65536        ,    16,777,216
t5 AS (SELECT 1 N FROM t4 x, t4 y),            -- 4,294,967,296,    A lot
Tally AS (SELECT ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) N
          FROM t5 x, t5 y)

INSERT INTO #MyTable 
SELECT N, CAST(N/RAND(N/8) AS bigINT)/5 , N%2
FROM Tally
WHERE N < 500000

    Ensuite, nous avons trois différents types de requêtes à l'examen du rendement (activer le "Plan d'Exécution" si vous utilisez SQL Server Management Studio): 

    SET STATISTICS IO ON
SET STATISTICS TIME ON
----- Try #1 
select  'T1' AS Qry, id, business_key, 
        result
from    #myTable
where   id in 
        (select max(id)
        from    #myTable
        group by business_key)

---- Try #2 
select 'T2' AS Qry, id, business_key, 
       result
    from 
    (select id, 
        business_key, 
        result, 
        max(id) over (partition by business_key) as max_id
    from #mytable) x
where id = max_id

---- Try #3 
;with cteRowNumber as (
    select id, 
        business_key, 
        result,
           row_number() over(partition by business_key order by id desc) as RowNum
        from #mytable
)

SELECT 'T3' AS Qry, id, business_key, 
       result
FROM cteRowNumber
WHERE RowNum = 1

    De nettoyage: 

    IF OBJECT_ID(N'TempDB..#myTable',N'U') IS NOT NULL 
    DROP TABLE #myTable;
    SET STATISTICS IO OFF
SET STATISTICS TIME OFF

    Vous trouverez, en regardant les plans d'exécution, Essayez de 1" a le meilleur de la Requête "Coût" et plus bas le temps CPU mais "Essayez 3" a le moins de lectures et de temps PROCESSEUR n'est pas trop mauvais. Je vous conseille d'utiliser un CTE méthode pour le moins lit

    OriginalL'auteur DBNewbie_2007