create type complex as (r float8, i float8);

create type quadarray as (c1 complex[], c2 complex);

do LANGUAGE uplpgsql $$ declare a int[];

begin a := array[1,2]; a[3] := 4; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a[3] := 4; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a[1][4] := 4; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a[1] := 23::text; raise notice 'a = %', a; end$$; -- lax typing

do LANGUAGE uplpgsql $$ declare a int[];

begin a := array[1,2]; a[2:3] := array[3,4]; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a := array[1,2]; a[2] := a[2] + 1; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a[1:2] := array[3,4]; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a[1:2] := 4; raise notice 'a = %', a; end$$; -- error

do LANGUAGE uplpgsql $$ declare a complex[];

begin a[1] := (1,2); a[1].i := 11; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a complex[];

begin a[1].i := 11; raise notice 'a = %, a[1].i = %', a, a[1].i; end$$;

do LANGUAGE uplpgsql $$ declare a complex[];

begin a[1:2].i := array[11,12]; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a quadarray;

begin a.c1[1].i := 11; raise notice 'a = %, a.c1[1].i = %', a, a.c1[1].i; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a := array_agg(x) from (values(1),(2),(3)) v(x); raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[] := array[1,2,3];

-- test scenarios for optimization of updates of R/W expanded objects

a := array_append(a, 42); -- optimizable using "transfer" method

a := a || a[3]; -- optimizable using "inplace" method

a := a[1] || a; -- ditto, but let's test array_prepend

a := a || a; -- not optimizable

raise notice 'a = %', a;

end$$;

create temp table onecol as select array[1,2] as f1;

do LANGUAGE uplpgsql $$ declare a int[];

begin a := f1 from onecol; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a := * from onecol for update; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a := from onecol; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a := f1, f1 from onecol; raise notice 'a = %', a; end$$;

insert into onecol values(array[11]);

do LANGUAGE uplpgsql $$ declare a int[];

begin a := f1 from onecol; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a int[];

begin a := f1 from onecol limit 1; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a real;

begin a[1] := 2; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$ declare a complex;

begin a.r[1] := 2; raise notice 'a = %', a; end$$;

do LANGUAGE uplpgsql $$

declare

v int;

v1 v%type;

v2 v%type[];

v3 v%type[1];

v4 v%type[][];

v5 v%type[1][3];

v6 v%type array;

v7 v%type array[];

v8 v%type array[1];

v9 v%type array[1][1];

v10 pg_catalog.pg_class%rowtype[];

raise notice '%', pg_typeof(v1);

raise notice '%', pg_typeof(v2);

raise notice '%', pg_typeof(v3);

raise notice '%', pg_typeof(v4);

raise notice '%', pg_typeof(v5);

raise notice '%', pg_typeof(v6);

raise notice '%', pg_typeof(v7);

raise notice '%', pg_typeof(v8);

raise notice '%', pg_typeof(v9);

raise notice '%', pg_typeof(v10);

end;

$$;

do LANGUAGE uplpgsql $$

declare

v pg_node_tree;

v1 v%type[];

end;

$$;

do LANGUAGE uplpgsql $$

declare

v1 int;

v2 varchar;

a1 v1%type[];

a2 v2%type[];

v1 := 10;

v2 := 'Hi';

a1 := array[v1,v1];

a2 := array[v2,v2];

raise notice '% %', a1, a2;

end;

$$;

create table array_test_table(a int, b varchar);

insert into array_test_table values(1, 'first'), (2, 'second');

do LANGUAGE uplpgsql $$

declare tg array_test_table%rowtype[];

tg := array(select array_test_table from array_test_table);

raise notice '%', tg;

tg := array(select row(a,b) from array_test_table);

raise notice '%', tg;

end;

$$;

create or replace function na_read_escape() returns int language uplpgsql as $$

declare x int[]; y int[];

x := array_fill(7, array[5]);

y := x;

return y[1];

end; $$;

select na_read_escape();

create or replace function na_write_escape() returns int language uplpgsql as $$

declare x int[];

x := array_fill(7, array[5]);

x := array[1,2,3];

return x[1];

end; $$;

select na_write_escape();

create or replace function na_read_then_subscript() returns text language uplpgsql as $$

declare x int[]; s text;

x := array_fill(7, array[3]);

s := array_to_string(x, ',');

x[2] := 9;

return s || '/' || x[2]::text;

end; $$;

select na_read_then_subscript();

create or replace function na_round_trip() returns text language uplpgsql as $$

declare x int[];

x := array_fill(0, array[3]);

x := array[10,20,30];

x[2] := x[1] + x[3];

return array_to_string(x, ',');

end; $$;

select na_round_trip();

create or replace function na_raise_escape() returns text language uplpgsql as $$

declare x int[];

x := array_fill(7, array[3]);

raise notice 'na_raise_escape: %', x;

return 'ok';

end; $$;

select na_raise_escape();

create or replace function na_foreach_escape() returns int language uplpgsql as $$

declare x int[]; e int; t int := 0;

x := array_fill(7, array[3]);

foreach e in array x loop t := t + e; end loop;

return t;

end; $$;

select na_foreach_escape();

create or replace function na_execute_escape() returns int language uplpgsql as $$

declare x int[]; r int;

x := array_fill(7, array[3]);

execute 'select ($1)[1]' into r using x;

return r;

end; $$;

select na_execute_escape();

create or replace function na_multidim_dims() returns text language uplpgsql as $$

declare a int[] := array[[1,2],[3,4]];

return array_dims(a) || '/' || array_ndims(a) || '/' || a[1][2];

end; $$;

select na_multidim_dims();

create or replace function na_multidim_foreach() returns text language uplpgsql as $$

declare a int[] := array[[1,2],[3,4]]; s int[]; t int := 0; n int := 0;

foreach s slice 1 in array a loop n := n + 1; t := t + s[1]; end loop;

return 'iters=' || n || ' sum=' || t;

end; $$;

select na_multidim_foreach();

create or replace function na_multidim_fill() returns text language uplpgsql as $$

declare a int[];

a := array_fill(7, array[2,2]);

return array_dims(a);

end; $$;

select na_multidim_fill();

create or replace function na_multidim_into() returns text language uplpgsql as $$

declare a int[];

select array[[1,2],[3,4]] into a;

return array_dims(a);

end; $$;

select na_multidim_into();

create or replace function na_lowerbound() returns text language uplpgsql as $$

declare a int[] := '[2:3]={9,10}'::int[];

return array_dims(a) || '/' || a[2];

end; $$;

select na_lowerbound();

drop function na_multidim_dims();

drop function na_multidim_foreach();

drop function na_multidim_fill();

drop function na_multidim_into();

drop function na_lowerbound();

create or replace function na_fors_escape() returns int language uplpgsql as $$

declare x int[]; t int := 0; rec record;

x := array_fill(7, array[3]);

for rec in select unnest(x) as v loop t := t + rec.v; end loop;

return t;

end; $$;

select na_fors_escape();

create or replace function na_dynfors_escape() returns int language uplpgsql as $$

declare x int[]; t int := 0; rec record;

x := array_fill(7, array[3]);

for rec in execute 'select unnest($1) as v' using x loop t := t + rec.v; end loop;

return t;

end; $$;

select na_dynfors_escape();

create or replace function na_forc_escape() returns int language uplpgsql as $$

declare x int[]; t int := 0; rec record; c cursor for select unnest(x) as v;

x := array_fill(7, array[3]);

for rec in c loop t := t + rec.v; end loop;

return t;

end; $$;

select na_forc_escape();

drop function na_fors_escape();

drop function na_dynfors_escape();

drop function na_forc_escape();

create or replace function na_oob_read() returns text language uplpgsql as $$

declare a int[]; begin

a := array_fill(1, array[3]);

return coalesce(a[10]::text,'N') || '/' || coalesce(a[0]::text,'N') || '/'

|| coalesce(a[-1]::text,'N');

end; $$;

select na_oob_read();

create or replace function na_null_read() returns text language uplpgsql as $$

declare a int[]; r int; begin r := a[1]; return coalesce(r::text,'NULL'); end; $$;

select na_null_read();

create or replace function na_oob_write() returns text language uplpgsql as $$

declare a int[]; begin

a := array_fill(1, array[3]);

a[6] := 9;

return array_dims(a) || ' ' || a[6] || ' gap=' || coalesce(a[4]::text,'NULL')

|| ' kept=' || a[2];

end; $$;

select na_oob_write();

create or replace function na_fill_gap() returns text language uplpgsql as $$

declare a int[]; begin

a := array_fill(1, array[3]);

a[6] := 9;

a[4] := 4;

return a[4]::text || '/' || a[6]::text;

end; $$;

select na_fill_gap();

create or replace function na_grow() returns text language uplpgsql as $$

declare a int[]; i int; s bigint := 0; begin

for i in 1..5 loop a[i] := i*i; end loop;

for i in 1..5 loop s := s + a[i]; end loop;

return s::text || ' ' || array_dims(a);

end; $$;

select na_grow();

create or replace function na_grow_null_default() returns text language uplpgsql as $$

declare a int[] := NULL; begin a[1] := 7; return a[1]::text; end; $$;

select na_grow_null_default();

create or replace function na_write_null_arr() returns text language uplpgsql as $$

declare a int[]; begin a[3] := 7; return array_dims(a) || ' ' || a[3]; end; $$;

select na_write_null_arr();

create or replace function na_lb_read() returns text language uplpgsql as $$

declare a int[] := '[2:3]={9,10}'::int[]; begin

return coalesce(a[2]::text,'N') || '/' || coalesce(a[1]::text,'N');

end; $$;

select na_lb_read();

create or replace function na_lb_extend() returns text language uplpgsql as $$

declare a int[] := '[2:3]={9,10}'::int[]; begin

a[5] := 1;

return array_dims(a) || '/' || a[5];

end; $$;

select na_lb_extend();

create or replace function na_2d_single() returns text language uplpgsql as $$

declare a int[] := array[[1,2],[3,4]]; r int; begin

r := a[1];

return coalesce(r::text,'NULL') || '/' || array_dims(a) || '/' || a[1][2];

end; $$;

select na_2d_single();

create or replace function na_int8_grow() returns text language uplpgsql as $$

declare a bigint[]; begin

a := array_fill(5::bigint, array[3]);

a[5] := 7;

return a[5]::text || '/' || coalesce(a[4]::text,'N');

end; $$;

select na_int8_grow();

create or replace function na_float8_grow() returns text language uplpgsql as $$

declare a float8[]; begin

a := array_fill(1.5::float8, array[2]);

a[4] := 2.5;

return a[4]::text || '/' || coalesce(a[3]::text,'N');

end; $$;

select na_float8_grow();

create or replace function na_fast_path() returns text language uplpgsql as $$

declare x int[]; t bigint := 0; i int; begin

x := array_fill(2, array[100]);

x[50] := 3;

for i in 1..100 loop t := t + x[i]; end loop;

return t::text;

end; $$;

select na_fast_path();

drop function na_oob_read();

drop function na_null_read();

drop function na_oob_write();

drop function na_fill_gap();

drop function na_grow();

drop function na_grow_null_default();

drop function na_write_null_arr();

drop function na_lb_read();

drop function na_lb_extend();

drop function na_2d_single();

drop function na_int8_grow();

drop function na_float8_grow();

drop function na_fast_path();

create or replace function na_declare_default() returns int language uplpgsql as $$

declare a int[] := array[5,6]; r int;

r := a[1];

return r;

end; $$;

select na_declare_default();

create or replace function na_declare_default_write() returns int language uplpgsql as $$

declare a int[] := array[5,6];

a[1] := 3;

return a[1];

end; $$;

select na_declare_default_write();

create or replace function na_declare_default_exc() returns int language uplpgsql as $$

declare r int;

declare a int[] := array[8,9];

begin

r := a[1];

exception when others then r := -1;

end;

return r;

end; $$;

select na_declare_default_exc();

drop function na_declare_default();

drop function na_declare_default_write();

drop function na_declare_default_exc();

create or replace function na_poly_nested() returns int language uplpgsql as $$

declare a int[] := array[5,6]; r int;

r := array_length(a,1) + 1;

return r;

end; $$;

select na_poly_nested();

create or replace function na_poly_deep() returns int language uplpgsql as $$

declare a int[] := array[5,6]; r int;

r := abs(array_length(a,1) * 2) + 1;

return r;

end; $$;

select na_poly_deep();

drop function na_poly_nested();

drop function na_poly_deep();

create or replace function na_if_cond() returns text language uplpgsql as $$

declare x int[];

x := array_fill(7, array[3]);

if array_length(x,1) = 3 then return 'yes'; else return 'no'; end if;

end; $$;

select na_if_cond();

create or replace function na_while_cond() returns int language uplpgsql as $$

declare x int[]; n int := 0;

x := array_fill(7, array[3]);

while array_length(x,1) > n loop n := n + 1; end loop;

return n;

end; $$;

select na_while_cond();

drop function na_if_cond();

drop function na_while_cond();

drop function na_raise_escape();

drop function na_foreach_escape();

drop function na_execute_escape();

drop function na_read_escape();

drop function na_write_escape();

drop function na_read_then_subscript();

drop function na_round_trip();

create function na_store_null() returns text language uplpgsql as $$

declare a int[] := ARRAY[1,2,3]; b int; f float8[] := ARRAY[1,2,3]::float8[]; g float8;

a[2] := b;

f[2] := g;

return a::text || ' ' || f::text;

end; $$;

select na_store_null();

create function na_store_null_read() returns text language uplpgsql as $$

declare a int[] := ARRAY[1,2,3,4]; b int; r text;

a[2] := b;

a[4] := 9;

if a[2] is null then r := 'null'; else r := a[2]::text; end if;

return r || ' ' || a::text;

end; $$;

select na_store_null_read();

create function na_store_null_extend() returns text language uplpgsql as $$

declare a int[] := ARRAY[1,2]; b int;

a[5] := b;

a[4] := 4;

return a::text;

end; $$;

select na_store_null_extend();

create function na_store_cast(n int) returns int[] language uplpgsql as $$

declare a int[]; i int; v float8 := 2.0;

a := array_fill(0, ARRAY[n]);

for i in 1..n loop a[i] := floor(power(v, 0.45)*255.0 + 0.5)::int; end loop;

return a;

end; $$;

select na_store_cast(4);

create function na_store_cast_int8() returns bigint[] language uplpgsql as $$

declare a bigint[] := ARRAY[0,0,0]::bigint[]; v float8 := 3.7; g float8;

a[1] := round(v)::bigint;

a[2] := g::bigint;

a[3] := (v*2)::bigint;

return a;

end; $$;

select na_store_cast_int8();

create function na_store_cast_oob() returns int[] language uplpgsql as $$

declare a int[] := ARRAY[1,2]; v float8 := 7.0;

a[5] := floor(v)::int;

return a;

end; $$;

select na_store_cast_oob();

drop function na_store_null();

drop function na_store_null_read();

drop function na_store_null_extend();

drop function na_store_cast(int);

drop function na_store_cast_int8();

drop function na_store_cast_oob();

create function na_selective_sync() returns text language uplpgsql as $$

declare a int[] := ARRAY[1,2,3]; b int[] := ARRAY[9,9,9]; r int;

a[1] := 42; -- native writes: both Datums now stale

b[1] := 77;

r := greatest(a[1], 0); -- falls back, reads a but not b

return r::text || ' ' || a::text || ' ' || b::text;

end; $$;

select na_selective_sync();

create function na_selective_sync2() returns text language uplpgsql as $$

declare a int[] := ARRAY[1,2,3]; b int[] := ARRAY[9,9,9]; r int;

a[2] := 5;

b[2] := 6;

r := least(b[2], 100); -- falls back, reads b but not a

return r::text || ' ' || a::text || ' ' || b::text;

end; $$;

select na_selective_sync2();

create function na_selective_sync3() returns text language uplpgsql as $$

declare a int[] := ARRAY[1,2]; b int[] := ARRAY[3,4]; x int := 7; r int; q int;

a[1] := 10;

b[1] := 20;

q := greatest(x, 0); -- falls back, reads no array at all

r := greatest(a[1], b[1]); -- falls back, reads both

a[2] := 11; -- keep writing after the round trips

return q::text || ' ' || r::text || ' ' || a::text || ' ' || b::text;

end; $$;

select na_selective_sync3();

create function na_selective_whole() returns text language uplpgsql as $$

declare a int[] := ARRAY[1,2,3]; b int[] := ARRAY[9,9,9]; c int[];

a[3] := 30;

b[3] := 90;

c := a || b; -- falls back, reads both whole arrays

return c::text;

end; $$;

select na_selective_whole();

drop function na_selective_sync();

drop function na_selective_sync2();

drop function na_selective_sync3();

drop function na_selective_whole();

create function na_sync_recfield() returns int language uplpgsql as $$

declare a int[]; r record;

a := array_fill(0, ARRAY[3]);

select 0 as x into r;

a[1] := 42; -- native flat write; a's Datum is stale

r.x := a[1]; -- fallback assign, unprepared expression

return r.x;

end; $$;

select na_sync_recfield();

create function na_sync_partial() returns int language uplpgsql as $$

declare a int[]; r record; x int;

a := array_fill(0, ARRAY[3]);

select 5 as f into r;

a[1] := 42; -- native flat write; a's Datum is stale

x := r.f + a[1]; -- r.f cannot be analyzed at compile time

return x;

end; $$;

select na_sync_partial();

drop function na_sync_recfield();

drop function na_sync_partial();

create function na_nullleaf_div() returns text language uplpgsql as $$

declare a int[] := array[1,2,3]; y int;

a[1] := 1 / y;

return a::text;

end; $$;

select na_nullleaf_div();

create function na_nullleaf_ovf() returns text language uplpgsql as $$

declare a int[] := array[1,2,3]; x int;

a[2] := x + 2147483647;

return a::text;

end; $$;

select na_nullleaf_ovf();

create function na_nullleaf_f8() returns text language uplpgsql as $$

declare a float8[] := array[1.5,2.5]; z float8;

a[1] := z / 0.0;

return a::text;

end; $$;

select na_nullleaf_f8();

create function na_nullleaf_plain() returns text language uplpgsql as $$

declare a int[] := array[1,2,3]; y int;

a[2] := y;

return a::text;

end; $$;

select na_nullleaf_plain();

create function na_nullleaf_extend() returns text language uplpgsql as $$

declare a int[] := array[1,2,3]; y int;

a[6] := 1 / y;

return a::text || ' len ' || array_length(a, 1)::text;

end; $$;

select na_nullleaf_extend();

create function na_nullleaf_std(a int[]) returns text language uplpgsql as $$

declare y int;

a[2] := y;

a[3] := 1 / y;

return a::text;

end; $$;

select na_nullleaf_std(array[1,2,3]);

drop function na_nullleaf_div();

drop function na_nullleaf_ovf();

drop function na_nullleaf_f8();

drop function na_nullleaf_plain();

drop function na_nullleaf_extend();

drop function na_nullleaf_std(int[]);

create function na_nullsub_var() returns int[] language uplpgsql as $$

declare a int[] := array[1,2,3]; i int;

a[i] := 99;

return a;

end; $$;

select na_nullsub_var();

create function na_nullsub_oob() returns int[] language uplpgsql as $$

declare a int[] := array[1,2,3]; b int[] := array[2,7];

a[b[9]] := 99;

return a;

end; $$;

select na_nullsub_oob();

create function na_nullsub_elem() returns int[] language uplpgsql as $$

declare a int[] := array[1,2,3]; b int[] := array[2,null];

a[b[2]] := 99;

return a;

end; $$;

select na_nullsub_elem();

create function na_nullsub_fmgr() returns int[] language uplpgsql as $$

declare a int[] := array[1,2,3]; i int;

a[i] := floor(1.5)::int;

return a;

end; $$;

select na_nullsub_fmgr();

create function na_nullsub_std(a int[]) returns int[] language uplpgsql as $$

declare i int;

a[i] := 5;

return a;

end; $$;

select na_nullsub_std(array[1,2,3]);

create function na_nullsub_ok() returns int[] language uplpgsql as $$

declare a int[] := array[1,2,3]; i int := 2;

a[i] := 99;

return a;

end; $$;

select na_nullsub_ok();

create function na_nullread_std(p numeric[]) returns text language uplpgsql as $$

declare i int; x numeric;

x := p[i];

return coalesce(x::text, 'NULL');

end; $$;

select na_nullread_std(array[1.5,2.5]);

create function na_nullread_oob(p numeric[]) returns text language uplpgsql as $$

declare x numeric;

x := p[9];

return coalesce(x::text, 'NULL');

end; $$;

select na_nullread_oob(array[1.5,2.5]);

create function na_nullread_ok(p numeric[]) returns text language uplpgsql as $$

declare x numeric;

x := p[2];

return coalesce(x::text, 'NULL');

end; $$;

select na_nullread_ok(array[1.5,2.5]);

drop function na_nullsub_var();

drop function na_nullsub_oob();

drop function na_nullsub_elem();

drop function na_nullsub_fmgr();

drop function na_nullsub_std(int[]);

drop function na_nullsub_ok();

drop function na_nullread_std(numeric[]);

drop function na_nullread_oob(numeric[]);

drop function na_nullread_ok(numeric[]);

create function pa_read(a int[]) returns int language uplpgsql as $$

declare x int;

x := a[2];

return x;

end; $$;

select pa_read(ARRAY[1,NULL,3]) is null as read_null;

select pa_read(ARRAY[1,7,3]);

select pa_read(ARRAY[1]) is null as read_oob;

create function pa_read_nullsub(a int[]) returns int language uplpgsql as $$

declare i int; x int;

x := a[i];

return x;

end; $$;

select pa_read_nullsub(ARRAY[1,2,3]) is null as read_nullsub;

create function pa_read_expr(a int[]) returns int language uplpgsql as $$

declare x int;

x := a[2] + 1;

return x;

end; $$;

select pa_read_expr(ARRAY[1,NULL,3]) is null as expr_null;

select pa_read_expr(ARRAY[1,7,3]);

create function pa_write(a int[]) returns int[] language uplpgsql as $$

declare b int;

a[2] := b;

return a;

end; $$;

select pa_write(ARRAY[1,2,3]);

create function pa_round_trip(a int[]) returns int language uplpgsql as $$

declare b int; x int;

a[2] := b;

x := a[2];

return x;

end; $$;

select pa_round_trip(ARRAY[1,2,3]) is null as round_trip_null;

create function pa_write_expr(a int[], d int) returns int[] language uplpgsql as $$

a[2] := 10 / d;

return a;

end; $$;

select pa_write_expr(ARRAY[1,2,3], NULL);

select pa_write_expr(ARRAY[1,2,3], 5);

create function pa_write_nullsub(a int[]) returns text language uplpgsql as $$

declare i int; msg text;

begin

a[i] := 5;

msg := 'not reached';

exception when null_value_not_allowed then

msg := 'caught: ' || sqlerrm;

end;

return msg;

end; $$;

select pa_write_nullsub(ARRAY[1,2,3]);

drop function pa_read(int[]);

drop function pa_read_nullsub(int[]);

drop function pa_read_expr(int[]);

drop function pa_write(int[]);

drop function pa_round_trip(int[]);

drop function pa_write_expr(int[], int);

drop function pa_write_nullsub(int[]);

create function na_write_alloc_numeric() returns int language uplpgsql as $$

declare a int[] := array_fill(0, ARRAY[3]); m numeric := 2.5;

for i in 1..3 loop a[i] := (m * 4.0)::int; end loop;

return a[1] + a[2] + a[3];

end; $$;

select na_write_alloc_numeric();

create function na_write_text_intermediate() returns int language uplpgsql as $$

declare a int[] := array_fill(0, ARRAY[3]);