Question

Lets say I have a database that looks like this:

tblA:
ID, Name, Sequence, tblBID
1     a       5        14
2     b       3        15
3     c       3        16
4     d       3        17

tblB:
ID, Group
14    1
15    1
16    2
17    3

I would like to sequence A so that the sequences go 1…n for each group of B.
So in this case, the sequences going down should be 1,2,1,1.

The ordering needs to be consistent with the current ordering, but there are no guarantees as to the current ordering.

I am not exactly a sql master and I am sure there is a fairly easy way to do this, but I really don’t know the right route to take. Any hints?

Answer 1

If you are using SQL Server 2005+ or higher, you can use a ranking function:

Select tblA.Id, tblA.Name
    , Row_Number() Over ( Partition By tblB.[Group] Order By tblA.Id ) As Sequence
    , tblA.tblBID
From tblA
    Join tblB
        On tblB.tblBID = tblB.ID

Row_Number ranking function.

Here’s another solution that would work in SQL Server 2000 and prior.

Select A.Id, A.Name
    , (Select Count(*)
        From tblB As B1
        Where B1.[Group] = B.[Group]
            And B1.Id < B.ID) + 1 As Sequence
    , A.tblBID
From tblA As A
    Join tblB As B
        On B.Id = A.tblBID

EDIT

Also want to make it clear that I want to actually update tblA to reflect the proper sequences.

In SQL Server, you can use their proprietary From clause in an Update statement like so:

Update tblA
Set Sequence =  (
                Select Count(*)
                From tblB As B1
                Where B1.[Group] = B.[Group]
                    And B1.Id < B.ID
                ) + 1
From tblA As A
    Join tblB As B
        On B.Id = A.tblBID

The Hoyle ANSI solution might be something like:

Update tblA
Set Sequence = (
                Select (Select Count(*)
                        From tblB As B1
                        Where B1.[Group] = B.[Group]
                            And B1.Id < B.ID) + 1
                From tblA As A
                    Join tblB As B
                        On B.Id = A.tblBID
                Where A.Id = tblA.Id
                )

EDIT

Can we do that [the inner group] comparison based on A.Sequence instead of B.ID?

Select A1.*
    , (Select Count(*)
        From tblB As B2
            Join tblA As A2
                On A2.tblBID = B2.Id
        Where B2.[Group] = B1.[Group]
            And A2.Sequence < A1.Sequence) + 1
From tblA As A1
    Join tblB As B1
        On B1.Id = A1.tblBID