mirror of
https://github.com/postgres/postgres.git
synced 2025-06-05 23:56:58 +03:00
08ea7a2291
This reverts commits d204ef63776b8a00ca220adec23979091564e465, 83454e3c2b28141c0db01c7d2027e01040df5249 and a few more commits thereafter (complete list at the end) related to MERGE feature. While the feature was fully functional, with sufficient test coverage and necessary documentation, it was felt that some parts of the executor and parse-analyzer can use a different design and it wasn't possible to do that in the available time. So it was decided to revert the patch for PG11 and retry again in the future. Thanks again to all reviewers and bug reporters. List of commits reverted, in reverse chronological order: f1464c5380 Improve parse representation for MERGE ddb4158579 MERGE syntax diagram correction 530e69e59b Allow cpluspluscheck to pass by renaming variable 01b88b4df5 MERGE minor errata 3af7b2b0d4 MERGE fix variable warning in non-assert builds a5d86181ec MERGE INSERT allows only one VALUES clause 4b2d44031f MERGE post-commit review 4923550c20 Tab completion for MERGE aa3faa3c7a WITH support in MERGE 83454e3c2b New files for MERGE d204ef6377 MERGE SQL Command following SQL:2016 Author: Pavan Deolasee Reviewed-by: Michael Paquier
214 lines
8.8 KiB
C
214 lines
8.8 KiB
C
/*--------------------------------------------------------------------
|
|
* execPartition.h
|
|
* POSTGRES partitioning executor interface
|
|
*
|
|
* Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
*
|
|
* IDENTIFICATION
|
|
* src/include/executor/execPartition.h
|
|
*--------------------------------------------------------------------
|
|
*/
|
|
|
|
#ifndef EXECPARTITION_H
|
|
#define EXECPARTITION_H
|
|
|
|
#include "catalog/partition.h"
|
|
#include "nodes/execnodes.h"
|
|
#include "nodes/parsenodes.h"
|
|
#include "nodes/plannodes.h"
|
|
#include "partitioning/partprune.h"
|
|
|
|
/*-----------------------
|
|
* PartitionDispatch - information about one partitioned table in a partition
|
|
* hierarchy required to route a tuple to one of its partitions
|
|
*
|
|
* reldesc Relation descriptor of the table
|
|
* key Partition key information of the table
|
|
* keystate Execution state required for expressions in the partition key
|
|
* partdesc Partition descriptor of the table
|
|
* tupslot A standalone TupleTableSlot initialized with this table's tuple
|
|
* descriptor
|
|
* tupmap TupleConversionMap to convert from the parent's rowtype to
|
|
* this table's rowtype (when extracting the partition key of a
|
|
* tuple just before routing it through this table)
|
|
* indexes Array with partdesc->nparts members (for details on what
|
|
* individual members represent, see how they are set in
|
|
* get_partition_dispatch_recurse())
|
|
*-----------------------
|
|
*/
|
|
typedef struct PartitionDispatchData
|
|
{
|
|
Relation reldesc;
|
|
PartitionKey key;
|
|
List *keystate; /* list of ExprState */
|
|
PartitionDesc partdesc;
|
|
TupleTableSlot *tupslot;
|
|
TupleConversionMap *tupmap;
|
|
int *indexes;
|
|
} PartitionDispatchData;
|
|
|
|
typedef struct PartitionDispatchData *PartitionDispatch;
|
|
|
|
/*-----------------------
|
|
* PartitionTupleRouting - Encapsulates all information required to execute
|
|
* tuple-routing between partitions.
|
|
*
|
|
* partition_dispatch_info Array of PartitionDispatch objects with one
|
|
* entry for every partitioned table in the
|
|
* partition tree.
|
|
* num_dispatch number of partitioned tables in the partition
|
|
* tree (= length of partition_dispatch_info[])
|
|
* partition_oids Array of leaf partitions OIDs with one entry
|
|
* for every leaf partition in the partition tree,
|
|
* initialized in full by
|
|
* ExecSetupPartitionTupleRouting.
|
|
* partitions Array of ResultRelInfo* objects with one entry
|
|
* for every leaf partition in the partition tree,
|
|
* initialized lazily by ExecInitPartitionInfo.
|
|
* num_partitions Number of leaf partitions in the partition tree
|
|
* (= 'partitions_oid'/'partitions' array length)
|
|
* parent_child_tupconv_maps Array of TupleConversionMap objects with one
|
|
* entry for every leaf partition (required to
|
|
* convert tuple from the root table's rowtype to
|
|
* a leaf partition's rowtype after tuple routing
|
|
* is done)
|
|
* child_parent_tupconv_maps Array of TupleConversionMap objects with one
|
|
* entry for every leaf partition (required to
|
|
* convert an updated tuple from the leaf
|
|
* partition's rowtype to the root table's rowtype
|
|
* so that tuple routing can be done)
|
|
* child_parent_map_not_required Array of bool. True value means that a map is
|
|
* determined to be not required for the given
|
|
* partition. False means either we haven't yet
|
|
* checked if a map is required, or it was
|
|
* determined to be required.
|
|
* subplan_partition_offsets Integer array ordered by UPDATE subplans. Each
|
|
* element of this array has the index into the
|
|
* corresponding partition in partitions array.
|
|
* num_subplan_partition_offsets Length of 'subplan_partition_offsets' array
|
|
* partition_tuple_slot TupleTableSlot to be used to manipulate any
|
|
* given leaf partition's rowtype after that
|
|
* partition is chosen for insertion by
|
|
* tuple-routing.
|
|
*-----------------------
|
|
*/
|
|
typedef struct PartitionTupleRouting
|
|
{
|
|
PartitionDispatch *partition_dispatch_info;
|
|
int num_dispatch;
|
|
Oid *partition_oids;
|
|
ResultRelInfo **partitions;
|
|
int num_partitions;
|
|
TupleConversionMap **parent_child_tupconv_maps;
|
|
TupleConversionMap **child_parent_tupconv_maps;
|
|
bool *child_parent_map_not_required;
|
|
int *subplan_partition_offsets;
|
|
int num_subplan_partition_offsets;
|
|
TupleTableSlot *partition_tuple_slot;
|
|
TupleTableSlot *root_tuple_slot;
|
|
} PartitionTupleRouting;
|
|
|
|
/*-----------------------
|
|
* PartitionPruningData - Encapsulates all information required to support
|
|
* elimination of partitions in node types which support arbitrary Lists of
|
|
* subplans. Information stored here allows the planner's partition pruning
|
|
* functions to be called and the return value of partition indexes translated
|
|
* into the subpath indexes of node types such as Append, thus allowing us to
|
|
* bypass certain subnodes when we have proofs that indicate that no tuple
|
|
* matching the 'pruning_steps' will be found within.
|
|
*
|
|
* subnode_map An array containing the subnode index which
|
|
* matches this partition index, or -1 if the
|
|
* subnode has been pruned already.
|
|
* subpart_map An array containing the offset into the
|
|
* 'partprunedata' array in PartitionPruning, or
|
|
* -1 if there is no such element in that array.
|
|
* present_parts A Bitmapset of the partition index that we have
|
|
* subnodes mapped for.
|
|
* context Contains the context details required to call
|
|
* the partition pruning code.
|
|
* pruning_steps Contains a list of PartitionPruneStep used to
|
|
* perform the actual pruning.
|
|
* extparams Contains paramids of external params found
|
|
* matching partition keys in 'pruning_steps'.
|
|
* allparams As 'extparams' but also including exec params.
|
|
*-----------------------
|
|
*/
|
|
typedef struct PartitionPruningData
|
|
{
|
|
int *subnode_map;
|
|
int *subpart_map;
|
|
Bitmapset *present_parts;
|
|
PartitionPruneContext context;
|
|
List *pruning_steps;
|
|
Bitmapset *extparams;
|
|
Bitmapset *allparams;
|
|
} PartitionPruningData;
|
|
|
|
/*-----------------------
|
|
* PartitionPruneState - State object required for executor nodes to perform
|
|
* partition pruning elimination of their subnodes. This encapsulates a
|
|
* flattened hierarchy of PartitionPruningData structs and also stores all
|
|
* paramids which were found to match the partition keys of each partition.
|
|
* This struct can be attached to node types which support arbitrary Lists of
|
|
* subnodes containing partitions to allow subnodes to be eliminated due to
|
|
* the clauses being unable to match to any tuple that the subnode could
|
|
* possibly produce.
|
|
*
|
|
* partprunedata Array of PartitionPruningData for the node's target
|
|
* partitioned relation. First element contains the
|
|
* details for the target partitioned table.
|
|
* num_partprunedata Number of items in 'partprunedata' array.
|
|
* prune_context A memory context which can be used to call the query
|
|
* planner's partition prune functions.
|
|
* extparams All PARAM_EXTERN paramids which were found to match a
|
|
* partition key in each of the contained
|
|
* PartitionPruningData structs.
|
|
* execparams As above but for PARAM_EXEC.
|
|
* allparams Union of 'extparams' and 'execparams', saved to avoid
|
|
* recalculation.
|
|
*-----------------------
|
|
*/
|
|
typedef struct PartitionPruneState
|
|
{
|
|
PartitionPruningData *partprunedata;
|
|
int num_partprunedata;
|
|
MemoryContext prune_context;
|
|
Bitmapset *extparams;
|
|
Bitmapset *execparams;
|
|
Bitmapset *allparams;
|
|
} PartitionPruneState;
|
|
|
|
extern PartitionTupleRouting *ExecSetupPartitionTupleRouting(ModifyTableState *mtstate,
|
|
Relation rel);
|
|
extern int ExecFindPartition(ResultRelInfo *resultRelInfo,
|
|
PartitionDispatch *pd,
|
|
TupleTableSlot *slot,
|
|
EState *estate);
|
|
extern ResultRelInfo *ExecInitPartitionInfo(ModifyTableState *mtstate,
|
|
ResultRelInfo *resultRelInfo,
|
|
PartitionTupleRouting *proute,
|
|
EState *estate, int partidx);
|
|
extern void ExecInitRoutingInfo(ModifyTableState *mtstate,
|
|
EState *estate,
|
|
PartitionTupleRouting *proute,
|
|
ResultRelInfo *partRelInfo,
|
|
int partidx);
|
|
extern void ExecSetupChildParentMapForLeaf(PartitionTupleRouting *proute);
|
|
extern TupleConversionMap *TupConvMapForLeaf(PartitionTupleRouting *proute,
|
|
ResultRelInfo *rootRelInfo, int leaf_index);
|
|
extern HeapTuple ConvertPartitionTupleSlot(TupleConversionMap *map,
|
|
HeapTuple tuple,
|
|
TupleTableSlot *new_slot,
|
|
TupleTableSlot **p_my_slot);
|
|
extern void ExecCleanupTupleRouting(ModifyTableState *mtstate,
|
|
PartitionTupleRouting *proute);
|
|
extern PartitionPruneState *ExecSetupPartitionPruneState(PlanState *planstate,
|
|
List *partitionpruneinfo);
|
|
extern Bitmapset *ExecFindMatchingSubPlans(PartitionPruneState *prunestate);
|
|
extern Bitmapset *ExecFindInitialMatchingSubPlans(PartitionPruneState *prunestate,
|
|
int nsubnodes);
|
|
|
|
#endif /* EXECPARTITION_H */
|