For each selected row insert another? - sql

Question

I have a single table TableA. It has columns id, type, relatedId, another1, another2. Column type can have values 1, 2 or 3.
What I need is, for each row in TableA, where type = 1, insert another row in the same table and update the original row (column relatedId) with id of newly inserted row. Also, values for some columns in newly inserted row should be copied from the original one.
So for current state:
id|type|relatedId|another1
10| 1 |null|"some text"
11| 2 |null|"somthing"
12| 1 |null|"somthing else"
result should be following:
id|type|relatedId|another1
10| 1 |13 |"some text" - now has relationship to 13
11| 2 |null|"somthing"
12| 1 |14 |"somthing else" - now has relationship to 13
13| 3 |null|"some text" - inserted, "another1" is copied from 10
14| 3 |null|"somthing else" - inserted, "another1" is copied from 12

Answer 1

Assuming the texts are unique you can do this:
demo:db<>fiddle
WITH ins AS (
INSERT INTO tablea(type, related_id, another1)
SELECT 3, null, another1
FROM tablea
WHERE type = 1
RETURNING id, another1
)
UPDATE tablea t
SET related_id = s.id
FROM (
SELECT * FROM ins
) s
WHERE s.another1 = t.another1 AND t.type = 1
The WITH clause allows to execute two separate statements sequentially. So first inserting the new data. With the new generated ids you can update the old data afterwards. Because you have to match the original data, the text is helpful as identifier.
This only works if you do not have to datasets with (1, 'something'). Then it would be hard to identify which of both records is the original for each copy.
Another way could be to store the type1-ids in the new type3-columns as well. If this would be ok for you, you could do this:
demo:db<>fiddle
WITH ins AS (
INSERT INTO tablea(type, related_id, another1)
SELECT 3, id, another1
FROM tablea
WHERE type = 1
RETURNING id, related_id, another1
)
UPDATE tablea t
SET related_id = s.id
FROM (
SELECT * FROM ins
) s
WHERE s.related_id = t.id
This stores the original type1-ids in the related_id column of the new ones. So in every case the original id can be found over this value.
Unfortunately, you cannot NULL out these columns in another WITH clause because the WITH clauses only work with existing data. At this moment the query itself is not done yet. So the new records do not exist physically.
This one could work...
demo:db<>fiddle
WITH to_be_copied AS (
SELECT id, another1
FROM tablea
WHERE type = 1
), ins AS (
INSERT INTO tablea(type, related_id, another1)
SELECT 3, null, another1
FROM to_be_copied
ORDER BY id -- 1
RETURNING id, another1
)
UPDATE tablea t
SET related_id = s.type3_id
FROM (
SELECT
*
FROM
(SELECT id as type1_id, row_number() OVER (ORDER BY id) FROM to_be_copied) tbc
JOIN
(SELECT id as type3_id, row_number() OVER (ORDER BY id) FROM ins) i
ON tbc.row_number = i.row_number
) s
WHERE t.id = s.type1_id
This solution assumes that the given order at (1) ensures the inserting order of the new records. In fact, I am not quite sure about it. But if so: First all type1 records are queried. After that there are copied (in the same order!). After that the old and the new records ids are taken. The row_number() window function adds a consecutive row count to the records. So if both data sets have the same order, the old ids should get the same row number as their corresponding new ids. In that case an identification is possible. For the small example this works...
--> Edit: This seems to say: Yes, the order will be preserved since Postgres 9.6 https://stackoverflow.com/a/50822258/3984221

Answer 2

According to this question Postgres retains the order of row inserted via a SELECT with explicit ORDER BY as of 9.6. We can use this to connect the inserted rows with those they come from using row_number().
WITH
"cte1"
AS
(
SELECT "id",
3 "type",
"related_id",
"another1",
row_number() OVER (ORDER BY "id") "rn"
FROM "tablea"
WHERE "type" = 1
),
"cte2"
AS
(
INSERT INTO "tablea"
("type",
"another1")
SELECT "type",
"another1"
FROM "cte1"
ORDER BY "id"
RETURNING "id"
),
"cte3"
AS
(
SELECT "id",
row_number() OVER (ORDER BY "id") "rn"
FROM "cte2"
)
UPDATE "tablea"
SET "related_id" = "cte3"."id"
FROM "cte1"
INNER JOIN "cte3"
ON "cte3"."rn" = "cte1"."rn"
WHERE "cte1"."id" = "tablea"."id";
In the first CTE we get all the rows, that should be insert along with their row_number() ordered by their ID. In the second one we insert them by selecting from the first CTE explicitly ordering by the ID. We return the inserted ID in the second CTE, so that we can select it in the third CTE where we again add a row_number() ordered by the ID. We can now join the first and the third CTE via the row number to get pairs of original ID and newly inserted IDs. Base on that we can update the table setting the related IDs.
db<>fiddle