🌐 AI搜索 & 代理 主页
Skip to content

Commit ab05eed

Browse files
tglsfdctglsfdc
committed
Add support for cross-type hashing in hashed subplans (hashed IN/NOT IN cases
that aren't turned into true joins). Since this is the last missing bit of infrastructure, go ahead and fill out the hash integer_ops and float_ops opfamilies with cross-type operators. The operator family project is now DONE ... er, except for documentation ...
1 parent b70e536 commit ab05eed

File tree

11 files changed

+219
-72
lines changed

11 files changed

+219
-72
lines changed

‎src/backend/executor/execGrouping.c‎

Lines changed: 73 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/executor/execGrouping.c,v 1.24 2007/01/30 01:33:36 tgl Exp $
11+
* $PostgreSQL: pgsql/src/backend/executor/execGrouping.c,v 1.25 2007/02/06 02:59:11 tgl Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -178,7 +178,7 @@ execTuplesUnequal(TupleTableSlot *slot1,
178178
/*
179179
* execTuplesMatchPrepare
180180
* Look up the equality functions needed for execTuplesMatch or
181-
* execTuplesUnequal.
181+
* execTuplesUnequal, given an array of equality operator OIDs.
182182
*
183183
* The result is a palloc'd array.
184184
*/
@@ -208,6 +208,8 @@ execTuplesMatchPrepare(int numCols,
208208
* This is similar to execTuplesMatchPrepare, but we also need to find the
209209
* hash functions associated with the equality operators. *eqFunctions and
210210
* *hashFunctions receive the palloc'd result arrays.
211+
*
212+
* Note: we expect that the given operators are not cross-type comparisons.
211213
*/
212214
void
213215
execTuplesHashPrepare(int numCols,
@@ -232,7 +234,7 @@ execTuplesHashPrepare(int numCols,
232234
&left_hash_function, &right_hash_function))
233235
elog(ERROR, "could not find hash function for hash operator %u",
234236
eq_opr);
235-
/* For the moment, we're not supporting cross-type cases here */
237+
/* We're not supporting cross-type cases here */
236238
Assert(left_hash_function == right_hash_function);
237239
fmgr_info(eq_function, &(*eqFunctions)[i]);
238240
fmgr_info(right_hash_function, &(*hashFunctions)[i]);
@@ -259,7 +261,9 @@ execTuplesHashPrepare(int numCols,
259261
* tablecxt: memory context in which to store table and table entries
260262
* tempcxt: short-lived context for evaluation hash and comparison functions
261263
*
262-
* The function arrays may be made with execTuplesHashPrepare().
264+
* The function arrays may be made with execTuplesHashPrepare(). Note they
265+
* are not cross-type functions, but expect to see the table datatype(s)
266+
* on both sides.
263267
*
264268
* Note that keyColIdx, eqfunctions, and hashfunctions must be allocated in
265269
* storage that will live as long as the hashtable does.
@@ -282,13 +286,15 @@ BuildTupleHashTable(int numCols, AttrNumber *keyColIdx,
282286

283287
hashtable->numCols = numCols;
284288
hashtable->keyColIdx = keyColIdx;
285-
hashtable->eqfunctions = eqfunctions;
286-
hashtable->hashfunctions = hashfunctions;
289+
hashtable->tab_hash_funcs = hashfunctions;
290+
hashtable->tab_eq_funcs = eqfunctions;
287291
hashtable->tablecxt = tablecxt;
288292
hashtable->tempcxt = tempcxt;
289293
hashtable->entrysize = entrysize;
290294
hashtable->tableslot = NULL; /* will be made on first lookup */
291295
hashtable->inputslot = NULL;
296+
hashtable->in_hash_funcs = NULL;
297+
hashtable->cur_eq_funcs = NULL;
292298

293299
MemSet(&hash_ctl, 0, sizeof(hash_ctl));
294300
hash_ctl.keysize = sizeof(TupleHashEntryData);
@@ -305,7 +311,7 @@ BuildTupleHashTable(int numCols, AttrNumber *keyColIdx,
305311

306312
/*
307313
* Find or create a hashtable entry for the tuple group containing the
308-
* given tuple.
314+
* given tuple. The tuple must be the same type as the hashtable entries.
309315
*
310316
* If isnew is NULL, we do not create new entries; we return NULL if no
311317
* match is found.
@@ -351,6 +357,9 @@ LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
351357
* invoke this code re-entrantly.
352358
*/
353359
hashtable->inputslot = slot;
360+
hashtable->in_hash_funcs = hashtable->tab_hash_funcs;
361+
hashtable->cur_eq_funcs = hashtable->tab_eq_funcs;
362+
354363
saveCurHT = CurTupleHashTable;
355364
CurTupleHashTable = hashtable;
356365

@@ -394,6 +403,55 @@ LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
394403
return entry;
395404
}
396405

406+
/*
407+
* Search for a hashtable entry matching the given tuple. No entry is
408+
* created if there's not a match. This is similar to the non-creating
409+
* case of LookupTupleHashEntry, except that it supports cross-type
410+
* comparisons, in which the given tuple is not of the same type as the
411+
* table entries. The caller must provide the hash functions to use for
412+
* the input tuple, as well as the equality functions, since these may be
413+
* different from the table's internal functions.
414+
*/
415+
TupleHashEntry
416+
FindTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot,
417+
FmgrInfo *eqfunctions,
418+
FmgrInfo *hashfunctions)
419+
{
420+
TupleHashEntry entry;
421+
MemoryContext oldContext;
422+
TupleHashTable saveCurHT;
423+
TupleHashEntryData dummy;
424+
425+
/* Need to run the hash functions in short-lived context */
426+
oldContext = MemoryContextSwitchTo(hashtable->tempcxt);
427+
428+
/*
429+
* Set up data needed by hash and match functions
430+
*
431+
* We save and restore CurTupleHashTable just in case someone manages to
432+
* invoke this code re-entrantly.
433+
*/
434+
hashtable->inputslot = slot;
435+
hashtable->in_hash_funcs = hashfunctions;
436+
hashtable->cur_eq_funcs = eqfunctions;
437+
438+
saveCurHT = CurTupleHashTable;
439+
CurTupleHashTable = hashtable;
440+
441+
/* Search the hash table */
442+
dummy.firstTuple = NULL; /* flag to reference inputslot */
443+
entry = (TupleHashEntry) hash_search(hashtable->hashtab,
444+
&dummy,
445+
HASH_FIND,
446+
NULL);
447+
448+
CurTupleHashTable = saveCurHT;
449+
450+
MemoryContextSwitchTo(oldContext);
451+
452+
return entry;
453+
}
454+
397455
/*
398456
* Compute the hash value for a tuple
399457
*
@@ -418,20 +476,23 @@ TupleHashTableHash(const void *key, Size keysize)
418476
TupleHashTable hashtable = CurTupleHashTable;
419477
int numCols = hashtable->numCols;
420478
AttrNumber *keyColIdx = hashtable->keyColIdx;
479+
FmgrInfo *hashfunctions;
421480
uint32 hashkey = 0;
422481
int i;
423482

424483
if (tuple == NULL)
425484
{
426485
/* Process the current input tuple for the table */
427486
slot = hashtable->inputslot;
487+
hashfunctions = hashtable->in_hash_funcs;
428488
}
429489
else
430490
{
431491
/* Process a tuple already stored in the table */
432492
/* (this case never actually occurs in current dynahash.c code) */
433493
slot = hashtable->tableslot;
434494
ExecStoreMinimalTuple(tuple, slot, false);
495+
hashfunctions = hashtable->tab_hash_funcs;
435496
}
436497

437498
for (i = 0; i < numCols; i++)
@@ -449,7 +510,7 @@ TupleHashTableHash(const void *key, Size keysize)
449510
{
450511
uint32 hkey;
451512

452-
hkey = DatumGetUInt32(FunctionCall1(&hashtable->hashfunctions[i],
513+
hkey = DatumGetUInt32(FunctionCall1(&hashfunctions[i],
453514
attr));
454515
hashkey ^= hkey;
455516
}
@@ -493,11 +554,12 @@ TupleHashTableMatch(const void *key1, const void *key2, Size keysize)
493554
Assert(tuple2 == NULL);
494555
slot2 = hashtable->inputslot;
495556

496-
if (execTuplesMatch(slot1,
497-
slot2,
557+
/* For crosstype comparisons, the inputslot must be first */
558+
if (execTuplesMatch(slot2,
559+
slot1,
498560
hashtable->numCols,
499561
hashtable->keyColIdx,
500-
hashtable->eqfunctions,
562+
hashtable->cur_eq_funcs,
501563
hashtable->tempcxt))
502564
return 0;
503565
else

‎src/backend/executor/nodeSubplan.c‎

Lines changed: 32 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
* Portions Copyright (c) 1994, Regents of the University of California
88
*
99
* IDENTIFICATION
10-
* $PostgreSQL: pgsql/src/backend/executor/nodeSubplan.c,v 1.84 2007/02/02 00:07:03 tgl Exp $
10+
* $PostgreSQL: pgsql/src/backend/executor/nodeSubplan.c,v 1.85 2007/02/06 02:59:11 tgl Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -139,7 +139,10 @@ ExecHashSubPlan(SubPlanState *node,
139139
if (slotNoNulls(slot))
140140
{
141141
if (node->havehashrows &&
142-
LookupTupleHashEntry(node->hashtable, slot, NULL) != NULL)
142+
FindTupleHashEntry(node->hashtable,
143+
slot,
144+
node->cur_eq_funcs,
145+
node->lhs_hash_funcs) != NULL)
143146
{
144147
ExecClearTuple(slot);
145148
return BoolGetDatum(true);
@@ -453,8 +456,8 @@ buildSubPlanHash(SubPlanState *node)
453456

454457
node->hashtable = BuildTupleHashTable(ncols,
455458
node->keyColIdx,
456-
node->eqfunctions,
457-
node->hashfunctions,
459+
node->tab_eq_funcs,
460+
node->tab_hash_funcs,
458461
nbuckets,
459462
sizeof(TupleHashEntryData),
460463
node->tablecxt,
@@ -472,8 +475,8 @@ buildSubPlanHash(SubPlanState *node)
472475
}
473476
node->hashnulls = BuildTupleHashTable(ncols,
474477
node->keyColIdx,
475-
node->eqfunctions,
476-
node->hashfunctions,
478+
node->tab_eq_funcs,
479+
node->tab_hash_funcs,
477480
nbuckets,
478481
sizeof(TupleHashEntryData),
479482
node->tablecxt,
@@ -573,9 +576,9 @@ findPartialMatch(TupleHashTable hashtable, TupleTableSlot *slot)
573576
while ((entry = ScanTupleHashTable(&hashiter)) != NULL)
574577
{
575578
ExecStoreMinimalTuple(entry->firstTuple, hashtable->tableslot, false);
576-
if (!execTuplesUnequal(hashtable->tableslot, slot,
579+
if (!execTuplesUnequal(slot, hashtable->tableslot,
577580
numCols, keyColIdx,
578-
hashtable->eqfunctions,
581+
hashtable->cur_eq_funcs,
579582
hashtable->tempcxt))
580583
return true;
581584
}
@@ -653,8 +656,10 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
653656
node->tablecxt = NULL;
654657
node->innerecontext = NULL;
655658
node->keyColIdx = NULL;
656-
node->eqfunctions = NULL;
657-
node->hashfunctions = NULL;
659+
node->tab_hash_funcs = NULL;
660+
node->tab_eq_funcs = NULL;
661+
node->lhs_hash_funcs = NULL;
662+
node->cur_eq_funcs = NULL;
658663

659664
/*
660665
* create an EState for the subplan
@@ -781,8 +786,10 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
781786

782787
lefttlist = righttlist = NIL;
783788
leftptlist = rightptlist = NIL;
784-
node->eqfunctions = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
785-
node->hashfunctions = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
789+
node->tab_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
790+
node->tab_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
791+
node->lhs_hash_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
792+
node->cur_eq_funcs = (FmgrInfo *) palloc(ncols * sizeof(FmgrInfo));
786793
i = 1;
787794
foreach(l, oplist)
788795
{
@@ -792,6 +799,7 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
792799
Expr *expr;
793800
TargetEntry *tle;
794801
GenericExprState *tlestate;
802+
Oid rhs_eq_oper;
795803
Oid left_hashfn;
796804
Oid right_hashfn;
797805

@@ -827,18 +835,24 @@ ExecInitSubPlan(SubPlanState *node, EState *estate, int eflags)
827835
righttlist = lappend(righttlist, tlestate);
828836
rightptlist = lappend(rightptlist, tle);
829837

830-
/* Lookup the combining function */
831-
fmgr_info(opexpr->opfuncid, &node->eqfunctions[i - 1]);
832-
node->eqfunctions[i - 1].fn_expr = (Node *) opexpr;
838+
/* Lookup the equality function (potentially cross-type) */
839+
fmgr_info(opexpr->opfuncid, &node->cur_eq_funcs[i - 1]);
840+
node->cur_eq_funcs[i - 1].fn_expr = (Node *) opexpr;
841+
842+
/* Look up the equality function for the RHS type */
843+
if (!get_compatible_hash_operators(opexpr->opno,
844+
NULL, &rhs_eq_oper))
845+
elog(ERROR, "could not find compatible hash operator for operator %u",
846+
opexpr->opno);
847+
fmgr_info(get_opcode(rhs_eq_oper), &node->tab_eq_funcs[i - 1]);
833848

834849
/* Lookup the associated hash functions */
835850
if (!get_op_hash_functions(opexpr->opno,
836851
&left_hashfn, &right_hashfn))
837852
elog(ERROR, "could not find hash function for hash operator %u",
838853
opexpr->opno);
839-
/* For the moment, not supporting cross-type cases */
840-
Assert(left_hashfn == right_hashfn);
841-
fmgr_info(right_hashfn, &node->hashfunctions[i - 1]);
854+
fmgr_info(left_hashfn, &node->lhs_hash_funcs[i - 1]);
855+
fmgr_info(right_hashfn, &node->tab_hash_funcs[i - 1]);
842856

843857
i++;
844858
}

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

Lines changed: 7 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@
77
* Portions Copyright (c) 1994, Regents of the University of California
88
*
99
* IDENTIFICATION
10-
* $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.117 2007/01/10 18:06:03 tgl Exp $
10+
* $PostgreSQL: pgsql/src/backend/optimizer/plan/subselect.c,v 1.118 2007/02/06 02:59:11 tgl Exp $
1111
*
1212
*-------------------------------------------------------------------------
1313
*/
@@ -598,17 +598,13 @@ subplan_is_hashable(SubLink *slink, SubPlan *node)
598598
return false;
599599

600600
/*
601-
* The combining operators must be hashable, strict, and self-commutative.
601+
* The combining operators must be hashable and strict.
602602
* The need for hashability is obvious, since we want to use hashing.
603603
* Without strictness, behavior in the presence of nulls is too
604-
* unpredictable. (We actually must assume even more than plain
605-
* strictness, see nodeSubplan.c for details.) And commutativity ensures
606-
* that the left and right datatypes are the same; this allows us to
607-
* assume that the combining operators are equality for the righthand
608-
* datatype, so that they can be used to compare righthand tuples as well
609-
* as comparing lefthand to righthand tuples. (This last restriction
610-
* could be relaxed by using two different sets of operators with the hash
611-
* table, but there is no obvious usefulness to that at present.)
604+
* unpredictable. We actually must assume even more than plain
605+
* strictness: they can't yield NULL for non-null inputs, either
606+
* (see nodeSubplan.c). However, hash indexes and hash joins assume
607+
* that too.
612608
*/
613609
if (IsA(slink->testexpr, OpExpr))
614610
{
@@ -644,8 +640,7 @@ hash_ok_operator(OpExpr *expr)
644640
if (!HeapTupleIsValid(tup))
645641
elog(ERROR, "cache lookup failed for operator %u", opid);
646642
optup = (Form_pg_operator) GETSTRUCT(tup);
647-
if (!optup->oprcanhash || optup->oprcom != opid ||
648-
!func_strict(optup->oprcode))
643+
if (!optup->oprcanhash || !func_strict(optup->oprcode))
649644
{
650645
ReleaseSysCache(tup);
651646
return false;

‎src/backend/optimizer/util/pathnode.c‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88
*
99
*
1010
* IDENTIFICATION
11-
* $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.137 2007/01/20 20:45:39 tgl Exp $
11+
* $PostgreSQL: pgsql/src/backend/optimizer/util/pathnode.c,v 1.138 2007/02/06 02:59:12 tgl Exp $
1212
*
1313
*-------------------------------------------------------------------------
1414
*/
@@ -1070,7 +1070,7 @@ distinct_col_search(int colno, List *colnos, List *opids)
10701070
* We assume hashed aggregation will work if each IN operator is marked
10711071
* hashjoinable. If the IN operators are cross-type, this could conceivably
10721072
* fail: the aggregation will need a hashable equality operator for the RHS
1073-
* datatype --- but it's pretty hard to conceive of a hash opclass that has
1073+
* datatype --- but it's pretty hard to conceive of a hash opfamily that has
10741074
* cross-type hashing without support for hashing the individual types, so
10751075
* we don't expend cycles here to support the case. We could check
10761076
* get_compatible_hash_operator() instead of just op_hashjoinable(), but the

‎src/include/catalog/catversion.h‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@
3737
* Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
3838
* Portions Copyright (c) 1994, Regents of the University of California
3939
*
40-
* $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.380 2007/02/05 04:22:18 tgl Exp $
40+
* $PostgreSQL: pgsql/src/include/catalog/catversion.h,v 1.381 2007/02/06 02:59:12 tgl Exp $
4141
*
4242
*-------------------------------------------------------------------------
4343
*/
@@ -53,6 +53,6 @@
5353
*/
5454

5555
/* yyyymmddN */
56-
#define CATALOG_VERSION_NO 200702041
56+
#define CATALOG_VERSION_NO 200702051
5757

5858
#endif

0 commit comments

Comments
 (0)