Test EXPLAIN (FORMAT JSON) ... XMLTABLE

Also, add an alias to the XMLTABLE expression in an existing test.  This
covers some code in explain.c that wasn't previously covered.

I patched xml_2.out blindly :-(

Discussion: https://postgr.es/m/202401181146[email protected]

diff --git a/src/test/regress/expected/xml.out b/src/test/regress/expected/xml.out
index 13e4296bf8ffbe1225824adcc06ac559b8443b2b..6500cff885d10a78dad632c6807c7e2939d89a0a 100644 (file)
--- a/src/test/regress/expected/xml.out
+++ b/src/test/regress/expected/xml.out
@@ -1549,19 +1549,60 @@ SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan"
 (1 row)
 
 EXPLAIN (VERBOSE, COSTS OFF)
-SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) WHERE "COUNTRY_NAME" = 'Japan';
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
                                                                                     QUERY PLAN                                                                                    
 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  Nested Loop
-   Output: "xmltable"."COUNTRY_NAME", "xmltable"."REGION_ID"
+   Output: f."COUNTRY_NAME", f."REGION_ID"
    ->  Seq Scan on public.xmldata
          Output: xmldata.data
-   ->  Table Function Scan on "xmltable"
-         Output: "xmltable"."COUNTRY_NAME", "xmltable"."REGION_ID"
+   ->  Table Function Scan on "xmltable" f
+         Output: f."COUNTRY_NAME", f."REGION_ID"
          Table Function Call: XMLTABLE(('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]'::text) PASSING (xmldata.data) COLUMNS "COUNTRY_NAME" text, "REGION_ID" integer)
-         Filter: ("xmltable"."COUNTRY_NAME" = 'Japan'::text)
+         Filter: (f."COUNTRY_NAME" = 'Japan'::text)
 (8 rows)
 
+EXPLAIN (VERBOSE, FORMAT JSON, COSTS OFF)
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
+                                                                                           QUERY PLAN                                                                                            
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ [                                                                                                                                                                                              +
+   {                                                                                                                                                                                            +
+     "Plan": {                                                                                                                                                                                  +
+       "Node Type": "Nested Loop",                                                                                                                                                              +
+       "Parallel Aware": false,                                                                                                                                                                 +
+       "Async Capable": false,                                                                                                                                                                  +
+       "Join Type": "Inner",                                                                                                                                                                    +
+       "Output": ["f.\"COUNTRY_NAME\"", "f.\"REGION_ID\""],                                                                                                                                     +
+       "Inner Unique": false,                                                                                                                                                                   +
+       "Plans": [                                                                                                                                                                               +
+         {                                                                                                                                                                                      +
+           "Node Type": "Seq Scan",                                                                                                                                                             +
+           "Parent Relationship": "Outer",                                                                                                                                                      +
+           "Parallel Aware": false,                                                                                                                                                             +
+           "Async Capable": false,                                                                                                                                                              +
+           "Relation Name": "xmldata",                                                                                                                                                          +
+           "Schema": "public",                                                                                                                                                                  +
+           "Alias": "xmldata",                                                                                                                                                                  +
+           "Output": ["xmldata.data"]                                                                                                                                                           +
+         },                                                                                                                                                                                     +
+         {                                                                                                                                                                                      +
+           "Node Type": "Table Function Scan",                                                                                                                                                  +
+           "Parent Relationship": "Inner",                                                                                                                                                      +
+           "Parallel Aware": false,                                                                                                                                                             +
+           "Async Capable": false,                                                                                                                                                              +
+           "Table Function Name": "xmltable",                                                                                                                                                   +
+           "Alias": "f",                                                                                                                                                                        +
+           "Output": ["f.\"COUNTRY_NAME\"", "f.\"REGION_ID\""],                                                                                                                                 +
+           "Table Function Call": "XMLTABLE(('/ROWS/ROW[COUNTRY_NAME=\"Japan\" or COUNTRY_NAME=\"India\"]'::text) PASSING (xmldata.data) COLUMNS \"COUNTRY_NAME\" text, \"REGION_ID\" integer)",+
+           "Filter": "(f.\"COUNTRY_NAME\" = 'Japan'::text)"                                                                                                                                     +
+         }                                                                                                                                                                                      +
+       ]                                                                                                                                                                                        +
+     }                                                                                                                                                                                          +
+   }                                                                                                                                                                                            +
+ ]
+(1 row)
+
 -- should to work with more data
 INSERT INTO xmldata VALUES('<ROWS>
 <ROW id="10">

diff --git a/src/test/regress/expected/xml_1.out b/src/test/regress/expected/xml_1.out
index eb9c6f2ed4196ceea64f80e80b5853679e9245a2..9323b84ae21d26aee2a6f98f8f0685d7022314bd 100644 (file)
--- a/src/test/regress/expected/xml_1.out
+++ b/src/test/regress/expected/xml_1.out
@@ -1174,19 +1174,60 @@ SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan"
 (0 rows)
 
 EXPLAIN (VERBOSE, COSTS OFF)
-SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) WHERE "COUNTRY_NAME" = 'Japan';
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
                                                                                     QUERY PLAN                                                                                    
 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  Nested Loop
-   Output: "xmltable"."COUNTRY_NAME", "xmltable"."REGION_ID"
+   Output: f."COUNTRY_NAME", f."REGION_ID"
    ->  Seq Scan on public.xmldata
          Output: xmldata.data
-   ->  Table Function Scan on "xmltable"
-         Output: "xmltable"."COUNTRY_NAME", "xmltable"."REGION_ID"
+   ->  Table Function Scan on "xmltable" f
+         Output: f."COUNTRY_NAME", f."REGION_ID"
          Table Function Call: XMLTABLE(('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]'::text) PASSING (xmldata.data) COLUMNS "COUNTRY_NAME" text, "REGION_ID" integer)
-         Filter: ("xmltable"."COUNTRY_NAME" = 'Japan'::text)
+         Filter: (f."COUNTRY_NAME" = 'Japan'::text)
 (8 rows)
 
+EXPLAIN (VERBOSE, FORMAT JSON, COSTS OFF)
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
+                                                                                           QUERY PLAN                                                                                            
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ [                                                                                                                                                                                              +
+   {                                                                                                                                                                                            +
+     "Plan": {                                                                                                                                                                                  +
+       "Node Type": "Nested Loop",                                                                                                                                                              +
+       "Parallel Aware": false,                                                                                                                                                                 +
+       "Async Capable": false,                                                                                                                                                                  +
+       "Join Type": "Inner",                                                                                                                                                                    +
+       "Output": ["f.\"COUNTRY_NAME\"", "f.\"REGION_ID\""],                                                                                                                                     +
+       "Inner Unique": false,                                                                                                                                                                   +
+       "Plans": [                                                                                                                                                                               +
+         {                                                                                                                                                                                      +
+           "Node Type": "Seq Scan",                                                                                                                                                             +
+           "Parent Relationship": "Outer",                                                                                                                                                      +
+           "Parallel Aware": false,                                                                                                                                                             +
+           "Async Capable": false,                                                                                                                                                              +
+           "Relation Name": "xmldata",                                                                                                                                                          +
+           "Schema": "public",                                                                                                                                                                  +
+           "Alias": "xmldata",                                                                                                                                                                  +
+           "Output": ["xmldata.data"]                                                                                                                                                           +
+         },                                                                                                                                                                                     +
+         {                                                                                                                                                                                      +
+           "Node Type": "Table Function Scan",                                                                                                                                                  +
+           "Parent Relationship": "Inner",                                                                                                                                                      +
+           "Parallel Aware": false,                                                                                                                                                             +
+           "Async Capable": false,                                                                                                                                                              +
+           "Table Function Name": "xmltable",                                                                                                                                                   +
+           "Alias": "f",                                                                                                                                                                        +
+           "Output": ["f.\"COUNTRY_NAME\"", "f.\"REGION_ID\""],                                                                                                                                 +
+           "Table Function Call": "XMLTABLE(('/ROWS/ROW[COUNTRY_NAME=\"Japan\" or COUNTRY_NAME=\"India\"]'::text) PASSING (xmldata.data) COLUMNS \"COUNTRY_NAME\" text, \"REGION_ID\" integer)",+
+           "Filter": "(f.\"COUNTRY_NAME\" = 'Japan'::text)"                                                                                                                                     +
+         }                                                                                                                                                                                      +
+       ]                                                                                                                                                                                        +
+     }                                                                                                                                                                                          +
+   }                                                                                                                                                                                            +
+ ]
+(1 row)
+
 -- should to work with more data
 INSERT INTO xmldata VALUES('<ROWS>
 <ROW id="10">

diff --git a/src/test/regress/expected/xml_2.out b/src/test/regress/expected/xml_2.out
index c8ed8e0cfa60f525629c769c44d2c4e51c716097..e1d165c6c936005cbc0f724d9a175d604068b549 100644 (file)
--- a/src/test/regress/expected/xml_2.out
+++ b/src/test/regress/expected/xml_2.out
@@ -1529,19 +1529,60 @@ SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan"
 (1 row)
 
 EXPLAIN (VERBOSE, COSTS OFF)
-SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) WHERE "COUNTRY_NAME" = 'Japan';
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
                                                                                     QUERY PLAN                                                                                    
 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
  Nested Loop
-   Output: "xmltable"."COUNTRY_NAME", "xmltable"."REGION_ID"
+   Output: f."COUNTRY_NAME", f."REGION_ID"
    ->  Seq Scan on public.xmldata
          Output: xmldata.data
-   ->  Table Function Scan on "xmltable"
-         Output: "xmltable"."COUNTRY_NAME", "xmltable"."REGION_ID"
+   ->  Table Function Scan on "xmltable" f
+         Output: f."COUNTRY_NAME", f."REGION_ID"
          Table Function Call: XMLTABLE(('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]'::text) PASSING (xmldata.data) COLUMNS "COUNTRY_NAME" text, "REGION_ID" integer)
-         Filter: ("xmltable"."COUNTRY_NAME" = 'Japan'::text)
+         Filter: (f."COUNTRY_NAME" = 'Japan'::text)
 (8 rows)
 
+EXPLAIN (VERBOSE, FORMAT JSON, COSTS OFF)
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
+                                                                                           QUERY PLAN                                                                                            
+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+ [                                                                                                                                                                                              +
+   {                                                                                                                                                                                            +
+     "Plan": {                                                                                                                                                                                  +
+       "Node Type": "Nested Loop",                                                                                                                                                              +
+       "Parallel Aware": false,                                                                                                                                                                 +
+       "Async Capable": false,                                                                                                                                                                  +
+       "Join Type": "Inner",                                                                                                                                                                    +
+       "Output": ["f.\"COUNTRY_NAME\"", "f.\"REGION_ID\""],                                                                                                                                     +
+       "Inner Unique": false,                                                                                                                                                                   +
+       "Plans": [                                                                                                                                                                               +
+         {                                                                                                                                                                                      +
+           "Node Type": "Seq Scan",                                                                                                                                                             +
+           "Parent Relationship": "Outer",                                                                                                                                                      +
+           "Parallel Aware": false,                                                                                                                                                             +
+           "Async Capable": false,                                                                                                                                                              +
+           "Relation Name": "xmldata",                                                                                                                                                          +
+           "Schema": "public",                                                                                                                                                                  +
+           "Alias": "xmldata",                                                                                                                                                                  +
+           "Output": ["xmldata.data"]                                                                                                                                                           +
+         },                                                                                                                                                                                     +
+         {                                                                                                                                                                                      +
+           "Node Type": "Table Function Scan",                                                                                                                                                  +
+           "Parent Relationship": "Inner",                                                                                                                                                      +
+           "Parallel Aware": false,                                                                                                                                                             +
+           "Async Capable": false,                                                                                                                                                              +
+           "Table Function Name": "xmltable",                                                                                                                                                   +
+           "Alias": "f",                                                                                                                                                                        +
+           "Output": ["f.\"COUNTRY_NAME\"", "f.\"REGION_ID\""],                                                                                                                                 +
+           "Table Function Call": "XMLTABLE(('/ROWS/ROW[COUNTRY_NAME=\"Japan\" or COUNTRY_NAME=\"India\"]'::text) PASSING (xmldata.data) COLUMNS \"COUNTRY_NAME\" text, \"REGION_ID\" integer)",+
+           "Filter": "(f.\"COUNTRY_NAME\" = 'Japan'::text)"                                                                                                                                     +
+         }                                                                                                                                                                                      +
+       ]                                                                                                                                                                                        +
+     }                                                                                                                                                                                          +
+   }                                                                                                                                                                                            +
+ ]
+(1 row)
+
 -- should to work with more data
 INSERT INTO xmldata VALUES('<ROWS>
 <ROW id="10">

diff --git a/src/test/regress/sql/xml.sql b/src/test/regress/sql/xml.sql
index 34dc4f1e39cfeaeb38b4616a0311887863efaeed..953bac09e45f9988b1c33489dc7085c9c387a99e 100644 (file)
--- a/src/test/regress/sql/xml.sql
+++ b/src/test/regress/sql/xml.sql
@@ -505,7 +505,10 @@ SELECT  xmltable.*
 SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) WHERE "COUNTRY_NAME" = 'Japan';
 
 EXPLAIN (VERBOSE, COSTS OFF)
-SELECT xmltable.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) WHERE "COUNTRY_NAME" = 'Japan';
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
+
+EXPLAIN (VERBOSE, FORMAT JSON, COSTS OFF)
+SELECT f.* FROM xmldata, LATERAL xmltable('/ROWS/ROW[COUNTRY_NAME="Japan" or COUNTRY_NAME="India"]' PASSING data COLUMNS "COUNTRY_NAME" text, "REGION_ID" int) AS f WHERE "COUNTRY_NAME" = 'Japan';
 
 -- should to work with more data
 INSERT INTO xmldata VALUES('<ROWS>