New ID based on shared attribute among rows - sql

Question

I have a table transactions with columns account_id, device_id and card_id. I'd like to create a new column token defined as user ID. This new column will have same value between transactions that share values of at least one of the 3 columns previously mentioned.
The idea is to create a user identifier that is a mix of account, device and card. This new ID is "stronger" than using any of the previous ones, in the sense that, for instance, if someone changes his account or device but not his card, his transactions will still be linked to the previous ones by this new token id.
Which would be a simple way to do this in Redshift SQL?
Example:
transaction_id account_id device_id card_id token
1 1 1 1 1
2 1 2 2 1
3 2 2 3 1
4 3 3 3 1
5 4 4 4 2
6 5 4 5 2
7 6 8 2 1
8 7 7 7 3
In the above example:
T1 has token 1 since first transaction.
T2 has token 1 since linked to T1 by account.
T3 has token 1 since linked to T2 by device.
T4 has token 1 since linked to T3 by card.
T5 has token 2 since any to the 3 fields share a value with previous transactions (new user).
T6 has token 2 since linked to T5 by device.
T7 has token 1 since linked to T2 by card.
T8 has token 3 since any to the 3 fields share a value with previous transactions (new user)
UPDATE
I managed to get a solution based on 2 steps :
For each transaction, I update the token column with the transaction_id of the oldest transaction linked to any of the 3 IDs (acccount, device or card). This step doesn't solve the problem because for instance, T4 should have token 1, but it has token 2 since the oldest transaction linked to T4 is T2, not T1.
Once each transaction has the oldest transaction linked, I update all the transactions (whose token is not the same transaction ID, just for performance since not needed), and I change its token for the token of the transaction linked. By doing this incrementaly one row at a time and in different SQL transactions, I get the output expected.
Here is the code
create table sandbox.test(
transaction_id integer,
account_id integer,
device_id integer,
card_id integer
);
insert into sandbox.test values
(1, 1, 1, 1),
(2, 1, 2, 2),
(3, 2, 2, 3),
(4, 3, 3, 3),
(5, 4, 4, 4),
(6, 5, 4, 5),
(7, 6, 8, 2),
(8, 7, 7, 7),
(9, 3, 9, 9),
(10, 10, 9, 9);
alter table sandbox.test
add column token int
default NULL;
-- Step 1
update sandbox.test
set token = A.token
from (
with links as (
select transaction_id,
first_value(transaction_id)
over(partition by account_id order by transaction_id rows unbounded preceding) as account_link,
first_value(transaction_id)
over(partition by device_id order by transaction_id rows unbounded preceding) device_link,
first_value(transaction_id)
over(partition by card_id order by transaction_id rows unbounded preceding) card_link
from sandbox.test
)
select l1.transaction_id, least(l2.account_link, l2.device_link, l2.card_link) token
from links l2
inner join links l1
on l2.transaction_id=least(l1.account_link, l1.device_link, l1.card_link)
) A
where sandbox.test.transaction_id=A.transaction_id;
-- Step 2
CREATE OR REPLACE PROCEDURE refresh_transactions() AS $$
DECLARE
transactions RECORD;
BEGIN
FOR transactions IN SELECT transaction_id FROM sandbox.test ORDER BY transaction_id LOOP
RAISE INFO '%', transactions.transaction_id;
EXECUTE 'update
sandbox.test
set token = (select A.token from sandbox.test A where
A.transaction_id = sandbox.test.token)
where transaction_id='||transactions.transaction_id||';';
END LOOP;
RETURN;
END;
$$ LANGUAGE plpgsql;
CALL refresh_transactions();
However, the second part of this solution (the refresh_transactions() call) takes too long to run on my DB with millions of transactions, so impossible to implement it. Maybe there is a way to do it more efficiently ?