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

Commitb0c4a50

Browse files
committed
Instead of rechecking lossy index operators by putting them into the
regular qpqual ('filter condition'), add special-purpose code tonodeIndexscan.c to recheck them. This ends being almost no net additionof code, because the removal of planner code balances out the extraexecutor code, but it is significantly more efficient when a lossyoperator is involved in an OR indexscan. The old implementation hadto recheck the entire indexqual in such cases.
1 parentfa559a8 commitb0c4a50

File tree

8 files changed

+134
-114
lines changed

8 files changed

+134
-114
lines changed

‎src/backend/executor/nodeIndexscan.c‎

Lines changed: 48 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/executor/nodeIndexscan.c,v 1.88 2003/12/30 20:05:05 tgl Exp $
11+
* $PostgreSQL: pgsql/src/backend/executor/nodeIndexscan.c,v 1.89 2004/01/06 04:31:01 tgl Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -99,7 +99,9 @@ IndexNext(IndexScanState *node)
9999
ExprContext*econtext;
100100
ScanDirectiondirection;
101101
IndexScanDescPtrscanDescs;
102+
List**lossyQuals;
102103
IndexScanDescscandesc;
104+
List*lossyQual;
103105
Indexscanrelid;
104106
HeapTupletuple;
105107
TupleTableSlot*slot;
@@ -120,6 +122,7 @@ IndexNext(IndexScanState *node)
120122
direction=ForwardScanDirection;
121123
}
122124
scanDescs=node->iss_ScanDescs;
125+
lossyQuals=node->iss_LossyQuals;
123126
numIndices=node->iss_NumIndices;
124127
econtext=node->ss.ps.ps_ExprContext;
125128
slot=node->ss.ss_ScanTupleSlot;
@@ -188,6 +191,8 @@ IndexNext(IndexScanState *node)
188191
while (indexNumber<numIndices)
189192
{
190193
scandesc=scanDescs[node->iss_IndexPtr];
194+
lossyQual=lossyQuals[node->iss_IndexPtr];
195+
191196
while ((tuple=index_getnext(scandesc,direction))!=NULL)
192197
{
193198
/*
@@ -201,6 +206,22 @@ IndexNext(IndexScanState *node)
201206
scandesc->xs_cbuf,/* buffer containing tuple */
202207
false);/* don't pfree */
203208

209+
/*
210+
* If any of the index operators involved in this scan are lossy,
211+
* recheck them by evaluating the original operator clauses.
212+
*/
213+
if (lossyQual)
214+
{
215+
econtext->ecxt_scantuple=slot;
216+
ResetExprContext(econtext);
217+
if (!ExecQual(lossyQual,econtext, false))
218+
{
219+
/* Fails lossy op, so drop it and loop back for another */
220+
ExecClearTuple(slot);
221+
continue;
222+
}
223+
}
224+
204225
/*
205226
* If it's a multiple-index scan, make sure not to double-report
206227
* a tuple matched by more than one index. (See notes above.)
@@ -615,6 +636,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
615636
List*indxqual;
616637
List*indxstrategy;
617638
List*indxsubtype;
639+
List*indxlossy;
618640
List*indxid;
619641
inti;
620642
intnumIndices;
@@ -623,6 +645,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
623645
int*numScanKeys;
624646
RelationPtrindexDescs;
625647
IndexScanDescPtrscanDescs;
648+
List**lossyQuals;
626649
ExprState***runtimeKeyInfo;
627650
boolhave_runtime_keys;
628651
RangeTblEntry*rtentry;
@@ -680,6 +703,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
680703
indexstate->iss_RuntimeKeysReady= false;
681704
indexstate->iss_RelationDescs=NULL;
682705
indexstate->iss_ScanDescs=NULL;
706+
indexstate->iss_LossyQuals=NULL;
683707

684708
/*
685709
* get the index node information
@@ -699,6 +723,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
699723
scanKeys= (ScanKey*)palloc(numIndices*sizeof(ScanKey));
700724
indexDescs= (RelationPtr)palloc(numIndices*sizeof(Relation));
701725
scanDescs= (IndexScanDescPtr)palloc(numIndices*sizeof(IndexScanDesc));
726+
lossyQuals= (List**)palloc0(numIndices*sizeof(List*));
702727

703728
/*
704729
* initialize space for runtime key info (may not be needed)
@@ -712,11 +737,13 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
712737
indxqual=node->indxqual;
713738
indxstrategy=node->indxstrategy;
714739
indxsubtype=node->indxsubtype;
740+
indxlossy=node->indxlossy;
715741
for (i=0;i<numIndices;i++)
716742
{
717743
List*quals;
718744
List*strategies;
719745
List*subtypes;
746+
List*lossyflags;
720747
intn_keys;
721748
ScanKeyscan_keys;
722749
ExprState**run_keys;
@@ -728,6 +755,8 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
728755
indxstrategy=lnext(indxstrategy);
729756
subtypes=lfirst(indxsubtype);
730757
indxsubtype=lnext(indxsubtype);
758+
lossyflags=lfirst(indxlossy);
759+
indxlossy=lnext(indxlossy);
731760
n_keys=length(quals);
732761
scan_keys= (n_keys <=0) ? (ScanKey)NULL :
733762
(ScanKey)palloc(n_keys*sizeof(ScanKeyData));
@@ -747,6 +776,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
747776
AttrNumbervarattno;/* att number used in scan */
748777
StrategyNumberstrategy;/* op's strategy number */
749778
Oidsubtype;/* op's strategy subtype */
779+
intlossy;/* op's recheck flag */
750780
RegProcedureopfuncid;/* operator proc id used in scan */
751781
Datumscanvalue;/* value used in scan (if const) */
752782

@@ -759,6 +789,8 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
759789
strategies=lnext(strategies);
760790
subtype=lfirsto(subtypes);
761791
subtypes=lnext(subtypes);
792+
lossy=lfirsti(lossyflags);
793+
lossyflags=lnext(lossyflags);
762794

763795
if (!IsA(clause,OpExpr))
764796
elog(ERROR,"indxqual is not an OpExpr");
@@ -839,6 +871,20 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
839871
subtype,/* strategy subtype */
840872
opfuncid,/* reg proc to use */
841873
scanvalue);/* constant */
874+
875+
/*
876+
* If this operator is lossy, add its indxqualorig expression
877+
* to the list of quals to recheck. The nth() calls here could
878+
* be avoided by chasing the lists in parallel to all the other
879+
* lists, but since lossy operators are very uncommon, it's
880+
* probably a waste of time to do so.
881+
*/
882+
if (lossy)
883+
{
884+
lossyQuals[i]=lappend(lossyQuals[i],
885+
nth(j,
886+
(List*)nth(i,indexstate->indxqualorig)));
887+
}
842888
}
843889

844890
/*
@@ -928,6 +974,7 @@ ExecInitIndexScan(IndexScan *node, EState *estate)
928974

929975
indexstate->iss_RelationDescs=indexDescs;
930976
indexstate->iss_ScanDescs=scanDescs;
977+
indexstate->iss_LossyQuals=lossyQuals;
931978

932979
/*
933980
* Initialize result tuple type and projection info.

‎src/backend/nodes/copyfuncs.c‎

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@
1515
* Portions Copyright (c) 1994, Regents of the University of California
1616
*
1717
* IDENTIFICATION
18-
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.273 2004/01/05 05:07:35 tgl Exp $
18+
* $PostgreSQL: pgsql/src/backend/nodes/copyfuncs.c,v 1.274 2004/01/06 04:31:01 tgl Exp $
1919
*
2020
*-------------------------------------------------------------------------
2121
*/
@@ -284,6 +284,17 @@ _copyIndexScan(IndexScan *from)
284284
}
285285
newnode->indxsubtype=newsubtype;
286286
}
287+
/* this can become COPY_NODE_FIELD when intlists are normal objects: */
288+
{
289+
List*newstrat=NIL;
290+
List*tmp;
291+
292+
foreach(tmp,from->indxlossy)
293+
{
294+
newstrat=lappend(newstrat,listCopy(lfirst(tmp)));
295+
}
296+
newnode->indxlossy=newstrat;
297+
}
287298
COPY_SCALAR_FIELD(indxorderdir);
288299

289300
returnnewnode;

‎src/backend/nodes/outfuncs.c‎

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.228 2004/01/05 23:39:53 tgl Exp $
11+
* $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.229 2004/01/06 04:31:01 tgl Exp $
1212
*
1313
* NOTES
1414
* Every node type that can appear in stored rules' parsetrees *must*
@@ -356,6 +356,16 @@ _outIndexScan(StringInfo str, IndexScan *node)
356356
_outOidList(str,lfirst(tmp));
357357
}
358358
}
359+
/* this can become WRITE_NODE_FIELD when intlists are normal objects: */
360+
{
361+
List*tmp;
362+
363+
appendStringInfo(str," :indxlossy ");
364+
foreach(tmp,node->indxlossy)
365+
{
366+
_outIntList(str,lfirst(tmp));
367+
}
368+
}
359369
WRITE_ENUM_FIELD(indxorderdir,ScanDirection);
360370
}
361371

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

Lines changed: 2 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@
4949
* Portions Copyright (c) 1994, Regents of the University of California
5050
*
5151
* IDENTIFICATION
52-
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.121 2004/01/05 23:39:54 tgl Exp $
52+
* $PostgreSQL: pgsql/src/backend/optimizer/path/costsize.c,v 1.122 2004/01/06 04:31:01 tgl Exp $
5353
*
5454
*-------------------------------------------------------------------------
5555
*/
@@ -384,10 +384,6 @@ cost_index(Path *path, Query *root,
384384
* some of the indexquals are join clauses and shouldn't be
385385
* subtracted. Rather than work out exactly how much to subtract, we
386386
* don't subtract anything.
387-
*
388-
* XXX For a lossy index, not all the quals will be removed and so we
389-
* really shouldn't subtract their costs; but detecting that seems
390-
* more expensive than it's worth.
391387
*/
392388
startup_cost+=baserel->baserestrictcost.startup;
393389
cpu_per_tuple=cpu_tuple_cost+baserel->baserestrictcost.per_tuple;
@@ -397,6 +393,7 @@ cost_index(Path *path, Query *root,
397393
QualCostindex_qual_cost;
398394

399395
cost_qual_eval(&index_qual_cost,indexQuals);
396+
/* any startup cost still has to be paid ... */
400397
cpu_per_tuple-=index_qual_cost.per_tuple;
401398
}
402399

0 commit comments

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