How to update multiple rows with values of two arrays in Postgres? - arrays

Question

I need to update a set of records in the x table with values stored in arrays. Anyone know how I could do it?
IDS_NEW_SPONSORS INTEGER[] := ARRAY[]::INTEGER[]; --possible values [1,2,3,4,5,6]
IDS_DEBTORS INTEGER[] := ARRAY[]::INTEGER[]; --possible values [20,21,22,23,24,25]
-- the arrays will be the same size--
UPDATE x
SET id_sponsor = [IDS_NEW_SPONSORS],-- HOW ADD
id_sponsor_historial = [IDS_DEBTORS], -- HOW ADD
id_patron = 5 -- ALWAYS SAME
WHERE id_sponsor = ANY(IDS_DEBTORS); -- this line working!!! loop each row
I'm working with postgres 11...
After update. the table would look like this:
id_sponsor | id_sponsor_historial | id_patron
1 20 5
2 21 5
3 22 5
4 23 5
5 24 5
6 25 5

Answer 1

The next a little tricky query do this work:
(The trick is match value in new values array by position in old values array)
UPDATE sponsors
SET
id_sponsor_historial = id_sponsor, -- save previous value as historical
id_sponsor = (array[1,2,3,4,5,6])[array_position(array[20,21,22,23,24,25], id_sponsor)],-- update new value
id_patron = 5
WHERE id_sponsor = ANY(array[20,21,22,23,24,25]); -- find rows
I rest the integers array for example. In your case it should be changed to variables. The example works only if new and old values arrays have equals lengths.

Answer 2

You can use a function to do that. Here is an example:
create table x(
id_sponsor int primary key,
id_sponsor_historial int,
id_patron int);
CREATE OR REPLACE FUNCTION update_x(
integer,
integer[],
integer[])
RETURNS integer AS
$BODY$
DECLARE
in_pat ALIAS FOR $1;
in_sp_arr ALIAS FOR $2;
in_sp_hi_arr ALIAS FOR $3;
BEGIN
IF in_sp_arr ISNULL
THEN
RETURN 0;
END IF;
IF array_lower(in_sp_arr,1) ISNULL
OR array_upper(in_sp_arr,1) ISNULL
THEN
RETURN 0;
END IF;
FOR index IN array_lower(in_sp_arr,1) .. array_upper(in_sp_arr,1) LOOP
BEGIN
INSERT INTO x(id_sponsor, id_sponsor_historial, id_patron )
VALUES ( in_sp_arr[index], in_sp_hi_arr[index], in_pat);
--EXCEPTION WHEN unique_violation THEN
--do nothing ?
END;
END LOOP;
RETURN 1;
END;
$BODY$
LANGUAGE plpgsql ;
select update_x(5, ARRAY[1,2,3,4,5,6],ARRAY[20,21,22,23,24,25]);
This would probably need more error checking: It assumes for example, that the arrays are of the same size, have the same bounds and all the elements are defined.

Answer 3

What I was trying to do is update the records as follows
A: Replacing the old sponsors (old_sponsor) with the new ones (new_sponsor)
B: Updating the historical_sponsor_id with the values ​​of old_sponsor
C: Adding all of them the same id_patron
I could do it this way based on the #clamp response..
DECLARE
new_sponsor INTEGER[] := array[2300,2034,2032];
old_sponsor INTEGER[] := array[1500,1501,1502];
BEGIN
FOR i IN array_lower(new_sponsor, 1) .. array_upper(new_sponsor, 1)
LOOP
UPDATE x SET id_sponsor = new_sponsor[i],
id_sponsor_historial = old_sponsor[i], id_patron = 5
WHERE id_sponsor = old_sponsor[i];
END LOOP;
END
I would like to know if it is useful for processing more than 10,000 records or if there is a better way to do it efficiently.

Answer 4

The most efficient way to achieve this would be using UNNEST:
UPDATE sponsors
SET
-- save previous value as historical
id_sponsor_historial = bulk_query.id_sponsor,
-- update new value
id_sponsor = bulk_query.updated_id_sponsor,
-- set another field
id_patron = 5
FROM
(
SELECT * FROM UNNEST(
array[20,21,22,23,24,25]::INT[],
array[1,2,3,4,5,6]:INT[]
) AS t(id_sponsor, updated_id_sponsor)
) AS bulk_query
WHERE
sponsors.id_sponsor=bulk_query.id_sponsor
This effectively creates a temporary table from the two arrays, and then uses that to perform the update.
I've written more about using UNNEST with Postgres in this blog post: https://www.atdatabases.org/blog/2022/01/21/optimizing-postgres-using-unnest