Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commitb204d10

Browse files
committed
Executor no longer cares about mergejoinop, mergerightorder, mergeleftorder,
so remove them from MergeJoin node. Hack together a partialsolution for commuted mergejoin operators --- yesterdaya mergejoin int4 = int8 would crash if the planner decided tocommute it, today it works. The planner's representation ofmergejoins really needs a rewrite though.Also, further testing of mergejoin ops in opr_sanity regress test.
1 parentd077c61 commitb204d10

File tree

10 files changed

+156
-95
lines changed

10 files changed

+156
-95
lines changed

‎src/backend/nodes/copyfuncs.c‎

Lines changed: 1 addition & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
*
88
*
99
* IDENTIFICATION
10-
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.74 1999/02/22 19:55:42 momjian Exp $
10+
* $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.75 1999/03/01 00:10:30 tgl Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -326,16 +326,6 @@ _copyMergeJoin(MergeJoin *from)
326326
*/
327327
Node_Copy(from,newnode,mergeclauses);
328328

329-
newnode->mergejoinop=from->mergejoinop;
330-
331-
newnode->mergerightorder= (Oid*)palloc(sizeof(Oid)*2);
332-
newnode->mergerightorder[0]=from->mergerightorder[0];
333-
newnode->mergerightorder[1]=0;
334-
335-
newnode->mergeleftorder= (Oid*)palloc(sizeof(Oid)*2);
336-
newnode->mergeleftorder[0]=from->mergeleftorder[0];
337-
newnode->mergeleftorder[1]=0;
338-
339329
returnnewnode;
340330
}
341331

‎src/backend/nodes/freefuncs.c‎

Lines changed: 1 addition & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
*
88
*
99
* IDENTIFICATION
10-
* $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.14 1999/02/22 19:55:42 momjian Exp $
10+
* $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.15 1999/03/01 00:10:31 tgl Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -267,9 +267,6 @@ _freeMergeJoin(MergeJoin *node)
267267
*/
268268
freeObject(node->mergeclauses);
269269

270-
pfree(node->mergerightorder);
271-
pfree(node->mergeleftorder);
272-
273270
pfree(node);
274271
}
275272

‎src/backend/nodes/outfuncs.c‎

Lines changed: 1 addition & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
*
66
* Copyright (c) 1994, Regents of the University of California
77
*
8-
* $Id: outfuncs.c,v 1.76 1999/02/23 08:01:47 thomas Exp $
8+
* $Id: outfuncs.c,v 1.77 1999/03/01 00:10:31 tgl Exp $
99
*
1010
* NOTES
1111
* Every (plan) node in POSTGRES has an associated "out" routine which
@@ -371,12 +371,6 @@ _outMergeJoin(StringInfo str, MergeJoin *node)
371371

372372
appendStringInfo(str," :mergeclauses ");
373373
_outNode(str,node->mergeclauses);
374-
375-
appendStringInfo(str,
376-
" :mergejoinop %u :mergerightorder %u :mergeleftorder %u ",
377-
node->mergejoinop,
378-
node->mergerightorder,
379-
node->mergeleftorder);
380374
}
381375

382376
/*

‎src/backend/nodes/readfuncs.c‎

Lines changed: 1 addition & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
*
88
*
99
* IDENTIFICATION
10-
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.59 1999/02/18 00:49:15 momjian Exp $
10+
* $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.60 1999/03/01 00:10:31 tgl Exp $
1111
*
1212
* NOTES
1313
* Most of the read functions for plan nodes are tested. (In fact, they
@@ -426,10 +426,6 @@ _readMergeJoin()
426426
token=lsptok(NULL,&length);/* eat :mergeclauses */
427427
local_node->mergeclauses=nodeRead(true);/* now read it */
428428

429-
token=lsptok(NULL,&length);/* eat :mergejoinop */
430-
token=lsptok(NULL,&length);/* get mergejoinop */
431-
local_node->mergejoinop=atol(token);
432-
433429
returnlocal_node;
434430
}
435431

‎src/backend/optimizer/path/mergeutils.c‎

Lines changed: 14 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
*
88
*
99
* IDENTIFICATION
10-
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.19 1999/02/15 03:22:06 momjian Exp $
10+
* $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/mergeutils.c,v 1.20 1999/03/01 00:10:32 tgl Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -27,6 +27,14 @@
2727
* it within a mergeinfo node containing other clause nodes with the same
2828
* mergejoin ordering.
2929
*
30+
* XXX This is completely braindead: there is no reason anymore to segregate
31+
* mergejoin clauses by join operator, since the executor can handle mergejoin
32+
* clause sets with different operators in them. Instead, we ought to be
33+
* building a MergeInfo for each potentially useful ordering of the input
34+
* relations. But right now the optimizer's internal data structures do not
35+
* support that (MergeInfo can only store one MergeOrder for a set of clauses).
36+
* Something to fix next time...
37+
*
3038
* 'restrictinfo_list' is the list of restrictinfo nodes
3139
* 'inner_relid' is the relid of the inner join relation
3240
*
@@ -38,7 +46,7 @@ group_clauses_by_order(List *restrictinfo_list,
3846
intinner_relid)
3947
{
4048
List*mergeinfo_list=NIL;
41-
List*xrestrictinfo=NIL;
49+
List*xrestrictinfo;
4250

4351
foreach(xrestrictinfo,restrictinfo_list)
4452
{
@@ -84,10 +92,10 @@ group_clauses_by_order(List *restrictinfo_list,
8492
mergeinfo_list);
8593
}
8694

87-
((JoinMethod*)xmergeinfo)->clauses=lcons(clause,
88-
((JoinMethod*)xmergeinfo)->clauses);
89-
((JoinMethod*)xmergeinfo)->jmkeys=lcons(jmkeys,
90-
((JoinMethod*)xmergeinfo)->jmkeys);
95+
xmergeinfo->jmethod.clauses=lcons(clause,
96+
xmergeinfo->jmethod.clauses);
97+
xmergeinfo->jmethod.jmkeys=lcons(jmkeys,
98+
xmergeinfo->jmethod.jmkeys);
9199
}
92100
}
93101
returnmergeinfo_list;

‎src/backend/optimizer/plan/createplan.c‎

Lines changed: 73 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
*
88
*
99
* IDENTIFICATION
10-
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.49 1999/02/21 03:48:45 scrappy Exp $
10+
* $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.50 1999/03/01 00:10:33 tgl Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -44,6 +44,8 @@
4444
#defineNONAME_MATERIAL2
4545

4646
staticList*switch_outer(List*clauses);
47+
staticOid*generate_merge_input_sortorder(List*pathkeys,
48+
MergeOrder*mergeorder);
4749
staticScan*create_scan_node(Path*best_path,List*tlist);
4850
staticJoin*create_join_node(JoinPath*best_path,List*tlist);
4951
staticSeqScan*create_seqscan_node(Path*best_path,List*tlist,
@@ -70,8 +72,7 @@ static HashJoin *make_hashjoin(List *tlist, List *qpqual,
7072
List*hashclauses,Plan*lefttree,Plan*righttree);
7173
staticHash*make_hash(List*tlist,Var*hashkey,Plan*lefttree);
7274
staticMergeJoin*make_mergejoin(List*tlist,List*qpqual,
73-
List*mergeclauses,Oidopcode,Oid*rightorder,
74-
Oid*leftorder,Plan*righttree,Plan*lefttree);
75+
List*mergeclauses,Plan*righttree,Plan*lefttree);
7576
staticMaterial*make_material(List*tlist,Oidnonameid,Plan*lefttree,
7677
intkeycount);
7778

@@ -505,9 +506,6 @@ create_mergejoin_node(MergePath *best_path,
505506
{
506507
List*qpqual,
507508
*mergeclauses;
508-
RegProcedureopcode;
509-
Oid*outer_order,
510-
*inner_order;
511509
MergeJoin*join_node;
512510

513511

@@ -528,50 +526,43 @@ create_mergejoin_node(MergePath *best_path,
528526
outer_tlist,
529527
inner_tlist));
530528

531-
opcode=get_opcode((best_path->jpath.path.pathorder->ord.merge)->join_operator);
532-
533-
outer_order= (Oid*)palloc(sizeof(Oid)*2);
534-
outer_order[0]= (best_path->jpath.path.pathorder->ord.merge)->left_operator;
535-
outer_order[1]=0;
536-
537-
inner_order= (Oid*)palloc(sizeof(Oid)*2);
538-
inner_order[0]= (best_path->jpath.path.pathorder->ord.merge)->right_operator;
539-
inner_order[1]=0;
540-
541529
/*
542530
* Create explicit sort paths for the outer and inner join paths if
543531
* necessary. The sort cost was already accounted for in the path.
544532
*/
545533
if (best_path->outersortkeys)
546534
{
535+
Oid*outer_order=generate_merge_input_sortorder(
536+
best_path->outersortkeys,
537+
best_path->jpath.path.pathorder->ord.merge);
547538
Noname*sorted_outer_node=make_noname(outer_tlist,
548-
best_path->outersortkeys,
549-
outer_order,
550-
outer_node,
551-
NONAME_SORT);
539+
best_path->outersortkeys,
540+
outer_order,
541+
outer_node,
542+
NONAME_SORT);
552543

553544
sorted_outer_node->plan.cost=outer_node->cost;
554545
outer_node= (Plan*)sorted_outer_node;
555546
}
556547

557548
if (best_path->innersortkeys)
558549
{
550+
Oid*inner_order=generate_merge_input_sortorder(
551+
best_path->innersortkeys,
552+
best_path->jpath.path.pathorder->ord.merge);
559553
Noname*sorted_inner_node=make_noname(inner_tlist,
560554
best_path->innersortkeys,
561555
inner_order,
562556
inner_node,
563557
NONAME_SORT);
564558

565-
sorted_inner_node->plan.cost=outer_node->cost;
559+
sorted_inner_node->plan.cost=outer_node->cost;/* XXX not inner_node? */
566560
inner_node= (Plan*)sorted_inner_node;
567561
}
568562

569563
join_node=make_mergejoin(tlist,
570564
qpqual,
571565
mergeclauses,
572-
opcode,
573-
inner_order,
574-
outer_order,
575566
inner_node,
576567
outer_node);
577568

@@ -662,7 +653,7 @@ fix_indxqual_references(Node *clause, Path *index_path)
662653
pos++;
663654
}
664655
}
665-
newclause=copyObject((Node*)clause);
656+
newclause=copyObject(clause);
666657
((Var*)newclause)->varattno=pos+1;
667658
returnnewclause;
668659
}
@@ -760,35 +751,39 @@ fix_indxqual_references(Node *clause, Path *index_path)
760751
* switch_outer
761752
* Given a list of merge clauses, rearranges the elements within the
762753
* clauses so the outer join variable is on the left and the inner is on
763-
* the right.
764-
*
765-
* Returns the rearranged list ?
766-
*
767-
* XXX Shouldn't the operator be commuted?!
754+
* the right. The original list is not touched; a modified list
755+
* is returned.
768756
*/
769757
staticList*
770758
switch_outer(List*clauses)
771759
{
772760
List*t_list=NIL;
773-
Expr*temp=NULL;
774-
List*i=NIL;
761+
Expr*temp;
762+
List*i;
775763
Expr*clause;
776764
Node*op;
777765

778766
foreach(i,clauses)
779767
{
780768
clause=lfirst(i);
769+
Assert(is_opclause((Node*)clause));
781770
op= (Node*)get_rightop(clause);
782771
Assert(op!= (Node*)NULL);
783772
if (IsA(op,ArrayRef))
784773
op= ((ArrayRef*)op)->refexpr;
785774
Assert(IsA(op,Var));
786775
if (var_is_outer((Var*)op))
787776
{
777+
/* Duplicate just enough of the structure to allow commuting
778+
* the clause without changing the original list. Could use
779+
* copyObject, but a complete deep copy is overkill.
780+
*/
788781
temp=make_clause(clause->opType,clause->oper,
789-
lcons(get_rightop(clause),
790-
lcons(get_leftop(clause),
782+
lcons(get_leftop(clause),
783+
lcons(get_rightop(clause),
791784
NIL)));
785+
/* Commute it --- note this modifies the temp node in-place. */
786+
CommuteClause((Node*)temp);
792787
t_list=lappend(t_list,temp);
793788
}
794789
else
@@ -797,6 +792,45 @@ switch_outer(List *clauses)
797792
returnt_list;
798793
}
799794

795+
/*
796+
* generate_merge_input_sortorder
797+
*
798+
* Generate the list of sort ops needed to sort one of the input paths for
799+
* a merge. We may have to use either left or right sortop for each item,
800+
* since the original mergejoin clause may or may not have been commuted
801+
* (compare switch_outer above).
802+
*
803+
* XXX This is largely a crock. It works only because group_clauses_by_order
804+
* only groups together mergejoin clauses that have identical MergeOrder info,
805+
* which means we can safely use a single MergeOrder input to deal with all
806+
* the data. There should be a more general data structure that allows coping
807+
* with groups of mergejoin clauses that have different join operators.
808+
*/
809+
staticOid*
810+
generate_merge_input_sortorder(List*pathkeys,MergeOrder*mergeorder)
811+
{
812+
intlistlength=length(pathkeys);
813+
Oid*result= (Oid*)palloc(sizeof(Oid)* (listlength+1));
814+
Oid*nextsortop=result;
815+
List*p;
816+
817+
foreach(p,pathkeys)
818+
{
819+
Var*pkey= (Var*)lfirst((List*)lfirst(p));
820+
Assert(IsA(pkey,Var));
821+
if (pkey->vartype==mergeorder->left_type)
822+
*nextsortop++=mergeorder->left_operator;
823+
elseif (pkey->vartype==mergeorder->right_type)
824+
*nextsortop++=mergeorder->right_operator;
825+
else
826+
elog(ERROR,
827+
"generate_merge_input_sortorder: can't handle data type %d",
828+
pkey->vartype);
829+
}
830+
*nextsortop++=InvalidOid;
831+
returnresult;
832+
}
833+
800834
/*
801835
* set_noname_tlist_operators
802836
* Sets the key and keyop fields of resdom nodes in a target list.
@@ -806,18 +840,16 @@ switch_outer(List *clauses)
806840
*corresponding to vars in the target list that are to
807841
*be sorted or hashed
808842
* 'operators' is the corresponding list of N sort or hash operators
809-
* 'keyno' is the first key number
810-
* XXX - keyno ? doesn't exist - jeff
811843
*
812-
* Returns the modified target list.
844+
* Returns the modified-in-place target list.
813845
*/
814846
staticList*
815847
set_noname_tlist_operators(List*tlist,List*pathkeys,Oid*operators)
816848
{
817-
Node*pathkey=NULL;
818849
intkeyno=1;
819-
Resdom*resdom= (Resdom*)NULL;
820-
List*i=NIL;
850+
Node*pathkey;
851+
Resdom*resdom;
852+
List*i;
821853

822854
foreach(i,pathkeys)
823855
{
@@ -828,12 +860,9 @@ set_noname_tlist_operators(List *tlist, List *pathkeys, Oid *operators)
828860
/*
829861
* Order the resdom pathkey and replace the operator OID for each
830862
* key with the regproc OID.
831-
*
832-
* XXX Note that the optimizer only generates merge joins with 1
833-
* operator (see create_mergejoin_node) - ay 2/95
834863
*/
835864
resdom->reskey=keyno;
836-
resdom->reskeyop=get_opcode(operators[0]);
865+
resdom->reskeyop=get_opcode(operators[keyno-1]);
837866
}
838867
keyno+=1;
839868
}
@@ -1024,9 +1053,6 @@ static MergeJoin *
10241053
make_mergejoin(List*tlist,
10251054
List*qpqual,
10261055
List*mergeclauses,
1027-
Oidopcode,
1028-
Oid*rightorder,
1029-
Oid*leftorder,
10301056
Plan*righttree,
10311057
Plan*lefttree)
10321058
{
@@ -1041,9 +1067,6 @@ make_mergejoin(List *tlist,
10411067
plan->lefttree=lefttree;
10421068
plan->righttree=righttree;
10431069
node->mergeclauses=mergeclauses;
1044-
node->mergejoinop=opcode;
1045-
node->mergerightorder=rightorder;
1046-
node->mergeleftorder=leftorder;
10471070

10481071
returnnode;
10491072
}

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp