mirror of https://github.com/postgres/postgres
This lets BRIN be used with R-Tree-like indexing strategies. Also provided are operator classes for range types, box and inet/cidr. The infrastructure provided here should be sufficient to create operator classes for similar datatypes; for instance, opclasses for PostGIS geometries should be doable, though we didn't try to implement one. (A box/point opclass was also submitted, but we ripped it out before commit because the handling of floating point comparisons in existing code is inconsistent and would generate corrupt indexes.) Author: Emre Hasegeli. Cosmetic changes by me Review: Andreas Karlssonpull/14/head
Alvaro Herrera
11 years ago
parent
199f5973c5
commit
b0b7be6133
@ -0,0 +1,696 @@ |
||||
/*
|
||||
* brin_inclusion.c |
||||
* Implementation of inclusion opclasses for BRIN |
||||
* |
||||
* This module provides framework BRIN support functions for the "inclusion" |
||||
* operator classes. A few SQL-level support functions are also required for |
||||
* each opclass. |
||||
* |
||||
* The "inclusion" BRIN strategy is useful for types that support R-Tree |
||||
* operations. This implementation is a straight mapping of those operations |
||||
* to the block-range nature of BRIN, with two exceptions: (a) we explicitly |
||||
* support "empty" elements: at least with range types, we need to consider |
||||
* emptiness separately from regular R-Tree strategies; and (b) we need to |
||||
* consider "unmergeable" elements, that is, a set of elements for whose union |
||||
* no representation exists. The only case where that happens as of this |
||||
* writing is the INET type, where IPv6 values cannot be merged with IPv4 |
||||
* values. |
||||
* |
||||
* Portions Copyright (c) 1996-2015, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* IDENTIFICATION |
||||
* src/backend/access/brin/brin_inclusion.c |
||||
*/ |
||||
#include "postgres.h" |
||||
|
||||
#include "access/brin_internal.h" |
||||
#include "access/brin_tuple.h" |
||||
#include "access/genam.h" |
||||
#include "access/skey.h" |
||||
#include "catalog/pg_amop.h" |
||||
#include "catalog/pg_type.h" |
||||
#include "utils/datum.h" |
||||
#include "utils/lsyscache.h" |
||||
#include "utils/rel.h" |
||||
#include "utils/syscache.h" |
||||
|
||||
|
||||
/*
|
||||
* Additional SQL level support functions |
||||
* |
||||
* Procedure numbers must not use values reserved for BRIN itself; see |
||||
* brin_internal.h. |
||||
*/ |
||||
#define INCLUSION_MAX_PROCNUMS 4 /* maximum support procs we need */ |
||||
#define PROCNUM_MERGE 11 /* required */ |
||||
#define PROCNUM_MERGEABLE 12 /* optional */ |
||||
#define PROCNUM_CONTAINS 13 /* optional */ |
||||
#define PROCNUM_EMPTY 14 /* optional */ |
||||
|
||||
|
||||
/*
|
||||
* Subtract this from procnum to obtain index in InclusionOpaque arrays |
||||
* (Must be equal to minimum of private procnums). |
||||
*/ |
||||
#define PROCNUM_BASE 11 |
||||
|
||||
/*-
|
||||
* The values stored in the bv_values arrays correspond to: |
||||
* |
||||
* 0 - the union of the values in the block range |
||||
* 1 - whether an empty value is present in any tuple in the block range |
||||
* 2 - whether the values in the block range cannot be merged (e.g. an IPv6 |
||||
* address amidst IPv4 addresses). |
||||
*/ |
||||
#define INCLUSION_UNION 0 |
||||
#define INCLUSION_UNMERGEABLE 1 |
||||
#define INCLUSION_CONTAINS_EMPTY 2 |
||||
|
||||
|
||||
typedef struct InclusionOpaque |
||||
{ |
||||
FmgrInfo extra_procinfos[INCLUSION_MAX_PROCNUMS]; |
||||
bool extra_proc_missing[INCLUSION_MAX_PROCNUMS]; |
||||
Oid cached_subtype; |
||||
FmgrInfo strategy_procinfos[RTMaxStrategyNumber]; |
||||
} InclusionOpaque; |
||||
|
||||
Datum brin_inclusion_opcinfo(PG_FUNCTION_ARGS); |
||||
Datum brin_inclusion_add_value(PG_FUNCTION_ARGS); |
||||
Datum brin_inclusion_consistent(PG_FUNCTION_ARGS); |
||||
Datum brin_inclusion_union(PG_FUNCTION_ARGS); |
||||
static FmgrInfo *inclusion_get_procinfo(BrinDesc *bdesc, uint16 attno, |
||||
uint16 procnum); |
||||
static FmgrInfo *inclusion_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno, |
||||
Oid subtype, uint16 strategynum); |
||||
|
||||
|
||||
/*
|
||||
* BRIN inclusion OpcInfo function |
||||
*/ |
||||
Datum |
||||
brin_inclusion_opcinfo(PG_FUNCTION_ARGS) |
||||
{ |
||||
Oid typoid = PG_GETARG_OID(0); |
||||
BrinOpcInfo *result; |
||||
TypeCacheEntry *bool_typcache = lookup_type_cache(BOOLOID, 0); |
||||
|
||||
/*
|
||||
* All members of opaque are initialized lazily; both procinfo arrays |
||||
* start out as non-initialized by having fn_oid be InvalidOid, and |
||||
* "missing" to false, by zeroing here. strategy_procinfos elements can |
||||
* be invalidated when cached_subtype changes by zeroing fn_oid. |
||||
* extra_procinfo entries are never invalidated, but if a lookup fails |
||||
* (which is expected), extra_proc_missing is set to true, indicating not |
||||
* to look it up again. |
||||
*/ |
||||
result = palloc0(MAXALIGN(SizeofBrinOpcInfo(3)) + sizeof(InclusionOpaque)); |
||||
result->oi_nstored = 3; |
||||
result->oi_opaque = (InclusionOpaque *) |
||||
MAXALIGN((char *) result + SizeofBrinOpcInfo(3)); |
||||
|
||||
/* the union */ |
||||
result->oi_typcache[INCLUSION_UNION] = |
||||
lookup_type_cache(typoid, 0); |
||||
|
||||
/* includes elements that are not mergeable */ |
||||
result->oi_typcache[INCLUSION_UNMERGEABLE] = bool_typcache; |
||||
|
||||
/* includes the empty element */ |
||||
result->oi_typcache[INCLUSION_CONTAINS_EMPTY] = bool_typcache; |
||||
|
||||
PG_RETURN_POINTER(result); |
||||
} |
||||
|
||||
/*
|
||||
* BRIN inclusion add value function |
||||
* |
||||
* Examine the given index tuple (which contains partial status of a certain |
||||
* page range) by comparing it to the given value that comes from another heap |
||||
* tuple. If the new value is outside the union specified by the existing |
||||
* tuple values, update the index tuple and return true. Otherwise, return |
||||
* false and do not modify in this case. |
||||
*/ |
||||
Datum |
||||
brin_inclusion_add_value(PG_FUNCTION_ARGS) |
||||
{ |
||||
BrinDesc *bdesc = (BrinDesc *) PG_GETARG_POINTER(0); |
||||
BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1); |
||||
Datum newval = PG_GETARG_DATUM(2); |
||||
bool isnull = PG_GETARG_BOOL(3); |
||||
Oid colloid = PG_GET_COLLATION(); |
||||
FmgrInfo *finfo; |
||||
Datum result; |
||||
bool new = false; |
||||
AttrNumber attno; |
||||
Form_pg_attribute attr; |
||||
|
||||
/*
|
||||
* If the new value is null, we record that we saw it if it's the first |
||||
* one; otherwise, there's nothing to do. |
||||
*/ |
||||
if (isnull) |
||||
{ |
||||
if (column->bv_hasnulls) |
||||
PG_RETURN_BOOL(false); |
||||
|
||||
column->bv_hasnulls = true; |
||||
PG_RETURN_BOOL(true); |
||||
} |
||||
|
||||
attno = column->bv_attno; |
||||
attr = bdesc->bd_tupdesc->attrs[attno - 1]; |
||||
|
||||
/*
|
||||
* If the recorded value is null, copy the new value (which we know to be |
||||
* not null), and we're almost done. |
||||
*/ |
||||
if (column->bv_allnulls) |
||||
{ |
||||
column->bv_values[INCLUSION_UNION] = |
||||
datumCopy(newval, attr->attbyval, attr->attlen); |
||||
column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(false); |
||||
column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(false); |
||||
column->bv_allnulls = false; |
||||
new = true; |
||||
} |
||||
|
||||
/*
|
||||
* No need for further processing if the block range is marked as |
||||
* containing unmergeable values. |
||||
*/ |
||||
if (DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE])) |
||||
PG_RETURN_BOOL(false); |
||||
|
||||
/*
|
||||
* If the opclass supports the concept of empty values, test the passed |
||||
* new value for emptiness; if it returns true, we need to set the |
||||
* "contains empty" flag in the element (unless already set). |
||||
*/ |
||||
finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_EMPTY); |
||||
if (finfo != NULL && DatumGetBool(FunctionCall1Coll(finfo, colloid, newval))) |
||||
{ |
||||
if (!DatumGetBool(column->bv_values[INCLUSION_CONTAINS_EMPTY])) |
||||
{ |
||||
column->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(true); |
||||
PG_RETURN_BOOL(true); |
||||
} |
||||
|
||||
PG_RETURN_BOOL(false); |
||||
} |
||||
|
||||
if (new) |
||||
PG_RETURN_BOOL(true); |
||||
|
||||
/* Check if the new value is already contained. */ |
||||
finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_CONTAINS); |
||||
if (finfo != NULL && |
||||
DatumGetBool(FunctionCall2Coll(finfo, colloid, |
||||
column->bv_values[INCLUSION_UNION], |
||||
newval))) |
||||
PG_RETURN_BOOL(false); |
||||
|
||||
/*
|
||||
* Check if the new value is mergeable to the existing union. If it is |
||||
* not, mark the value as containing unmergeable elements and get out. |
||||
* |
||||
* Note: at this point we could remove the value from the union, since |
||||
* it's not going to be used any longer. However, the BRIN framework |
||||
* doesn't allow for the value not being present. Improve someday. |
||||
*/ |
||||
finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGEABLE); |
||||
if (finfo != NULL && |
||||
!DatumGetBool(FunctionCall2Coll(finfo, colloid, |
||||
column->bv_values[INCLUSION_UNION], |
||||
newval))) |
||||
{ |
||||
column->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true); |
||||
PG_RETURN_BOOL(true); |
||||
} |
||||
|
||||
/* Finally, merge the new value to the existing union. */ |
||||
finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGE); |
||||
Assert(finfo != NULL); |
||||
result = FunctionCall2Coll(finfo, colloid, |
||||
column->bv_values[INCLUSION_UNION], newval); |
||||
if (!attr->attbyval) |
||||
pfree(DatumGetPointer(column->bv_values[INCLUSION_UNION])); |
||||
column->bv_values[INCLUSION_UNION] = result; |
||||
|
||||
PG_RETURN_BOOL(true); |
||||
} |
||||
|
||||
/*
|
||||
* BRIN inclusion consistent function |
||||
* |
||||
* All of the strategies are optional. |
||||
*/ |
||||
Datum |
||||
brin_inclusion_consistent(PG_FUNCTION_ARGS) |
||||
{ |
||||
BrinDesc *bdesc = (BrinDesc *) PG_GETARG_POINTER(0); |
||||
BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1); |
||||
ScanKey key = (ScanKey) PG_GETARG_POINTER(2); |
||||
Oid colloid = PG_GET_COLLATION(), |
||||
subtype; |
||||
Datum unionval; |
||||
AttrNumber attno; |
||||
Datum query; |
||||
FmgrInfo *finfo; |
||||
Datum result; |
||||
|
||||
Assert(key->sk_attno == column->bv_attno); |
||||
|
||||
/* Handle IS NULL/IS NOT NULL tests. */ |
||||
if (key->sk_flags & SK_ISNULL) |
||||
{ |
||||
if (key->sk_flags & SK_SEARCHNULL) |
||||
{ |
||||
if (column->bv_allnulls || column->bv_hasnulls) |
||||
PG_RETURN_BOOL(true); |
||||
PG_RETURN_BOOL(false); |
||||
} |
||||
|
||||
/*
|
||||
* For IS NOT NULL, we can only skip ranges that are known to have |
||||
* only nulls. |
||||
*/ |
||||
Assert(key->sk_flags & SK_SEARCHNOTNULL); |
||||
PG_RETURN_BOOL(!column->bv_allnulls); |
||||
} |
||||
|
||||
/* If it is all nulls, it cannot possibly be consistent. */ |
||||
if (column->bv_allnulls) |
||||
PG_RETURN_BOOL(false); |
||||
|
||||
/* It has to be checked, if it contains elements that are not mergeable. */ |
||||
if (DatumGetBool(column->bv_values[INCLUSION_UNMERGEABLE])) |
||||
PG_RETURN_BOOL(true); |
||||
|
||||
attno = key->sk_attno; |
||||
subtype = key->sk_subtype; |
||||
query = key->sk_argument; |
||||
unionval = column->bv_values[INCLUSION_UNION]; |
||||
switch (key->sk_strategy) |
||||
{ |
||||
/*
|
||||
* Placement strategies |
||||
* |
||||
* These are implemented by logically negating the result of the |
||||
* converse placement operator; for this to work, the converse operator |
||||
* must be part of the opclass. An error will be thrown by |
||||
* inclusion_get_strategy_procinfo() if the required strategy is not |
||||
* part of the opclass. |
||||
* |
||||
* These all return false if either argument is empty, so there is |
||||
* no need to check for empty elements. |
||||
*/ |
||||
|
||||
case RTLeftStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTOverRightStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
case RTOverLeftStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTRightStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
case RTOverRightStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTLeftStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
case RTRightStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTOverLeftStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
case RTBelowStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTOverAboveStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
case RTOverBelowStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTAboveStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
case RTOverAboveStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTBelowStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
case RTAboveStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTOverBelowStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
/*
|
||||
* Overlap and contains strategies |
||||
* |
||||
* These strategies are simple enough that we can simply call the |
||||
* operator and return its result. Empty elements don't change |
||||
* the result. |
||||
*/ |
||||
|
||||
case RTOverlapStrategyNumber: |
||||
case RTContainsStrategyNumber: |
||||
case RTOldContainsStrategyNumber: |
||||
case RTContainsElemStrategyNumber: |
||||
case RTSubStrategyNumber: |
||||
case RTSubEqualStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
key->sk_strategy); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_DATUM(result); |
||||
|
||||
/*
|
||||
* Contained by strategies |
||||
* |
||||
* We cannot just call the original operator for the contained by |
||||
* strategies because some elements can be contained even though |
||||
* the union is not; instead we use the overlap operator. |
||||
* |
||||
* We check for empty elements separately as they are not merged to |
||||
* the union but contained by everything. |
||||
*/ |
||||
|
||||
case RTContainedByStrategyNumber: |
||||
case RTOldContainedByStrategyNumber: |
||||
case RTSuperStrategyNumber: |
||||
case RTSuperEqualStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTOverlapStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
if (DatumGetBool(result)) |
||||
PG_RETURN_BOOL(true); |
||||
|
||||
PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); |
||||
|
||||
/*
|
||||
* Adjacent strategy |
||||
* |
||||
* We test for overlap first but to be safe we need to call |
||||
* the actual adjacent operator also. |
||||
* |
||||
* An empty element cannot be adjacent to any other, so there is |
||||
* no need to check for it. |
||||
*/ |
||||
|
||||
case RTAdjacentStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTOverlapStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
if (DatumGetBool(result)) |
||||
PG_RETURN_BOOL(true); |
||||
|
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTAdjacentStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_DATUM(result); |
||||
|
||||
/*
|
||||
* Basic comparison strategies |
||||
* |
||||
* It is straightforward to support the equality strategies with |
||||
* the contains operator. Generally, inequality strategies do not |
||||
* make much sense for the types which will be used with the |
||||
* inclusion BRIN family of opclasses, but is is possible to |
||||
* implement them with logical negation of the left-of and right-of |
||||
* operators. |
||||
* |
||||
* NB: These strategies cannot be used with geometric datatypes |
||||
* that use comparison of areas! The only exception is the "same" |
||||
* strategy. |
||||
* |
||||
* Empty elements are considered to be less than the others. We |
||||
* cannot use the empty support function to check the query is an |
||||
* empty element, because the query can be another data type than |
||||
* the empty support function argument. So we will return true, |
||||
* if there is a possibility that empty elements will change the |
||||
* result. |
||||
*/ |
||||
|
||||
case RTLessStrategyNumber: |
||||
case RTLessEqualStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTRightStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
if (!DatumGetBool(result)) |
||||
PG_RETURN_BOOL(true); |
||||
|
||||
PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); |
||||
|
||||
case RTSameStrategyNumber: |
||||
case RTEqualStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTContainsStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
if (DatumGetBool(result)) |
||||
PG_RETURN_BOOL(true); |
||||
|
||||
PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); |
||||
|
||||
case RTGreaterEqualStrategyNumber: |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTLeftStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
if (!DatumGetBool(result)) |
||||
PG_RETURN_BOOL(true); |
||||
|
||||
PG_RETURN_DATUM(column->bv_values[INCLUSION_CONTAINS_EMPTY]); |
||||
|
||||
case RTGreaterStrategyNumber: |
||||
/* no need to check for empty elements */ |
||||
finfo = inclusion_get_strategy_procinfo(bdesc, attno, subtype, |
||||
RTLeftStrategyNumber); |
||||
result = FunctionCall2Coll(finfo, colloid, unionval, query); |
||||
PG_RETURN_BOOL(!DatumGetBool(result)); |
||||
|
||||
default: |
||||
/* shouldn't happen */ |
||||
elog(ERROR, "invalid strategy number %d", key->sk_strategy); |
||||
PG_RETURN_BOOL(false); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* BRIN inclusion union function |
||||
* |
||||
* Given two BrinValues, update the first of them as a union of the summary |
||||
* values contained in both. The second one is untouched. |
||||
*/ |
||||
Datum |
||||
brin_inclusion_union(PG_FUNCTION_ARGS) |
||||
{ |
||||
BrinDesc *bdesc = (BrinDesc *) PG_GETARG_POINTER(0); |
||||
BrinValues *col_a = (BrinValues *) PG_GETARG_POINTER(1); |
||||
BrinValues *col_b = (BrinValues *) PG_GETARG_POINTER(2); |
||||
Oid colloid = PG_GET_COLLATION(); |
||||
AttrNumber attno; |
||||
Form_pg_attribute attr; |
||||
FmgrInfo *finfo; |
||||
Datum result; |
||||
|
||||
Assert(col_a->bv_attno == col_b->bv_attno); |
||||
|
||||
/* Adjust "hasnulls". */ |
||||
if (!col_a->bv_hasnulls && col_b->bv_hasnulls) |
||||
col_a->bv_hasnulls = true; |
||||
|
||||
/* If there are no values in B, there's nothing left to do. */ |
||||
if (col_b->bv_allnulls) |
||||
PG_RETURN_VOID(); |
||||
|
||||
attno = col_a->bv_attno; |
||||
attr = bdesc->bd_tupdesc->attrs[attno - 1]; |
||||
|
||||
/*
|
||||
* Adjust "allnulls". If A doesn't have values, just copy the values from |
||||
* B into A, and we're done. We cannot run the operators in this case, |
||||
* because values in A might contain garbage. Note we already established |
||||
* that B contains values. |
||||
*/ |
||||
if (col_a->bv_allnulls) |
||||
{ |
||||
col_a->bv_allnulls = false; |
||||
col_a->bv_values[INCLUSION_UNION] = |
||||
datumCopy(col_b->bv_values[INCLUSION_UNION], |
||||
attr->attbyval, attr->attlen); |
||||
col_a->bv_values[INCLUSION_UNMERGEABLE] = |
||||
col_b->bv_values[INCLUSION_UNMERGEABLE]; |
||||
col_a->bv_values[INCLUSION_CONTAINS_EMPTY] = |
||||
col_b->bv_values[INCLUSION_CONTAINS_EMPTY]; |
||||
PG_RETURN_VOID(); |
||||
} |
||||
|
||||
/* If B includes empty elements, mark A similarly, if needed. */ |
||||
if (!DatumGetBool(col_a->bv_values[INCLUSION_CONTAINS_EMPTY]) && |
||||
DatumGetBool(col_b->bv_values[INCLUSION_CONTAINS_EMPTY])) |
||||
col_a->bv_values[INCLUSION_CONTAINS_EMPTY] = BoolGetDatum(true); |
||||
|
||||
/* Check if A includes elements that are not mergeable. */ |
||||
if (DatumGetBool(col_a->bv_values[INCLUSION_UNMERGEABLE])) |
||||
PG_RETURN_VOID(); |
||||
|
||||
/* If B includes elements that are not mergeable, mark A similarly. */ |
||||
if (DatumGetBool(col_b->bv_values[INCLUSION_UNMERGEABLE])) |
||||
{ |
||||
col_a->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true); |
||||
PG_RETURN_VOID(); |
||||
} |
||||
|
||||
/* Check if A and B are mergeable; if not, mark A unmergeable. */ |
||||
finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGEABLE); |
||||
if (finfo != NULL && |
||||
!DatumGetBool(FunctionCall2Coll(finfo, colloid, |
||||
col_a->bv_values[INCLUSION_UNION], |
||||
col_b->bv_values[INCLUSION_UNION]))) |
||||
{ |
||||
col_a->bv_values[INCLUSION_UNMERGEABLE] = BoolGetDatum(true); |
||||
PG_RETURN_VOID(); |
||||
} |
||||
|
||||
/* Finally, merge B to A. */ |
||||
finfo = inclusion_get_procinfo(bdesc, attno, PROCNUM_MERGE); |
||||
Assert(finfo != NULL); |
||||
result = FunctionCall2Coll(finfo, colloid, |
||||
col_a->bv_values[INCLUSION_UNION], |
||||
col_b->bv_values[INCLUSION_UNION]); |
||||
if (!attr->attbyval) |
||||
pfree(DatumGetPointer(col_a->bv_values[INCLUSION_UNION])); |
||||
col_a->bv_values[INCLUSION_UNION] = result; |
||||
|
||||
PG_RETURN_VOID(); |
||||
} |
||||
|
||||
/*
|
||||
* Cache and return inclusion opclass support procedure |
||||
* |
||||
* Return the procedure corresponding to the given function support number |
||||
* or null if it is not exists. |
||||
*/ |
||||
static FmgrInfo * |
||||
inclusion_get_procinfo(BrinDesc *bdesc, uint16 attno, uint16 procnum) |
||||
{ |
||||
InclusionOpaque *opaque; |
||||
uint16 basenum = procnum - PROCNUM_BASE; |
||||
|
||||
/*
|
||||
* We cache these in the opaque struct, to avoid repetitive syscache |
||||
* lookups. |
||||
*/ |
||||
opaque = (InclusionOpaque *) bdesc->bd_info[attno - 1]->oi_opaque; |
||||
|
||||
/*
|
||||
* If we already searched for this proc and didn't find it, don't bother |
||||
* searching again. |
||||
*/ |
||||
if (opaque->extra_proc_missing[basenum]) |
||||
return NULL; |
||||
|
||||
if (opaque->extra_procinfos[basenum].fn_oid == InvalidOid) |
||||
{ |
||||
if (RegProcedureIsValid(index_getprocid(bdesc->bd_index, attno, |
||||
procnum))) |
||||
{ |
||||
fmgr_info_copy(&opaque->extra_procinfos[basenum], |
||||
index_getprocinfo(bdesc->bd_index, attno, procnum), |
||||
bdesc->bd_context); |
||||
} |
||||
else |
||||
{ |
||||
opaque->extra_proc_missing[basenum] = true; |
||||
return NULL; |
||||
} |
||||
} |
||||
|
||||
return &opaque->extra_procinfos[basenum]; |
||||
} |
||||
|
||||
/*
|
||||
* Cache and return the procedure of the given strategy |
||||
* |
||||
* Return the procedure corresponding to the given sub-type and strategy |
||||
* number. The data type of the index will be used as the left hand side of |
||||
* the operator and the given sub-type will be used as the right hand side. |
||||
* Throws an error if the pg_amop row does not exist, but that should not |
||||
* happen with a properly configured opclass. |
||||
* |
||||
* It always throws an error when the data type of the opclass is different |
||||
* from the data type of the column or the expression. That happens when the |
||||
* column data type has implicit cast to the opclass data type. We don't |
||||
* bother casting types, because this situation can easily be avoided by |
||||
* setting storage data type to that of the opclass. The same problem does not |
||||
* apply to the data type of the right hand side, because the type in the |
||||
* ScanKey always matches the opclass' one. |
||||
* |
||||
* Note: this function mirrors minmax_get_strategy_procinfo; if changes are |
||||
* made here, see that function too. |
||||
*/ |
||||
static FmgrInfo * |
||||
inclusion_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno, Oid subtype, |
||||
uint16 strategynum) |
||||
{ |
||||
InclusionOpaque *opaque; |
||||
|
||||
Assert(strategynum >= 1 && |
||||
strategynum <= RTMaxStrategyNumber); |
||||
|
||||
opaque = (InclusionOpaque *) bdesc->bd_info[attno - 1]->oi_opaque; |
||||
|
||||
/*
|
||||
* We cache the procedures for the last sub-type in the opaque struct, to |
||||
* avoid repetitive syscache lookups. If the sub-type is changed, |
||||
* invalidate all the cached entries. |
||||
*/ |
||||
if (opaque->cached_subtype != subtype) |
||||
{ |
||||
uint16 i; |
||||
|
||||
for (i = 1; i <= RTMaxStrategyNumber; i++) |
||||
opaque->strategy_procinfos[i - 1].fn_oid = InvalidOid; |
||||
opaque->cached_subtype = subtype; |
||||
} |
||||
|
||||
if (opaque->strategy_procinfos[strategynum - 1].fn_oid == InvalidOid) |
||||
{ |
||||
Form_pg_attribute attr; |
||||
HeapTuple tuple; |
||||
Oid opfamily, |
||||
oprid; |
||||
bool isNull; |
||||
|
||||
opfamily = bdesc->bd_index->rd_opfamily[attno - 1]; |
||||
attr = bdesc->bd_tupdesc->attrs[attno - 1]; |
||||
tuple = SearchSysCache4(AMOPSTRATEGY, ObjectIdGetDatum(opfamily), |
||||
ObjectIdGetDatum(attr->atttypid), |
||||
ObjectIdGetDatum(subtype), |
||||
Int16GetDatum(strategynum)); |
||||
|
||||
if (!HeapTupleIsValid(tuple)) |
||||
elog(ERROR, "missing operator %d(%u,%u) in opfamily %u", |
||||
strategynum, attr->atttypid, subtype, opfamily); |
||||
|
||||
oprid = DatumGetObjectId(SysCacheGetAttr(AMOPSTRATEGY, tuple, |
||||
Anum_pg_amop_amopopr, &isNull)); |
||||
ReleaseSysCache(tuple); |
||||
Assert(!isNull && RegProcedureIsValid(oprid)); |
||||
|
||||
fmgr_info_cxt(get_opcode(oprid), |
||||
&opaque->strategy_procinfos[strategynum - 1], |
||||
bdesc->bd_context); |
||||
} |
||||
|
||||
return &opaque->strategy_procinfos[strategynum - 1]; |
||||
} |
||||
Loading…
Reference in new issue