SQL: obliczenia sekwencji w zapytaniu SQL

Question

mam cztery poniższe tabele w SQL Server 2008R2:

DECLARE @ParentGroup TABLE (ParentGroup_ID INT, ParentGroup_Name VARCHAR(100)); 
DECLARE @ChildGroup TABLE (ChildGroup_id INT, ChildGroup_name VARCHAR(100), ParentGroup_id INT); 
DECLARE @Entity TABLE ([Entity_id] INT, [Entity_name] VARCHAR(100)); 
DECLARE @ChildGroupEntity TABLE (ChildGroupEntity_id INT, ChildGroup_id INT, [Entity_ID] INT); 
INSERT INTO @parentGroup VALUES (1, 'England'), (2, 'USA'); 
INSERT INTO @ChildGroup VALUES (10, 'Sussex', 1), (11, 'Essex', 1), (12, 'Middlesex', 1); 
INSERT INTO @entity VALUES (100, 'Entity0'),(101, 'Entity1'),(102, 'Entity2'),(103, 'Entity3'),(104, 'Entity4'),(105, 'Entity5'),(106, 'Entity6'); 
INSERT INTO @ChildGroupEntity VALUES (1000, 10, 100), (1001, 10, 101), (1002, 10, 102), (1003, 11, 103), (1004, 11, 104), (1005, 12, 100), (1006, 12, 105), (1007, 12, 106); 
/* 
SELECT * FROM @parentGroup 
SELECT * FROM @ChildGroup 
SELECT * FROm @entity 
SELECT * FROM @ChildGroupEntity 
*/ 

Relacje między tabelami, jak poniżej:

SELECT ParentGroup_Name, ChildGroup_name, [Entity_name], 0 [ChildGroupSequence], 0 [EntitySequence] 
FROM @ChildGroupEntity cge 
INNER JOIN @ChildGroup cg ON cg.ChildGroup_id=cge.ChildGroup_id 
INNER JOIN @parentGroup pg ON pg.parentGroup_id=cg.parentGroup_id 
INNER JOIN @entity e ON e.[entity_id]=cge.[Entity_ID] 
ORDER BY ParentGroup_Name, ChildGroup_name, [Entity_name] 

Wyjście z powyższych zapytanie to:

------------------------------------------------------------------------------- 
ParentGroup_Name|ChildGroup_name|Entity_name|ChildGroupSequence|EntitySequence| 
------------------------------------------------------------------------------- 
England   |Essex   |Entity3 |0     |0    | 
England   |Essex   |Entity4 |0     |0    | 
England   |Middlesex  |Entity0 |0     |0    | 
England   |Middlesex  |Entity5 |0     |0    | 
England   |Middlesex  |Entity6 |0     |0    | 
England   |Sussex   |Entity0 |0     |0    | 
England   |Sussex   |Entity1 |0     |0    | 
England   |Sussex   |Entity2 |0     |0    | 
------------------------------------------------------------------------------- 

Chcę teraz poznać grupy podrzędne i wszystkie podmioty powiązane z grupami dzieci do grupy macierzystej 1. Ponadto, aby obliczyć [ChildGroupSequence] [EntitySequence] jak poniżej logiki:

1. Kolumna ChildGroupSequence powinny stanowić sekwencję grupy podrzędnej do grupy macierzystej, począwszy od 1000, zwiększając o 100. Tj. pierwsza podgrupa będzie 1000, druga podgrupa będzie 1100.
2. Kolumna EntitySequence powinna reprezentować sekwencję encji w grupie podrzędnej, zaczynając od 100 i zwiększając ją o jedną cyfrę, resetując dla każdej podgrupy. To znaczy. pierwsza jednostka w childgroup 1 od 100, podobnie jak pierwszy podmiot w childgroup 2.

Tak, wyjście powinno być w następującym formacie:

------------------------------------------------------------------------------- 
ParentGroup_Name|ChildGroup_name|Entity_name|ChildGroupSequence|EntitySequence| 
------------------------------------------------------------------------------- 
England   |Essex   |Entity3 |1000    |100   | 
England   |Essex   |Entity4 |1000    |101   | 
England   |Middlesex  |Entity0 |1100    |100   | 
England   |Middlesex  |Entity5 |1100    |101   | 
England   |Middlesex  |Entity6 |1100    |102   | 
England   |Sussex   |Entity0 |1200    |100   | 
England   |Sussex   |Entity1 |1200    |101   | 
England   |Sussex   |Entity2 |1200    |102   | 
------------------------------------------------------------------------------- 

mogę to zrobić łatwo poprzez czytanie wartości do warstwy aplikacji (program .Net), ale chcą nauczyć się serwera SQL, eksperymentując kilka drobnych rzeczy, takich jak ten. Czy ktoś mógłby mi pomóc w pisaniu tego zapytania SQL?

Każda pomoc będzie mile widziana. Z góry dziękuję.

EDYTOWANIE: Moje przykładowe dane nie wydają się poprawnie odzwierciedlać pierwszą regułę, reguła stwierdza, że ​​ChildGroupSequence powinna zostać zwiększona o 100, a wynik próbki zwiększa się o 1. Drugie zapytanie odzwierciedla przyrost o 100. @jpw : Dziękuję bardzo za wskazanie tego.

Answer 1

Wierzę, że to może być dokonane za pomocą partitioning i ranking funkcje tak:

SELECT ParentGroup_Name, ChildGroup_name, [Entity_name], 
    999 + DENSE_RANK() OVER(PARTITION BY ParentGroup_Name ORDER BY ChildGroup_name) AS [ChildGroupSequence], 
    99 + ROW_NUMBER() OVER(PARTITION BY ParentGroup_Name, ChildGroup_name ORDER BY ChildGroup_name, Entity_name) AS [EntitySequence] 
FROM @ChildGroupEntity cge 
INNER JOIN @ChildGroup cg ON cg.ChildGroup_id=cge.ChildGroup_id 
INNER JOIN @parentGroup pg ON pg.parentGroup_id=cg.parentGroup_id 
INNER JOIN @entity e ON e.[entity_id]=cge.[Entity_ID] 
ORDER BY ParentGroup_Name, ChildGroup_name, [Entity_name] 

To zapytanie generuje wyjście próbki opisałeś. Dane próbka nie wydają się prawidłowo odzwierciedla pierwszą zasadę chociaż jako reguła stanowi, że ChildGroupSequence należy zwiększana o 100, a przyrosty wyjściowe próbki przez 1. Drugie zapytanie odzwierciedla przyrost o 100:

SELECT ParentGroup_Name, ChildGroup_name, [Entity_name], 
    900 + 100 * DENSE_RANK() OVER(PARTITION BY ParentGroup_Name ORDER BY ChildGroup_name) AS [ChildGroupSequence], 
    99 + ROW_NUMBER() OVER(PARTITION BY ParentGroup_Name, ChildGroup_name ORDER BY ChildGroup_name, Entity_name) AS [EntitySequence] 
FROM @ChildGroupEntity cge 
INNER JOIN @ChildGroup cg ON cg.ChildGroup_id=cge.ChildGroup_id 
INNER JOIN @parentGroup pg ON pg.parentGroup_id=cg.parentGroup_id 
INNER JOIN @entity e ON e.[entity_id]=cge.[Entity_ID] 
ORDER BY ParentGroup_Name, ChildGroup_name, [Entity_name] 

proszę zobaczyć to sample SQL Fiddle dla przykładów obu zapytań.

Może zapytanie należy podzielić przez ID, a nie nazwa, jeśli tak Sussex przyjdzie przed Essex, ponieważ ma mniejszą identyfikator i kwerenda byłoby to:

SELECT ParentGroup_Name, ChildGroup_name, [Entity_name], 
    900 + 100 * DENSE_RANK() OVER(PARTITION BY pg.ParentGroup_ID ORDER BY cg.ChildGroup_ID) AS [ChildGroupSequence], 
    99 + ROW_NUMBER() OVER(PARTITION BY pg.ParentGroup_ID, cg.ChildGroup_ID ORDER BY cg.ChildGroup_ID, cge.Entity_ID) AS [EntitySequence] 
FROM @ChildGroupEntity cge 
INNER JOIN @ChildGroup cg ON cg.ChildGroup_id=cge.ChildGroup_id 
INNER JOIN @parentGroup pg ON pg.parentGroup_id=cg.parentGroup_id 
INNER JOIN @entity e ON e.[entity_id]=cge.[Entity_ID] 
ORDER BY pg.ParentGroup_ID, cg.ChildGroup_ID, [Entity_name] 

Answer 2

SELECT ParentGroup_Name, 
     ChildGroup_name, 
     [Entity_name], 
     LU.R [ChildGroupSequence], 
     99 + ROW_NUMBER() OVER (PARTITION BY LU.ParentGroup_id,LU.ChildGroup_id ORDER BY ChildGroup_name) [EntitySequence] 
FROM @ChildGroupEntity cge 
JOIN (
     SELECT cg.ChildGroup_id, 
       cg.ChildGroup_name, 
       pg.ParentGroup_id, 
       pg.ParentGroup_Name,  
       999 + (ROW_NUMBER() OVER (ORDER BY cg.ChildGroup_id)) [R] 
     FROM @ChildGroup cg 
     JOIN @parentGroup pg On pg.ParentGroup_ID = cg.ParentGroup_ID) LU 
     ON  cge.ChildGroup_id = LU.ChildGroup_id 
INNER JOIN @entity e ON e.[entity_id]=cge.[Entity_ID] 
ORDER BY LU.ParentGroup_Name, LU.ChildGroup_name, e.[Entity_name] 

Wynik:

Answer 3

można rozwiązać ten problem za pomocą ranking functions

SELECT ParentGroup_Name, ChildGroup_name, [Entity_name], 
     899 + DENSE_RANK() OVER(PARTITION BY ParentGroup_Name ORDER BY ChildGroup_name) + 
     100 * DENSE_RANK() OVER(ORDER BY ParentGroup_Name ASC) AS ChildGroupSequence, 
     99 + ROW_NUMBER() OVER(PARTITION BY ParentGroup_Name, ChildGroup_name ORDER BY [Entity_name]) AS [EntitySequence] 
FROM @ChildGroupEntity cge 
INNER JOIN @ChildGroup cg ON cg.ChildGroup_id=cge.ChildGroup_id 
INNER JOIN @parentGroup pg ON pg.parentGroup_id=cg.parentGroup_id 
INNER JOIN @entity e ON e.[entity_id]=cge.[Entity_ID] 
ORDER BY ParentGroup_Name, ChildGroup_name, [Entity_name] 

Wynik można znaleźć tutaj SQL Fiddle