/*
* Inet histogram partial match divider calculation
*
* First the families and the lengths of the network parts are compared using
* the subnet inclusion operator. If those are acceptable for the operator,
* the divider will be calculated using the masklens and the common bits of
* the addresses. -1 will be returned if it cannot be calculated.
*
* See commentary for inet_hist_value_sel() for some rationale for this.
*/
static int
inet_hist_match_divider(inet *boundary, inet *query, int opr_codenum)
{
if (ip_family(boundary) == ip_family(query) &&
inet_masklen_inclusion_cmp(boundary, query, opr_codenum) == 0)
{
int min_bits,
decisive_bits;
min_bits = Min(ip_bits(boundary), ip_bits(query));
/*
* Set decisive_bits to the masklen of the one that should contain the
* other according to the operator.
*/
if (opr_codenum < 0)
decisive_bits = ip_bits(boundary);
else if (opr_codenum > 0)
decisive_bits = ip_bits(query);
else
decisive_bits = min_bits;
/*
* Now return the number of non-common decisive bits. (This will be
* zero if the boundary and query in fact match, else positive.)
*/
if (min_bits > 0)
return decisive_bits - bitncommon(ip_addr(boundary),
ip_addr(query),
min_bits);
return decisive_bits;
}
return -1;
}
/*
* Comparison function for the subnet inclusion/overlap operators
*
* If the comparison is okay for the specified inclusion operator, the return
* value will be 0. Otherwise the return value will be less than or greater
* than 0 as appropriate for the operator.
*
* Comparison is compatible with the basic comparison function for the inet
* type. See network_cmp_internal() in network.c for the original. Basic
* comparison operators are implemented with the network_cmp_internal()
* function. It is possible to implement the subnet inclusion operators with
* this function.
*
* Comparison is first on the common bits of the network part, then on the
* length of the network part (masklen) as in the network_cmp_internal()
* function. Only the first part is in this function. The second part is
* separated to another function for reusability. The difference between the
* second part and the original network_cmp_internal() is that the inclusion
* operator is considered while comparing the lengths of the network parts.
* See the inet_masklen_inclusion_cmp() function below.
*/
static int
inet_inclusion_cmp(inet *left, inet *right, int opr_codenum)
{
if (ip_family(left) == ip_family(right))
{
int order;
order = bitncmp(ip_addr(left), ip_addr(right),
Min(ip_bits(left), ip_bits(right)));
if (order != 0)
return order;
return inet_masklen_inclusion_cmp(left, right, opr_codenum);
}
return ip_family(left) - ip_family(right);
}
/*
* Calculate node number (within a 4-node, single-family inner index tuple)
*
* The value must have the same family as the node's prefix, and
* commonbits is the mask length of the prefix. We use even or odd
* nodes according to the next address bit after the commonbits,
* and low or high nodes according to whether the value's mask length
* is larger than commonbits.
*/
static int
inet_spg_node_number(const inet *val, int commonbits)
{
int nodeN = 0;
if (commonbits < ip_maxbits(val) &&
ip_addr(val)[commonbits / 8] & (1 << (7 - commonbits % 8)))
nodeN |= 1;
if (commonbits < ip_bits(val))
nodeN |= 2;
return nodeN;
}
/*
* Masklen comparison function for the subnet inclusion/overlap operators
*
* Compares the lengths of the network parts of the inputs. If the comparison
* is okay for the specified inclusion operator, the return value will be 0.
* Otherwise the return value will be less than or greater than 0 as
* appropriate for the operator.
*/
static int
inet_masklen_inclusion_cmp(inet *left, inet *right, int opr_codenum)
{
int order;
order = (int) ip_bits(left) - (int) ip_bits(right);
/*
* Return 0 if the operator would accept this combination of masklens.
* Note that opr_codenum zero (overlaps) will accept all cases.
*/
if ((order > 0 && opr_codenum >= 0) ||
(order == 0 && opr_codenum >= -1 && opr_codenum <= 1) ||
(order < 0 && opr_codenum <= 0))
return 0;
/*
* Otherwise, return a negative value for sup/supeq (notionally, the RHS
* needs to have a larger masklen than it has, which would make it sort
* later), or a positive value for sub/subeq (vice versa).
*/
return opr_codenum;
}
/*
* The SP-GiST choose function
*/
Datum
inet_spg_choose(PG_FUNCTION_ARGS)
{
spgChooseIn *in = (spgChooseIn *) PG_GETARG_POINTER(0);
spgChooseOut *out = (spgChooseOut *) PG_GETARG_POINTER(1);
inet *val = DatumGetInetPP(in->datum),
*prefix;
int commonbits;
/*
* If we're looking at a tuple that splits by address family, choose the
* appropriate subnode.
*/
if (!in->hasPrefix)
{
/* allTheSame isn't possible for such a tuple */
Assert(!in->allTheSame);
Assert(in->nNodes == 2);
out->resultType = spgMatchNode;
out->result.matchNode.nodeN = (ip_family(val) == PGSQL_AF_INET) ? 0 : 1;
out->result.matchNode.restDatum = InetPGetDatum(val);
PG_RETURN_VOID();
}
/* Else it must split by prefix */
Assert(in->nNodes == 4 || in->allTheSame);
prefix = DatumGetInetPP(in->prefixDatum);
commonbits = ip_bits(prefix);
/*
* We cannot put addresses from different families under the same inner
* node, so we have to split if the new value's family is different.
*/
if (ip_family(val) != ip_family(prefix))
{
/* Set up 2-node tuple */
out->resultType = spgSplitTuple;
out->result.splitTuple.prefixHasPrefix = false;
out->result.splitTuple.prefixNNodes = 2;
out->result.splitTuple.prefixNodeLabels = NULL;
/* Identify which node the existing data goes into */
out->result.splitTuple.childNodeN =
(ip_family(prefix) == PGSQL_AF_INET) ? 0 : 1;
out->result.splitTuple.postfixHasPrefix = true;
out->result.splitTuple.postfixPrefixDatum = InetPGetDatum(prefix);
PG_RETURN_VOID();
}
/*
* If the new value does not match the existing prefix, we have to split.
*/
if (ip_bits(val) < commonbits ||
bitncmp(ip_addr(prefix), ip_addr(val), commonbits) != 0)
{
/* Determine new prefix length for the split tuple */
commonbits = bitncommon(ip_addr(prefix), ip_addr(val),
Min(ip_bits(val), commonbits));
/* Set up 4-node tuple */
out->resultType = spgSplitTuple;
out->result.splitTuple.prefixHasPrefix = true;
out->result.splitTuple.prefixPrefixDatum =
InetPGetDatum(cidr_set_masklen_internal(val, commonbits));
out->result.splitTuple.prefixNNodes = 4;
out->result.splitTuple.prefixNodeLabels = NULL;
/* Identify which node the existing data goes into */
out->result.splitTuple.childNodeN =
inet_spg_node_number(prefix, commonbits);
out->result.splitTuple.postfixHasPrefix = true;
out->result.splitTuple.postfixPrefixDatum = InetPGetDatum(prefix);
PG_RETURN_VOID();
}
/*
* All OK, choose the node to descend into. (If this tuple is marked
* allTheSame, the core code will ignore our choice of nodeN; but we need
* not account for that case explicitly here.)
*/
out->resultType = spgMatchNode;
out->result.matchNode.nodeN = inet_spg_node_number(val, commonbits);
out->result.matchNode.restDatum = InetPGetDatum(val);
PG_RETURN_VOID();
}
/*
* Calculate bitmap of node numbers that are consistent with the query
*
* This can be used either at a 4-way inner tuple, or at a leaf tuple.
* In the latter case, we should return a boolean result (0 or 1)
* not a bitmap.
*
* This definition is pretty odd, but the inner and leaf consistency checks
* are mostly common and it seems best to keep them in one function.
*/
static int
inet_spg_consistent_bitmap(const inet *prefix, int nkeys, ScanKey scankeys,
bool leaf)
{
int bitmap;
int commonbits,
i;
/* Initialize result to allow visiting all children */
if (leaf)
bitmap = 1;
else
bitmap = 1 | (1 << 1) | (1 << 2) | (1 << 3);
commonbits = ip_bits(prefix);
for (i = 0; i < nkeys; i++)
{
inet *argument = DatumGetInetPP(scankeys[i].sk_argument);
StrategyNumber strategy = scankeys[i].sk_strategy;
int order;
/*
* Check 0: different families
*
* Matching families do not help any of the strategies.
*/
if (ip_family(argument) != ip_family(prefix))
{
switch (strategy)
{
case RTLessStrategyNumber:
case RTLessEqualStrategyNumber:
if (ip_family(argument) < ip_family(prefix))
bitmap = 0;
break;
case RTGreaterEqualStrategyNumber:
case RTGreaterStrategyNumber:
if (ip_family(argument) > ip_family(prefix))
bitmap = 0;
break;
case RTNotEqualStrategyNumber:
break;
default:
/* For all other cases, we can be sure there is no match */
bitmap = 0;
break;
}
if (!bitmap)
break;
/* Other checks make no sense with different families. */
continue;
}
/*
* Check 1: network bit count
*
* Network bit count (ip_bits) helps to check leaves for sub network
* and sup network operators. At non-leaf nodes, we know every child
* value has greater ip_bits, so we can avoid descending in some cases
* too.
*
* This check is less expensive than checking the address bits, so we
* are doing this before, but it has to be done after for the basic
* comparison strategies, because ip_bits only affect their results
* when the common network bits are the same.
*/
switch (strategy)
{
case RTSubStrategyNumber:
if (commonbits <= ip_bits(argument))
bitmap &= (1 << 2) | (1 << 3);
break;
case RTSubEqualStrategyNumber:
if (commonbits < ip_bits(argument))
bitmap &= (1 << 2) | (1 << 3);
break;
case RTSuperStrategyNumber:
if (commonbits == ip_bits(argument) - 1)
bitmap &= 1 | (1 << 1);
else if (commonbits >= ip_bits(argument))
bitmap = 0;
break;
case RTSuperEqualStrategyNumber:
if (commonbits == ip_bits(argument))
bitmap &= 1 | (1 << 1);
else if (commonbits > ip_bits(argument))
bitmap = 0;
break;
case RTEqualStrategyNumber:
if (commonbits < ip_bits(argument))
bitmap &= (1 << 2) | (1 << 3);
else if (commonbits == ip_bits(argument))
bitmap &= 1 | (1 << 1);
else
bitmap = 0;
break;
}
if (!bitmap)
break;
/*
* Check 2: common network bits
*
* Compare available common prefix bits to the query, but not beyond
* either the query's netmask or the minimum netmask among the
* represented values. If these bits don't match the query, we can
* eliminate some cases.
*/
order = bitncmp(ip_addr(prefix), ip_addr(argument),
Min(commonbits, ip_bits(argument)));
if (order != 0)
{
switch (strategy)
{
case RTLessStrategyNumber:
case RTLessEqualStrategyNumber:
if (order > 0)
bitmap = 0;
break;
case RTGreaterEqualStrategyNumber:
case RTGreaterStrategyNumber:
if (order < 0)
bitmap = 0;
break;
case RTNotEqualStrategyNumber:
break;
default:
/* For all other cases, we can be sure there is no match */
bitmap = 0;
break;
}
if (!bitmap)
break;
/*
* Remaining checks make no sense when common bits don't match.
*/
continue;
}
/*
* Check 3: next network bit
*
* We can filter out branch 2 or 3 using the next network bit of the
* argument, if it is available.
*
* This check matters for the performance of the search. The results
* would be correct without it.
*/
if (bitmap & ((1 << 2) | (1 << 3)) &&
commonbits < ip_bits(argument))
{
int nextbit;
nextbit = ip_addr(argument)[commonbits / 8] &
(1 << (7 - commonbits % 8));
switch (strategy)
{
case RTLessStrategyNumber:
case RTLessEqualStrategyNumber:
if (!nextbit)
bitmap &= 1 | (1 << 1) | (1 << 2);
break;
case RTGreaterEqualStrategyNumber:
case RTGreaterStrategyNumber:
if (nextbit)
bitmap &= 1 | (1 << 1) | (1 << 3);
break;
case RTNotEqualStrategyNumber:
break;
default:
if (!nextbit)
bitmap &= 1 | (1 << 1) | (1 << 2);
else
bitmap &= 1 | (1 << 1) | (1 << 3);
break;
}
if (!bitmap)
break;
}
/*
* Remaining checks are only for the basic comparison strategies. This
* test relies on the strategy number ordering defined in stratnum.h.
*/
if (strategy < RTEqualStrategyNumber ||
strategy > RTGreaterEqualStrategyNumber)
continue;
/*
* Check 4: network bit count
*
* At this point, we know that the common network bits of the prefix
* and the argument are the same, so we can go forward and check the
* ip_bits.
*/
switch (strategy)
{
case RTLessStrategyNumber:
case RTLessEqualStrategyNumber:
if (commonbits == ip_bits(argument))
bitmap &= 1 | (1 << 1);
else if (commonbits > ip_bits(argument))
bitmap = 0;
break;
case RTGreaterEqualStrategyNumber:
case RTGreaterStrategyNumber:
if (commonbits < ip_bits(argument))
bitmap &= (1 << 2) | (1 << 3);
break;
}
if (!bitmap)
break;
/* Remaining checks don't make sense with different ip_bits. */
if (commonbits != ip_bits(argument))
continue;
/*
* Check 5: next host bit
*
* We can filter out branch 0 or 1 using the next host bit of the
* argument, if it is available.
*
* This check matters for the performance of the search. The results
* would be correct without it. There is no point in running it for
* leafs as we have to check the whole address on the next step.
*/
if (!leaf && bitmap & (1 | (1 << 1)) &&
commonbits < ip_maxbits(argument))
{
int nextbit;
nextbit = ip_addr(argument)[commonbits / 8] &
(1 << (7 - commonbits % 8));
switch (strategy)
{
case RTLessStrategyNumber:
case RTLessEqualStrategyNumber:
if (!nextbit)
bitmap &= 1 | (1 << 2) | (1 << 3);
break;
case RTGreaterEqualStrategyNumber:
case RTGreaterStrategyNumber:
if (nextbit)
bitmap &= (1 << 1) | (1 << 2) | (1 << 3);
break;
case RTNotEqualStrategyNumber:
break;
default:
if (!nextbit)
bitmap &= 1 | (1 << 2) | (1 << 3);
else
bitmap &= (1 << 1) | (1 << 2) | (1 << 3);
break;
}
if (!bitmap)
break;
}
/*
* Check 6: whole address
*
* This is the last check for correctness of the basic comparison
* strategies. It's only appropriate at leaf entries.
*/
if (leaf)
{
/* Redo ordering comparison using all address bits */
order = bitncmp(ip_addr(prefix), ip_addr(argument),
ip_maxbits(prefix));
switch (strategy)
{
case RTLessStrategyNumber:
if (order >= 0)
bitmap = 0;
break;
case RTLessEqualStrategyNumber:
if (order > 0)
bitmap = 0;
break;
case RTEqualStrategyNumber:
if (order != 0)
bitmap = 0;
break;
case RTGreaterEqualStrategyNumber:
if (order < 0)
bitmap = 0;
break;
case RTGreaterStrategyNumber:
if (order <= 0)
bitmap = 0;
break;
case RTNotEqualStrategyNumber:
if (order == 0)
bitmap = 0;
break;
}
if (!bitmap)
break;
}
}
return bitmap;
}
/*
* The GiST PickSplit method
*/
Datum
inet_spg_picksplit(PG_FUNCTION_ARGS)
{
spgPickSplitIn *in = (spgPickSplitIn *) PG_GETARG_POINTER(0);
spgPickSplitOut *out = (spgPickSplitOut *) PG_GETARG_POINTER(1);
inet *prefix,
*tmp;
int i,
commonbits;
bool differentFamilies = false;
/* Initialize the prefix with the first item */
prefix = DatumGetInetPP(in->datums[0]);
commonbits = ip_bits(prefix);
/* Examine remaining items to discover minimum common prefix length */
for (i = 1; i < in->nTuples; i++)
{
tmp = DatumGetInetPP(in->datums[i]);
if (ip_family(tmp) != ip_family(prefix))
{
differentFamilies = true;
break;
}
if (ip_bits(tmp) < commonbits)
commonbits = ip_bits(tmp);
commonbits = bitncommon(ip_addr(prefix), ip_addr(tmp), commonbits);
if (commonbits == 0)
break;
}
/* Don't need labels; allocate output arrays */
out->nodeLabels = NULL;
out->mapTuplesToNodes = (int *) palloc(sizeof(int) * in->nTuples);
out->leafTupleDatums = (Datum *) palloc(sizeof(Datum) * in->nTuples);
if (differentFamilies)
{
/* Set up 2-node tuple */
out->hasPrefix = false;
out->nNodes = 2;
for (i = 0; i < in->nTuples; i++)
{
tmp = DatumGetInetPP(in->datums[i]);
out->mapTuplesToNodes[i] =
(ip_family(tmp) == PGSQL_AF_INET) ? 0 : 1;
out->leafTupleDatums[i] = InetPGetDatum(tmp);
}
}
else
{
/* Set up 4-node tuple */
out->hasPrefix = true;
out->prefixDatum =
InetPGetDatum(cidr_set_masklen_internal(prefix, commonbits));
out->nNodes = 4;
for (i = 0; i < in->nTuples; i++)
{
tmp = DatumGetInetPP(in->datums[i]);
out->mapTuplesToNodes[i] = inet_spg_node_number(tmp, commonbits);
out->leafTupleDatums[i] = InetPGetDatum(tmp);
}
}
PG_RETURN_VOID();
}
