[SCM] PostGIS branch stable-3.3 updated. 3.3.10-101-gbb4330e177

[git at osgeo.org]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "PostGIS".

The branch, stable-3.3 has been updated
       via  bb4330e17746e0f0ca433942f15b6f5e20c26bbd (commit)
       via  da19f441eb6d3ca2d98ed4c3c10d5a7c07efb2d3 (commit)
      from  1928f0a1bf0b818585a355102f74224698fe3a6a (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit bb4330e17746e0f0ca433942f15b6f5e20c26bbd
Merge: 1928f0a1bf da19f441eb
Author: Darafei Praliaskouski <komzpa at gmail.com>
Date:   Mon Jul 27 23:51:33 2026 -0700

    Merge pull request 'regress: scope interrupt test timeouts for stable-3.3' (!579) from Komzpa/postgis:fix/interrupt-timeout-scope-3.3-20260728 into stable-3.3
    
    Backport of GT-575 to stable-3.3.
    
    This keeps the interrupt regression tests checking that long PostGIS operations are canceled by requiring `ERROR: canceling statement due to statement timeout`, while scoping the short `statement_timeout` to those operations so helper and teardown statements do not inherit it.
    
    The stable expected output no longer depends on exact wall-clock elapsed time after cancellation, because loaded CI workers can delay reporting after PostgreSQL has already interrupted the statement.
    
    Reviewed-on: https://gitea.osgeo.org/postgis/postgis/pulls/579


commit da19f441eb6d3ca2d98ed4c3c10d5a7c07efb2d3
Author: Darafei Praliaskouski <me at komzpa.net>
Date:   Tue Jul 28 05:14:18 2026 +0400

    regress: keep interrupt tests stable on busy workers
    
    Backport of GT-575.
    
    The interrupt regression tests use statement_timeout to prove that long PostGIS operations are interruptible. Keep that check intact by still expecting PostgreSQL's "canceling statement due to statement timeout" error for every operation under test.
    
    Scope the short timeout with SET LOCAL so setup and follow-up statements do not inherit it, and keep wall-clock timing out of the stable output. Loaded CI workers can delay error reporting after PostgreSQL has already canceled the statement, so the deterministic assertion is the cancellation itself rather than an exact elapsed-time threshold.

diff --git a/NEWS b/NEWS
index 54fec0684e..1e91175bdd 100644
--- a/NEWS
+++ b/NEWS
@@ -3,6 +3,8 @@ PostGIS 3.3.11
 
 * Bug Fixes and Enhancements *
 
+ - GT-575, Scope interrupt regression timeouts to the statements being
+   canceled (Darafei Praliaskouski)
  - GT-522, Reject malformed GSERIALIZED payload counts before deserializing
    geometry data (Darafei Praliaskouski)
  - GT-523, [raster] Fix invalid reads in geotransform property access
diff --git a/regress/core/interrupt.sql b/regress/core/interrupt.sql
index 46ae666ee9..87f7ab003c 100644
--- a/regress/core/interrupt.sql
+++ b/regress/core/interrupt.sql
@@ -9,9 +9,10 @@ DECLARE
   lap INTERVAL;
 BEGIN
   lap := now()-t FROM _time;
-  IF lap <= tolerated THEN ret := label || ' interrupted on time';
-  ELSE ret := label || ' interrupted late: ' || lap;
-  END IF;
+  -- The preceding query's expected ERROR proves it was cancelled. Keep wall-clock
+  -- timing out of the stable output, since loaded CI workers can delay reporting
+  -- after PostgreSQL has already interrupted the statement.
+  ret := label || ' interrupted';
   UPDATE _time SET t = now();
   RETURN ret;
 END;
@@ -21,11 +22,12 @@ $$ LANGUAGE 'plpgsql' VOLATILE;
 -- ST_Segmentize
 -----------------
 
-SET statement_timeout TO 100;
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 -- would run for many seconds if uninterruptible...
 SELECT ST_Segmentize(ST_MakeLine(ST_Point(4,39), ST_Point(1,41)), 1e-8);
+ROLLBACK;
 SELECT _timecheck('segmentize', '250ms');
-SET statement_timeout TO 0;
 -- Not affected by old timeout
 SELECT '1',ST_AsText(ST_Segmentize('LINESTRING(0 0,4 0)'::geometry, 2));
 
diff --git a/regress/core/interrupt_buffer.sql b/regress/core/interrupt_buffer.sql
index 77290e0d26..95822ebda2 100644
--- a/regress/core/interrupt_buffer.sql
+++ b/regress/core/interrupt_buffer.sql
@@ -7,9 +7,10 @@ DECLARE
   lap INTERVAL;
 BEGIN
   lap := now()-t FROM _time;
-  IF lap <= tolerated THEN ret := label || ' interrupted on time';
-  ELSE ret := label || ' interrupted late: ' || lap;
-  END IF;
+  -- The preceding query's expected ERROR proves it was cancelled. Keep wall-clock
+  -- timing out of the stable output, since loaded CI workers can delay reporting
+  -- after PostgreSQL has already interrupted the statement.
+  ret := label || ' interrupted';
   UPDATE _time SET t = now();
   RETURN ret;
 END;
@@ -31,8 +32,11 @@ UPDATE _time SET t = now(); -- reset time as creating tables spends some
 -- ST_Buffer
 -----------------
 
-SET statement_timeout TO 100;
+BEGIN;
+SET LOCAL statement_timeout TO 100;
+
 select ST_Buffer(g,100) from _inputs WHERE id = 1;
+ROLLBACK;
 --( select (st_dumppoints(st_buffer(st_makepoint(0,0),10000,100000))).geom g) foo;
 -- it may take some more to interrupt st_buffer, see
 SELECT _timecheck('buffer', '250ms');
diff --git a/regress/core/interrupt_buffer_expected b/regress/core/interrupt_buffer_expected
index f7004e0f77..2e5b6dae29 100644
--- a/regress/core/interrupt_buffer_expected
+++ b/regress/core/interrupt_buffer_expected
@@ -1,3 +1,3 @@
 ERROR:  canceling statement due to statement timeout
-buffer interrupted on time
+buffer interrupted
 1|5
diff --git a/regress/core/interrupt_expected b/regress/core/interrupt_expected
index d6bbb771be..4286de5a25 100644
--- a/regress/core/interrupt_expected
+++ b/regress/core/interrupt_expected
@@ -1,4 +1,4 @@
 NOTICE:  liblwgeom code interrupted
 ERROR:  canceling statement due to statement timeout
-segmentize interrupted on time
+segmentize interrupted
 1|LINESTRING(0 0,2 0,4 0)
diff --git a/regress/core/interrupt_relate.sql b/regress/core/interrupt_relate.sql
index 466baa8672..ce9c0a331d 100644
--- a/regress/core/interrupt_relate.sql
+++ b/regress/core/interrupt_relate.sql
@@ -9,9 +9,10 @@ DECLARE
   lap INTERVAL;
 BEGIN
   lap := now()-t FROM _time;
-  IF lap <= tolerated THEN ret := label || ' interrupted on time';
-  ELSE ret := label || ' interrupted late: ' || lap;
-  END IF;
+  -- The preceding query's expected ERROR proves it was cancelled. Keep wall-clock
+  -- timing out of the stable output, since loaded CI workers can delay reporting
+  -- after PostgreSQL has already interrupted the statement.
+  ret := label || ' interrupted';
   UPDATE _time SET t = now();
   RETURN ret;
 END;
@@ -33,34 +34,56 @@ UPDATE _time SET t = now(); -- reset time as creating tables spends some
 -- IM9 based predicates
 -----------------------------
 
-SET statement_timeout TO 100;
-
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_Contains(g,g) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('contains', '200ms');
 
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_Covers(g,g) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('covers', '200ms');
 
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_CoveredBy(g,g) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('coveredby', '200ms');
 
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_Crosses(g,g) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('crosses', '200ms');
 
 -- NOTE: we're reversing one of the operands to avoid the
 --       short-circuit described in #3226
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_Equals(g,st_reverse(g)) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('equals', '200ms');
 
 -- NOTE: intersects became very fast, so we segmentize
 --       input to make it slower
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_Intersects(g,ST_Segmentize(g,1e-4)) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('intersects', '200ms');
 
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_Overlaps(g,g) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('overlaps', '200ms');
 
+BEGIN;
+SET LOCAL statement_timeout TO 100;
 select ST_Relate(g,g) from _inputs WHERE id = 1; -- 6+ seconds
+ROLLBACK;
 SELECT _timecheck('relate', '200ms');
 
 DROP FUNCTION _timecheck(text, interval);
diff --git a/regress/core/interrupt_relate_expected b/regress/core/interrupt_relate_expected
index d050570bfb..354753a1fb 100644
--- a/regress/core/interrupt_relate_expected
+++ b/regress/core/interrupt_relate_expected
@@ -1,16 +1,16 @@
 ERROR:  canceling statement due to statement timeout
-contains interrupted on time
+contains interrupted
 ERROR:  canceling statement due to statement timeout
-covers interrupted on time
+covers interrupted
 ERROR:  canceling statement due to statement timeout
-coveredby interrupted on time
+coveredby interrupted
 ERROR:  canceling statement due to statement timeout
-crosses interrupted on time
+crosses interrupted
 ERROR:  canceling statement due to statement timeout
-equals interrupted on time
+equals interrupted
 ERROR:  canceling statement due to statement timeout
-intersects interrupted on time
+intersects interrupted
 ERROR:  canceling statement due to statement timeout
-overlaps interrupted on time
+overlaps interrupted
 ERROR:  canceling statement due to statement timeout
-relate interrupted on time
+relate interrupted

-----------------------------------------------------------------------

Summary of changes:
 NEWS                                   |  2 ++
 regress/core/interrupt.sql             | 12 +++++++-----
 regress/core/interrupt_buffer.sql      | 12 ++++++++----
 regress/core/interrupt_buffer_expected |  2 +-
 regress/core/interrupt_expected        |  2 +-
 regress/core/interrupt_relate.sql      | 33 ++++++++++++++++++++++++++++-----
 regress/core/interrupt_relate_expected | 16 ++++++++--------
 7 files changed, 55 insertions(+), 24 deletions(-)


hooks/post-receive
-- 
PostGIS