SQL Count of rows in a group in a sequence - sql-server

Question

I apologise for the title of the question, it isn't very clear, but I can't think of a better way of describing it in words, the data should speak for itself.
I have a table of data where I need to know the count of rows that are the same depending on a value, but also taking into account the sequence they are currently in. The table is much larger than this, but these are the columns which are relevant.
Id | MinCode | MaxCode | ExpectedResult
----------------------------------------------------
1 | 00001.000001 | 00001.000001 | 2
2 | 00001.000001 | 00001.000002 | 2
3 | 00002.00001a | 00002.00001a | 3
4 | 00002.00001a | 00002.00001b | 3
5 | 00002.00001a | 00002.00001c | 3
6 | 00002.000002 | 00002.000002 | 1
7 | 00002.00003a | 00002.00003a | 2
8 | 00002.00003a | 00002.00003b | 2
9 | 00002.000002 | 00002.000004 | 1
10 | 00003.000001 | 00003.000001 | 1
Note: Id is also the order in this example, I just didn't see the point of an extra column with the same data.
I have tried several versions using COUNT, ROW_NUMBER/RANK, PARTITION and GROUP BY without getting the ExpectedResult values. The issue is with Ids 6 and 9 as my ExpectedResult value always combines them to produce a 2 which I partially understand as these functions don't take into account the ordering of the data. I believe I'm close, but my T-SQL is pretty rusty these days!
I know I could get this value with processing this data set through a CURSOR, but I'd like to avoid that.

Answer 1

The key here is to create a sequence id you can use in a window function to get the count. You won't be able to do it in one query because window functions can't be combined, but you can pull it off with a subquery or CTE.
To determine the sequence number for a row, you need to count the number of times the group key has changed in the preceding rows. So to determine the changes, create an inner query that checks if the current group key is different from the previous by using the lag window function. Use a case statement that results in 1 or 0 depending on if the lagged value is different from the current. The outer query then just has to sum up the values for all rows preceding up to the current.
Once you have the sequence number, you can use a count window function to count all the rows with matching numbers.
WITH src AS ( -- cte to mimic table.
SELECT *
FROM (VALUES
(1, N'00001.000001', N'00001.000001', 2),
/* ... test data ... */
(10, N'00003.000001', N'00003.000001', 1)
) [src] ( [Id],[MinCode],[MaxCode],[ExpectedResult] )
)
SELECT src.Id, MinCode, MaxCode, ExpectedResult
, COUNT(1) OVER (PARTITION BY seq.SequenceId) [Result]
FROM src
INNER JOIN (
SELECT x.Id, SUM(x.IsNew) OVER (ORDER BY Id ROWS UNBOUNDED PRECEDING) [SequenceId]
FROM (
SELECT Id, CASE WHEN LAG(MinCode) OVER (ORDER BY Id) <> MinCode THEN 1 ELSE 0 END [IsNew]
FROM src
) x
) seq ON seq.Id = src.Id
ORDER BY Id

Answer 2

Here's another possibility:
/* Testing Data */
DECLARE #Data table (
Id int, MinCode varchar(20), MaxCode varchar(20), ExpectedResult int
);
INSERT INTO #Data VALUES
( 1 , '00001.000001', '00001.000001', 2 ),
( 2 , '00001.000001', '00001.000002', 2 ),
( 3 , '00002.00001a', '00002.00001a', 3 ),
( 4 , '00002.00001a', '00002.00001b', 3 ),
( 5 , '00002.00001a', '00002.00001c', 3 ),
( 6 , '00002.000002', '00002.000002', 1 ),
( 7 , '00002.00003a', '00002.00003a', 2 ),
( 8 , '00002.00003a', '00002.00003b', 2 ),
( 9 , '00002.000002', '00002.000004', 1 ),
( 10, '00003.000001', '00003.000001', 1 );
/* Get count of MinCode rows that are the same, taking into account their sequence */
WITH cte AS (
SELECT
Id,
MinCode,
CASE WHEN
LAG ( MinCode, 1 ) OVER ( ORDER BY Id ) = MinCode
OR
LEAD ( MinCode, 1 ) OVER ( ORDER BY Id ) = MinCode
THEN 1
ELSE 0
END AS SeqMatch
FROM #Data
)
SELECT
Id, MinCode, MaxCode, ExpectedResult,
CASE WHEN MatchCount = 0 THEN 1 ELSE MatchCount END AS DerivedResult
FROM #Data d
OUTER APPLY (
SELECT SUM( SeqMatch ) AS MatchCount FROM cte WHERE cte.MinCode = d.MinCode
) AS x;
Returns
+----+--------------+--------------+----------------+---------------+
| Id | MinCode | MaxCode | ExpectedResult | DerivedResult |
+----+--------------+--------------+----------------+---------------+
| 1 | 00001.000001 | 00001.000001 | 2 | 2 |
| 2 | 00001.000001 | 00001.000002 | 2 | 2 |
| 3 | 00002.00001a | 00002.00001a | 3 | 3 |
| 4 | 00002.00001a | 00002.00001b | 3 | 3 |
| 5 | 00002.00001a | 00002.00001c | 3 | 3 |
| 6 | 00002.000002 | 00002.000002 | 1 | 1 |
| 7 | 00002.00003a | 00002.00003a | 2 | 2 |
| 8 | 00002.00003a | 00002.00003b | 2 | 2 |
| 9 | 00002.000002 | 00002.000004 | 1 | 1 |
| 10 | 00003.000001 | 00003.000001 | 1 | 1 |
+----+--------------+--------------+----------------+---------------+

Answer 3

I understand you want this
SELECT count(*) over (partition by MinCode ) as result
FROM test
order BY id
Gives
create table test (Id int, MinCode VARCHAR(30), MaxCode VARCHAR(30), ExpectedResult INT);
INSERT INTO test VALUES (1 , '00001.000001', '00001.000001', 2);
INSERT INTO test VALUES (2 , '00001.000001', '00001.000002', 2);
INSERT INTO test VALUES (3 , '00002.00001a', '00002.00001a', 3);
INSERT INTO test VALUES (4 , '00002.00001a', '00002.00001b', 3);
INSERT INTO test VALUES (5 , '00002.00001a', '00002.00001c', 3);
INSERT INTO test VALUES (6 , '00002.000002', '00002.000002', 1);
INSERT INTO test VALUES (7 , '00002.00003a', '00002.00003a', 2);
INSERT INTO test VALUES (8 , '00002.00003a', '00002.00003b', 2);
INSERT INTO test VALUES (9 , '00002.000002', '00002.000004', 1);
INSERT INTO test VALUES (10 , '00003.000001', '00003.000001', 1);
SELECT Id,MinCode,MaxCode, ExpectedResult AS You,
(count(*) over (partition by MinCode )) as Me
FROM test
order BY id
Id MinCode MaxCode You Me
1 00001.000001 00001.000001 2 2
2 00001.000001 00001.000002 2 2
3 00002.00001a 00002.00001a 3 3
4 00002.00001a 00002.00001b 3 3
5 00002.00001a 00002.00001c 3 3
6 00002.000002 00002.000002 1 2
7 00002.00003a 00002.00003a 2 2
8 00002.00003a 00002.00003b 2 2
9 00002.000002 00002.000004 1 2
10 00003.000001 00003.000001 1 1