2008-05-17 03:28:26 +02:00
|
|
|
/*
|
2010-09-20 22:08:53 +02:00
|
|
|
* contrib/intarray/_int_gist.c
|
2008-05-17 03:28:26 +02:00
|
|
|
*/
|
2008-05-12 02:00:54 +02:00
|
|
|
#include "postgres.h"
|
|
|
|
|
2015-03-25 22:39:42 +01:00
|
|
|
#include <limits.h>
|
|
|
|
|
2019-10-23 05:56:22 +02:00
|
|
|
#include "_int.h"
|
2008-05-12 02:00:54 +02:00
|
|
|
#include "access/gist.h"
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
#include "access/reloptions.h"
|
2015-05-15 22:03:16 +02:00
|
|
|
#include "access/stratnum.h"
|
2008-05-12 02:00:54 +02:00
|
|
|
|
2004-03-30 17:45:33 +02:00
|
|
|
#define GETENTRY(vec,pos) ((ArrayType *) DatumGetPointer((vec)->vector[(pos)].key))
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2018-11-24 00:56:39 +01:00
|
|
|
/*
|
|
|
|
* Control the maximum sparseness of compressed keys.
|
|
|
|
*
|
|
|
|
* The upper safe bound for this limit is half the maximum allocatable array
|
|
|
|
* size. A lower bound would give more guarantees that pathological data
|
|
|
|
* wouldn't eat excessive CPU and memory, but at the expense of breaking
|
|
|
|
* possibly working (after a fashion) indexes.
|
|
|
|
*/
|
|
|
|
#define MAXNUMELTS (Min((MaxAllocSize / sizeof(Datum)),((MaxAllocSize - ARR_OVERHEAD_NONULLS(1)) / sizeof(int)))/2)
|
|
|
|
/* or: #define MAXNUMELTS 1000000 */
|
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
/*
|
|
|
|
** GiST support methods
|
|
|
|
*/
|
|
|
|
PG_FUNCTION_INFO_V1(g_int_consistent);
|
|
|
|
PG_FUNCTION_INFO_V1(g_int_compress);
|
|
|
|
PG_FUNCTION_INFO_V1(g_int_decompress);
|
|
|
|
PG_FUNCTION_INFO_V1(g_int_penalty);
|
|
|
|
PG_FUNCTION_INFO_V1(g_int_picksplit);
|
|
|
|
PG_FUNCTION_INFO_V1(g_int_union);
|
|
|
|
PG_FUNCTION_INFO_V1(g_int_same);
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
PG_FUNCTION_INFO_V1(g_int_options);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** The GiST Consistent method for _intments
|
|
|
|
** Should return false if for all data items x below entry,
|
2017-08-16 06:22:32 +02:00
|
|
|
** the predicate x op query == false, where op is the oper
|
2003-06-11 21:31:05 +02:00
|
|
|
** corresponding to strategy in the pg_amop table.
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
g_int_consistent(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
|
2011-01-09 06:39:21 +01:00
|
|
|
ArrayType *query = PG_GETARG_ARRAYTYPE_P_COPY(1);
|
2003-06-11 21:31:05 +02:00
|
|
|
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
|
2009-06-11 16:49:15 +02:00
|
|
|
|
2008-04-14 19:05:34 +02:00
|
|
|
/* Oid subtype = PG_GETARG_OID(3); */
|
|
|
|
bool *recheck = (bool *) PG_GETARG_POINTER(4);
|
2003-06-11 21:31:05 +02:00
|
|
|
bool retval;
|
|
|
|
|
2008-04-14 19:05:34 +02:00
|
|
|
/* this is exact except for RTSameStrategyNumber */
|
|
|
|
*recheck = (strategy == RTSameStrategyNumber);
|
|
|
|
|
2006-10-04 02:30:14 +02:00
|
|
|
if (strategy == BooleanSearchStrategy)
|
|
|
|
{
|
2006-04-03 10:21:05 +02:00
|
|
|
retval = execconsistent((QUERYTYPE *) query,
|
2006-10-04 02:30:14 +02:00
|
|
|
(ArrayType *) DatumGetPointer(entry->key),
|
|
|
|
GIST_LEAF(entry));
|
2006-04-03 10:21:05 +02:00
|
|
|
|
2006-10-04 02:30:14 +02:00
|
|
|
pfree(query);
|
2006-04-03 10:21:05 +02:00
|
|
|
PG_RETURN_BOOL(retval);
|
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
/* sort query for fast search, key is already sorted */
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(query);
|
2003-06-11 21:31:05 +02:00
|
|
|
PREPAREARR(query);
|
|
|
|
|
|
|
|
switch (strategy)
|
|
|
|
{
|
|
|
|
case RTOverlapStrategyNumber:
|
|
|
|
retval = inner_int_overlap((ArrayType *) DatumGetPointer(entry->key),
|
|
|
|
query);
|
|
|
|
break;
|
|
|
|
case RTSameStrategyNumber:
|
|
|
|
if (GIST_LEAF(entry))
|
2011-01-09 06:39:21 +01:00
|
|
|
DirectFunctionCall3(g_int_same,
|
2003-06-11 21:31:05 +02:00
|
|
|
entry->key,
|
|
|
|
PointerGetDatum(query),
|
2011-01-09 06:39:21 +01:00
|
|
|
PointerGetDatum(&retval));
|
2003-06-11 21:31:05 +02:00
|
|
|
else
|
|
|
|
retval = inner_int_contains((ArrayType *) DatumGetPointer(entry->key),
|
|
|
|
query);
|
|
|
|
break;
|
|
|
|
case RTContainsStrategyNumber:
|
2006-09-10 19:36:52 +02:00
|
|
|
case RTOldContainsStrategyNumber:
|
2003-06-11 21:31:05 +02:00
|
|
|
retval = inner_int_contains((ArrayType *) DatumGetPointer(entry->key),
|
|
|
|
query);
|
|
|
|
break;
|
|
|
|
case RTContainedByStrategyNumber:
|
2006-09-10 19:36:52 +02:00
|
|
|
case RTOldContainedByStrategyNumber:
|
2003-06-11 21:31:05 +02:00
|
|
|
if (GIST_LEAF(entry))
|
|
|
|
retval = inner_int_contains(query,
|
Phase 3 of pgindent updates.
Don't move parenthesized lines to the left, even if that means they
flow past the right margin.
By default, BSD indent lines up statement continuation lines that are
within parentheses so that they start just to the right of the preceding
left parenthesis. However, traditionally, if that resulted in the
continuation line extending to the right of the desired right margin,
then indent would push it left just far enough to not overrun the margin,
if it could do so without making the continuation line start to the left of
the current statement indent. That makes for a weird mix of indentations
unless one has been completely rigid about never violating the 80-column
limit.
This behavior has been pretty universally panned by Postgres developers.
Hence, disable it with indent's new -lpl switch, so that parenthesized
lines are always lined up with the preceding left paren.
This patch is much less interesting than the first round of indent
changes, but also bulkier, so I thought it best to separate the effects.
Discussion: https://postgr.es/m/E1dAmxK-0006EE-1r@gemulon.postgresql.org
Discussion: https://postgr.es/m/30527.1495162840@sss.pgh.pa.us
2017-06-21 21:35:54 +02:00
|
|
|
(ArrayType *) DatumGetPointer(entry->key));
|
2003-06-11 21:31:05 +02:00
|
|
|
else
|
Fix intarray's GiST opclasses to not fail for empty arrays with <@.
contrib/intarray considers "arraycol <@ constant-array" to be indexable,
but its GiST opclass code fails to reliably find index entries for empty
array values (which of course should trivially match such queries).
This is because the test condition to see whether we should descend
through a non-leaf node is wrong.
Unfortunately, empty array entries could be anywhere in the index,
as these index opclasses are currently designed. So there's no way
to fix this except by lobotomizing <@ indexscans to scan the whole
index ... which is what this patch does. That's pretty unfortunate:
the performance is now actually worse than a seqscan, in most cases.
We'd be better off to remove <@ from the GiST opclasses entirely,
and perhaps a future non-back-patchable patch will do so.
In the meantime, applications whose performance is adversely impacted
have a couple of options. They could switch to a GIN index, which
doesn't have this bug, or they could replace "arraycol <@ constant-array"
with "arraycol <@ constant-array AND arraycol && constant-array".
That will provide about the same performance as before, and it will find
all non-empty subsets of the given constant-array, which is all that
could reliably be expected of the query before.
While at it, add some more regression test cases to improve code
coverage of contrib/intarray.
In passing, adjust resize_intArrayType so that when it's returning an
empty array, it uses construct_empty_array for that rather than
cowboy hacking on the input array. While the hack produces an array
that looks valid for most purposes, it isn't bitwise equal to empty
arrays produced by other code paths, which could have subtle odd
effects. I don't think this code path is performance-critical
enough to justify such shortcuts. (Back-patch this part only as far
as v11; before commit 01783ac36 we were not careful about this in
other intarray code paths either.)
Back-patch the <@ fixes to all supported versions, since this was
broken from day one.
Patch by me; thanks to Alexander Korotkov for review.
Discussion: https://postgr.es/m/458.1565114141@sss.pgh.pa.us
2019-08-07 00:04:51 +02:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Unfortunately, because empty arrays could be anywhere in
|
|
|
|
* the index, we must search the whole tree.
|
|
|
|
*/
|
|
|
|
retval = true;
|
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
break;
|
|
|
|
default:
|
2017-08-16 06:22:32 +02:00
|
|
|
retval = false;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
2006-10-04 02:30:14 +02:00
|
|
|
pfree(query);
|
2003-06-11 21:31:05 +02:00
|
|
|
PG_RETURN_BOOL(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
2003-08-04 02:43:34 +02:00
|
|
|
g_int_union(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
2003-08-04 02:43:34 +02:00
|
|
|
int *size = (int *) PG_GETARG_POINTER(1);
|
2012-06-25 00:51:46 +02:00
|
|
|
int32 i,
|
2003-08-04 02:43:34 +02:00
|
|
|
*ptr;
|
2005-11-19 04:00:09 +01:00
|
|
|
ArrayType *res;
|
|
|
|
int totlen = 0;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2004-03-30 17:45:33 +02:00
|
|
|
for (i = 0; i < entryvec->n; i++)
|
2005-11-19 04:00:09 +01:00
|
|
|
{
|
2005-11-22 19:17:34 +01:00
|
|
|
ArrayType *ent = GETENTRY(entryvec, i);
|
2005-11-19 04:00:09 +01:00
|
|
|
|
|
|
|
CHECKARRVALID(ent);
|
|
|
|
totlen += ARRNELEMS(ent);
|
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
res = new_intArrayType(totlen);
|
|
|
|
ptr = ARRPTR(res);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2004-03-30 17:45:33 +02:00
|
|
|
for (i = 0; i < entryvec->n; i++)
|
2003-08-04 02:43:34 +02:00
|
|
|
{
|
2005-11-22 19:17:34 +01:00
|
|
|
ArrayType *ent = GETENTRY(entryvec, i);
|
|
|
|
int nel;
|
2005-11-19 04:00:09 +01:00
|
|
|
|
|
|
|
nel = ARRNELEMS(ent);
|
2012-06-25 00:51:46 +02:00
|
|
|
memcpy(ptr, ARRPTR(ent), nel * sizeof(int32));
|
2005-11-19 04:00:09 +01:00
|
|
|
ptr += nel;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
QSORT(res, 1);
|
|
|
|
res = _int_unique(res);
|
|
|
|
*size = VARSIZE(res);
|
2003-06-11 21:31:05 +02:00
|
|
|
PG_RETURN_POINTER(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** GiST Compress and Decompress methods
|
|
|
|
*/
|
|
|
|
Datum
|
|
|
|
g_int_compress(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
|
|
|
|
GISTENTRY *retval;
|
|
|
|
ArrayType *r;
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
int num_ranges = G_INT_GET_NUMRANGES();
|
2018-11-24 00:56:39 +01:00
|
|
|
int len,
|
|
|
|
lenr;
|
2003-06-11 21:31:05 +02:00
|
|
|
int *dr;
|
|
|
|
int i,
|
2018-11-24 00:56:39 +01:00
|
|
|
j,
|
2003-06-11 21:31:05 +02:00
|
|
|
cand;
|
2018-11-24 00:56:39 +01:00
|
|
|
int64 min;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
if (entry->leafkey)
|
|
|
|
{
|
2011-01-09 06:39:21 +01:00
|
|
|
r = DatumGetArrayTypePCopy(entry->key);
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(r);
|
2003-06-11 21:31:05 +02:00
|
|
|
PREPAREARR(r);
|
2005-11-14 17:11:37 +01:00
|
|
|
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
if (ARRNELEMS(r) >= 2 * num_ranges)
|
intarray: Prevent out-of-bound memory reads with gist__int_ops
As gist__int_ops stands in intarray, it is possible to store GiST
entries for leaf pages that can cause corruptions when decompressed.
Leaf nodes are stored as decompressed all the time by the compression
method, and the decompression method should map with that, retrieving
the contents of the page without doing any decompression. However, the
code authorized the insertion of leaf page data with a higher number of
array items than what can be supported, generating a NOTICE message to
inform about this matter (199 for a 8k page, for reference). When
calling the decompression method, a decompression would be attempted on
this leaf node item but the contents should be retrieved as they are.
The NOTICE message generated when dealing with the compression of a leaf
page and too many elements in the input array for gist__int_ops has been
introduced by 08ee64e, removing the marker stored in the array to track
if this is actually a leaf node. However, it also missed the fact that
the decompression path should do nothing for a leaf page. Hence, as the
code stand, a too-large array would be stored as uncompressed but the
decompression path would attempt a decompression rather that retrieving
the contents as they are.
This leads to various problems. First, even if 08ee64e tried to address
that, it is possible to do out-of-bound chunk writes with a large input
array, with the backend informing about that with WARNINGs. On
decompression, retrieving the stored leaf data would lead to incorrect
memory reads, leading to crashes or even worse.
Perhaps somebody would be interested in expanding the number of array
items that can be handled in a leaf page for this operator in the
future, which would require revisiting the choice done in 08ee64e, but
based on the lack of reports about this problem since 2005 it does not
look so. For now, this commit prevents the insertion of data for leaf
pages when using more array items that the code can handle on
decompression, switching the NOTICE message to an ERROR. If one wishes
to use more array items, gist__intbig_ops is an optional choice.
While on it, use ERRCODE_PROGRAM_LIMIT_EXCEEDED as error code when a
limit is reached, because that's what the module is facing in such
cases.
Author: Ankit Kumar Pandey, Alexander Lakhin
Reviewed-by: Richard Guo, Michael Paquier
Discussion: https://postgr.es/m/796b65c3-57b7-bddf-b0d5-a8afafb8b627@gmail.com
Discussion: https://postgr.es/m/17888-f72930e6b5ce8c14@postgresql.org
Backpatch-through: 11
2023-06-15 06:45:41 +02:00
|
|
|
ereport(ERROR,
|
|
|
|
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
|
|
|
|
errmsg("input array is too big (%d maximum allowed, %d current), use gist__intbig_ops opclass instead",
|
|
|
|
2 * num_ranges - 1, ARRNELEMS(r))));
|
2005-11-22 19:17:34 +01:00
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
retval = palloc(sizeof(GISTENTRY));
|
|
|
|
gistentryinit(*retval, PointerGetDatum(r),
|
2017-08-16 06:22:32 +02:00
|
|
|
entry->rel, entry->page, entry->offset, false);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
PG_RETURN_POINTER(retval);
|
|
|
|
}
|
|
|
|
|
2005-11-22 19:17:34 +01:00
|
|
|
/*
|
|
|
|
* leaf entries never compress one more time, only when entry->leafkey
|
|
|
|
* ==true, so now we work only with internal keys
|
|
|
|
*/
|
2005-11-14 17:11:37 +01:00
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
r = DatumGetArrayTypeP(entry->key);
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(r);
|
2011-01-09 06:39:21 +01:00
|
|
|
if (ARRISEMPTY(r))
|
2003-06-11 21:31:05 +02:00
|
|
|
{
|
|
|
|
if (r != (ArrayType *) DatumGetPointer(entry->key))
|
|
|
|
pfree(r);
|
|
|
|
PG_RETURN_POINTER(entry);
|
|
|
|
}
|
|
|
|
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
if ((len = ARRNELEMS(r)) >= 2 * num_ranges)
|
2003-06-11 21:31:05 +02:00
|
|
|
{ /* compress */
|
|
|
|
if (r == (ArrayType *) DatumGetPointer(entry->key))
|
2011-01-09 06:39:21 +01:00
|
|
|
r = DatumGetArrayTypePCopy(entry->key);
|
2003-06-11 21:31:05 +02:00
|
|
|
r = resize_intArrayType(r, 2 * (len));
|
|
|
|
|
|
|
|
dr = ARRPTR(r);
|
|
|
|
|
2018-11-24 00:56:39 +01:00
|
|
|
/*
|
|
|
|
* "len" at this point is the number of ranges we will construct.
|
|
|
|
* "lenr" is the number of ranges we must eventually remove by
|
|
|
|
* merging, we must be careful to remove no more than this number.
|
|
|
|
*/
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
lenr = len - num_ranges;
|
2018-11-24 00:56:39 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initially assume we can merge consecutive ints into a range. but we
|
|
|
|
* must count every value removed and stop when lenr runs out
|
|
|
|
*/
|
|
|
|
for (j = i = len - 1; i > 0 && lenr > 0; i--, j--)
|
|
|
|
{
|
2019-05-22 18:55:34 +02:00
|
|
|
int r_end = dr[i];
|
|
|
|
int r_start = r_end;
|
|
|
|
|
|
|
|
while (i > 0 && lenr > 0 && dr[i - 1] == r_start - 1)
|
2018-11-24 00:56:39 +01:00
|
|
|
--r_start, --i, --lenr;
|
2019-05-22 18:55:34 +02:00
|
|
|
dr[2 * j] = r_start;
|
|
|
|
dr[2 * j + 1] = r_end;
|
2018-11-24 00:56:39 +01:00
|
|
|
}
|
|
|
|
/* just copy the rest, if any, as trivial ranges */
|
|
|
|
for (; i >= 0; i--, j--)
|
2019-05-22 18:55:34 +02:00
|
|
|
dr[2 * j] = dr[2 * j + 1] = dr[i];
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2018-11-24 00:56:39 +01:00
|
|
|
if (++j)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* shunt everything down to start at the right place
|
|
|
|
*/
|
2019-05-22 18:55:34 +02:00
|
|
|
memmove((void *) &dr[0], (void *) &dr[2 * j], 2 * (len - j) * sizeof(int32));
|
2018-11-24 00:56:39 +01:00
|
|
|
}
|
2019-05-22 18:55:34 +02:00
|
|
|
|
2018-11-24 00:56:39 +01:00
|
|
|
/*
|
|
|
|
* make "len" be number of array elements, not ranges
|
|
|
|
*/
|
2019-05-22 18:55:34 +02:00
|
|
|
len = 2 * (len - j);
|
2003-06-11 21:31:05 +02:00
|
|
|
cand = 1;
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
while (len > num_ranges * 2)
|
2003-06-11 21:31:05 +02:00
|
|
|
{
|
2018-11-24 00:56:39 +01:00
|
|
|
min = PG_INT64_MAX;
|
2003-06-11 21:31:05 +02:00
|
|
|
for (i = 2; i < len; i += 2)
|
2019-05-22 18:55:34 +02:00
|
|
|
if (min > ((int64) dr[i] - (int64) dr[i - 1]))
|
2003-06-11 21:31:05 +02:00
|
|
|
{
|
2019-05-22 18:55:34 +02:00
|
|
|
min = ((int64) dr[i] - (int64) dr[i - 1]);
|
2003-06-11 21:31:05 +02:00
|
|
|
cand = i;
|
|
|
|
}
|
2006-04-12 23:46:31 +02:00
|
|
|
memmove((void *) &dr[cand - 1], (void *) &dr[cand + 1], (len - cand - 1) * sizeof(int32));
|
2003-06-11 21:31:05 +02:00
|
|
|
len -= 2;
|
|
|
|
}
|
2019-05-22 18:55:34 +02:00
|
|
|
|
2018-11-24 00:56:39 +01:00
|
|
|
/*
|
|
|
|
* check sparseness of result
|
|
|
|
*/
|
|
|
|
lenr = internal_size(dr, len);
|
|
|
|
if (lenr < 0 || lenr > MAXNUMELTS)
|
|
|
|
ereport(ERROR,
|
intarray: Prevent out-of-bound memory reads with gist__int_ops
As gist__int_ops stands in intarray, it is possible to store GiST
entries for leaf pages that can cause corruptions when decompressed.
Leaf nodes are stored as decompressed all the time by the compression
method, and the decompression method should map with that, retrieving
the contents of the page without doing any decompression. However, the
code authorized the insertion of leaf page data with a higher number of
array items than what can be supported, generating a NOTICE message to
inform about this matter (199 for a 8k page, for reference). When
calling the decompression method, a decompression would be attempted on
this leaf node item but the contents should be retrieved as they are.
The NOTICE message generated when dealing with the compression of a leaf
page and too many elements in the input array for gist__int_ops has been
introduced by 08ee64e, removing the marker stored in the array to track
if this is actually a leaf node. However, it also missed the fact that
the decompression path should do nothing for a leaf page. Hence, as the
code stand, a too-large array would be stored as uncompressed but the
decompression path would attempt a decompression rather that retrieving
the contents as they are.
This leads to various problems. First, even if 08ee64e tried to address
that, it is possible to do out-of-bound chunk writes with a large input
array, with the backend informing about that with WARNINGs. On
decompression, retrieving the stored leaf data would lead to incorrect
memory reads, leading to crashes or even worse.
Perhaps somebody would be interested in expanding the number of array
items that can be handled in a leaf page for this operator in the
future, which would require revisiting the choice done in 08ee64e, but
based on the lack of reports about this problem since 2005 it does not
look so. For now, this commit prevents the insertion of data for leaf
pages when using more array items that the code can handle on
decompression, switching the NOTICE message to an ERROR. If one wishes
to use more array items, gist__intbig_ops is an optional choice.
While on it, use ERRCODE_PROGRAM_LIMIT_EXCEEDED as error code when a
limit is reached, because that's what the module is facing in such
cases.
Author: Ankit Kumar Pandey, Alexander Lakhin
Reviewed-by: Richard Guo, Michael Paquier
Discussion: https://postgr.es/m/796b65c3-57b7-bddf-b0d5-a8afafb8b627@gmail.com
Discussion: https://postgr.es/m/17888-f72930e6b5ce8c14@postgresql.org
Backpatch-through: 11
2023-06-15 06:45:41 +02:00
|
|
|
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
|
|
|
|
errmsg("data is too sparse, recreate index using gist__intbig_ops opclass instead")));
|
2018-11-24 00:56:39 +01:00
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
r = resize_intArrayType(r, len);
|
|
|
|
retval = palloc(sizeof(GISTENTRY));
|
|
|
|
gistentryinit(*retval, PointerGetDatum(r),
|
2017-08-16 06:22:32 +02:00
|
|
|
entry->rel, entry->page, entry->offset, false);
|
2003-06-11 21:31:05 +02:00
|
|
|
PG_RETURN_POINTER(retval);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
PG_RETURN_POINTER(entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
Datum
|
|
|
|
g_int_decompress(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
|
|
|
|
GISTENTRY *retval;
|
|
|
|
ArrayType *r;
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
int num_ranges = G_INT_GET_NUMRANGES();
|
2003-06-11 21:31:05 +02:00
|
|
|
int *dr,
|
|
|
|
lenr;
|
|
|
|
ArrayType *in;
|
|
|
|
int lenin;
|
|
|
|
int *din;
|
|
|
|
int i,
|
|
|
|
j;
|
|
|
|
|
2011-01-09 06:39:21 +01:00
|
|
|
in = DatumGetArrayTypeP(entry->key);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(in);
|
2011-01-09 06:39:21 +01:00
|
|
|
if (ARRISEMPTY(in))
|
2007-04-06 06:21:44 +02:00
|
|
|
{
|
2007-11-15 22:14:46 +01:00
|
|
|
if (in != (ArrayType *) DatumGetPointer(entry->key))
|
|
|
|
{
|
2007-04-06 06:21:44 +02:00
|
|
|
retval = palloc(sizeof(GISTENTRY));
|
|
|
|
gistentryinit(*retval, PointerGetDatum(in),
|
2017-08-16 06:22:32 +02:00
|
|
|
entry->rel, entry->page, entry->offset, false);
|
2007-04-06 06:21:44 +02:00
|
|
|
PG_RETURN_POINTER(retval);
|
|
|
|
}
|
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
PG_RETURN_POINTER(entry);
|
2007-04-06 06:21:44 +02:00
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
lenin = ARRNELEMS(in);
|
|
|
|
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
if (lenin < 2 * num_ranges)
|
2003-06-11 21:31:05 +02:00
|
|
|
{ /* not compressed value */
|
|
|
|
if (in != (ArrayType *) DatumGetPointer(entry->key))
|
|
|
|
{
|
|
|
|
retval = palloc(sizeof(GISTENTRY));
|
|
|
|
gistentryinit(*retval, PointerGetDatum(in),
|
2017-08-16 06:22:32 +02:00
|
|
|
entry->rel, entry->page, entry->offset, false);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
PG_RETURN_POINTER(retval);
|
|
|
|
}
|
|
|
|
PG_RETURN_POINTER(entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
din = ARRPTR(in);
|
|
|
|
lenr = internal_size(din, lenin);
|
2018-11-24 00:56:39 +01:00
|
|
|
if (lenr < 0 || lenr > MAXNUMELTS)
|
|
|
|
ereport(ERROR,
|
intarray: Prevent out-of-bound memory reads with gist__int_ops
As gist__int_ops stands in intarray, it is possible to store GiST
entries for leaf pages that can cause corruptions when decompressed.
Leaf nodes are stored as decompressed all the time by the compression
method, and the decompression method should map with that, retrieving
the contents of the page without doing any decompression. However, the
code authorized the insertion of leaf page data with a higher number of
array items than what can be supported, generating a NOTICE message to
inform about this matter (199 for a 8k page, for reference). When
calling the decompression method, a decompression would be attempted on
this leaf node item but the contents should be retrieved as they are.
The NOTICE message generated when dealing with the compression of a leaf
page and too many elements in the input array for gist__int_ops has been
introduced by 08ee64e, removing the marker stored in the array to track
if this is actually a leaf node. However, it also missed the fact that
the decompression path should do nothing for a leaf page. Hence, as the
code stand, a too-large array would be stored as uncompressed but the
decompression path would attempt a decompression rather that retrieving
the contents as they are.
This leads to various problems. First, even if 08ee64e tried to address
that, it is possible to do out-of-bound chunk writes with a large input
array, with the backend informing about that with WARNINGs. On
decompression, retrieving the stored leaf data would lead to incorrect
memory reads, leading to crashes or even worse.
Perhaps somebody would be interested in expanding the number of array
items that can be handled in a leaf page for this operator in the
future, which would require revisiting the choice done in 08ee64e, but
based on the lack of reports about this problem since 2005 it does not
look so. For now, this commit prevents the insertion of data for leaf
pages when using more array items that the code can handle on
decompression, switching the NOTICE message to an ERROR. If one wishes
to use more array items, gist__intbig_ops is an optional choice.
While on it, use ERRCODE_PROGRAM_LIMIT_EXCEEDED as error code when a
limit is reached, because that's what the module is facing in such
cases.
Author: Ankit Kumar Pandey, Alexander Lakhin
Reviewed-by: Richard Guo, Michael Paquier
Discussion: https://postgr.es/m/796b65c3-57b7-bddf-b0d5-a8afafb8b627@gmail.com
Discussion: https://postgr.es/m/17888-f72930e6b5ce8c14@postgresql.org
Backpatch-through: 11
2023-06-15 06:45:41 +02:00
|
|
|
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
|
|
|
|
errmsg("compressed array is too big, recreate index using gist__intbig_ops opclass instead")));
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
r = new_intArrayType(lenr);
|
|
|
|
dr = ARRPTR(r);
|
|
|
|
|
|
|
|
for (i = 0; i < lenin; i += 2)
|
|
|
|
for (j = din[i]; j <= din[i + 1]; j++)
|
|
|
|
if ((!i) || *(dr - 1) != j)
|
|
|
|
*dr++ = j;
|
|
|
|
|
|
|
|
if (in != (ArrayType *) DatumGetPointer(entry->key))
|
|
|
|
pfree(in);
|
|
|
|
retval = palloc(sizeof(GISTENTRY));
|
|
|
|
gistentryinit(*retval, PointerGetDatum(r),
|
2017-08-16 06:22:32 +02:00
|
|
|
entry->rel, entry->page, entry->offset, false);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
PG_RETURN_POINTER(retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** The GiST Penalty method for _intments
|
|
|
|
*/
|
|
|
|
Datum
|
2003-08-04 02:43:34 +02:00
|
|
|
g_int_penalty(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
|
|
|
|
GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
|
|
|
|
float *result = (float *) PG_GETARG_POINTER(2);
|
2003-06-11 21:31:05 +02:00
|
|
|
ArrayType *ud;
|
|
|
|
float tmp1,
|
|
|
|
tmp2;
|
|
|
|
|
|
|
|
ud = inner_int_union((ArrayType *) DatumGetPointer(origentry->key),
|
2003-08-04 02:43:34 +02:00
|
|
|
(ArrayType *) DatumGetPointer(newentry->key));
|
2003-06-11 21:31:05 +02:00
|
|
|
rt__int_size(ud, &tmp1);
|
|
|
|
rt__int_size((ArrayType *) DatumGetPointer(origentry->key), &tmp2);
|
|
|
|
*result = tmp1 - tmp2;
|
|
|
|
pfree(ud);
|
|
|
|
|
2003-08-04 02:43:34 +02:00
|
|
|
PG_RETURN_POINTER(result);
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Datum
|
|
|
|
g_int_same(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2011-01-09 06:39:21 +01:00
|
|
|
ArrayType *a = PG_GETARG_ARRAYTYPE_P(0);
|
|
|
|
ArrayType *b = PG_GETARG_ARRAYTYPE_P(1);
|
2003-06-11 21:31:05 +02:00
|
|
|
bool *result = (bool *) PG_GETARG_POINTER(2);
|
2012-06-25 00:51:46 +02:00
|
|
|
int32 n = ARRNELEMS(a);
|
|
|
|
int32 *da,
|
2003-06-11 21:31:05 +02:00
|
|
|
*db;
|
|
|
|
|
2005-11-19 04:00:09 +01:00
|
|
|
CHECKARRVALID(a);
|
|
|
|
CHECKARRVALID(b);
|
|
|
|
|
2003-06-11 21:31:05 +02:00
|
|
|
if (n != ARRNELEMS(b))
|
|
|
|
{
|
|
|
|
*result = false;
|
|
|
|
PG_RETURN_POINTER(result);
|
|
|
|
}
|
2017-08-16 06:22:32 +02:00
|
|
|
*result = true;
|
2003-06-11 21:31:05 +02:00
|
|
|
da = ARRPTR(a);
|
|
|
|
db = ARRPTR(b);
|
|
|
|
while (n--)
|
2011-01-09 06:39:21 +01:00
|
|
|
{
|
2003-06-11 21:31:05 +02:00
|
|
|
if (*da++ != *db++)
|
|
|
|
{
|
2017-08-16 06:22:32 +02:00
|
|
|
*result = false;
|
2003-06-11 21:31:05 +02:00
|
|
|
break;
|
|
|
|
}
|
2011-01-09 06:39:21 +01:00
|
|
|
}
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
PG_RETURN_POINTER(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************
|
|
|
|
** Common GiST Method
|
|
|
|
*****************************************************************/
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
OffsetNumber pos;
|
|
|
|
float cost;
|
2007-11-15 23:25:18 +01:00
|
|
|
} SPLITCOST;
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
static int
|
|
|
|
comparecost(const void *a, const void *b)
|
|
|
|
{
|
2011-09-11 20:54:32 +02:00
|
|
|
if (((const SPLITCOST *) a)->cost == ((const SPLITCOST *) b)->cost)
|
2003-06-11 21:31:05 +02:00
|
|
|
return 0;
|
|
|
|
else
|
2011-09-11 20:54:32 +02:00
|
|
|
return (((const SPLITCOST *) a)->cost > ((const SPLITCOST *) b)->cost) ? 1 : -1;
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** The GiST PickSplit method for _intments
|
|
|
|
** We use Guttman's poly time split algorithm
|
|
|
|
*/
|
|
|
|
Datum
|
2003-08-04 02:43:34 +02:00
|
|
|
g_int_picksplit(PG_FUNCTION_ARGS)
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
|
2003-06-11 21:31:05 +02:00
|
|
|
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
|
|
|
|
OffsetNumber i,
|
|
|
|
j;
|
|
|
|
ArrayType *datum_alpha,
|
|
|
|
*datum_beta;
|
|
|
|
ArrayType *datum_l,
|
|
|
|
*datum_r;
|
|
|
|
ArrayType *union_d,
|
|
|
|
*union_dl,
|
|
|
|
*union_dr;
|
|
|
|
ArrayType *inter_d;
|
|
|
|
bool firsttime;
|
|
|
|
float size_alpha,
|
|
|
|
size_beta,
|
|
|
|
size_union,
|
|
|
|
size_inter;
|
|
|
|
float size_waste,
|
|
|
|
waste;
|
|
|
|
float size_l,
|
|
|
|
size_r;
|
|
|
|
int nbytes;
|
|
|
|
OffsetNumber seed_1 = 0,
|
|
|
|
seed_2 = 0;
|
|
|
|
OffsetNumber *left,
|
|
|
|
*right;
|
|
|
|
OffsetNumber maxoff;
|
|
|
|
SPLITCOST *costvector;
|
|
|
|
|
|
|
|
#ifdef GIST_DEBUG
|
2004-03-30 17:45:33 +02:00
|
|
|
elog(DEBUG3, "--------picksplit %d", entryvec->n);
|
2003-06-11 21:31:05 +02:00
|
|
|
#endif
|
|
|
|
|
2004-03-30 17:45:33 +02:00
|
|
|
maxoff = entryvec->n - 2;
|
2003-06-11 21:31:05 +02:00
|
|
|
nbytes = (maxoff + 2) * sizeof(OffsetNumber);
|
|
|
|
v->spl_left = (OffsetNumber *) palloc(nbytes);
|
|
|
|
v->spl_right = (OffsetNumber *) palloc(nbytes);
|
|
|
|
|
|
|
|
firsttime = true;
|
|
|
|
waste = 0.0;
|
|
|
|
for (i = FirstOffsetNumber; i < maxoff; i = OffsetNumberNext(i))
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
datum_alpha = GETENTRY(entryvec, i);
|
2003-06-11 21:31:05 +02:00
|
|
|
for (j = OffsetNumberNext(i); j <= maxoff; j = OffsetNumberNext(j))
|
|
|
|
{
|
2004-08-29 07:07:03 +02:00
|
|
|
datum_beta = GETENTRY(entryvec, j);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
/* compute the wasted space by unioning these guys */
|
|
|
|
/* size_waste = size_union - size_inter; */
|
|
|
|
union_d = inner_int_union(datum_alpha, datum_beta);
|
|
|
|
rt__int_size(union_d, &size_union);
|
|
|
|
inter_d = inner_int_inter(datum_alpha, datum_beta);
|
|
|
|
rt__int_size(inter_d, &size_inter);
|
|
|
|
size_waste = size_union - size_inter;
|
|
|
|
|
|
|
|
pfree(union_d);
|
2015-02-16 22:26:23 +01:00
|
|
|
pfree(inter_d);
|
2003-06-11 21:31:05 +02:00
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* are these a more promising split that what we've already seen?
|
2003-06-11 21:31:05 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (size_waste > waste || firsttime)
|
|
|
|
{
|
|
|
|
waste = size_waste;
|
|
|
|
seed_1 = i;
|
|
|
|
seed_2 = j;
|
|
|
|
firsttime = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
left = v->spl_left;
|
|
|
|
v->spl_nleft = 0;
|
|
|
|
right = v->spl_right;
|
|
|
|
v->spl_nright = 0;
|
|
|
|
if (seed_1 == 0 || seed_2 == 0)
|
|
|
|
{
|
|
|
|
seed_1 = 1;
|
|
|
|
seed_2 = 2;
|
|
|
|
}
|
|
|
|
|
2004-08-29 07:07:03 +02:00
|
|
|
datum_alpha = GETENTRY(entryvec, seed_1);
|
2003-06-11 21:31:05 +02:00
|
|
|
datum_l = copy_intArrayType(datum_alpha);
|
|
|
|
rt__int_size(datum_l, &size_l);
|
2004-08-29 07:07:03 +02:00
|
|
|
datum_beta = GETENTRY(entryvec, seed_2);
|
2003-06-11 21:31:05 +02:00
|
|
|
datum_r = copy_intArrayType(datum_beta);
|
|
|
|
rt__int_size(datum_r, &size_r);
|
|
|
|
|
|
|
|
maxoff = OffsetNumberNext(maxoff);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* sort entries
|
|
|
|
*/
|
|
|
|
costvector = (SPLITCOST *) palloc(sizeof(SPLITCOST) * maxoff);
|
|
|
|
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
|
|
|
|
{
|
|
|
|
costvector[i - 1].pos = i;
|
2004-08-29 07:07:03 +02:00
|
|
|
datum_alpha = GETENTRY(entryvec, i);
|
2003-06-11 21:31:05 +02:00
|
|
|
union_d = inner_int_union(datum_l, datum_alpha);
|
|
|
|
rt__int_size(union_d, &size_alpha);
|
|
|
|
pfree(union_d);
|
|
|
|
union_d = inner_int_union(datum_r, datum_alpha);
|
|
|
|
rt__int_size(union_d, &size_beta);
|
|
|
|
pfree(union_d);
|
2004-10-21 21:28:36 +02:00
|
|
|
costvector[i - 1].cost = Abs((size_alpha - size_l) - (size_beta - size_r));
|
2003-06-11 21:31:05 +02:00
|
|
|
}
|
|
|
|
qsort((void *) costvector, maxoff, sizeof(SPLITCOST), comparecost);
|
|
|
|
|
|
|
|
/*
|
2014-05-06 18:12:18 +02:00
|
|
|
* Now split up the regions between the two seeds. An important property
|
2005-10-15 04:49:52 +02:00
|
|
|
* of this split algorithm is that the split vector v has the indices of
|
|
|
|
* items to be split in order in its left and right vectors. We exploit
|
|
|
|
* this property by doing a merge in the code that actually splits the
|
|
|
|
* page.
|
2003-06-11 21:31:05 +02:00
|
|
|
*
|
2005-10-15 04:49:52 +02:00
|
|
|
* For efficiency, we also place the new index tuple in this loop. This is
|
|
|
|
* handled at the very end, when we have placed all the existing tuples
|
|
|
|
* and i == maxoff + 1.
|
2003-06-11 21:31:05 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < maxoff; j++)
|
|
|
|
{
|
|
|
|
i = costvector[j].pos;
|
|
|
|
|
|
|
|
/*
|
2005-10-15 04:49:52 +02:00
|
|
|
* If we've already decided where to place this item, just put it on
|
2014-05-06 18:12:18 +02:00
|
|
|
* the right list. Otherwise, we need to figure out which page needs
|
2005-10-15 04:49:52 +02:00
|
|
|
* the least enlargement in order to store the item.
|
2003-06-11 21:31:05 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
if (i == seed_1)
|
|
|
|
{
|
|
|
|
*left++ = i;
|
|
|
|
v->spl_nleft++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
else if (i == seed_2)
|
|
|
|
{
|
|
|
|
*right++ = i;
|
|
|
|
v->spl_nright++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* okay, which page needs least enlargement? */
|
2004-08-29 07:07:03 +02:00
|
|
|
datum_alpha = GETENTRY(entryvec, i);
|
2003-06-11 21:31:05 +02:00
|
|
|
union_dl = inner_int_union(datum_l, datum_alpha);
|
|
|
|
union_dr = inner_int_union(datum_r, datum_alpha);
|
|
|
|
rt__int_size(union_dl, &size_alpha);
|
|
|
|
rt__int_size(union_dr, &size_beta);
|
|
|
|
|
|
|
|
/* pick which page to add it to */
|
|
|
|
if (size_alpha - size_l < size_beta - size_r + WISH_F(v->spl_nleft, v->spl_nright, 0.01))
|
|
|
|
{
|
2015-02-16 22:26:23 +01:00
|
|
|
pfree(datum_l);
|
|
|
|
pfree(union_dr);
|
2003-06-11 21:31:05 +02:00
|
|
|
datum_l = union_dl;
|
|
|
|
size_l = size_alpha;
|
|
|
|
*left++ = i;
|
|
|
|
v->spl_nleft++;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2015-02-16 22:26:23 +01:00
|
|
|
pfree(datum_r);
|
|
|
|
pfree(union_dl);
|
2003-06-11 21:31:05 +02:00
|
|
|
datum_r = union_dr;
|
|
|
|
size_r = size_beta;
|
|
|
|
*right++ = i;
|
|
|
|
v->spl_nright++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pfree(costvector);
|
|
|
|
*right = *left = FirstOffsetNumber;
|
|
|
|
|
|
|
|
v->spl_ldatum = PointerGetDatum(datum_l);
|
|
|
|
v->spl_rdatum = PointerGetDatum(datum_r);
|
|
|
|
|
|
|
|
PG_RETURN_POINTER(v);
|
|
|
|
}
|
Implement operator class parameters
PostgreSQL provides set of template index access methods, where opclasses have
much freedom in the semantics of indexing. These index AMs are GiST, GIN,
SP-GiST and BRIN. There opclasses define representation of keys, operations on
them and supported search strategies. So, it's natural that opclasses may be
faced some tradeoffs, which require user-side decision. This commit implements
opclass parameters allowing users to set some values, which tell opclass how to
index the particular dataset.
This commit doesn't introduce new storage in system catalog. Instead it uses
pg_attribute.attoptions, which is used for table column storage options but
unused for index attributes.
In order to evade changing signature of each opclass support function, we
implement unified way to pass options to opclass support functions. Options
are set to fn_expr as the constant bytea expression. It's possible due to the
fact that opclass support functions are executed outside of expressions, so
fn_expr is unused for them.
This commit comes with some examples of opclass options usage. We parametrize
signature length in GiST. That applies to multiple opclasses: tsvector_ops,
gist__intbig_ops, gist_ltree_ops, gist__ltree_ops, gist_trgm_ops and
gist_hstore_ops. Also we parametrize maximum number of integer ranges for
gist__int_ops. However, the main future usage of this feature is expected
to be json, where users would be able to specify which way to index particular
json parts.
Catversion is bumped.
Discussion: https://postgr.es/m/d22c3a18-31c7-1879-fc11-4c1ce2f5e5af%40postgrespro.ru
Author: Nikita Glukhov, revised by me
Reviwed-by: Nikolay Shaplov, Robert Haas, Tom Lane, Tomas Vondra, Alvaro Herrera
2020-03-30 18:17:11 +02:00
|
|
|
|
|
|
|
Datum
|
|
|
|
g_int_options(PG_FUNCTION_ARGS)
|
|
|
|
{
|
|
|
|
local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0);
|
|
|
|
|
|
|
|
init_local_reloptions(relopts, sizeof(GISTIntArrayOptions));
|
|
|
|
add_local_int_reloption(relopts, "numranges",
|
|
|
|
"number of ranges for compression",
|
|
|
|
G_INT_NUMRANGES_DEFAULT, 1, G_INT_NUMRANGES_MAX,
|
|
|
|
offsetof(GISTIntArrayOptions, num_ranges));
|
|
|
|
|
|
|
|
PG_RETURN_VOID();
|
|
|
|
}
|