postgres array : update multiple non contiguous array indices in one query - arrays

Question

Consider a table temp1
create temporary table temp1 (
id integer,
days integer[]
);
insert into temp1 values (1, '{}');
And another table temp2
create temporary table temp2(
id integer
);
insert into temp2 values (2);
insert into temp2 values (5);
insert into temp2 values (6);
I want to use temp2 id values as indices of the days array of temp1. i.e. I want to update
days[index] = 99 where index is the id value from temp2. I want to accomplish this in single query or if not possible, the most optimal way.
Here is what I am trying and it updates only one index and not all. Is it possible to update multiple indices of the array ? I understand it can be done using a loop but just was hoping if more optimized solution is possible ?
update temp1
set days[temp2.id] = 99
from temp2;
select * from temp1;
id | days
----+------------
1 | [2:2]={99}
(1 row)

Answer 1

TL;DR: Don't use arrays for this. Really. Just because you can doesn't mean you should.
PostgreSQL's arrays are really not designed for in-place modification; they're data values, not dynamic data structures. I don't think what you're trying to do makes much sense, and suggest you re-evaluate your schema now before you dig yourself into a deeper hole.
You can't just construct a single null-padded array value from temp2 and do a slice-update because that'll overwrite values in days with nulls. There is no "update only non-null array elements" operator.
So we have to do this by decomposing the array into a set, modifying it, recomposing it into an array.
To solve that what I'm doing is:
Taking all rows from temp2 and adding the associated value, to produce (index, value) pairs
Doing a generate_series over the range from 1 to the highest index on temp2 and doing a left join on it, so there's one row for each index position
Left joining all that on the unnested original array and coalesceing away nulls
... then doing an array_agg ordered by index to reconstruct the array.
With a more realistic/useful starting array state:
create temporary table temp1 (
id integer primary key,
days integer[]
);
insert into temp1 values (1, '{42,42,42}');
Development step 1: index/value pairs
First associate values with each index:
select id, 99 from temp2;
Development step 2: add nulls for missing indexes
then join on generate_series to add entries for missing indexes:
SELECT gs.i, temp2values.newval
FROM (
SELECT id AS newvalindex, 99 as newval FROM temp2
) temp2values
RIGHT OUTER JOIN (
SELECT i FROM generate_series(1, (select max(id) from temp2)) i
) gs
ON (temp2values.newvalindex = gs.i);
Development step 3: merge the original array values in
then join that on the unnested original array. You can use UNNEST ... WITH ORDINALITY for this in PostgreSQL 9.4, but I'm guessing you're not running that yet so I'll show the old approach with row_number. Note the use of a full outer join and the change to the outer bound of the generate_series to handle the case where the original values array is longer than the highest index in the new values list:
SELECT gs.i, coalesce(temp2values.newval, originals.val) AS val
FROM (
SELECT id AS newvalindex, 99 as newval FROM temp2
) temp2values
RIGHT OUTER JOIN (
SELECT i FROM generate_series(1, (select greatest(max(temp2.id), array_length(days,1)) from temp2, temp1 group by temp1.id)) i
) gs
ON (temp2values.newvalindex = gs.i)
FULL OUTER JOIN (
SELECT row_number() OVER () AS index, val
FROM temp1, LATERAL unnest(days) val
WHERE temp1.id = 1
) originals
ON (originals.index = gs.i)
ORDER BY gs.i;
This produces something like:
regress=> \e
i | val
---+----------
1 | 42
2 | 99
3 | 42
4 |
5 | 99
6 | 99
(6 rows)
Development step 4: Produce the desired new array value
so now we just need to turn it back into an array by removing the ORDER BY clause at the end and using array_agg:
SELECT array_agg(coalesce(temp2values.newval, originals.val) ORDER BY gs.i)
FROM (
SELECT id AS newvalindex, 99 as newval FROM temp2
) temp2values
RIGHT OUTER JOIN (
SELECT i FROM generate_series(1, (select greatest(max(temp2.id), array_length(days,1)) from temp2, temp1 group by temp1.id)) i
) gs
ON (temp2values.newvalindex = gs.i)
FULL OUTER JOIN (
SELECT row_number() OVER () AS index, val
FROM temp1, LATERAL unnest(days) val
WHERE temp1.id = 1
) originals
ON (originals.index = gs.i);
with a result like:
array_agg
-----------------------
{42,99,42,NULL,99,99}
(1 row)
Final query: Use it in an UPDATE
UPDATE temp1
SET days = newdays
FROM (
SELECT array_agg(coalesce(temp2values.newval, originals.val) ORDER BY gs.i)
FROM (
SELECT id AS newvalindex, 99 as newval FROM temp2
) temp2values
RIGHT OUTER JOIN (
SELECT i FROM generate_series(1, (select greatest(max(temp2.id), array_length(days,1)) from temp2, temp1 group by temp1.id)) i
) gs
ON (temp2values.newvalindex = gs.i)
FULL OUTER JOIN (
SELECT row_number() OVER () AS index, val
FROM temp1, LATERAL unnest(days) val
WHERE temp1.id = 1
) originals
ON (originals.index = gs.i)
) calc_new_days(newdays)
WHERE temp1.id = 1;
Note, however, that **this only works for a single entry in temp1.id,and I've specified temp1.id twice in the query: once inside the query to generate the new array value, and once in the update predicate.
To avoid that, you'd need a key in temp2 that references temp1.id and you'd need to make some changes to allow the generated padding rows to have the correct id value.
I hope this convinces you that you should probably not be using arrays for what you're doing, because it's horrible.