projects / postgresql.git / commitdiff
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 8a6e85b)
Optimize tuplestore usage for WITH RECURSIVE CTEs
authorDavid Rowley <drowley@postgresql.org>
Thu, 19 Sep 2024 03:20:35 +0000 (15:20 +1200)
committerDavid Rowley <drowley@postgresql.org>
Thu, 19 Sep 2024 03:20:35 +0000 (15:20 +1200)
nodeRecursiveunion.c makes use of two tuplestores and, until now, would
delete and recreate one of these tuplestores after every recursive
iteration.

Here we adjust that behavior and instead reuse one of the existing
tuplestores and just empty it of all tuples using tuplestore_clear().

This saves some free/malloc roundtrips and has shown a 25-30% performance
improvement for queries that perform very little work between recursive
iterations.

This also paves the way to add some EXPLAIN ANALYZE telemetry output for
recursive common table expressions, similar to what was done in 1eff8279d
and 95d6e9af0.  Previously calling tuplestore_end() would have caused
the maximum storage space used to be lost.

Reviewed-by: Tatsuo Ishii
Discussion: https://postgr.es/m/CAApHDvr9yW0YRiK8A2J7nvyT8g17YzbSfOviEWrghazKZbHbig@mail.gmail.com

src/backend/executor/nodeRecursiveunion.c patch | blob | blame | history

diff --git a/src/backend/executor/nodeRecursiveunion.c b/src/backend/executor/nodeRecursiveunion.c
index c7f8a19fa44fc9ce152422ecaca0bdd59094955e..22e7b83b2e6e9a11972a1a12b2e9b7c375b4d85e 100644 (file)
--- a/src/backend/executor/nodeRecursiveunion.c
+++ b/src/backend/executor/nodeRecursiveunion.c
@@ -115,19 +115,26 @@ ExecRecursiveUnion(PlanState *pstate)
        slot = ExecProcNode(innerPlan);
        if (TupIsNull(slot))
        {
+           Tuplestorestate *swaptemp;
+
            /* Done if there's nothing in the intermediate table */
            if (node->intermediate_empty)
                break;
 
-           /* done with old working table ... */
-           tuplestore_end(node->working_table);
+           /*
+            * Now we let the intermediate table become the work table.  We
+            * need a fresh intermediate table, so delete the tuples from the
+            * current working table and use that as the new intermediate
+            * table.  This saves a round of free/malloc from creating a new
+            * tuple store.
+            */
+           tuplestore_clear(node->working_table);
 
-           /* intermediate table becomes working table */
+           swaptemp = node->working_table;
            node->working_table = node->intermediate_table;
+           node->intermediate_table = swaptemp;
 
-           /* create new empty intermediate table */
-           node->intermediate_table = tuplestore_begin_heap(false, false,
-                                                            work_mem);
+           /* mark the intermediate table as empty */
            node->intermediate_empty = true;
 
            /* reset the recursive term */
This is the main PostgreSQL git repository.