Age         Owner                    Branch data    TLA  Line data    Source code

                                  1                 :                : /*-------------------------------------------------------------------------
                                  2                 :                :  *
                                  3                 :                :  * pgpa_join.h
                                  4                 :                :  *    analysis of joins in Plan trees
                                  5                 :                :  *
                                  6                 :                :  * Copyright (c) 2016-2026, PostgreSQL Global Development Group
                                  7                 :                :  *
                                  8                 :                :  *    contrib/pg_plan_advice/pgpa_join.h
                                  9                 :                :  *
                                 10                 :                :  *-------------------------------------------------------------------------
                                 11                 :                :  */
                                 12                 :                : #ifndef PGPA_JOIN_H
                                 13                 :                : #define PGPA_JOIN_H
                                 14                 :                : 
                                 15                 :                : #include "nodes/plannodes.h"
                                 16                 :                : 
                                 17                 :                : typedef struct pgpa_plan_walker_context pgpa_plan_walker_context;
                                 18                 :                : typedef struct pgpa_join_unroller pgpa_join_unroller;
                                 19                 :                : typedef struct pgpa_unrolled_join pgpa_unrolled_join;
                                 20                 :                : 
                                 21                 :                : /*
                                 22                 :                :  * Although there are three main join strategies, we try to classify things
                                 23                 :                :  * more precisely here: merge joins have the option of using materialization
                                 24                 :                :  * on the inner side, and nested loops can use either materialization or
                                 25                 :                :  * memoization.
                                 26                 :                :  */
                                 27                 :                : typedef enum
                                 28                 :                : {
                                 29                 :                :     JSTRAT_MERGE_JOIN_PLAIN = 0,
                                 30                 :                :     JSTRAT_MERGE_JOIN_MATERIALIZE,
                                 31                 :                :     JSTRAT_NESTED_LOOP_PLAIN,
                                 32                 :                :     JSTRAT_NESTED_LOOP_MATERIALIZE,
                                 33                 :                :     JSTRAT_NESTED_LOOP_MEMOIZE,
                                 34                 :                :     JSTRAT_HASH_JOIN
                                 35                 :                :     /* update NUM_PGPA_JOIN_STRATEGY if you add anything here */
                                 36                 :                : } pgpa_join_strategy;
                                 37                 :                : 
                                 38                 :                : #define NUM_PGPA_JOIN_STRATEGY      ((int) JSTRAT_HASH_JOIN + 1)
                                 39                 :                : 
                                 40                 :                : /*
                                 41                 :                :  * In an outer-deep join tree, every member of an unrolled join will be a scan,
                                 42                 :                :  * but join trees with other shapes can contain unrolled joins.
                                 43                 :                :  *
                                 44                 :                :  * The plan node we store here will be the inner or outer child of the join
                                 45                 :                :  * node, as appropriate, except that we look through subnodes that we regard as
                                 46                 :                :  * part of the join method itself. For instance, for a Nested Loop that
                                 47                 :                :  * materializes the inner input, we'll store the child of the Materialize node,
                                 48                 :                :  * not the Materialize node itself.
                                 49                 :                :  *
                                 50                 :                :  * If setrefs processing elided one or more nodes from the plan tree, then
                                 51                 :                :  * we'll store details about the topmost of those in elided_node; otherwise,
                                 52                 :                :  * it will be NULL.
                                 53                 :                :  *
                                 54                 :                :  * Exactly one of scan and unrolled_join will be non-NULL.
                                 55                 :                :  */
                                 56                 :                : typedef struct
                                 57                 :                : {
                                 58                 :                :     Plan       *plan;
                                 59                 :                :     ElidedNode *elided_node;
                                 60                 :                :     struct pgpa_scan *scan;
                                 61                 :                :     pgpa_unrolled_join *unrolled_join;
                                 62                 :                : } pgpa_join_member;
                                 63                 :                : 
                                 64                 :                : /*
                                 65                 :                :  * We convert outer-deep join trees to a flat structure; that is, ((A JOIN B)
                                 66                 :                :  * JOIN C) JOIN D gets converted to outer = A, inner = <B C D>.  When joins
                                 67                 :                :  * aren't outer-deep, substructure is required, e.g. (A JOIN B) JOIN (C JOIN D)
                                 68                 :                :  * is represented as outer = A, inner = <B X>, where X is a pgpa_unrolled_join
                                 69                 :                :  * covering C-D.
                                 70                 :                :  */
                                 71                 :                : struct pgpa_unrolled_join
                                 72                 :                : {
                                 73                 :                :     /* Outermost member; must not itself be an unrolled join. */
                                 74                 :                :     pgpa_join_member outer;
                                 75                 :                : 
                                 76                 :                :     /* Number of inner members. Length of the strategy and inner arrays. */
                                 77                 :                :     unsigned    ninner;
                                 78                 :                : 
                                 79                 :                :     /* Array of strategies, one per non-outermost member. */
                                 80                 :                :     pgpa_join_strategy *strategy;
                                 81                 :                : 
                                 82                 :                :     /* Array of members, excluding the outermost. Deepest first. */
                                 83                 :                :     pgpa_join_member *inner;
                                 84                 :                : };
                                 85                 :                : 
                                 86                 :                : /*
                                 87                 :                :  * Does this plan node inherit from Join?
                                 88                 :                :  */
                                 89                 :                : static inline bool
    3 rhaas@postgresql.org       90                 :GNC         714 : pgpa_is_join(Plan *plan)
                                 91                 :                : {
                                 92   [ +  +  +  +  :            714 :     return IsA(plan, NestLoop) || IsA(plan, MergeJoin) || IsA(plan, HashJoin);
                                              +  + ]
                                 93                 :                : }
                                 94                 :                : 
                                 95                 :                : extern pgpa_join_unroller *pgpa_create_join_unroller(void);
                                 96                 :                : extern void pgpa_unroll_join(pgpa_plan_walker_context *walker,
                                 97                 :                :                              Plan *plan, bool beneath_any_gather,
                                 98                 :                :                              pgpa_join_unroller *join_unroller,
                                 99                 :                :                              pgpa_join_unroller **outer_join_unroller,
                                100                 :                :                              pgpa_join_unroller **inner_join_unroller);
                                101                 :                : extern pgpa_unrolled_join *pgpa_build_unrolled_join(pgpa_plan_walker_context *walker,
                                102                 :                :                                                     pgpa_join_unroller *join_unroller);
                                103                 :                : extern void pgpa_destroy_join_unroller(pgpa_join_unroller *join_unroller);
                                104                 :                : 
                                105                 :                : #endif