agora inbox for [email protected]help / color / mirror / Atom feed
[PATCH 5/6] BRIN minmax-multi indexes 30+ messages / 6 participants [nested] [flat]
* [PATCH 5/6] BRIN minmax-multi indexes @ 2020-12-16 20:32 Tomas Vondra <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Tomas Vondra @ 2020-12-16 20:32 UTC (permalink / raw) Adds a BRIN minmax-multi opclass, summarizing each range into a list of intervals, allowing more efficient handling of cases where the minmax opclasses quickly degrade. Instead of representing each range with a single interval, minmax-multi opclasses store a list of intervals and points. This allows effective handling of outliers and poorly correlated values. The number of intervals/points per range may be configured using an opclass parameter values_per_range. When building the summary, the interval are merged based on distance, determined by the new support BRIN procedure. Author: Tomas Vondra <[email protected]> Reviewed-by: Alvaro Herrera <[email protected]> Reviewed-by: Alexander Korotkov <[email protected]> Reviewed-by: Sokolov Yura <[email protected]> Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/5d78b774-7e9c-c94e-12cf-fef51cc89b1a%402ndquadrant.com --- doc/src/sgml/brin.sgml | 252 +- doc/src/sgml/ref/create_index.sgml | 11 + src/backend/access/brin/Makefile | 1 + src/backend/access/brin/brin_minmax_multi.c | 2389 +++++++++++++++++++ src/backend/access/brin/brin_tuple.c | 17 + src/include/access/brin.h | 1 + src/include/access/brin_internal.h | 3 + src/include/access/brin_tuple.h | 4 + src/include/access/transam.h | 2 +- src/include/catalog/pg_amop.dat | 544 +++++ src/include/catalog/pg_amproc.dat | 600 ++++- src/include/catalog/pg_opclass.dat | 57 + src/include/catalog/pg_opfamily.dat | 28 + src/include/catalog/pg_proc.dat | 80 + src/include/catalog/pg_type.dat | 7 + src/test/regress/expected/brin_multi.out | 421 ++++ src/test/regress/expected/psql.out | 13 +- src/test/regress/expected/type_sanity.out | 7 +- src/test/regress/parallel_schedule | 2 +- src/test/regress/serial_schedule | 1 + src/test/regress/sql/brin_multi.sql | 371 +++ 21 files changed, 4792 insertions(+), 19 deletions(-) create mode 100644 src/backend/access/brin/brin_minmax_multi.c create mode 100644 src/test/regress/expected/brin_multi.out create mode 100644 src/test/regress/sql/brin_multi.sql diff --git a/doc/src/sgml/brin.sgml b/doc/src/sgml/brin.sgml index 577dd18c49..3caa30f104 100644 --- a/doc/src/sgml/brin.sgml +++ b/doc/src/sgml/brin.sgml @@ -214,6 +214,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (date,date)</literal></entry></row> <row><entry><literal>>= (date,date)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>date_minmax_multi_ops</literal></entry> + <entry><literal>= (date,date)</literal></entry> + </row> + <row><entry><literal>< (date,date)</literal></entry></row> + <row><entry><literal><= (date,date)</literal></entry></row> + <row><entry><literal>> (date,date)</literal></entry></row> + <row><entry><literal>>= (date,date)</literal></entry></row> + <row> <entry valign="middle"><literal>float4_bloom_ops</literal></entry> <entry><literal>= (float4,float4)</literal></entry> @@ -228,6 +237,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (float4,float4)</literal></entry></row> <row><entry><literal>>= (float4,float4)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>float4_minmax_multi_ops</literal></entry> + <entry><literal>= (float4,float4)</literal></entry> + </row> + <row><entry><literal>< (float4,float4)</literal></entry></row> + <row><entry><literal>> (float4,float4)</literal></entry></row> + <row><entry><literal><= (float4,float4)</literal></entry></row> + <row><entry><literal>>= (float4,float4)</literal></entry></row> + <row> <entry valign="middle"><literal>float8_bloom_ops</literal></entry> <entry><literal>= (float8,float8)</literal></entry> @@ -242,6 +260,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (float8,float8)</literal></entry></row> <row><entry><literal>>= (float8,float8)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>float8_minmax_multi_ops</literal></entry> + <entry><literal>= (float8,float8)</literal></entry> + </row> + <row><entry><literal>< (float8,float8)</literal></entry></row> + <row><entry><literal><= (float8,float8)</literal></entry></row> + <row><entry><literal>> (float8,float8)</literal></entry></row> + <row><entry><literal>>= (float8,float8)</literal></entry></row> + <row> <entry valign="middle" morerows="5"><literal>inet_inclusion_ops</literal></entry> <entry><literal><< (inet,inet)</literal></entry> @@ -266,6 +293,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (inet,inet)</literal></entry></row> <row><entry><literal>>= (inet,inet)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>inet_minmax_multi_ops</literal></entry> + <entry><literal>= (inet,inet)</literal></entry> + </row> + <row><entry><literal>< (inet,inet)</literal></entry></row> + <row><entry><literal><= (inet,inet)</literal></entry></row> + <row><entry><literal>> (inet,inet)</literal></entry></row> + <row><entry><literal>>= (inet,inet)</literal></entry></row> + <row> <entry valign="middle"><literal>int2_bloom_ops</literal></entry> <entry><literal>= (int2,int2)</literal></entry> @@ -280,6 +316,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (int2,int2)</literal></entry></row> <row><entry><literal>>= (int2,int2)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>int2_minmax_multi_ops</literal></entry> + <entry><literal>= (int2,int2)</literal></entry> + </row> + <row><entry><literal>< (int2,int2)</literal></entry></row> + <row><entry><literal>> (int2,int2)</literal></entry></row> + <row><entry><literal><= (int2,int2)</literal></entry></row> + <row><entry><literal>>= (int2,int2)</literal></entry></row> + <row> <entry valign="middle"><literal>int4_bloom_ops</literal></entry> <entry><literal>= (int4,int4)</literal></entry> @@ -294,6 +339,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (int4,int4)</literal></entry></row> <row><entry><literal>>= (int4,int4)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>int4_minmax_multi_ops</literal></entry> + <entry><literal>= (int4,int4)</literal></entry> + </row> + <row><entry><literal>< (int4,int4)</literal></entry></row> + <row><entry><literal>> (int4,int4)</literal></entry></row> + <row><entry><literal><= (int4,int4)</literal></entry></row> + <row><entry><literal>>= (int4,int4)</literal></entry></row> + <row> <entry valign="middle"><literal>int8_bloom_ops</literal></entry> <entry><literal>= (bigint,bigint)</literal></entry> @@ -308,6 +362,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (bigint,bigint)</literal></entry></row> <row><entry><literal>>= (bigint,bigint)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>int8_minmax_multi_ops</literal></entry> + <entry><literal>= (bigint,bigint)</literal></entry> + </row> + <row><entry><literal>< (bigint,bigint)</literal></entry></row> + <row><entry><literal>> (bigint,bigint)</literal></entry></row> + <row><entry><literal><= (bigint,bigint)</literal></entry></row> + <row><entry><literal>>= (bigint,bigint)</literal></entry></row> + <row> <entry valign="middle"><literal>interval_bloom_ops</literal></entry> <entry><literal>= (interval,interval)</literal></entry> @@ -322,6 +385,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (interval,interval)</literal></entry></row> <row><entry><literal>>= (interval,interval)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>interval_minmax_multi_ops</literal></entry> + <entry><literal>= (interval,interval)</literal></entry> + </row> + <row><entry><literal>< (interval,interval)</literal></entry></row> + <row><entry><literal><= (interval,interval)</literal></entry></row> + <row><entry><literal>> (interval,interval)</literal></entry></row> + <row><entry><literal>>= (interval,interval)</literal></entry></row> + <row> <entry valign="middle"><literal>macaddr_bloom_ops</literal></entry> <entry><literal>= (macaddr,macaddr)</literal></entry> @@ -336,6 +408,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (macaddr,macaddr)</literal></entry></row> <row><entry><literal>>= (macaddr,macaddr)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>macaddr_minmax_multi_ops</literal></entry> + <entry><literal>= (macaddr,macaddr)</literal></entry> + </row> + <row><entry><literal>< (macaddr,macaddr)</literal></entry></row> + <row><entry><literal><= (macaddr,macaddr)</literal></entry></row> + <row><entry><literal>> (macaddr,macaddr)</literal></entry></row> + <row><entry><literal>>= (macaddr,macaddr)</literal></entry></row> + <row> <entry valign="middle"><literal>macaddr8_bloom_ops</literal></entry> <entry><literal>= (macaddr8,macaddr8)</literal></entry> @@ -350,6 +431,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (macaddr8,macaddr8)</literal></entry></row> <row><entry><literal>>= (macaddr8,macaddr8)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>macaddr8_minmax_multi_ops</literal></entry> + <entry><literal>= (macaddr8,macaddr8)</literal></entry> + </row> + <row><entry><literal>< (macaddr8,macaddr8)</literal></entry></row> + <row><entry><literal><= (macaddr8,macaddr8)</literal></entry></row> + <row><entry><literal>> (macaddr8,macaddr8)</literal></entry></row> + <row><entry><literal>>= (macaddr8,macaddr8)</literal></entry></row> + <row> <entry valign="middle"><literal>name_bloom_ops</literal></entry> <entry><literal>= (name,name)</literal></entry> @@ -378,6 +468,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (numeric,numeric)</literal></entry></row> <row><entry><literal>>= (numeric,numeric)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>numeric_minmax_multi_ops</literal></entry> + <entry><literal>= (numeric,numeric)</literal></entry> + </row> + <row><entry><literal>< (numeric,numeric)</literal></entry></row> + <row><entry><literal><= (numeric,numeric)</literal></entry></row> + <row><entry><literal>> (numeric,numeric)</literal></entry></row> + <row><entry><literal>>= (numeric,numeric)</literal></entry></row> + <row> <entry valign="middle"><literal>oid_bloom_ops</literal></entry> <entry><literal>= (oid,oid)</literal></entry> @@ -392,6 +491,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (oid,oid)</literal></entry></row> <row><entry><literal>>= (oid,oid)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>oid_minmax_multi_ops</literal></entry> + <entry><literal>= (oid,oid)</literal></entry> + </row> + <row><entry><literal>< (oid,oid)</literal></entry></row> + <row><entry><literal>> (oid,oid)</literal></entry></row> + <row><entry><literal><= (oid,oid)</literal></entry></row> + <row><entry><literal>>= (oid,oid)</literal></entry></row> + <row> <entry valign="middle"><literal>pg_lsn_bloom_ops</literal></entry> <entry><literal>= (pg_lsn,pg_lsn)</literal></entry> @@ -406,6 +514,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (pg_lsn,pg_lsn)</literal></entry></row> <row><entry><literal>>= (pg_lsn,pg_lsn)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>pg_lsn_minmax_multi_ops</literal></entry> + <entry><literal>= (pg_lsn,pg_lsn)</literal></entry> + </row> + <row><entry><literal>< (pg_lsn,pg_lsn)</literal></entry></row> + <row><entry><literal>> (pg_lsn,pg_lsn)</literal></entry></row> + <row><entry><literal><= (pg_lsn,pg_lsn)</literal></entry></row> + <row><entry><literal>>= (pg_lsn,pg_lsn)</literal></entry></row> + <row> <entry valign="middle" morerows="13"><literal>range_inclusion_ops</literal></entry> <entry><literal>= (anyrange,anyrange)</literal></entry> @@ -452,6 +569,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (tid,tid)</literal></entry></row> <row><entry><literal>>= (tid,tid)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>tid_minmax_multi_ops</literal></entry> + <entry><literal>= (tid,tid)</literal></entry> + </row> + <row><entry><literal>< (tid,tid)</literal></entry></row> + <row><entry><literal>> (tid,tid)</literal></entry></row> + <row><entry><literal><= (tid,tid)</literal></entry></row> + <row><entry><literal>>= (tid,tid)</literal></entry></row> + <row> <entry valign="middle"><literal>timestamp_bloom_ops</literal></entry> <entry><literal>= (timestamp,timestamp)</literal></entry> @@ -466,6 +592,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (timestamp,timestamp)</literal></entry></row> <row><entry><literal>>= (timestamp,timestamp)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>timestamp_minmax_multi_ops</literal></entry> + <entry><literal>= (timestamp,timestamp)</literal></entry> + </row> + <row><entry><literal>< (timestamp,timestamp)</literal></entry></row> + <row><entry><literal><= (timestamp,timestamp)</literal></entry></row> + <row><entry><literal>> (timestamp,timestamp)</literal></entry></row> + <row><entry><literal>>= (timestamp,timestamp)</literal></entry></row> + <row> <entry valign="middle"><literal>timestamptz_bloom_ops</literal></entry> <entry><literal>= (timestamptz,timestamptz)</literal></entry> @@ -480,6 +615,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (timestamptz,timestamptz)</literal></entry></row> <row><entry><literal>>= (timestamptz,timestamptz)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>timestamptz_minmax_multi_ops</literal></entry> + <entry><literal>= (timestamptz,timestamptz)</literal></entry> + </row> + <row><entry><literal>< (timestamptz,timestamptz)</literal></entry></row> + <row><entry><literal><= (timestamptz,timestamptz)</literal></entry></row> + <row><entry><literal>> (timestamptz,timestamptz)</literal></entry></row> + <row><entry><literal>>= (timestamptz,timestamptz)</literal></entry></row> + <row> <entry valign="middle"><literal>time_bloom_ops</literal></entry> <entry><literal>= (time,time)</literal></entry> @@ -494,6 +638,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (time,time)</literal></entry></row> <row><entry><literal>>= (time,time)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>time_minmax_multi_ops</literal></entry> + <entry><literal>= (time,time)</literal></entry> + </row> + <row><entry><literal>< (time,time)</literal></entry></row> + <row><entry><literal><= (time,time)</literal></entry></row> + <row><entry><literal>> (time,time)</literal></entry></row> + <row><entry><literal>>= (time,time)</literal></entry></row> + <row> <entry valign="middle"><literal>timetz_bloom_ops</literal></entry> <entry><literal>= (timetz,timetz)</literal></entry> @@ -508,6 +661,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal>> (timetz,timetz)</literal></entry></row> <row><entry><literal>>= (timetz,timetz)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>timetz_minmax_multi_ops</literal></entry> + <entry><literal>= (timetz,timetz)</literal></entry> + </row> + <row><entry><literal>< (timetz,timetz)</literal></entry></row> + <row><entry><literal><= (timetz,timetz)</literal></entry></row> + <row><entry><literal>> (timetz,timetz)</literal></entry></row> + <row><entry><literal>>= (timetz,timetz)</literal></entry></row> + <row> <entry valign="middle"><literal>uuid_bloom_ops</literal></entry> <entry><literal>= (uuid,uuid)</literal></entry> @@ -522,6 +684,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was <row><entry><literal><= (uuid,uuid)</literal></entry></row> <row><entry><literal>>= (uuid,uuid)</literal></entry></row> + <row> + <entry valign="middle" morerows="4"><literal>uuid_minmax_multi_ops</literal></entry> + <entry><literal>= (uuid,uuid)</literal></entry> + </row> + <row><entry><literal>< (uuid,uuid)</literal></entry></row> + <row><entry><literal>> (uuid,uuid)</literal></entry></row> + <row><entry><literal><= (uuid,uuid)</literal></entry></row> + <row><entry><literal>>= (uuid,uuid)</literal></entry></row> + <row> <entry valign="middle" morerows="4"><literal>varbit_minmax_ops</literal></entry> <entry><literal>= (varbit,varbit)</literal></entry> @@ -654,13 +825,14 @@ typedef struct BrinOpcInfo </varlistentry> </variablelist> - The core distribution includes support for two types of operator classes: - minmax and inclusion. Operator class definitions using them are shipped for - in-core data types as appropriate. Additional operator classes can be - defined by the user for other data types using equivalent definitions, - without having to write any source code; appropriate catalog entries being - declared is enough. Note that assumptions about the semantics of operator - strategies are embedded in the support functions' source code. + The core distribution includes support for four types of operator classes: + minmax, multi-minmax, inclusion and bloom. Operator class definitions + using them are shipped for in-core data types as appropriate. Additional + operator classes can be defined by the user for other data types using + equivalent definitions, without having to write any source code; + appropriate catalog entries being declared is enough. Note that + assumptions about the semantics of operator strategies are embedded in the + support functions' source code. </para> <para> @@ -957,6 +1129,72 @@ typedef struct BrinOpcInfo and return a hash of the value. </para> + <para> + The multi-minmax operator class is also intended for data types implementing + a totally ordered sets, and may be seen as a simple extension of the minmax + operator class. While minmax operator class summarizes values from each block + range into a single contiguous interval, multi-minmax allows summarization + into multiple smaller intervals to improve handling of outlier values. + It is possible to use the multi-minmax support procedures alongside the + corresponding operators, as shown in + <xref linkend="brin-extensibility-multi-minmax-table"/>. + All operator class members (procedures and operators) are mandatory. + </para> + + <table id="brin-extensibility-multi-minmax-table"> + <title>Procedure and Support Numbers for Multi-Minmax Operator Classes</title> + <tgroup cols="2"> + <thead> + <row> + <entry>Operator class member</entry> + <entry>Object</entry> + </row> + </thead> + <tbody> + <row> + <entry>Support Procedure 1</entry> + <entry>internal function <function>brin_minmax_multi_opcinfo()</function></entry> + </row> + <row> + <entry>Support Procedure 2</entry> + <entry>internal function <function>brin_minmax_multi_add_value()</function></entry> + </row> + <row> + <entry>Support Procedure 3</entry> + <entry>internal function <function>brin_minmax_multi_consistent()</function></entry> + </row> + <row> + <entry>Support Procedure 4</entry> + <entry>internal function <function>brin_minmax_multi_union()</function></entry> + </row> + <row> + <entry>Support Procedure 11</entry> + <entry>function to compute distance between two values (length of a range)</entry> + </row> + <row> + <entry>Operator Strategy 1</entry> + <entry>operator less-than</entry> + </row> + <row> + <entry>Operator Strategy 2</entry> + <entry>operator less-than-or-equal-to</entry> + </row> + <row> + <entry>Operator Strategy 3</entry> + <entry>operator equal-to</entry> + </row> + <row> + <entry>Operator Strategy 4</entry> + <entry>operator greater-than-or-equal-to</entry> + </row> + <row> + <entry>Operator Strategy 5</entry> + <entry>operator greater-than</entry> + </row> + </tbody> + </tgroup> + </table> + <para> Both minmax and inclusion operator classes support cross-data-type operators, though with these the dependencies become more complicated. diff --git a/doc/src/sgml/ref/create_index.sgml b/doc/src/sgml/ref/create_index.sgml index 244e5834d8..ce61a28a72 100644 --- a/doc/src/sgml/ref/create_index.sgml +++ b/doc/src/sgml/ref/create_index.sgml @@ -590,6 +590,17 @@ CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] <replaceable class= </listitem> </varlistentry> + <varlistentry> + <term><literal>values_per_range</literal></term> + <listitem> + <para> + Defines the maximum number of values stored by <acronym>BRIN</acronym> + minmax indexes to summarize a block range. Each value may represent + eiter a point, or boundary of an interval. Values must be be between + 16 and 256, and the default value is 32. + </para> + </listitem> + </varlistentry> </variablelist> </refsect2> diff --git a/src/backend/access/brin/Makefile b/src/backend/access/brin/Makefile index 6b56131215..a386cb71f1 100644 --- a/src/backend/access/brin/Makefile +++ b/src/backend/access/brin/Makefile @@ -17,6 +17,7 @@ OBJS = \ brin_bloom.o \ brin_inclusion.o \ brin_minmax.o \ + brin_minmax_multi.o \ brin_pageops.o \ brin_revmap.o \ brin_tuple.o \ diff --git a/src/backend/access/brin/brin_minmax_multi.c b/src/backend/access/brin/brin_minmax_multi.c new file mode 100644 index 0000000000..0a76557cc1 --- /dev/null +++ b/src/backend/access/brin/brin_minmax_multi.c @@ -0,0 +1,2389 @@ +/* + * brin_minmax_multi.c + * Implementation of Multi Min/Max opclass for BRIN + * + * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * + * Implements a variant of minmax opclass, where the summary is composed of + * multiple smaller intervals. This allows us to handle outliers, which + * usually makes the simple minmax opclass inefficient. + * + * Consider for example page range with simple minmax interval [1000,2000], + * and assume a new row gets inserted into the range with value 1000000. + * Due to that the interval gets [1000,1000000]. I.e. the minmax interval + * got 1000x wider and won't be useful to eliminate scan keys between 2001 + * and 1000000. + * + * With multi-minmax opclass, we may have [1000,2000] interval initially, + * but after adding the new row we start tracking it as two interval: + * + * [1000,2000] and [1000000,1000000] + * + * This allow us to still eliminate the page range when the scan keys hit + * the gap between 2000 and 1000000, making it useful in cases when the + * simple minmax opclass gets inefficient. + * + * The number of intervals tracked per page range is somewhat flexible. + * What is restricted is the number of values per page range, and the limit + * is currently 64 (see values_per_range reloption). Collapsed intervals + * (with equal minimum and maximum value) are stored as a single value, + * while regular intervals require two values. + * + * When the number of values gets too high (by adding new values to the + * summary), we merge some of the intervals to free space for more values. + * This is done in a greedy way - we simply pick the two closest intervals, + * merge them, and repeat this until the number of values to store gets + * sufficiently low (below 75% of maximum values), but that is mostly + * arbitrary threshold and may be changed easily). + * + * To pick the closest intervals we use the "distance" support procedure, + * which measures space between two ranges (i.e. length of an interval). + * The computed value may be an approximation - in the worst case we will + * merge two ranges that are slightly less optimal at that step, but the + * index should still produce correct results. + * + * + * IDENTIFICATION + * src/backend/access/brin/brin_minmax_multi.c + */ +#include "postgres.h" + +#include "access/genam.h" +#include "access/brin.h" +#include "access/brin_internal.h" +#include "access/brin_tuple.h" +#include "access/reloptions.h" +#include "access/stratnum.h" +#include "access/htup_details.h" +#include "catalog/pg_type.h" +#include "catalog/pg_amop.h" +#include "utils/array.h" +#include "utils/builtins.h" +#include "utils/date.h" +#include "utils/datum.h" +#include "utils/inet.h" +#include "utils/lsyscache.h" +#include "utils/memutils.h" +#include "utils/numeric.h" +#include "utils/pg_lsn.h" +#include "utils/rel.h" +#include "utils/syscache.h" +#include "utils/uuid.h" + +/* + * Additional SQL level support functions + * + * Procedure numbers must not use values reserved for BRIN itself; see + * brin_internal.h. + */ +#define MINMAX_MAX_PROCNUMS 1 /* maximum support procs we need */ +#define PROCNUM_DISTANCE 11 /* required, distance between values*/ + +/* + * Subtract this from procnum to obtain index in MinmaxMultiOpaque arrays + * (Must be equal to minimum of private procnums). + */ +#define PROCNUM_BASE 11 + + +typedef struct MinmaxMultiOpaque +{ + FmgrInfo extra_procinfos[MINMAX_MAX_PROCNUMS]; + bool extra_proc_missing[MINMAX_MAX_PROCNUMS]; + Oid cached_subtype; + FmgrInfo strategy_procinfos[BTMaxStrategyNumber]; +} MinmaxMultiOpaque; + +/* + * Storage type for BRIN's minmax reloptions + */ +typedef struct MinMaxOptions +{ + int32 vl_len_; /* varlena header (do not touch directly!) */ + int valuesPerRange; /* number of values per range */ +} MinMaxOptions; + +#define MINMAX_DEFAULT_VALUES_PER_PAGE 32 + +#define MinMaxGetValuesPerRange(opts) \ + ((opts) && (((MinMaxOptions *) (opts))->valuesPerRange != 0) ? \ + ((MinMaxOptions *) (opts))->valuesPerRange : \ + MINMAX_DEFAULT_VALUES_PER_PAGE) + + + +/* + * The summary of multi-minmax indexes has two representations - Ranges for + * convenient processing, and SerializedRanges for storage in bytea value. + * + * The Ranges struct stores the boundary values in a single array, but we + * treat regular and single-point ranges differently to save space. For + * regular ranges (with different boundary values) we have to store both + * values, while for "single-point ranges" we only need to save one value. + * + * The 'values' array stores boundary values for regular ranges first (there + * are 2*nranges values to store), and then the nvalues boundary values for + * single-point ranges. That is, we have (2*nranges + nvalues) boundary + * values in the array. + * + * +---------------------------------+-------------------------------+ + * | ranges (sorted pairs of values) | sorted values (single points) | + * +---------------------------------+-------------------------------+ + * + * This allows us to quickly add new values, and store outliers without + * making the other ranges very wide. + * + * We never store more than maxvalues values (as set by values_per_range + * reloption). If needed we merge some of the ranges. + * + * To minimize palloc overhead, we always allocate the full array with + * space for maxvalues elements. This should be fine as long as the + * maxvalues is reasonably small (64 seems fine), which is the case + * thanks to values_per_range reloption being limited to 256. + */ +typedef struct Ranges +{ + Oid typid; + + /* (2*nranges + nvalues) <= maxvalues */ + int nranges; /* number of ranges in the array (stored) */ + int nvalues; /* number of values in the data array (all) */ + int maxvalues; /* maximum number of values (reloption) */ + + /* values stored for this range - either raw values, or ranges */ + Datum values[FLEXIBLE_ARRAY_MEMBER]; +} Ranges; + +/* + * On-disk the summary is stored as a bytea value, represented by the + * SerializedRanges structure. It has a 4B varlena header, so can treated + * as varlena directly. + * + * See range_serialize/range_deserialize methods for serialization details. + */ +typedef struct SerializedRanges +{ + /* varlena header (do not touch directly!) */ + int32 vl_len_; + + /* type of values stored in the data array */ + Oid typid; + + /* (2*nranges + nvalues) <= maxvalues */ + int nranges; /* number of ranges in the array (stored) */ + int nvalues; /* number of values in the data array (all) */ + int maxvalues; /* maximum number of values (reloption) */ + + /* contains the actual data */ + char data[FLEXIBLE_ARRAY_MEMBER]; +} SerializedRanges; + +static SerializedRanges *range_serialize(Ranges *range); + +static Ranges *range_deserialize(SerializedRanges *range); + +/* Cache for support and strategy procesures. */ + +static FmgrInfo *minmax_multi_get_procinfo(BrinDesc *bdesc, uint16 attno, + uint16 procnum); + +static FmgrInfo *minmax_multi_get_strategy_procinfo(BrinDesc *bdesc, + uint16 attno, Oid subtype, uint16 strategynum); + + +/* + * minmax_multi_init + * Initialize the deserialized range list, allocate all the memory. + * + * This is only in-memory representation of the ranges, so we allocate + * everything enough space for the maximum number of values (so as not + * to have to do repallocs as the ranges grow). + */ +static Ranges * +minmax_multi_init(int maxvalues) +{ + Size len; + Ranges * ranges; + + Assert(maxvalues > 0); + + len = offsetof(Ranges, values); /* fixed header */ + len += maxvalues * sizeof(Datum); /* Datum values */ + + ranges = (Ranges *) palloc0(len); + + ranges->maxvalues = maxvalues; + + return ranges; +} + +/* + * range_serialize + * Serialize the in-memory representation into a compact varlena value. + * + * Simply copy the header and then also the individual values, as stored + * in the in-memory value array. + */ +static SerializedRanges * +range_serialize(Ranges *range) +{ + Size len; + int nvalues; + SerializedRanges *serialized; + Oid typid; + int typlen; + bool typbyval; + + int i; + char *ptr; + + /* simple sanity checks */ + Assert(range->nranges >= 0); + Assert(range->nvalues >= 0); + Assert(range->maxvalues > 0); + + /* see how many Datum values we actually have */ + nvalues = 2*range->nranges + range->nvalues; + + Assert(2*range->nranges + range->nvalues <= range->maxvalues); + + typid = range->typid; + typbyval = get_typbyval(typid); + typlen = get_typlen(typid); + + /* header is always needed */ + len = offsetof(SerializedRanges,data); + + /* + * The space needed depends on data type - for fixed-length data types + * (by-value and some by-reference) it's pretty simple, just multiply + * (attlen * nvalues) and we're done. For variable-length by-reference + * types we need to actually walk all the values and sum the lengths. + */ + if (typlen == -1) /* varlena */ + { + int i; + for (i = 0; i < nvalues; i++) + { + len += VARSIZE_ANY(range->values[i]); + } + } + else if (typlen == -2) /* cstring */ + { + int i; + for (i = 0; i < nvalues; i++) + { + /* don't forget to include the null terminator ;-) */ + len += strlen(DatumGetPointer(range->values[i])) + 1; + } + } + else /* fixed-length types (even by-reference) */ + { + Assert(typlen > 0); + len += nvalues * typlen; + } + + /* + * Allocate the serialized object, copy the basic information. The + * serialized object is a varlena, so update the header. + */ + serialized = (SerializedRanges *) palloc0(len); + SET_VARSIZE(serialized, len); + + serialized->typid = typid; + serialized->nranges = range->nranges; + serialized->nvalues = range->nvalues; + serialized->maxvalues = range->maxvalues; + + /* + * And now copy also the boundary values (like the length calculation + * this depends on the particular data type). + */ + ptr = serialized->data; /* start of the serialized data */ + + for (i = 0; i < nvalues; i++) + { + if (typbyval) /* simple by-value data types */ + { + memcpy(ptr, &range->values[i], typlen); + ptr += typlen; + } + else if (typlen > 0) /* fixed-length by-ref types */ + { + memcpy(ptr, DatumGetPointer(range->values[i]), typlen); + ptr += typlen; + } + else if (typlen == -1) /* varlena */ + { + int tmp = VARSIZE_ANY(DatumGetPointer(range->values[i])); + memcpy(ptr, DatumGetPointer(range->values[i]), tmp); + ptr += tmp; + } + else if (typlen == -2) /* cstring */ + { + int tmp = strlen(DatumGetPointer(range->values[i])) + 1; + memcpy(ptr, DatumGetPointer(range->values[i]), tmp); + ptr += tmp; + } + + /* make sure we haven't overflown the buffer end */ + Assert(ptr <= ((char *)serialized + len)); + } + + /* exact size */ + Assert(ptr == ((char *)serialized + len)); + + return serialized; +} + +/* + * range_deserialize + * Serialize the in-memory representation into a compact varlena value. + * + * Simply copy the header and then also the individual values, as stored + * in the in-memory value array. + */ +static Ranges * +range_deserialize(SerializedRanges *serialized) +{ + int i, + nvalues; + char *ptr; + bool typbyval; + int typlen; + + Ranges *range; + + Assert(serialized->nranges >= 0); + Assert(serialized->nvalues >= 0); + Assert(serialized->maxvalues > 0); + + nvalues = 2*serialized->nranges + serialized->nvalues; + + Assert(nvalues <= serialized->maxvalues); + + range = minmax_multi_init(serialized->maxvalues); + + /* copy the header info */ + range->nranges = serialized->nranges; + range->nvalues = serialized->nvalues; + range->maxvalues = serialized->maxvalues; + range->typid = serialized->typid; + + typbyval = get_typbyval(serialized->typid); + typlen = get_typlen(serialized->typid); + + /* + * And now deconstruct the values into Datum array. We don't need + * to copy the values and will instead just point the values to the + * serialized varlena value (assuming it will be kept around). + */ + ptr = serialized->data; + + for (i = 0; i < nvalues; i++) + { + if (typbyval) /* simple by-value data types */ + { + memcpy(&range->values[i], ptr, typlen); + ptr += typlen; + } + else if (typlen > 0) /* fixed-length by-ref types */ + { + /* no copy, just set the value to the pointer */ + range->values[i] = PointerGetDatum(ptr); + ptr += typlen; + } + else if (typlen == -1) /* varlena */ + { + range->values[i] = PointerGetDatum(ptr); + ptr += VARSIZE_ANY(DatumGetPointer(range->values[i])); + } + else if (typlen == -2) /* cstring */ + { + range->values[i] = PointerGetDatum(ptr); + ptr += strlen(DatumGetPointer(range->values[i])) + 1; + } + + /* make sure we haven't overflown the buffer end */ + Assert(ptr <= ((char *)serialized + VARSIZE_ANY(serialized))); + } + + /* should have consumed the whole input value exactly */ + Assert(ptr == ((char *)serialized + VARSIZE_ANY(serialized))); + + /* return the deserialized value */ + return range; +} + +typedef struct compare_context +{ + FmgrInfo *cmpFn; + Oid colloid; +} compare_context; + +/* + * Used to represent ranges expanded during merging and combining (to + * reduce number of boundary values to store). + * + * XXX CombineRange name seems a bit weird. Consider renaming, perhaps to + * something ExpandedRange or so. + */ +typedef struct CombineRange +{ + Datum minval; /* lower boundary */ + Datum maxval; /* upper boundary */ + bool collapsed; /* true if minval==maxval */ +} CombineRange; + +/* + * compare_combine_ranges + * Compare the combine ranges - first by minimum, then by maximum. + * + * We do guarantee that ranges in a single Range object do not overlap, + * so it may seem strange that we don't order just by minimum. But when + * merging two Ranges (which happens in the union function), the ranges + * may in fact overlap. So we do compare both. + */ +static int +compare_combine_ranges(const void *a, const void *b, void *arg) +{ + CombineRange *ra = (CombineRange *)a; + CombineRange *rb = (CombineRange *)b; + Datum r; + + compare_context *cxt = (compare_context *)arg; + + /* first compare minvals */ + r = FunctionCall2Coll(cxt->cmpFn, cxt->colloid, ra->minval, rb->minval); + + if (DatumGetBool(r)) + return -1; + + r = FunctionCall2Coll(cxt->cmpFn, cxt->colloid, rb->minval, ra->minval); + + if (DatumGetBool(r)) + return 1; + + /* then compare maxvals */ + r = FunctionCall2Coll(cxt->cmpFn, cxt->colloid, ra->maxval, rb->maxval); + + if (DatumGetBool(r)) + return -1; + + r = FunctionCall2Coll(cxt->cmpFn, cxt->colloid, rb->maxval, ra->maxval); + + if (DatumGetBool(r)) + return 1; + + return 0; +} + +/* + * range_contains_value + * See if the new value is already contained in the range list. + * + * We first inspect the list of intervals. We use a small trick - we check + * the value against min/max of the whole range (min of the first interval, + * max of the last one) first, and only inspect the individual intervals if + * this passes. + * + * If the value matches none of the intervals, we check the exact values. + * We simply loop through them and invoke equality operator on them. + * + * XXX This might benefit from the fact that both the intervals and exact + * values are sorted - we might do bsearch or something. Currently that + * does not make much difference (there are only ~32 intervals), but if + * this gets increased and/or the comparator function is more expensive, + * it might be a huge win. + */ +static bool +range_contains_value(BrinDesc *bdesc, Oid colloid, + AttrNumber attno, Form_pg_attribute attr, + Ranges *ranges, Datum newval) +{ + int i; + FmgrInfo *cmpLessFn; + FmgrInfo *cmpGreaterFn; + FmgrInfo *cmpEqualFn; + Oid typid = attr->atttypid; + + /* + * First inspect the ranges, if there are any. We first check the whole + * range, and only when there's still a chance of getting a match we + * inspect the individual ranges. + */ + if (ranges->nranges > 0) + { + Datum compar; + bool match = true; + + Datum minvalue = ranges->values[0]; + Datum maxvalue = ranges->values[2*ranges->nranges - 1]; + + /* + * Otherwise, need to compare the new value with boundaries of all + * the ranges. First check if it's less than the absolute minimum, + * which is the first value in the array. + */ + cmpLessFn = minmax_multi_get_strategy_procinfo(bdesc, attno, typid, + BTLessStrategyNumber); + compar = FunctionCall2Coll(cmpLessFn, colloid, newval, minvalue); + + /* smaller than the smallest value in the range list */ + if (DatumGetBool(compar)) + match = false; + + /* + * And now compare it to the existing maximum (last value in the + * data array). But only if we haven't already ruled out a possible + * match in the minvalue check. + */ + if (match) + { + cmpGreaterFn = minmax_multi_get_strategy_procinfo(bdesc, attno, typid, + BTGreaterStrategyNumber); + compar = FunctionCall2Coll(cmpGreaterFn, colloid, newval, maxvalue); + + if (DatumGetBool(compar)) + match = false; + } + + /* + * So it's in the general range, but is it actually covered by any + * of the ranges? Repeat the check for each range. + * + * XXX We simply walk the ranges sequentially, but maybe we could + * further leverage the ordering and non-overlap and use bsearch to + * speed this up a bit. + */ + for (i = 0; i < ranges->nranges && match; i++) + { + /* copy the min/max values from the ranges */ + minvalue = ranges->values[2*i]; + maxvalue = ranges->values[2*i+1]; + + /* + * Otherwise, need to compare the new value with boundaries of all + * the ranges. First check if it's less than the absolute minimum, + * which is the first value in the array. + */ + compar = FunctionCall2Coll(cmpLessFn, colloid, newval, minvalue); + + /* smaller than the smallest value in this range */ + if (DatumGetBool(compar)) + continue; + + compar = FunctionCall2Coll(cmpGreaterFn, colloid, newval, maxvalue); + + /* larger than the largest value in this range */ + if (DatumGetBool(compar)) + continue; + + /* hey, we found a matching row */ + return true; + } + } + + cmpEqualFn = minmax_multi_get_strategy_procinfo(bdesc, attno, typid, + BTEqualStrategyNumber); + + /* + * We're done with the ranges, now let's inspect the exact values. + * + * XXX Again, we do sequentially search the values - consider leveraging + * the ordering of values to improve performance. + */ + for (i = 2*ranges->nranges; i < 2*ranges->nranges + ranges->nvalues; i++) + { + Datum compar; + + compar = FunctionCall2Coll(cmpEqualFn, colloid, newval, ranges->values[i]); + + /* found an exact match */ + if (DatumGetBool(compar)) + return true; + } + + /* the value is not covered by this BRIN tuple */ + return false; +} + +/* + * insert_value + * Adds a new value into the single-point part, while maintaining ordering. + * + * The function inserts the new value to the right place in the single-point + * part of the range. It assumes there's enough free space, and then does + * essentially an insert-sort. + * + * XXX Assumes the 'values' array has space for (nvalues+1) entries, and that + * only the first nvalues are used. + */ +static void +insert_value(FmgrInfo *cmp, Oid colloid, Datum *values, int nvalues, + Datum newvalue) +{ + int i; + Datum lt; + + /* If there are no values yet, store the new one and we're done. */ + if (!nvalues) + { + values[0] = newvalue; + return; + } + + /* + * A common case is that the new value is entirely out of the existing + * range, i.e. it's either smaller or larger than all previous values. + * So we check and handle this case first - first we check the larger + * case, because in that case we can just append the value to the end + * of the array and we're done. + */ + + /* Is it greater than all existing values in the array? */ + lt = FunctionCall2Coll(cmp, colloid, values[nvalues-1], newvalue); + if (DatumGetBool(lt)) + { + /* just copy it in-place and we're done */ + values[nvalues] = newvalue; + return; + } + + /* + * OK, I lied a bit - we won't check the smaller case explicitly, but + * we'll just compare the value to all existing values in the array. + * But we happen to start with the smallest value, so we're actually + * doing the check anyway. + * + * XXX We do walk the values sequentially. Perhaps we could/should be + * smarter and do some sort of bisection, to improve performance? + */ + for (i = 0; i < nvalues; i++) + { + lt = FunctionCall2Coll(cmp, colloid, newvalue, values[i]); + if (DatumGetBool(lt)) + { + /* + * Move values to make space for the new entry, which should go + * to index 'i'. Entries 0 ... (i-1) should stay where they are. + */ + memmove(&values[i+1], &values[i], (nvalues-i) * sizeof(Datum)); + values[i] = newvalue; + return; + } + } + + /* We should never really get here. */ + Assert(false); +} + +/* + * Check that the order of the array values is correct, using the cmp + * function (which should be BTLessStrategyNumber). + */ +static void +AssertArrayOrder(FmgrInfo *cmp, Oid colloid, Datum *values, int nvalues) +{ +#ifdef USE_ASSERT_CHECKING + int i; + Datum lt; + + for (i = 0; i < (nvalues-1); i++) + { + lt = FunctionCall2Coll(cmp, colloid, values[i], values[i+1]); + Assert(DatumGetBool(lt)); + } +#endif +} + +/* + * Check ordering of boundary values in both parts of the ranges, using + * the cmp function (which should be BTLessStrategyNumber). + * + * XXX We might also check that the ranges and points do not overlap. But + * that will break this check sooner or later anyway. + */ +static void +AssertRangeOrdering(FmgrInfo *cmpFn, Oid colloid, Ranges *ranges) +{ +#ifdef USE_ASSERT_CHECKING + /* first the ranges (there are 2*nranges boundary values) */ + AssertArrayOrder(cmpFn, colloid, ranges->values, 2*ranges->nranges); + + /* then the single-point ranges (with nvalues boundar values ) */ + AssertArrayOrder(cmpFn, colloid, &ranges->values[2*ranges->nranges], + ranges->nvalues); +#endif +} + +/* + * Check that the expanded ranges (built when reducing the number of ranges + * by combining some of them) are correctly sorted and do not overlap. + */ +static void +AssertValidCombineRanges(BrinDesc *bdesc, Oid colloid, AttrNumber attno, + Form_pg_attribute attr, CombineRange *ranges, + int nranges) +{ +#ifdef USE_ASSERT_CHECKING + int i; + FmgrInfo *eq; + FmgrInfo *lt; + + eq = minmax_multi_get_strategy_procinfo(bdesc, attno, attr->atttypid, + BTEqualStrategyNumber); + + lt = minmax_multi_get_strategy_procinfo(bdesc, attno, attr->atttypid, + BTLessStrategyNumber); + + /* + * Each range independently should be valid, i.e. that for the boundary + * values (lower <= upper). + */ + for (i = 0; i < nranges; i++) + { + Datum r; + Datum minval = ranges[i].minval; + Datum maxval = ranges[i].maxval; + + if (ranges[i].collapsed) /* collapsed: minval == maxval */ + r = FunctionCall2Coll(eq, colloid, minval, maxval); + else /* non-collapsed: minval < maxval */ + r = FunctionCall2Coll(lt, colloid, minval, maxval); + + Assert(DatumGetBool(r)); + } + + /* + * And the ranges should be ordered and must nor overlap, i.e. + * upper < lower for boundaries of consecutive ranges. + */ + for (i = 0; i < nranges-1; i++) + { + Datum r; + Datum maxval = ranges[i].maxval; + Datum minval = ranges[i+1].minval; + + r = FunctionCall2Coll(lt, colloid, maxval, minval); + + Assert(DatumGetBool(r)); + } +#endif +} + +/* + * Expand ranges from Ranges into CombineRange array. This expects the + * cranges to be pre-allocated and sufficiently large (there needs to be + * at least (nranges + nvalues) slots). + */ +static void +fill_combine_ranges(CombineRange *cranges, int ncranges, Ranges *ranges) +{ + int idx; + int i; + + idx = 0; + for (i = 0; i < ranges->nranges; i++) + { + cranges[idx].minval = ranges->values[2*i]; + cranges[idx].maxval = ranges->values[2*i+1]; + cranges[idx].collapsed = false; + idx++; + + Assert(idx <= ncranges); + } + + for (i = 0; i < ranges->nvalues; i++) + { + cranges[idx].minval = ranges->values[2*ranges->nranges + i]; + cranges[idx].maxval = ranges->values[2*ranges->nranges + i]; + cranges[idx].collapsed = true; + idx++; + + Assert(idx <= ncranges); + } + + Assert(idx == ncranges); + + return; +} + +/* + * Sort combine ranges using qsort (with BTLessStrategyNumber function). + */ +static void +sort_combine_ranges(FmgrInfo *cmp, Oid colloid, + CombineRange *cranges, int ncranges) +{ + compare_context cxt; + + /* sort the values */ + cxt.colloid = colloid; + cxt.cmpFn = cmp; + + qsort_arg(cranges, ncranges, sizeof(CombineRange), + compare_combine_ranges, (void *) &cxt); +} + +/* + * When combining multiple Range values (in union function), some of the + * ranges may overlap. We simply merge the overlapping ranges to fix that. + * + * XXX This assumes the combine ranges were previously sorted (by minval + * and then maxval). We leverage this when detecting overlap. + */ +static int +merge_combine_ranges(FmgrInfo *cmp, Oid colloid, + CombineRange *cranges, int ncranges) +{ + int idx; + + /* TODO: add assert checking the ordering of input ranges */ + + /* try merging ranges (idx) and (idx+1) if they overlap */ + idx = 0; + while (idx < (ncranges-1)) + { + Datum r; + + /* + * comparing [?,maxval] vs. [minval,?] - the ranges overlap + * if (minval < maxval) + */ + r = FunctionCall2Coll(cmp, colloid, + cranges[idx].maxval, + cranges[idx+1].minval); + + /* + * Nope, maxval < minval, so no overlap. And we know the ranges + * are ordered, so there are no more overlaps, because all the + * remaining ranges have greater or equal minval. + */ + if (DatumGetBool(r)) + { + /* proceed to the next range */ + idx += 1; + continue; + } + + /* + * So ranges 'idx' and 'idx+1' do overlap, but we don't know if + * 'idx+1' is contained in 'idx', or if they only overlap only + * partially. So compare the upper bounds and keep the larger one. + */ + r = FunctionCall2Coll(cmp, colloid, + cranges[idx].maxval, + cranges[idx+1].maxval); + + if (DatumGetBool(r)) + cranges[idx].maxval = cranges[idx+1].maxval; + + /* + * The range certainly is no longer collapsed (irrespectedly of + * the previous state). + */ + cranges[idx].collapsed = false; + + /* + * Now get rid of the (idx+1) range entirely by shifting the + * remaining ranges by 1. There are ncranges elements, and we + * need to move elements from (idx+2). That means the number + * of elements to move is [ncranges - (idx+2)]. + */ + memmove(&cranges[idx+1], &cranges[idx+2], + (ncranges - (idx + 2)) * sizeof(CombineRange)); + + /* + * Decrease the number of ranges, and repeat (with the same range, + * as it might overlap with additional ranges thanks to the merge). + */ + ncranges--; + } + + /* TODO: add assert checking the ordering etc. of produced ranges */ + + return ncranges; +} + +/* + * Represents a distance between two ranges (identified by index into + * an array of combine ranges). + */ +typedef struct DistanceValue +{ + int index; + double value; +} DistanceValue; + +/* + * Simple comparator for distance values, comparing the double value. + */ +static int +compare_distances(const void *a, const void *b) +{ + DistanceValue *da = (DistanceValue *)a; + DistanceValue *db = (DistanceValue *)b; + + if (da->value < db->value) + return -1; + else if (da->value > db->value) + return 1; + + return 0; +} + +/* + * Given an array of combine ranges, compute distance of the gaps betwen + * the ranges - for ncranges there are (ncranges-1) gaps. + * + * We simply call the "distance" function to compute the (min-max) for pairs + * of consecutive ganges. The function may be fairly expensive, so we do that + * just once (and then use it to pick as many ranges to merge as possible). + * + * See reduce_combine_ranges for details. + */ +static DistanceValue * +build_distances(FmgrInfo *distanceFn, Oid colloid, + CombineRange *cranges, int ncranges) +{ + int i; + DistanceValue *distances; + + Assert(ncranges >= 2); + + distances = (DistanceValue *) palloc0(sizeof(DistanceValue) * (ncranges - 1)); + + /* + * Walk though the ranges once and compute distance between the ranges + * so that we can sort them once. + */ + for (i = 0; i < (ncranges-1); i++) + { + Datum a1, a2, r; + + a1 = cranges[i].maxval; + a2 = cranges[i+1].minval; + + /* compute length of the empty gap (distance between max/min) */ + r = FunctionCall2Coll(distanceFn, colloid, a1, a2); + + /* remember the index */ + distances[i].index = i; + distances[i].value = DatumGetFloat8(r); + } + + /* sort the distances in ascending order */ + pg_qsort(distances, (ncranges-1), sizeof(DistanceValue), compare_distances); + + return distances; +} + +/* + * Builds combine ranges for the existing ranges (and single-point ranges), + * and also the new value (which did not fit into the array). + * + * XXX We do perform qsort on all the values, but we could also leverage + * the fact that the input data is already sorted and do merge sort. + */ +static CombineRange * +build_combine_ranges(FmgrInfo *cmp, Oid colloid, Ranges *ranges, + Datum newvalue, int *nranges) +{ + int ncranges; + CombineRange *cranges; + + /* now do the actual merge sort */ + ncranges = ranges->nranges + ranges->nvalues + 1; + cranges = (CombineRange *) palloc0(ncranges * sizeof(CombineRange)); + *nranges = ncranges; + + /* put the new value at the beginning */ + cranges[0].minval = newvalue; + cranges[0].maxval = newvalue; + cranges[0].collapsed = true; + + /* then the regular and collapsed ranges */ + fill_combine_ranges(&cranges[1], ncranges-1, ranges); + + /* and sort the ranges */ + sort_combine_ranges(cmp, colloid, cranges, ncranges); + + return cranges; +} + +/* + * Counts bondary values needed to store the ranges. Each single-point + * range is stored using a single value, each regular range needs two. + */ +static int +count_values(CombineRange *cranges, int ncranges) +{ + int i; + int count; + + count = 0; + for (i = 0; i < ncranges; i++) + { + if (cranges[i].collapsed) + count += 1; + else + count += 2; + } + + return count; +} + +/* + * Combines ranges until the number of boundary values drops below 75% + * of the capacity (as set by values_per_range reloption). + * + * XXX The ranges to merge are selected solely using the distance. But + * that may not be the best strategy, for example when multiple gaps + * are of equal (or very similar) length. + * + * Consider for example points 1, 2, 3, .., 64, which have gaps of the + * same length 1 of course. In that case we tend to pick the first + * gap of that length, which leads to this: + * + * step 1: [1, 2], 3, 4, 5, .., 64 + * step 2: [1, 3], 4, 5, .., 64 + * step 3: [1, 4], 5, .., 64 + * ... + * + * So in the end we'll have one "large" range and multiple small points. + * That may be fine, but it seems a bit strange and non-optimal. Maybe + * we should consider other things when picking ranges to merge - e.g. + * length of the ranges? Or perhaps randomize the choice of ranges, with + * probability inversely proportional to the distance (the gap lengths + * may be very close, but not exactly the same). + */ +static int +reduce_combine_ranges(CombineRange *cranges, int ncranges, + DistanceValue *distances, int max_values) +{ + int i; + int ndistances = (ncranges - 1); + int count = count_values(cranges, ncranges); + + /* + * We have one fewer 'gaps' than the ranges. We'll be decrementing + * the number of combine ranges (reduction is the primary goal of + * this function), so we must use a separate value. + */ + for (i = 0; i < ndistances; i++) + { + int j; + int shortest; + + if (count <= max_values * 0.75) + break; + + shortest = distances[i].index; + + /* + * The index must be still valid with respect to the current size + * of cranges array (and it always points to the first range, so + * never to the last one - hence the -1 in the condition). + */ + Assert(shortest < (ncranges - 1)); + + if (!cranges[shortest].collapsed && !cranges[shortest+1].collapsed) + count -= 2; + else if (!cranges[shortest].collapsed || !cranges[shortest+1].collapsed) + count -= 1; + + /* + * Move the values to join the two selected ranges. The new range is + * definiely not collapsed but a regular range. + */ + cranges[shortest].maxval = cranges[shortest+1].maxval; + cranges[shortest].collapsed = false; + + /* shuffle the subsequent combine ranges */ + memmove(&cranges[shortest+1], &cranges[shortest+2], + (ncranges - shortest - 2) * sizeof(CombineRange)); + + /* also, shuffle all higher indexes (we've just moved the ranges) */ + for (j = i; j < ndistances; j++) + { + if (distances[j].index > shortest) + distances[j].index--; + } + + ncranges--; + + Assert(ncranges > 0); + } + + return ncranges; +} + +/* + * Store the boundary values from CombineRanges back into Range (using + * only the minimal number of values needed). + */ +static void +store_combine_ranges(Ranges *ranges, CombineRange *cranges, int ncranges) +{ + int i; + int idx = 0; + + /* first copy in the regular ranges */ + ranges->nranges = 0; + for (i = 0; i < ncranges; i++) + { + if (!cranges[i].collapsed) + { + ranges->values[idx++] = cranges[i].minval; + ranges->values[idx++] = cranges[i].maxval; + ranges->nranges++; + } + } + + /* now copy in the collapsed ones */ + ranges->nvalues = 0; + for (i = 0; i < ncranges; i++) + { + if (cranges[i].collapsed) + { + ranges->values[idx++] = cranges[i].minval; + ranges->nvalues++; + } + } +} + +/* + * range_add_value + * Add the new value to the multi-minmax range. + */ +static bool +range_add_value(BrinDesc *bdesc, Oid colloid, + AttrNumber attno, Form_pg_attribute attr, + Ranges *ranges, Datum newval) +{ + FmgrInfo *cmpFn, + *distanceFn; + + /* combine ranges */ + CombineRange *cranges; + int ncranges; + DistanceValue *distances; + + MemoryContext ctx; + MemoryContext oldctx; + + Assert(2*ranges->nranges + ranges->nvalues <= ranges->maxvalues); + + /* + * Bail out if the value already is covered by the range. + * + * We could also add values until we hit values_per_range, and then + * do the deduplication in a batch, hoping for better efficiency. But + * that would mean we actually modify the range every time, which means + * having to serialize the value, which does palloc, walks the values, + * copies them, etc. Not exactly cheap. + * + * So instead we do the check, which should be fairly cheap - assuming + * the comparator function is not very expensive. + * + * This also implies means the values array can't contain duplicities. + */ + if (range_contains_value(bdesc, colloid, attno, attr, ranges, newval)) + return false; + + /* we'll certainly need the comparator, so just look it up now */ + cmpFn = minmax_multi_get_strategy_procinfo(bdesc, attno, attr->atttypid, + BTLessStrategyNumber); + + /* + * If there's space in the values array, copy it in and we're done. + * + * We do want to keep the values sorted (to speed up searches), so we + * do a simple insertion sort. We could do something more elaborate, + * e.g. by sorting the values only now and then, but for small counts + * (e.g. when maxvalues is 64) this should be fine. + */ + if (2*ranges->nranges + ranges->nvalues < ranges->maxvalues) + { + Datum *values; + + /* beginning of the 'single value' part (for convenience) */ + values = &ranges->values[2*ranges->nranges]; + + insert_value(cmpFn, colloid, values, ranges->nvalues, newval); + + ranges->nvalues++; + + /* + * Check we haven't broken the ordering of boundary values (checks + * both parts, but that doesn't hurt). + */ + AssertRangeOrdering(cmpFn, colloid, ranges); + + /* yep, we've modified the range */ + return true; + } + + /* + * Damn - the new value is not in the range yet, but we don't have space + * to just insert it. So we need to combine some of the existing ranges, + * to reduce the number of values we need to store (joining two intervals + * reduces the number of boundaries to store by 2). + * + * To do that we first construct an array of CombineRange items - each + * combine range tracks if it's a regular range or collapsed range, where + * "collapsed" means "single point." + * + * Existing ranges (we have ranges->nranges of them) map to combine ranges + * directly, while single points (ranges->nvalues of them) have to be + * expanded. We neet the combine ranges to be sorted, and we do that by + * performing a merge sort of ranges, values and new value. + */ + + /* Check the ordering invariants are not violated (for both parts). */ + AssertArrayOrder(cmpFn, colloid, ranges->values, ranges->nranges*2); + AssertArrayOrder(cmpFn, colloid, &ranges->values[ranges->nranges*2], + ranges->nvalues); + + /* and we'll also need the 'distance' procedure */ + distanceFn = minmax_multi_get_procinfo(bdesc, attno, PROCNUM_DISTANCE); + + /* + * The distanceFn calls (which may internally call e.g. numeric_le) may + * allocate quite a bit of memory, and we must not leak it. Otherwise + * we'd have problems e.g. when building indexes. So we create a local + * memory context and make sure we free the memory before leaving this + * function (not after every call). + */ + ctx = AllocSetContextCreate(CurrentMemoryContext, + "minmax-multi context", + ALLOCSET_DEFAULT_SIZES); + + oldctx = MemoryContextSwitchTo(ctx); + + /* OK build the combine ranges */ + cranges = build_combine_ranges(cmpFn, colloid, ranges, newval, &ncranges); + + /* build array of gap distances and sort them in ascending order */ + distances = build_distances(distanceFn, colloid, cranges, ncranges); + + /* + * Combine ranges until we release at least 25% of the space. This + * threshold is somewhat arbitrary, perhaps needs tuning. We must not + * use too low or high value. + */ + ncranges = reduce_combine_ranges(cranges, ncranges, distances, + ranges->maxvalues); + + Assert(count_values(cranges, ncranges) <= ranges->maxvalues * 0.75); + + /* decompose the combine ranges into regular ranges and single values */ + store_combine_ranges(ranges, cranges, ncranges); + + MemoryContextSwitchTo(oldctx); + MemoryContextDelete(ctx); + + /* Check the ordering invariants are not violated (for both parts). */ + AssertArrayOrder(cmpFn, colloid, ranges->values, ranges->nranges*2); + AssertArrayOrder(cmpFn, colloid, &ranges->values[ranges->nranges*2], + ranges->nvalues); + + return true; +} + +Datum +brin_minmax_multi_opcinfo(PG_FUNCTION_ARGS) +{ + BrinOpcInfo *result; + + /* + * opaque->strategy_procinfos is initialized lazily; here it is set to + * all-uninitialized by palloc0 which sets fn_oid to InvalidOid. + */ + + result = palloc0(MAXALIGN(SizeofBrinOpcInfo(1)) + + sizeof(MinmaxMultiOpaque)); + result->oi_nstored = 1; + result->oi_regular_nulls = true; + result->oi_opaque = (MinmaxMultiOpaque *) + MAXALIGN((char *) result + SizeofBrinOpcInfo(1)); + result->oi_typcache[0] = lookup_type_cache(PG_BRIN_MINMAX_MULTI_SUMMARYOID, 0); + + PG_RETURN_POINTER(result); +} + +/* + * Compute distance between two float4 values (plain subtraction). + */ +Datum +brin_minmax_multi_distance_float4(PG_FUNCTION_ARGS) +{ + float a1 = PG_GETARG_FLOAT4(0); + float a2 = PG_GETARG_FLOAT4(1); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(a1 <= a2); + + PG_RETURN_FLOAT8((double) a2 - (double) a1); +} + +/* + * Compute distance between two float8 values (plain subtraction). + */ +Datum +brin_minmax_multi_distance_float8(PG_FUNCTION_ARGS) +{ + double a1 = PG_GETARG_FLOAT8(0); + double a2 = PG_GETARG_FLOAT8(1); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(a1 <= a2); + + PG_RETURN_FLOAT8(a2 - a1); +} + +/* + * Compute distance between two int2 values (plain subtraction). + */ +Datum +brin_minmax_multi_distance_int2(PG_FUNCTION_ARGS) +{ + int16 a1 = PG_GETARG_INT16(0); + int16 a2 = PG_GETARG_INT16(1); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(a1 <= a2); + + PG_RETURN_FLOAT8((double) a2 - (double) a1); +} + +/* + * Compute distance between two int4 values (plain subtraction). + */ +Datum +brin_minmax_multi_distance_int4(PG_FUNCTION_ARGS) +{ + int32 a1 = PG_GETARG_INT32(0); + int32 a2 = PG_GETARG_INT32(1); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(a1 <= a2); + + PG_RETURN_FLOAT8((double) a2 - (double) a1); +} + +/* + * Compute distance between two int8 values (plain subtraction). + */ +Datum +brin_minmax_multi_distance_int8(PG_FUNCTION_ARGS) +{ + int64 a1 = PG_GETARG_INT64(0); + int64 a2 = PG_GETARG_INT64(1); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(a1 <= a2); + + PG_RETURN_FLOAT8((double) a2 - (double) a1); +} + +/* + * Compute distance between two tid values (by mapping them to float8 + * and then subtracting them). + */ +Datum +brin_minmax_multi_distance_tid(PG_FUNCTION_ARGS) +{ + double da1, + da2; + + ItemPointer pa1 = (ItemPointer) PG_GETARG_DATUM(0); + ItemPointer pa2 = (ItemPointer) PG_GETARG_DATUM(1); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(ItemPointerCompare(pa1, pa2) <= 0); + + da1 = ItemPointerGetBlockNumber(pa1) * MaxHeapTuplesPerPage + + ItemPointerGetOffsetNumber(pa1); + + da2 = ItemPointerGetBlockNumber(pa2) * MaxHeapTuplesPerPage + + ItemPointerGetOffsetNumber(pa2); + + PG_RETURN_FLOAT8(da2 - da1); +} + +/* + * Comutes distance between two numeric values (plain subtraction). + */ +Datum +brin_minmax_multi_distance_numeric(PG_FUNCTION_ARGS) +{ + Datum d; + Datum a1 = PG_GETARG_DATUM(0); + Datum a2 = PG_GETARG_DATUM(1); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(DatumGetBool(DirectFunctionCall2(numeric_le, a1, a2))); + + d = DirectFunctionCall2(numeric_sub, a2, a1); /* a2 - a1 */ + + PG_RETURN_FLOAT8(DirectFunctionCall1(numeric_float8, d)); +} + +/* + * Computes approximate distance between two UUID values. + * + * XXX We do not need a perfectly accurate value, so we approximate the + * deltas (which would have to be 128-bit integers) with a 64-bit float. + * The small inaccuracies do not matter in practice, in the worst case + * we'll decide to merge ranges that are not the closest ones. + */ +Datum +brin_minmax_multi_distance_uuid(PG_FUNCTION_ARGS) +{ + int i; + double delta = 0; + + Datum a1 = PG_GETARG_DATUM(0); + Datum a2 = PG_GETARG_DATUM(1); + + pg_uuid_t *u1 = DatumGetUUIDP(a1); + pg_uuid_t *u2 = DatumGetUUIDP(a2); + + /* + * We know the values are range boundaries, but the range may be + * collapsed (i.e. single points), with equal values. + */ + Assert(DatumGetBool(DirectFunctionCall2(uuid_le, a1, a2))); + + /* compute approximate delta as a double precision value */ + for (i = UUID_LEN-1; i >= 0; i--) + { + delta += (int) u2->data[i] - (int) u1->data[i]; + delta /= 256; + } + + Assert(delta >= 0); + + PG_RETURN_FLOAT8(delta); +} + +/* + * Computes approximate distance between two time (without tz) values. + * + * TimeADT is just an int64, so we simply subtract the values directly. + */ +Datum +brin_minmax_multi_distance_time(PG_FUNCTION_ARGS) +{ + double delta = 0; + + TimeADT ta = PG_GETARG_TIMEADT(0); + TimeADT tb = PG_GETARG_TIMEADT(1); + + delta = (tb - ta); + + Assert(delta >= 0); + + PG_RETURN_FLOAT8(delta); +} + +/* + * Computes approximate distance between two timetz values. + * + * Simply subtracts the TimeADT (int64) values embedded in TimeTzADT. + * + * XXX Does this need to consider the time zones? + */ +Datum +brin_minmax_multi_distance_timetz(PG_FUNCTION_ARGS) +{ + double delta = 0; + + TimeTzADT *ta = PG_GETARG_TIMETZADT_P(0); + TimeTzADT *tb = PG_GETARG_TIMETZADT_P(1); + + delta = tb->time - ta->time; + + Assert(delta >= 0); + + PG_RETURN_FLOAT8(delta); +} + +/* + * Computes distance between two interval values. + * + * Intervals are internally just 'time' values, so use the same approach + * as for in brin_minmax_multi_distance_time. + * + * XXX Do we actually need two separate functions, then? + */ +Datum +brin_minmax_multi_distance_interval(PG_FUNCTION_ARGS) +{ + double delta = 0; + + TimeADT ia = PG_GETARG_TIMEADT(0); + TimeADT ib = PG_GETARG_TIMEADT(1); + + delta = (ib - ia); + + Assert(delta >= 0); + + PG_RETURN_FLOAT8(delta); +} + +/* + * Compute distance between two pg_lsn values. + * + * LSN is just an int64 encoding position in the stream, so just subtract + * those int64 values directly. + */ +Datum +brin_minmax_multi_distance_pg_lsn(PG_FUNCTION_ARGS) +{ + double delta = 0; + + XLogRecPtr lsna = PG_GETARG_LSN(0); + XLogRecPtr lsnb = PG_GETARG_LSN(1); + + delta = (lsnb - lsna); + + Assert(delta >= 0); + + PG_RETURN_FLOAT8(delta); +} + +/* + * Compute distance between two macaddr values. + * + * mac addresses are treated as 6 unsigned chars, so do the same thing we + * already do for UUID values. + */ +Datum +brin_minmax_multi_distance_macaddr(PG_FUNCTION_ARGS) +{ + double delta; + + macaddr *a = PG_GETARG_MACADDR_P(0); + macaddr *b = PG_GETARG_MACADDR_P(1); + + delta = ((double)b->f - (double)a->f); + delta /= 256; + + delta += ((double)b->e - (double)a->e); + delta /= 256; + + delta += ((double)b->d - (double)a->d); + delta /= 256; + + delta += ((double)b->c - (double)a->c); + delta /= 256; + + delta += ((double)b->b - (double)a->b); + delta /= 256; + + delta += ((double)b->a - (double)a->a); + delta /= 256; + + Assert(delta >= 0); + + PG_RETURN_FLOAT8(delta); +} + +/* + * Compute distance between two macaddr8 values. + * + * macaddr8 addresses are 8 unsigned chars, so do the same thing we + * already do for UUID values. + */ +Datum +brin_minmax_multi_distance_macaddr8(PG_FUNCTION_ARGS) +{ + double delta; + + macaddr8 *a = PG_GETARG_MACADDR8_P(0); + macaddr8 *b = PG_GETARG_MACADDR8_P(1); + + delta = ((double)b->h - (double)a->h); + delta /= 256; + + delta += ((double)b->g - (double)a->g); + delta /= 256; + + delta += ((double)b->f - (double)a->f); + delta /= 256; + + delta += ((double)b->e - (double)a->e); + delta /= 256; + + delta += ((double)b->d - (double)a->d); + delta /= 256; + + delta += ((double)b->c - (double)a->c); + delta /= 256; + + delta += ((double)b->b - (double)a->b); + delta /= 256; + + delta += ((double)b->a - (double)a->a); + delta /= 256; + + Assert(delta >= 0); + + PG_RETURN_FLOAT8(delta); +} + +/* + * Compute distance between two inet values. + * + * The distance is defined as difference between 32-bit/128-bit values, + * depending on the IP version. The distance is computed by subtracting + * the bytes and normalizing it to [0,1] range for each IP family. + * Addresses from difference families are consider to be in maximum + * distance, which is 1.0. + * + * XXX Does this need to consider the mask (bits)? For now it's ignored. + */ +Datum +brin_minmax_multi_distance_inet(PG_FUNCTION_ARGS) +{ + double delta; + int i; + int len; + unsigned char *addra, + *addrb; + + inet *ipa = PG_GETARG_INET_PP(0); + inet *ipb = PG_GETARG_INET_PP(1); + + /* + * If the addresses are from different families, consider them to be + * in maximal possible distance (which is 1.0). + */ + if (ip_family(ipa) != ip_family(ipb)) + return 1.0; + + /* ipv4 or ipv6 */ + if (ip_family(ipa) == PGSQL_AF_INET) + len = 4; + else + len = 16; /* NS_IN6ADDRSZ */ + + addra = ip_addr(ipa); + addrb = ip_addr(ipb); + + delta = 0; + for (i = len-1; i >= 0; i--) + { + delta += (double)addrb[i] - (double)addra[i]; + delta /= 256; + } + + Assert((delta >= 0) && (delta <= 1)); + + PG_RETURN_FLOAT8(delta); +} + +static void +brin_minmax_multi_serialize(Datum src, Datum *dst) +{ + Ranges *ranges = (Ranges *) DatumGetPointer(src); + SerializedRanges *s = range_serialize(ranges); + dst[0] = PointerGetDatum(s); +} + +static int +brin_minmax_multi_get_values(BrinDesc *bdesc, MinMaxOptions *opts) +{ + return MinMaxGetValuesPerRange(opts); +} + +/* + * 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 min/max range 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_minmax_multi_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_USED_FOR_ASSERTS_ONLY = PG_GETARG_DATUM(3); + MinMaxOptions *opts = (MinMaxOptions *) PG_GET_OPCLASS_OPTIONS(); + Oid colloid = PG_GET_COLLATION(); + bool modified = false; + Form_pg_attribute attr; + AttrNumber attno; + Ranges *ranges; + SerializedRanges *serialized = NULL; + + Assert(!isnull); + + attno = column->bv_attno; + attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1); + + /* use the already deserialized value, is possible */ + ranges = (Ranges *) DatumGetPointer(column->bv_mem_value); + + /* + * If this is the first non-null value, we need to initialize the range + * list. Otherwise just extract the existing range list from BrinValues. + */ + if (column->bv_allnulls) + { + MemoryContext oldctx; + + oldctx = MemoryContextSwitchTo(column->bv_context); + + ranges = minmax_multi_init(brin_minmax_multi_get_values(bdesc, opts)); + ranges->typid = attr->atttypid; + + MemoryContextSwitchTo(oldctx); + + column->bv_allnulls = false; + modified = true; + + column->bv_mem_value = PointerGetDatum(ranges); + column->bv_serialize = brin_minmax_multi_serialize; + } + else if (!ranges) + { + MemoryContext oldctx; + + oldctx = MemoryContextSwitchTo(column->bv_context); + + serialized = (SerializedRanges *) PG_DETOAST_DATUM(column->bv_values[0]); + ranges = range_deserialize(serialized); + + column->bv_mem_value = PointerGetDatum(ranges); + column->bv_serialize = brin_minmax_multi_serialize; + + MemoryContextSwitchTo(oldctx); + } + + /* + * Try to add the new value to the range. We need to update the modified + * flag, so that we serialize the correct value. + */ + modified |= range_add_value(bdesc, colloid, attno, attr, ranges, newval); + + + PG_RETURN_BOOL(modified); +} + +/* + * Given an index tuple corresponding to a certain page range and a scan key, + * return whether the scan key is consistent with the index tuple's min/max + * values. Return true if so, false otherwise. + */ +Datum +brin_minmax_multi_consistent(PG_FUNCTION_ARGS) +{ + BrinDesc *bdesc = (BrinDesc *) PG_GETARG_POINTER(0); + BrinValues *column = (BrinValues *) PG_GETARG_POINTER(1); + ScanKey *keys = (ScanKey *) PG_GETARG_POINTER(2); + int nkeys = PG_GETARG_INT32(3); + // MinMaxOptions *opts = (MinMaxOptions *) PG_GET_OPCLASS_OPTIONS(); + Oid colloid = PG_GET_COLLATION(), + subtype; + AttrNumber attno; + Datum value; + FmgrInfo *finfo; + SerializedRanges *serialized; + Ranges *ranges; + int keyno; + int rangeno; + int i; + + attno = column->bv_attno; + + serialized = (SerializedRanges *) PG_DETOAST_DATUM(column->bv_values[0]); + ranges = range_deserialize(serialized); + + /* inspect the ranges, and for each one evaluate the scan keys */ + for (rangeno = 0; rangeno < ranges->nranges; rangeno++) + { + Datum minval = ranges->values[2*rangeno]; + Datum maxval = ranges->values[2*rangeno+1]; + + /* assume the range is matching, and we'll try to prove otherwise */ + bool matching = true; + + for (keyno = 0; keyno < nkeys; keyno++) + { + Datum matches; + ScanKey key = keys[keyno]; + + /* NULL keys are handled and filtered-out in bringetbitmap */ + Assert(!(key->sk_flags & SK_ISNULL)); + + attno = key->sk_attno; + subtype = key->sk_subtype; + value = key->sk_argument; + switch (key->sk_strategy) + { + case BTLessStrategyNumber: + case BTLessEqualStrategyNumber: + finfo = minmax_multi_get_strategy_procinfo(bdesc, attno, subtype, + key->sk_strategy); + /* first value from the array */ + matches = FunctionCall2Coll(finfo, colloid, minval, value); + break; + + case BTEqualStrategyNumber: + { + Datum compar; + FmgrInfo *cmpFn; + + /* by default this range does not match */ + matches = false; + + /* + * Otherwise, need to compare the new value with boundaries of all + * the ranges. First check if it's less than the absolute minimum, + * which is the first value in the array. + */ + cmpFn = minmax_multi_get_strategy_procinfo(bdesc, attno, subtype, + BTLessStrategyNumber); + compar = FunctionCall2Coll(cmpFn, colloid, value, minval); + + /* smaller than the smallest value in this range */ + if (DatumGetBool(compar)) + break; + + cmpFn = minmax_multi_get_strategy_procinfo(bdesc, attno, subtype, + BTGreaterStrategyNumber); + compar = FunctionCall2Coll(cmpFn, colloid, value, maxval); + + /* larger than the largest value in this range */ + if (DatumGetBool(compar)) + break; + + /* haven't managed to eliminate this range, so consider it matching */ + matches = true; + + break; + } + case BTGreaterEqualStrategyNumber: + case BTGreaterStrategyNumber: + finfo = minmax_multi_get_strategy_procinfo(bdesc, attno, subtype, + key->sk_strategy); + /* last value from the array */ + matches = FunctionCall2Coll(finfo, colloid, maxval, value); + break; + + default: + /* shouldn't happen */ + elog(ERROR, "invalid strategy number %d", key->sk_strategy); + matches = 0; + break; + } + + /* the range has to match all the scan keys */ + matching &= DatumGetBool(matches); + + /* once we find a non-matching key, we're done */ + if (! matching) + break; + } + + /* have we found a range matching all scan keys? if yes, we're + * done */ + if (matching) + PG_RETURN_DATUM(BoolGetDatum(true)); + } + + /* and now inspect the values */ + for (i = 0; i < ranges->nvalues; i++) + { + Datum val = ranges->values[2*ranges->nranges + i]; + + /* assume the range is matching, and we'll try to prove otherwise */ + bool matching = true; + + for (keyno = 0; keyno < nkeys; keyno++) + { + Datum matches; + ScanKey key = keys[keyno]; + + /* we've already dealt with NULL keys at the beginning */ + if (key->sk_flags & SK_ISNULL) + continue; + + attno = key->sk_attno; + subtype = key->sk_subtype; + value = key->sk_argument; + switch (key->sk_strategy) + { + case BTLessStrategyNumber: + case BTLessEqualStrategyNumber: + case BTEqualStrategyNumber: + case BTGreaterEqualStrategyNumber: + case BTGreaterStrategyNumber: + + finfo = minmax_multi_get_strategy_procinfo(bdesc, attno, subtype, + key->sk_strategy); + matches = FunctionCall2Coll(finfo, colloid, val, value); + break; + + default: + /* shouldn't happen */ + elog(ERROR, "invalid strategy number %d", key->sk_strategy); + matches = 0; + break; + } + + /* the range has to match all the scan keys */ + matching &= DatumGetBool(matches); + + /* once we find a non-matching key, we're done */ + if (! matching) + break; + } + + /* have we found a range matching all scan keys? if yes, we're + * done */ + if (matching) + PG_RETURN_DATUM(BoolGetDatum(true)); + } + + PG_RETURN_DATUM(BoolGetDatum(false)); +} + +/* + * 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_minmax_multi_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); + // MinMaxOptions *opts = (MinMaxOptions *) PG_GET_OPCLASS_OPTIONS(); + Oid colloid = PG_GET_COLLATION(); + SerializedRanges *serialized_a; + SerializedRanges *serialized_b; + Ranges *ranges_a; + Ranges *ranges_b; + AttrNumber attno; + Form_pg_attribute attr; + CombineRange *cranges; + int ncranges; + FmgrInfo *cmpFn, + *distanceFn; + DistanceValue *distances; + MemoryContext ctx; + MemoryContext oldctx; + + Assert(col_a->bv_attno == col_b->bv_attno); + Assert(!col_a->bv_allnulls && !col_b->bv_allnulls); + + attno = col_a->bv_attno; + attr = TupleDescAttr(bdesc->bd_tupdesc, attno - 1); + + serialized_a = (SerializedRanges *) PG_DETOAST_DATUM(col_a->bv_values[0]); + serialized_b = (SerializedRanges *) PG_DETOAST_DATUM(col_b->bv_values[0]); + + ranges_a = range_deserialize(serialized_a); + ranges_b = range_deserialize(serialized_b); + + /* make sure neither of the ranges is NULL */ + Assert(ranges_a && ranges_b); + + ncranges = (ranges_a->nranges + ranges_a->nvalues) + + (ranges_b->nranges + ranges_b->nvalues); + + /* + * The distanceFn calls (which may internally call e.g. numeric_le) may + * allocate quite a bit of memory, and we must not leak it. Otherwise + * we'd have problems e.g. when building indexes. So we create a local + * memory context and make sure we free the memory before leaving this + * function (not after every call). + */ + ctx = AllocSetContextCreate(CurrentMemoryContext, + "minmax-multi context", + ALLOCSET_DEFAULT_SIZES); + + oldctx = MemoryContextSwitchTo(ctx); + + /* allocate and fill */ + cranges = (CombineRange *)palloc0(ncranges * sizeof(CombineRange)); + + /* fill the combine ranges with entries for the first range */ + fill_combine_ranges(cranges, ranges_a->nranges + ranges_a->nvalues, + ranges_a); + + /* and now add combine ranges for the second range */ + fill_combine_ranges(&cranges[ranges_a->nranges + ranges_a->nvalues], + ranges_b->nranges + ranges_b->nvalues, + ranges_b); + + cmpFn = minmax_multi_get_strategy_procinfo(bdesc, attno, attr->atttypid, + BTLessStrategyNumber); + + /* sort the combine ranges */ + sort_combine_ranges(cmpFn, colloid, cranges, ncranges); + + /* + * We've merged two different lists of ranges, so some of them may be + * overlapping. So walk through them and merge them. + */ + ncranges = merge_combine_ranges(cmpFn, colloid, cranges, ncranges); + + /* check that the combine ranges are correct (no overlaps, ordering) */ + AssertValidCombineRanges(bdesc, colloid, attno, attr, cranges, ncranges); + + /* build array of gap distances and sort them in ascending order */ + distanceFn = minmax_multi_get_procinfo(bdesc, attno, PROCNUM_DISTANCE); + distances = build_distances(distanceFn, colloid, cranges, ncranges); + + /* + * See how many values would be needed to store the current ranges, and if + * needed combine as many off them to get below the maxvalues threshold. + * The collapsed ranges will be stored as a single value. + * + * XXX The maxvalues may be different, so perhaps use Max? + */ + ncranges = reduce_combine_ranges(cranges, ncranges, distances, + ranges_a->maxvalues); + + /* update the first range summary */ + store_combine_ranges(ranges_a, cranges, ncranges); + + MemoryContextSwitchTo(oldctx); + MemoryContextDelete(ctx); + + /* cleanup and update the serialized value */ + pfree(serialized_a); + col_a->bv_values[0] = PointerGetDatum(range_serialize(ranges_a)); + + PG_RETURN_VOID(); +} + +/* + * Cache and return minmax multi opclass support procedure + * + * Return the procedure corresponding to the given function support number + * or null if it is not exists. + */ +static FmgrInfo * +minmax_multi_get_procinfo(BrinDesc *bdesc, uint16 attno, uint16 procnum) +{ + MinmaxMultiOpaque *opaque; + uint16 basenum = procnum - PROCNUM_BASE; + + /* + * We cache these in the opaque struct, to avoid repetitive syscache + * lookups. + */ + opaque = (MinmaxMultiOpaque *) 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 for the given strategy. + * + * Note: this function mirrors minmax_multi_get_strategy_procinfo; see notes + * there. If changes are made here, see that function too. + */ +static FmgrInfo * +minmax_multi_get_strategy_procinfo(BrinDesc *bdesc, uint16 attno, Oid subtype, + uint16 strategynum) +{ + MinmaxMultiOpaque *opaque; + + Assert(strategynum >= 1 && + strategynum <= BTMaxStrategyNumber); + + opaque = (MinmaxMultiOpaque *) bdesc->bd_info[attno - 1]->oi_opaque; + + /* + * We cache the procedures for the previous subtype in the opaque struct, + * to avoid repetitive syscache lookups. If the subtype changed, + * invalidate all the cached entries. + */ + if (opaque->cached_subtype != subtype) + { + uint16 i; + + for (i = 1; i <= BTMaxStrategyNumber; 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 = TupleDescAttr(bdesc->bd_tupdesc, 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]; +} + +Datum +brin_minmax_multi_options(PG_FUNCTION_ARGS) +{ + local_relopts *relopts = (local_relopts *) PG_GETARG_POINTER(0); + + init_local_reloptions(relopts, sizeof(MinMaxOptions)); + + add_local_int_reloption(relopts, "values_per_range", "desc", + 32, 16, 256, offsetof(MinMaxOptions, valuesPerRange)); + + PG_RETURN_VOID(); +} + +/* + * brin_minmax_multi_summary_in + * - input routine for type brin_minmax_multi_summary. + * + * brin_minmax_multi_summary is only used internally to represent summaries + * in BRIN minmax-multi indexes, so it has no operations of its own, and we + * disallow input too. + */ +Datum +brin_minmax_multi_summary_in(PG_FUNCTION_ARGS) +{ + /* + * brin_minmax_multi_summary stores the data in binary form and parsing + * text input is not needed, so disallow this. + */ + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("cannot accept a value of type %s", "brin_minmax_multi_summary"))); + + PG_RETURN_VOID(); /* keep compiler quiet */ +} + + +/* + * brin_minmax_multi_summary_out + * - output routine for type brin_minmax_multi_summary. + * + * BRIN minmax-multi summaries are serialized into a bytea value, but we + * want to output something nicer humans can understand. + */ +Datum +brin_minmax_multi_summary_out(PG_FUNCTION_ARGS) +{ + int i; + int idx; + SerializedRanges *ranges; + Ranges *ranges_deserialized; + StringInfoData str; + bool isvarlena; + Oid outfunc; + FmgrInfo fmgrinfo; + ArrayBuildState *astate_values = NULL; + + initStringInfo(&str); + appendStringInfoChar(&str, '{'); + + /* + * Detoast to get value with full 4B header (can't be stored in a toast + * table, but can use 1B header). + */ + ranges = (SerializedRanges *) PG_DETOAST_DATUM(PG_GETARG_BYTEA_PP(0)); + + /* lookup output func for the type */ + getTypeOutputInfo(ranges->typid, &outfunc, &isvarlena); + fmgr_info(outfunc, &fmgrinfo); + + /* deserialize the range info easy-to-process pieces */ + ranges_deserialized = range_deserialize(ranges); + + appendStringInfo(&str, "nranges: %u nvalues: %u maxvalues: %u", + ranges_deserialized->nranges, + ranges_deserialized->nvalues, + ranges_deserialized->maxvalues); + + /* serialize ranges */ + idx = 0; + for (i = 0; i < ranges_deserialized->nranges; i++) + { + Datum a, b; + text *c; + StringInfoData str; + + initStringInfo(&str); + + a = FunctionCall1(&fmgrinfo, ranges_deserialized->values[idx++]); + b = FunctionCall1(&fmgrinfo, ranges_deserialized->values[idx++]); + + appendStringInfo(&str, "%s ... %s", + DatumGetPointer(a), + DatumGetPointer(b)); + + c = cstring_to_text(str.data); + + astate_values = accumArrayResult(astate_values, + PointerGetDatum(c), + false, + TEXTOID, + CurrentMemoryContext); + } + + if (ranges_deserialized->nranges > 0) + { + Oid typoutput; + bool typIsVarlena; + Datum val; + char *extval; + + getTypeOutputInfo(ANYARRAYOID, &typoutput, &typIsVarlena); + + val = PointerGetDatum(makeArrayResult(astate_values, CurrentMemoryContext)); + + extval = OidOutputFunctionCall(typoutput, val); + + appendStringInfo(&str, " ranges: %s", extval); + } + + /* serialize individual values */ + astate_values = NULL; + + for (i = 0; i < ranges_deserialized->nvalues; i++) + { + Datum a; + text *b; + StringInfoData str; + + initStringInfo(&str); + + a = FunctionCall1(&fmgrinfo, ranges_deserialized->values[idx++]); + + appendStringInfo(&str, "%s", DatumGetPointer(a)); + + b = cstring_to_text(str.data); + + astate_values = accumArrayResult(astate_values, + PointerGetDatum(b), + false, + TEXTOID, + CurrentMemoryContext); + } + + if (ranges_deserialized->nvalues > 0) + { + Oid typoutput; + bool typIsVarlena; + Datum val; + char *extval; + + getTypeOutputInfo(ANYARRAYOID, &typoutput, &typIsVarlena); + + val = PointerGetDatum(makeArrayResult(astate_values, CurrentMemoryContext)); + + extval = OidOutputFunctionCall(typoutput, val); + + appendStringInfo(&str, " values: %s", extval); + } + + + appendStringInfoChar(&str, '}'); + + PG_RETURN_CSTRING(str.data); +} + +/* + * brin_minmax_multi_summary_recv + * - binary input routine for type brin_minmax_multi_summary. + */ +Datum +brin_minmax_multi_summary_recv(PG_FUNCTION_ARGS) +{ + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("cannot accept a value of type %s", "brin_minmax_multi_summary"))); + + PG_RETURN_VOID(); /* keep compiler quiet */ +} + +/* + * brin_minmax_multi_summary_send + * - binary output routine for type brin_minmax_multi_summary. + * + * BRIN minmax-multi summaries are serialized in a bytea value (although + * the type is named differently), so let's just send that. + */ +Datum +brin_minmax_multi_summary_send(PG_FUNCTION_ARGS) +{ + return byteasend(fcinfo); +} diff --git a/src/backend/access/brin/brin_tuple.c b/src/backend/access/brin/brin_tuple.c index a7eb1c9473..df820db029 100644 --- a/src/backend/access/brin/brin_tuple.c +++ b/src/backend/access/brin/brin_tuple.c @@ -159,6 +159,14 @@ brin_form_tuple(BrinDesc *brdesc, BlockNumber blkno, BrinMemTuple *tuple, if (tuple->bt_columns[keyno].bv_hasnulls) anynulls = true; + /* if needed, serialize the values before forming the on-disk tuple */ + if (tuple->bt_columns[keyno].bv_serialize) + { + tuple->bt_columns[keyno].bv_serialize( + tuple->bt_columns[keyno].bv_mem_value, + tuple->bt_columns[keyno].bv_values); + } + /* * Now obtain the values of each stored datum. Note that some values * might be toasted, and we cannot rely on the original heap values @@ -495,6 +503,11 @@ brin_memtuple_initialize(BrinMemTuple *dtuple, BrinDesc *brdesc) dtuple->bt_columns[i].bv_allnulls = true; dtuple->bt_columns[i].bv_hasnulls = false; dtuple->bt_columns[i].bv_values = (Datum *) currdatum; + + dtuple->bt_columns[i].bv_mem_value = PointerGetDatum(NULL); + dtuple->bt_columns[i].bv_serialize = NULL; + dtuple->bt_columns[i].bv_context = dtuple->bt_context; + currdatum += sizeof(Datum) * brdesc->bd_info[i]->oi_nstored; } @@ -574,6 +587,10 @@ brin_deform_tuple(BrinDesc *brdesc, BrinTuple *tuple, BrinMemTuple *dMemtuple) dtup->bt_columns[keyno].bv_hasnulls = hasnulls[keyno]; dtup->bt_columns[keyno].bv_allnulls = false; + + dtup->bt_columns[keyno].bv_mem_value = PointerGetDatum(NULL); + dtup->bt_columns[keyno].bv_serialize = NULL; + dtup->bt_columns[keyno].bv_context = dtup->bt_context; } MemoryContextSwitchTo(oldcxt); diff --git a/src/include/access/brin.h b/src/include/access/brin.h index 0e52d75457..9cd5fa9f62 100644 --- a/src/include/access/brin.h +++ b/src/include/access/brin.h @@ -24,6 +24,7 @@ typedef struct BrinOptions bool autosummarize; double nDistinctPerRange; /* number of distinct values per range */ double falsePositiveRate; /* false positive for bloom filter */ + int valuesPerRange; /* number of values per range */ } BrinOptions; diff --git a/src/include/access/brin_internal.h b/src/include/access/brin_internal.h index d114ac58cd..e7ce4d0209 100644 --- a/src/include/access/brin_internal.h +++ b/src/include/access/brin_internal.h @@ -62,6 +62,9 @@ typedef struct BrinDesc double bd_nDistinctPerRange; double bd_falsePositiveRange; + /* parameters for multi-minmax indexes */ + int bd_valuesPerRange; + /* per-column info; bd_tupdesc->natts entries long */ BrinOpcInfo *bd_info[FLEXIBLE_ARRAY_MEMBER]; } BrinDesc; diff --git a/src/include/access/brin_tuple.h b/src/include/access/brin_tuple.h index 5715bd58df..66a6c3c792 100644 --- a/src/include/access/brin_tuple.h +++ b/src/include/access/brin_tuple.h @@ -14,6 +14,7 @@ #include "access/brin_internal.h" #include "access/tupdesc.h" +typedef void (*brin_serialize_callback_type) (Datum src, Datum * dst); /* * A BRIN index stores one index tuple per page range. Each index tuple @@ -27,6 +28,9 @@ typedef struct BrinValues bool bv_hasnulls; /* are there any nulls in the page range? */ bool bv_allnulls; /* are all values nulls in the page range? */ Datum *bv_values; /* current accumulated values */ + Datum bv_mem_value; /* expanded accumulated values */ + MemoryContext bv_context; + brin_serialize_callback_type bv_serialize; } BrinValues; /* diff --git a/src/include/access/transam.h b/src/include/access/transam.h index e07dd83550..e2a04d9cb0 100644 --- a/src/include/access/transam.h +++ b/src/include/access/transam.h @@ -186,7 +186,7 @@ FullTransactionIdAdvance(FullTransactionId *dest) * ---------- */ #define FirstGenbkiObjectId 10000 -#define FirstBootstrapObjectId 12000 +#define FirstBootstrapObjectId 13000 #define FirstNormalObjectId 16384 /* diff --git a/src/include/catalog/pg_amop.dat b/src/include/catalog/pg_amop.dat index c48d07f8fc..791c755492 100644 --- a/src/include/catalog/pg_amop.dat +++ b/src/include/catalog/pg_amop.dat @@ -2009,6 +2009,152 @@ amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int4,int8)', amopmethod => 'brin' }, +# minmax multi integer + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int8,int8)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int8,int2)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int8,int4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int2,int2)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int2,int8)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int2,int4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int4,int4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int4,int2)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_multi_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int4,int8)', + amopmethod => 'brin' }, + # bloom integer { amopfamily => 'brin/integer_bloom_ops', amoplefttype => 'int8', @@ -2086,6 +2232,23 @@ amoprighttype => 'oid', amopstrategy => '5', amopopr => '>(oid,oid)', amopmethod => 'brin' }, +# minmax multi oid +{ amopfamily => 'brin/oid_minmax_multi_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '1', amopopr => '<(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_multi_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '2', amopopr => '<=(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_multi_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '3', amopopr => '=(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_multi_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '4', amopopr => '>=(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_multi_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '5', amopopr => '>(oid,oid)', + amopmethod => 'brin' }, + # bloom oid { amopfamily => 'brin/oid_bloom_ops', amoplefttype => 'oid', amoprighttype => 'oid', amopstrategy => '1', amopopr => '=(oid,oid)', @@ -2112,6 +2275,22 @@ { amopfamily => 'brin/tid_bloom_ops', amoplefttype => 'tid', amoprighttype => 'tid', amopstrategy => '1', amopopr => '=(tid,tid)', amopmethod => 'brin' }, +# minmax multi tid +{ amopfamily => 'brin/tid_minmax_multi_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '1', amopopr => '<(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_multi_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '2', amopopr => '<=(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_multi_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '3', amopopr => '=(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_multi_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '4', amopopr => '>=(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_multi_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '5', amopopr => '>(tid,tid)', + amopmethod => 'brin' }, # minmax float (float4, float8) @@ -2179,6 +2358,72 @@ amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float8,float8)', amopmethod => 'brin' }, +# minmax multi float (float4, float8) + +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float4,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '2', + amopopr => '<=(float4,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float4,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '4', + amopopr => '>=(float4,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float4,float4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float4,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '2', + amopopr => '<=(float4,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float4,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '4', + amopopr => '>=(float4,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float4,float8)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float8,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '2', + amopopr => '<=(float8,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float8,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '4', + amopopr => '>=(float8,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float8,float4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float8,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '2', + amopopr => '<=(float8,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float8,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '4', + amopopr => '>=(float8,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_multi_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float8,float8)', + amopmethod => 'brin' }, + # bloom float { amopfamily => 'brin/float_bloom_ops', amoplefttype => 'float4', amoprighttype => 'float4', amopstrategy => '1', amopopr => '=(float4,float4)', @@ -2210,6 +2455,23 @@ amoprighttype => 'macaddr', amopstrategy => '5', amopopr => '>(macaddr,macaddr)', amopmethod => 'brin' }, +# minmax multi macaddr +{ amopfamily => 'brin/macaddr_minmax_multi_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '1', + amopopr => '<(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_multi_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '2', + amopopr => '<=(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_multi_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '3', + amopopr => '=(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_multi_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '4', + amopopr => '>=(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_multi_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '5', + amopopr => '>(macaddr,macaddr)', amopmethod => 'brin' }, + # bloom macaddr { amopfamily => 'brin/macaddr_bloom_ops', amoplefttype => 'macaddr', amoprighttype => 'macaddr', amopstrategy => '1', @@ -2232,6 +2494,23 @@ amoprighttype => 'macaddr8', amopstrategy => '5', amopopr => '>(macaddr8,macaddr8)', amopmethod => 'brin' }, +# minmax multi macaddr8 +{ amopfamily => 'brin/macaddr8_minmax_multi_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '1', + amopopr => '<(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_multi_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '2', + amopopr => '<=(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_multi_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '3', + amopopr => '=(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_multi_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '4', + amopopr => '>=(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_multi_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '5', + amopopr => '>(macaddr8,macaddr8)', amopmethod => 'brin' }, + # bloom macaddr8 { amopfamily => 'brin/macaddr8_bloom_ops', amoplefttype => 'macaddr8', amoprighttype => 'macaddr8', amopstrategy => '1', @@ -2254,6 +2533,23 @@ amoprighttype => 'inet', amopstrategy => '5', amopopr => '>(inet,inet)', amopmethod => 'brin' }, +# minmax multi inet +{ amopfamily => 'brin/network_minmax_multi_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '1', amopopr => '<(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_multi_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '2', amopopr => '<=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_multi_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '3', amopopr => '=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_multi_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '4', amopopr => '>=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_multi_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '5', amopopr => '>(inet,inet)', + amopmethod => 'brin' }, + # bloom inet { amopfamily => 'brin/network_bloom_ops', amoplefttype => 'inet', amoprighttype => 'inet', amopstrategy => '1', amopopr => '=(inet,inet)', @@ -2318,6 +2614,23 @@ amoprighttype => 'time', amopstrategy => '5', amopopr => '>(time,time)', amopmethod => 'brin' }, +# minmax multi time without time zone +{ amopfamily => 'brin/time_minmax_multi_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '1', amopopr => '<(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_multi_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '2', amopopr => '<=(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_multi_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '3', amopopr => '=(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_multi_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '4', amopopr => '>=(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_multi_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '5', amopopr => '>(time,time)', + amopmethod => 'brin' }, + # bloom time without time zone { amopfamily => 'brin/time_bloom_ops', amoplefttype => 'time', amoprighttype => 'time', amopstrategy => '1', amopopr => '=(time,time)', @@ -2469,6 +2782,152 @@ amoprighttype => 'timestamptz', amopstrategy => '5', amopopr => '>(timestamptz,timestamptz)', amopmethod => 'brin' }, +# minmax multi datetime (date, timestamp, timestamptz) + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(timestamp,timestamp)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '1', amopopr => '<(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '3', amopopr => '=(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '5', amopopr => '>(timestamp,date)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(timestamp,timestamptz)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '1', amopopr => '<(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '3', amopopr => '=(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '5', amopopr => '>(date,date)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(date,timestamp)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(date,timestamptz)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '1', + amopopr => '<(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '2', + amopopr => '<=(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '3', + amopopr => '=(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '4', + amopopr => '>=(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '5', + amopopr => '>(timestamptz,date)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(timestamptz,timestamp)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_multi_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(timestamptz,timestamptz)', amopmethod => 'brin' }, + # bloom datetime (date, timestamp, timestamptz) { amopfamily => 'brin/datetime_bloom_ops', amoplefttype => 'timestamp', @@ -2524,6 +2983,23 @@ amoprighttype => 'interval', amopstrategy => '5', amopopr => '>(interval,interval)', amopmethod => 'brin' }, +# minmax multi interval +{ amopfamily => 'brin/interval_minmax_multi_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '1', + amopopr => '<(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_multi_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '2', + amopopr => '<=(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_multi_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '3', + amopopr => '=(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_multi_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '4', + amopopr => '>=(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_multi_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '5', + amopopr => '>(interval,interval)', amopmethod => 'brin' }, + # bloom interval { amopfamily => 'brin/interval_bloom_ops', amoplefttype => 'interval', amoprighttype => 'interval', amopstrategy => '1', @@ -2546,6 +3022,23 @@ amoprighttype => 'timetz', amopstrategy => '5', amopopr => '>(timetz,timetz)', amopmethod => 'brin' }, +# minmax multi time with time zone +{ amopfamily => 'brin/timetz_minmax_multi_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '1', amopopr => '<(timetz,timetz)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_multi_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '2', + amopopr => '<=(timetz,timetz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_multi_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '3', amopopr => '=(timetz,timetz)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_multi_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '4', + amopopr => '>=(timetz,timetz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_multi_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '5', amopopr => '>(timetz,timetz)', + amopmethod => 'brin' }, + # bloom time with time zone { amopfamily => 'brin/timetz_bloom_ops', amoplefttype => 'timetz', amoprighttype => 'timetz', amopstrategy => '1', amopopr => '=(timetz,timetz)', @@ -2602,6 +3095,23 @@ amoprighttype => 'numeric', amopstrategy => '5', amopopr => '>(numeric,numeric)', amopmethod => 'brin' }, +# minmax multi numeric +{ amopfamily => 'brin/numeric_minmax_multi_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '1', + amopopr => '<(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_multi_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '2', + amopopr => '<=(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_multi_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '3', + amopopr => '=(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_multi_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '4', + amopopr => '>=(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_multi_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '5', + amopopr => '>(numeric,numeric)', amopmethod => 'brin' }, + # bloom numeric { amopfamily => 'brin/numeric_bloom_ops', amoplefttype => 'numeric', amoprighttype => 'numeric', amopstrategy => '1', @@ -2624,6 +3134,23 @@ amoprighttype => 'uuid', amopstrategy => '5', amopopr => '>(uuid,uuid)', amopmethod => 'brin' }, +# minmax multi uuid +{ amopfamily => 'brin/uuid_minmax_multi_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '1', amopopr => '<(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_multi_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '2', amopopr => '<=(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_multi_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '3', amopopr => '=(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_multi_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '4', amopopr => '>=(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_multi_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '5', amopopr => '>(uuid,uuid)', + amopmethod => 'brin' }, + # bloom uuid { amopfamily => 'brin/uuid_bloom_ops', amoplefttype => 'uuid', amoprighttype => 'uuid', amopstrategy => '1', amopopr => '=(uuid,uuid)', @@ -2690,6 +3217,23 @@ amoprighttype => 'pg_lsn', amopstrategy => '5', amopopr => '>(pg_lsn,pg_lsn)', amopmethod => 'brin' }, +# minmax multi pg_lsn +{ amopfamily => 'brin/pg_lsn_minmax_multi_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '<(pg_lsn,pg_lsn)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_multi_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '2', + amopopr => '<=(pg_lsn,pg_lsn)', amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_multi_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '3', amopopr => '=(pg_lsn,pg_lsn)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_multi_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '4', + amopopr => '>=(pg_lsn,pg_lsn)', amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_multi_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '5', amopopr => '>(pg_lsn,pg_lsn)', + amopmethod => 'brin' }, + # bloom pg_lsn { amopfamily => 'brin/pg_lsn_bloom_ops', amoplefttype => 'pg_lsn', amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '=(pg_lsn,pg_lsn)', diff --git a/src/include/catalog/pg_amproc.dat b/src/include/catalog/pg_amproc.dat index d9308c1337..41bd834770 100644 --- a/src/include/catalog/pg_amproc.dat +++ b/src/include/catalog/pg_amproc.dat @@ -982,6 +982,152 @@ { amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi integer: int2, int4, int8 +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int8' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int8' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int8' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int2' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int8' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int4' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int4' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int8' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/integer_minmax_multi_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int4' }, + # bloom integer: int2, int4, int8 { amprocfamily => 'brin/integer_bloom_ops', amproclefttype => 'int8', amprocrighttype => 'int8', amprocnum => '1', @@ -1077,6 +1223,23 @@ { amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid', amprocrighttype => 'oid', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi oid +{ amprocfamily => 'brin/oid_minmax_multi_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '1', amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/oid_minmax_multi_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/oid_minmax_multi_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/oid_minmax_multi_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/oid_minmax_multi_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/oid_minmax_multi_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '11', amproc => 'brin_minmax_multi_distance_int4' }, + # bloom oid { amprocfamily => 'brin/oid_bloom_ops', amproclefttype => 'oid', amprocrighttype => 'oid', amprocnum => '1', amproc => 'brin_bloom_opcinfo' }, @@ -1123,6 +1286,23 @@ { amprocfamily => 'brin/tid_bloom_ops', amproclefttype => 'tid', amprocrighttype => 'tid', amprocnum => '11', amproc => 'hashtid' }, +# minmax multi tid +{ amprocfamily => 'brin/tid_minmax_multi_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '1', amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/tid_minmax_multi_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/tid_minmax_multi_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/tid_minmax_multi_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/tid_minmax_multi_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/tid_minmax_multi_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '11', amproc => 'brin_minmax_multi_distance_tid' }, + # minmax float { amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', amprocrighttype => 'float4', amprocnum => '1', @@ -1173,6 +1353,80 @@ amprocrighttype => 'float4', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi float +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float4' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/float_minmax_multi_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, + # bloom float { amprocfamily => 'brin/float_bloom_ops', amproclefttype => 'float4', amprocrighttype => 'float4', amprocnum => '1', @@ -1226,6 +1480,26 @@ amprocrighttype => 'macaddr', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi macaddr +{ amprocfamily => 'brin/macaddr_minmax_multi_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/macaddr_minmax_multi_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/macaddr_minmax_multi_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/macaddr_minmax_multi_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/macaddr_minmax_multi_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/macaddr_minmax_multi_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_macaddr' }, + # bloom macaddr { amprocfamily => 'brin/macaddr_bloom_ops', amproclefttype => 'macaddr', amprocrighttype => 'macaddr', amprocnum => '1', @@ -1260,6 +1534,26 @@ amprocrighttype => 'macaddr8', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi macaddr8 +{ amprocfamily => 'brin/macaddr8_minmax_multi_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/macaddr8_minmax_multi_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/macaddr8_minmax_multi_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/macaddr8_minmax_multi_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/macaddr8_minmax_multi_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/macaddr8_minmax_multi_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_macaddr8' }, + # bloom macaddr8 { amprocfamily => 'brin/macaddr8_bloom_ops', amproclefttype => 'macaddr8', amprocrighttype => 'macaddr8', amprocnum => '1', @@ -1293,6 +1587,26 @@ { amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet', amprocrighttype => 'inet', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi inet +{ amprocfamily => 'brin/network_minmax_multi_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/network_minmax_multi_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/network_minmax_multi_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/network_minmax_multi_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/network_minmax_multi_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/network_minmax_multi_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_inet' }, + # bloom inet { amprocfamily => 'brin/network_bloom_ops', amproclefttype => 'inet', amprocrighttype => 'inet', amprocnum => '1', @@ -1378,6 +1692,25 @@ { amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time', amprocrighttype => 'time', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi time without time zone +{ amprocfamily => 'brin/time_minmax_multi_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/time_minmax_multi_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/time_minmax_multi_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/time_minmax_multi_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '4', amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/time_minmax_multi_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/time_minmax_multi_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_time' }, + # bloom time without time zone { amprocfamily => 'brin/time_bloom_ops', amproclefttype => 'time', amprocrighttype => 'time', amprocnum => '1', @@ -1503,6 +1836,170 @@ amprocrighttype => 'timestamptz', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi datetime (date, timestamp, timestamptz) +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/datetime_minmax_multi_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_float8' }, + # bloom datetime (date, timestamp, timestamptz) { amprocfamily => 'brin/datetime_bloom_ops', amproclefttype => 'timestamp', amprocrighttype => 'timestamp', amprocnum => '1', @@ -1573,6 +2070,26 @@ amprocrighttype => 'interval', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi interval +{ amprocfamily => 'brin/interval_minmax_multi_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/interval_minmax_multi_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/interval_minmax_multi_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/interval_minmax_multi_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/interval_minmax_multi_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/interval_minmax_multi_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_interval' }, + # bloom interval { amprocfamily => 'brin/interval_bloom_ops', amproclefttype => 'interval', amprocrighttype => 'interval', amprocnum => '1', @@ -1607,6 +2124,26 @@ amprocrighttype => 'timetz', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi time with time zone +{ amprocfamily => 'brin/timetz_minmax_multi_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/timetz_minmax_multi_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/timetz_minmax_multi_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/timetz_minmax_multi_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/timetz_minmax_multi_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/timetz_minmax_multi_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_timetz' }, + # bloom time with time zone { amprocfamily => 'brin/timetz_bloom_ops', amproclefttype => 'timetz', amprocrighttype => 'timetz', amprocnum => '1', @@ -1667,6 +2204,26 @@ amprocrighttype => 'numeric', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi numeric +{ amprocfamily => 'brin/numeric_minmax_multi_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/numeric_minmax_multi_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/numeric_minmax_multi_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/numeric_minmax_multi_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/numeric_minmax_multi_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/numeric_minmax_multi_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_numeric' }, + # bloom numeric { amprocfamily => 'brin/numeric_bloom_ops', amproclefttype => 'numeric', amprocrighttype => 'numeric', amprocnum => '1', @@ -1698,7 +2255,28 @@ amprocrighttype => 'uuid', amprocnum => '3', amproc => 'brin_minmax_consistent' }, { amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid', - amprocrighttype => 'uuid', amprocnum => '4', amproc => 'brin_minmax_union' }, + amprocrighttype => 'uuid', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax multi uuid +{ amprocfamily => 'brin/uuid_minmax_multi_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/uuid_minmax_multi_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/uuid_minmax_multi_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/uuid_minmax_multi_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/uuid_minmax_multi_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/uuid_minmax_multi_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_uuid' }, # bloom uuid { amprocfamily => 'brin/uuid_bloom_ops', amproclefttype => 'uuid', @@ -1754,6 +2332,26 @@ amprocrighttype => 'pg_lsn', amprocnum => '4', amproc => 'brin_minmax_union' }, +# minmax multi pg_lsn +{ amprocfamily => 'brin/pg_lsn_minmax_multi_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '1', + amproc => 'brin_minmax_multi_opcinfo' }, +{ amprocfamily => 'brin/pg_lsn_minmax_multi_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '2', + amproc => 'brin_minmax_multi_add_value' }, +{ amprocfamily => 'brin/pg_lsn_minmax_multi_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '3', + amproc => 'brin_minmax_multi_consistent' }, +{ amprocfamily => 'brin/pg_lsn_minmax_multi_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '4', + amproc => 'brin_minmax_multi_union' }, +{ amprocfamily => 'brin/pg_lsn_minmax_multi_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '5', + amproc => 'brin_minmax_multi_options' }, +{ amprocfamily => 'brin/pg_lsn_minmax_multi_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '11', + amproc => 'brin_minmax_multi_distance_pg_lsn' }, + # bloom pg_lsn { amprocfamily => 'brin/pg_lsn_bloom_ops', amproclefttype => 'pg_lsn', amprocrighttype => 'pg_lsn', amprocnum => '1', diff --git a/src/include/catalog/pg_opclass.dat b/src/include/catalog/pg_opclass.dat index b9e96bf27e..e0e9651cb1 100644 --- a/src/include/catalog/pg_opclass.dat +++ b/src/include/catalog/pg_opclass.dat @@ -283,18 +283,27 @@ { opcmethod => 'brin', opcname => 'int8_minmax_ops', opcfamily => 'brin/integer_minmax_ops', opcintype => 'int8', opckeytype => 'int8' }, +{ opcmethod => 'brin', opcname => 'int8_minmax_multi_ops', + opcfamily => 'brin/integer_minmax_multi_ops', opcintype => 'int8', + opckeytype => 'int8', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'int8_bloom_ops', opcfamily => 'brin/integer_bloom_ops', opcintype => 'int8', opckeytype => 'int8', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'int2_minmax_ops', opcfamily => 'brin/integer_minmax_ops', opcintype => 'int2', opckeytype => 'int2' }, +{ opcmethod => 'brin', opcname => 'int2_minmax_multi_ops', + opcfamily => 'brin/integer_minmax_multi_ops', opcintype => 'int2', + opckeytype => 'int2', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'int2_bloom_ops', opcfamily => 'brin/integer_bloom_ops', opcintype => 'int2', opckeytype => 'int2', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'int4_minmax_ops', opcfamily => 'brin/integer_minmax_ops', opcintype => 'int4', opckeytype => 'int4' }, +{ opcmethod => 'brin', opcname => 'int4_minmax_multi_ops', + opcfamily => 'brin/integer_minmax_multi_ops', opcintype => 'int4', + opckeytype => 'int4', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'int4_bloom_ops', opcfamily => 'brin/integer_bloom_ops', opcintype => 'int4', opckeytype => 'int4', opcdefault => 'f' }, @@ -306,6 +315,9 @@ opckeytype => 'text', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'oid_minmax_ops', opcfamily => 'brin/oid_minmax_ops', opcintype => 'oid', opckeytype => 'oid' }, +{ opcmethod => 'brin', opcname => 'oid_minmax_multi_ops', + opcfamily => 'brin/oid_minmax_multi_ops', opcintype => 'oid', + opckeytype => 'oid', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'oid_bloom_ops', opcfamily => 'brin/oid_bloom_ops', opcintype => 'oid', opckeytype => 'oid', opcdefault => 'f' }, @@ -314,33 +326,51 @@ { opcmethod => 'brin', opcname => 'tid_bloom_ops', opcfamily => 'brin/tid_bloom_ops', opcintype => 'tid', opckeytype => 'tid', opcdefault => 'f'}, +{ opcmethod => 'brin', opcname => 'tid_minmax_multi_ops', + opcfamily => 'brin/tid_minmax_multi_ops', opcintype => 'tid', + opckeytype => 'tid', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'float4_minmax_ops', opcfamily => 'brin/float_minmax_ops', opcintype => 'float4', opckeytype => 'float4' }, +{ opcmethod => 'brin', opcname => 'float4_minmax_multi_ops', + opcfamily => 'brin/float_minmax_multi_ops', opcintype => 'float4', + opckeytype => 'float4', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'float4_bloom_ops', opcfamily => 'brin/float_bloom_ops', opcintype => 'float4', opckeytype => 'float4', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'float8_minmax_ops', opcfamily => 'brin/float_minmax_ops', opcintype => 'float8', opckeytype => 'float8' }, +{ opcmethod => 'brin', opcname => 'float8_minmax_multi_ops', + opcfamily => 'brin/float_minmax_multi_ops', opcintype => 'float8', + opckeytype => 'float8', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'float8_bloom_ops', opcfamily => 'brin/float_bloom_ops', opcintype => 'float8', opckeytype => 'float8', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'macaddr_minmax_ops', opcfamily => 'brin/macaddr_minmax_ops', opcintype => 'macaddr', opckeytype => 'macaddr' }, +{ opcmethod => 'brin', opcname => 'macaddr_minmax_multi_ops', + opcfamily => 'brin/macaddr_minmax_multi_ops', opcintype => 'macaddr', + opckeytype => 'macaddr', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'macaddr_bloom_ops', opcfamily => 'brin/macaddr_bloom_ops', opcintype => 'macaddr', opckeytype => 'macaddr', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'macaddr8_minmax_ops', opcfamily => 'brin/macaddr8_minmax_ops', opcintype => 'macaddr8', opckeytype => 'macaddr8' }, +{ opcmethod => 'brin', opcname => 'macaddr8_minmax_multi_ops', + opcfamily => 'brin/macaddr8_minmax_multi_ops', opcintype => 'macaddr8', + opckeytype => 'macaddr8', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'macaddr8_bloom_ops', opcfamily => 'brin/macaddr8_bloom_ops', opcintype => 'macaddr8', opckeytype => 'macaddr8', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'inet_minmax_ops', opcfamily => 'brin/network_minmax_ops', opcintype => 'inet', opcdefault => 'f', opckeytype => 'inet' }, +{ opcmethod => 'brin', opcname => 'inet_minmax_multi_ops', + opcfamily => 'brin/network_minmax_multi_ops', opcintype => 'inet', + opcdefault => 'f', opckeytype => 'inet', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'inet_bloom_ops', opcfamily => 'brin/network_bloom_ops', opcintype => 'inet', opcdefault => 'f', opckeytype => 'inet', opcdefault => 'f' }, @@ -356,36 +386,54 @@ { opcmethod => 'brin', opcname => 'time_minmax_ops', opcfamily => 'brin/time_minmax_ops', opcintype => 'time', opckeytype => 'time' }, +{ opcmethod => 'brin', opcname => 'time_minmax_multi_ops', + opcfamily => 'brin/time_minmax_multi_ops', opcintype => 'time', + opckeytype => 'time', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'time_bloom_ops', opcfamily => 'brin/time_bloom_ops', opcintype => 'time', opckeytype => 'time', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'date_minmax_ops', opcfamily => 'brin/datetime_minmax_ops', opcintype => 'date', opckeytype => 'date' }, +{ opcmethod => 'brin', opcname => 'date_minmax_multi_ops', + opcfamily => 'brin/datetime_minmax_multi_ops', opcintype => 'date', + opckeytype => 'date', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'date_bloom_ops', opcfamily => 'brin/datetime_bloom_ops', opcintype => 'date', opckeytype => 'date', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'timestamp_minmax_ops', opcfamily => 'brin/datetime_minmax_ops', opcintype => 'timestamp', opckeytype => 'timestamp' }, +{ opcmethod => 'brin', opcname => 'timestamp_minmax_multi_ops', + opcfamily => 'brin/datetime_minmax_multi_ops', opcintype => 'timestamp', + opckeytype => 'timestamp', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'timestamp_bloom_ops', opcfamily => 'brin/datetime_bloom_ops', opcintype => 'timestamp', opckeytype => 'timestamp', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'timestamptz_minmax_ops', opcfamily => 'brin/datetime_minmax_ops', opcintype => 'timestamptz', opckeytype => 'timestamptz' }, +{ opcmethod => 'brin', opcname => 'timestamptz_minmax_multi_ops', + opcfamily => 'brin/datetime_minmax_multi_ops', opcintype => 'timestamptz', + opckeytype => 'timestamptz', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'timestamptz_bloom_ops', opcfamily => 'brin/datetime_bloom_ops', opcintype => 'timestamptz', opckeytype => 'timestamptz', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'interval_minmax_ops', opcfamily => 'brin/interval_minmax_ops', opcintype => 'interval', opckeytype => 'interval' }, +{ opcmethod => 'brin', opcname => 'interval_minmax_multi_ops', + opcfamily => 'brin/interval_minmax_multi_ops', opcintype => 'interval', + opckeytype => 'interval', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'interval_bloom_ops', opcfamily => 'brin/interval_bloom_ops', opcintype => 'interval', opckeytype => 'interval', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'timetz_minmax_ops', opcfamily => 'brin/timetz_minmax_ops', opcintype => 'timetz', opckeytype => 'timetz' }, +{ opcmethod => 'brin', opcname => 'timetz_minmax_multi_ops', + opcfamily => 'brin/timetz_minmax_multi_ops', opcintype => 'timetz', + opckeytype => 'timetz', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'timetz_bloom_ops', opcfamily => 'brin/timetz_bloom_ops', opcintype => 'timetz', opckeytype => 'timetz', opcdefault => 'f' }, @@ -397,6 +445,9 @@ { opcmethod => 'brin', opcname => 'numeric_minmax_ops', opcfamily => 'brin/numeric_minmax_ops', opcintype => 'numeric', opckeytype => 'numeric' }, +{ opcmethod => 'brin', opcname => 'numeric_minmax_multi_ops', + opcfamily => 'brin/numeric_minmax_multi_ops', opcintype => 'numeric', + opckeytype => 'numeric', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'numeric_bloom_ops', opcfamily => 'brin/numeric_bloom_ops', opcintype => 'numeric', opckeytype => 'numeric', opcdefault => 'f' }, @@ -406,6 +457,9 @@ { opcmethod => 'brin', opcname => 'uuid_minmax_ops', opcfamily => 'brin/uuid_minmax_ops', opcintype => 'uuid', opckeytype => 'uuid' }, +{ opcmethod => 'brin', opcname => 'uuid_minmax_multi_ops', + opcfamily => 'brin/uuid_minmax_multi_ops', opcintype => 'uuid', + opckeytype => 'uuid', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'uuid_bloom_ops', opcfamily => 'brin/uuid_bloom_ops', opcintype => 'uuid', opckeytype => 'uuid', opcdefault => 'f' }, @@ -415,6 +469,9 @@ { opcmethod => 'brin', opcname => 'pg_lsn_minmax_ops', opcfamily => 'brin/pg_lsn_minmax_ops', opcintype => 'pg_lsn', opckeytype => 'pg_lsn' }, +{ opcmethod => 'brin', opcname => 'pg_lsn_minmax_multi_ops', + opcfamily => 'brin/pg_lsn_minmax_multi_ops', opcintype => 'pg_lsn', + opckeytype => 'pg_lsn', opcdefault => 'f' }, { opcmethod => 'brin', opcname => 'pg_lsn_bloom_ops', opcfamily => 'brin/pg_lsn_bloom_ops', opcintype => 'pg_lsn', opckeytype => 'pg_lsn', opcdefault => 'f' }, diff --git a/src/include/catalog/pg_opfamily.dat b/src/include/catalog/pg_opfamily.dat index 5c294bac89..c00d6d6500 100644 --- a/src/include/catalog/pg_opfamily.dat +++ b/src/include/catalog/pg_opfamily.dat @@ -182,10 +182,14 @@ opfmethod => 'gin', opfname => 'jsonb_path_ops' }, { oid => '4054', opfmethod => 'brin', opfname => 'integer_minmax_ops' }, +{ oid => '9015', + opfmethod => 'brin', opfname => 'integer_minmax_multi_ops' }, { oid => '8100', opfmethod => 'brin', opfname => 'integer_bloom_ops' }, { oid => '4055', opfmethod => 'brin', opfname => 'numeric_minmax_ops' }, +{ oid => '9016', + opfmethod => 'brin', opfname => 'numeric_minmax_multi_ops' }, { oid => '4056', opfmethod => 'brin', opfname => 'text_minmax_ops' }, { oid => '8101', @@ -194,10 +198,14 @@ opfmethod => 'brin', opfname => 'numeric_bloom_ops' }, { oid => '4058', opfmethod => 'brin', opfname => 'timetz_minmax_ops' }, +{ oid => '9017', + opfmethod => 'brin', opfname => 'timetz_minmax_multi_ops' }, { oid => '8103', opfmethod => 'brin', opfname => 'timetz_bloom_ops' }, { oid => '4059', opfmethod => 'brin', opfname => 'datetime_minmax_ops' }, +{ oid => '9018', + opfmethod => 'brin', opfname => 'datetime_minmax_multi_ops' }, { oid => '8104', opfmethod => 'brin', opfname => 'datetime_bloom_ops' }, { oid => '4062', @@ -214,26 +222,38 @@ opfmethod => 'brin', opfname => 'name_bloom_ops' }, { oid => '4068', opfmethod => 'brin', opfname => 'oid_minmax_ops' }, +{ oid => '9019', + opfmethod => 'brin', opfname => 'oid_minmax_multi_ops' }, { oid => '8108', opfmethod => 'brin', opfname => 'oid_bloom_ops' }, { oid => '4069', opfmethod => 'brin', opfname => 'tid_minmax_ops' }, { oid => '8123', opfmethod => 'brin', opfname => 'tid_bloom_ops' }, +{ oid => '9020', + opfmethod => 'brin', opfname => 'tid_minmax_multi_ops' }, { oid => '4070', opfmethod => 'brin', opfname => 'float_minmax_ops' }, +{ oid => '9021', + opfmethod => 'brin', opfname => 'float_minmax_multi_ops' }, { oid => '8109', opfmethod => 'brin', opfname => 'float_bloom_ops' }, { oid => '4074', opfmethod => 'brin', opfname => 'macaddr_minmax_ops' }, +{ oid => '9022', + opfmethod => 'brin', opfname => 'macaddr_minmax_multi_ops' }, { oid => '8110', opfmethod => 'brin', opfname => 'macaddr_bloom_ops' }, { oid => '4109', opfmethod => 'brin', opfname => 'macaddr8_minmax_ops' }, +{ oid => '9023', + opfmethod => 'brin', opfname => 'macaddr8_minmax_multi_ops' }, { oid => '8111', opfmethod => 'brin', opfname => 'macaddr8_bloom_ops' }, { oid => '4075', opfmethod => 'brin', opfname => 'network_minmax_ops' }, +{ oid => '9024', + opfmethod => 'brin', opfname => 'network_minmax_multi_ops' }, { oid => '4102', opfmethod => 'brin', opfname => 'network_inclusion_ops' }, { oid => '8112', @@ -244,10 +264,14 @@ opfmethod => 'brin', opfname => 'bpchar_bloom_ops' }, { oid => '4077', opfmethod => 'brin', opfname => 'time_minmax_ops' }, +{ oid => '9025', + opfmethod => 'brin', opfname => 'time_minmax_multi_ops' }, { oid => '8114', opfmethod => 'brin', opfname => 'time_bloom_ops' }, { oid => '4078', opfmethod => 'brin', opfname => 'interval_minmax_ops' }, +{ oid => '9026', + opfmethod => 'brin', opfname => 'interval_minmax_multi_ops' }, { oid => '8115', opfmethod => 'brin', opfname => 'interval_bloom_ops' }, { oid => '4079', @@ -256,12 +280,16 @@ opfmethod => 'brin', opfname => 'varbit_minmax_ops' }, { oid => '4081', opfmethod => 'brin', opfname => 'uuid_minmax_ops' }, +{ oid => '9027', + opfmethod => 'brin', opfname => 'uuid_minmax_multi_ops' }, { oid => '8116', opfmethod => 'brin', opfname => 'uuid_bloom_ops' }, { oid => '4103', opfmethod => 'brin', opfname => 'range_inclusion_ops' }, { oid => '4082', opfmethod => 'brin', opfname => 'pg_lsn_minmax_ops' }, +{ oid => '9028', + opfmethod => 'brin', opfname => 'pg_lsn_minmax_multi_ops' }, { oid => '8117', opfmethod => 'brin', opfname => 'pg_lsn_bloom_ops' }, { oid => '4104', diff --git a/src/include/catalog/pg_proc.dat b/src/include/catalog/pg_proc.dat index c8c4f449d4..41f76e6104 100644 --- a/src/include/catalog/pg_proc.dat +++ b/src/include/catalog/pg_proc.dat @@ -8149,6 +8149,71 @@ proname => 'brin_minmax_union', prorettype => 'bool', proargtypes => 'internal internal internal', prosrc => 'brin_minmax_union' }, +# BRIN minmax multi +{ oid => '9029', descr => 'BRIN multi minmax support', + proname => 'brin_minmax_multi_opcinfo', prorettype => 'internal', + proargtypes => 'internal', prosrc => 'brin_minmax_multi_opcinfo' }, +{ oid => '9030', descr => 'BRIN multi minmax support', + proname => 'brin_minmax_multi_add_value', prorettype => 'bool', + proargtypes => 'internal internal internal internal', + prosrc => 'brin_minmax_multi_add_value' }, +{ oid => '9031', descr => 'BRIN multi minmax support', + proname => 'brin_minmax_multi_consistent', prorettype => 'bool', + proargtypes => 'internal internal internal int4', + prosrc => 'brin_minmax_multi_consistent' }, +{ oid => '9032', descr => 'BRIN multi minmax support', + proname => 'brin_minmax_multi_union', prorettype => 'bool', + proargtypes => 'internal internal internal', prosrc => 'brin_minmax_multi_union' }, +{ oid => '9033', descr => 'BRIN multi minmax support', + proname => 'brin_minmax_multi_options', prorettype => 'void', proisstrict => 'f', + proargtypes => 'internal', prosrc => 'brin_minmax_multi_options' }, + +{ oid => '9000', descr => 'BRIN multi minmax int2 distance', + proname => 'brin_minmax_multi_distance_int2', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_int2' }, +{ oid => '9001', descr => 'BRIN multi minmax int4 distance', + proname => 'brin_minmax_multi_distance_int4', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_int4' }, +{ oid => '9002', descr => 'BRIN multi minmax int8 distance', + proname => 'brin_minmax_multi_distance_int8', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_int8' }, +{ oid => '9003', descr => 'BRIN multi minmax float4 distance', + proname => 'brin_minmax_multi_distance_float4', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_float4' }, +{ oid => '9004', descr => 'BRIN multi minmax float8 distance', + proname => 'brin_minmax_multi_distance_float8', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_float8' }, +{ oid => '9005', descr => 'BRIN multi minmax numeric distance', + proname => 'brin_minmax_multi_distance_numeric', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_numeric' }, +{ oid => '9006', descr => 'BRIN multi minmax tid distance', + proname => 'brin_minmax_multi_distance_tid', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_tid' }, +{ oid => '9007', descr => 'BRIN multi minmax uuid distance', + proname => 'brin_minmax_multi_distance_uuid', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_uuid' }, +{ oid => '9008', descr => 'BRIN multi minmax time distance', + proname => 'brin_minmax_multi_distance_time', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_time' }, +{ oid => '9009', descr => 'BRIN multi minmax interval distance', + proname => 'brin_minmax_multi_distance_interval', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_interval' }, +{ oid => '9010', descr => 'BRIN multi minmax timetz distance', + proname => 'brin_minmax_multi_distance_timetz', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_timetz' }, +{ oid => '9011', descr => 'BRIN multi minmax pg_lsn distance', + proname => 'brin_minmax_multi_distance_pg_lsn', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_pg_lsn' }, +{ oid => '9012', descr => 'BRIN multi minmax macaddr distance', + proname => 'brin_minmax_multi_distance_macaddr', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_macaddr' }, +{ oid => '9013', descr => 'BRIN multi minmax macaddr8 distance', + proname => 'brin_minmax_multi_distance_macaddr8', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_macaddr8' }, +{ oid => '9014', descr => 'BRIN multi minmax inet distance', + proname => 'brin_minmax_multi_distance_inet', prorettype => 'float8', + proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_inet' }, + # BRIN inclusion { oid => '4105', descr => 'BRIN inclusion support', proname => 'brin_inclusion_opcinfo', prorettype => 'internal', @@ -11349,3 +11414,18 @@ { oid => '9038', descr => 'I/O', proname => 'brin_bloom_summary_send', provolatile => 's', prorettype => 'bytea', proargtypes => 'pg_brin_bloom_summary', prosrc => 'brin_bloom_summary_send' }, + + +{ oid => '9040', descr => 'I/O', + proname => 'brin_minmax_multi_summary_in', prorettype => 'pg_brin_minmax_multi_summary', + proargtypes => 'cstring', prosrc => 'brin_minmax_multi_summary_in' }, +{ oid => '9041', descr => 'I/O', + proname => 'brin_minmax_multi_summary_out', prorettype => 'cstring', + proargtypes => 'pg_brin_minmax_multi_summary', prosrc => 'brin_minmax_multi_summary_out' }, +{ oid => '9042', descr => 'I/O', + proname => 'brin_minmax_multi_summary_recv', provolatile => 's', + prorettype => 'pg_brin_minmax_multi_summary', proargtypes => 'internal', + prosrc => 'brin_minmax_multi_summary_recv' }, +{ oid => '9043', descr => 'I/O', + proname => 'brin_minmax_multi_summary_send', provolatile => 's', prorettype => 'bytea', + proargtypes => 'pg_brin_minmax_multi_summary', prosrc => 'brin_minmax_multi_summary_send' }, diff --git a/src/include/catalog/pg_type.dat b/src/include/catalog/pg_type.dat index 3275719896..93b745757a 100644 --- a/src/include/catalog/pg_type.dat +++ b/src/include/catalog/pg_type.dat @@ -680,3 +680,10 @@ typinput => 'brin_bloom_summary_in', typoutput => 'brin_bloom_summary_out', typreceive => 'brin_bloom_summary_recv', typsend => 'brin_bloom_summary_send', typalign => 'i', typstorage => 'x', typcollation => 'default' }, + +{ oid => '9039', + descr => 'BRIN minmax-multi summary', + typname => 'pg_brin_minmax_multi_summary', typlen => '-1', typbyval => 'f', typcategory => 'S', + typinput => 'brin_minmax_multi_summary_in', typoutput => 'brin_minmax_multi_summary_out', + typreceive => 'brin_minmax_multi_summary_recv', typsend => 'brin_minmax_multi_summary_send', + typalign => 'i', typstorage => 'x', typcollation => 'default' }, diff --git a/src/test/regress/expected/brin_multi.out b/src/test/regress/expected/brin_multi.out new file mode 100644 index 0000000000..966dc4aadc --- /dev/null +++ b/src/test/regress/expected/brin_multi.out @@ -0,0 +1,421 @@ +CREATE TABLE brintest_multi ( + int8col bigint, + int2col smallint, + int4col integer, + oidcol oid, + tidcol tid, + float4col real, + float8col double precision, + macaddrcol macaddr, + inetcol inet, + cidrcol cidr, + datecol date, + timecol time without time zone, + timestampcol timestamp without time zone, + timestamptzcol timestamp with time zone, + intervalcol interval, + timetzcol time with time zone, + numericcol numeric, + uuidcol uuid, + lsncol pg_lsn +) WITH (fillfactor=10); +INSERT INTO brintest_multi SELECT + 142857 * tenthous, + thousand, + twothousand, + unique1::oid, + format('(%s,%s)', tenthous, twenty)::tid, + (four + 1.0)/(hundred+1), + odd::float8 / (tenthous + 1), + format('%s:00:%s:00:%s:00', to_hex(odd), to_hex(even), to_hex(hundred))::macaddr, + inet '10.2.3.4/24' + tenthous, + cidr '10.2.3/24' + tenthous, + date '1995-08-15' + tenthous, + time '01:20:30' + thousand * interval '18.5 second', + timestamp '1942-07-23 03:05:09' + tenthous * interval '36.38 hours', + timestamptz '1972-10-10 03:00' + thousand * interval '1 hour', + justify_days(justify_hours(tenthous * interval '12 minutes')), + timetz '01:30:20+02' + hundred * interval '15 seconds', + tenthous::numeric(36,30) * fivethous * even / (hundred + 1), + format('%s%s-%s-%s-%s-%s%s%s', to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'))::uuid, + format('%s/%s%s', odd, even, tenthous)::pg_lsn +FROM tenk1 ORDER BY unique2 LIMIT 100; +-- throw in some NULL's and different values +INSERT INTO brintest_multi (inetcol, cidrcol) SELECT + inet 'fe80::6e40:8ff:fea9:8c46' + tenthous, + cidr 'fe80::6e40:8ff:fea9:8c46' + tenthous +FROM tenk1 ORDER BY thousand, tenthous LIMIT 25; +-- test minmax-multi specific index options +-- number of values must be >= 16 +CREATE INDEX brinidx_multi ON brintest_multi USING brin ( + int8col int8_minmax_multi_ops(values_per_range = 15) +); +ERROR: value 15 out of bounds for option "values_per_range" +DETAIL: Valid values are between "16" and "256". +-- number of values must be <= 256 +CREATE INDEX brinidx_multi ON brintest_multi USING brin ( + int8col int8_minmax_multi_ops(values_per_range = 257) +); +ERROR: value 257 out of bounds for option "values_per_range" +DETAIL: Valid values are between "16" and "256". +CREATE INDEX brinidx_multi ON brintest_multi USING brin ( + int8col int8_minmax_multi_ops, + int2col int2_minmax_multi_ops, + int4col int4_minmax_multi_ops, + oidcol oid_minmax_multi_ops, + tidcol tid_minmax_multi_ops, + float4col float4_minmax_multi_ops, + float8col float8_minmax_multi_ops, + macaddrcol macaddr_minmax_multi_ops, + inetcol inet_minmax_multi_ops, + cidrcol inet_minmax_multi_ops, + datecol date_minmax_multi_ops, + timecol time_minmax_multi_ops, + timestampcol timestamp_minmax_multi_ops, + timestamptzcol timestamptz_minmax_multi_ops, + intervalcol interval_minmax_multi_ops, + timetzcol timetz_minmax_multi_ops, + numericcol numeric_minmax_multi_ops, + uuidcol uuid_minmax_multi_ops, + lsncol pg_lsn_minmax_multi_ops +) with (pages_per_range = 1); +CREATE TABLE brinopers_multi (colname name, typ text, + op text[], value text[], matches int[], + check (cardinality(op) = cardinality(value)), + check (cardinality(op) = cardinality(matches))); +INSERT INTO brinopers_multi VALUES + ('int2col', 'int2', + '{>, >=, =, <=, <}', + '{0, 0, 800, 999, 999}', + '{100, 100, 1, 100, 100}'), + ('int2col', 'int4', + '{>, >=, =, <=, <}', + '{0, 0, 800, 999, 1999}', + '{100, 100, 1, 100, 100}'), + ('int2col', 'int8', + '{>, >=, =, <=, <}', + '{0, 0, 800, 999, 1428427143}', + '{100, 100, 1, 100, 100}'), + ('int4col', 'int2', + '{>, >=, =, <=, <}', + '{0, 0, 800, 1999, 1999}', + '{100, 100, 1, 100, 100}'), + ('int4col', 'int4', + '{>, >=, =, <=, <}', + '{0, 0, 800, 1999, 1999}', + '{100, 100, 1, 100, 100}'), + ('int4col', 'int8', + '{>, >=, =, <=, <}', + '{0, 0, 800, 1999, 1428427143}', + '{100, 100, 1, 100, 100}'), + ('int8col', 'int2', + '{>, >=}', + '{0, 0}', + '{100, 100}'), + ('int8col', 'int4', + '{>, >=}', + '{0, 0}', + '{100, 100}'), + ('int8col', 'int8', + '{>, >=, =, <=, <}', + '{0, 0, 1257141600, 1428427143, 1428427143}', + '{100, 100, 1, 100, 100}'), + ('oidcol', 'oid', + '{>, >=, =, <=, <}', + '{0, 0, 8800, 9999, 9999}', + '{100, 100, 1, 100, 100}'), + ('tidcol', 'tid', + '{>, >=, =, <=, <}', + '{"(0,0)", "(0,0)", "(8800,0)", "(9999,19)", "(9999,19)"}', + '{100, 100, 1, 100, 100}'), + ('float4col', 'float4', + '{>, >=, =, <=, <}', + '{0.0103093, 0.0103093, 1, 1, 1}', + '{100, 100, 4, 100, 96}'), + ('float4col', 'float8', + '{>, >=, =, <=, <}', + '{0.0103093, 0.0103093, 1, 1, 1}', + '{100, 100, 4, 100, 96}'), + ('float8col', 'float4', + '{>, >=, =, <=, <}', + '{0, 0, 0, 1.98, 1.98}', + '{99, 100, 1, 100, 100}'), + ('float8col', 'float8', + '{>, >=, =, <=, <}', + '{0, 0, 0, 1.98, 1.98}', + '{99, 100, 1, 100, 100}'), + ('macaddrcol', 'macaddr', + '{>, >=, =, <=, <}', + '{00:00:01:00:00:00, 00:00:01:00:00:00, 2c:00:2d:00:16:00, ff:fe:00:00:00:00, ff:fe:00:00:00:00}', + '{99, 100, 2, 100, 100}'), + ('inetcol', 'inet', + '{=, <, <=, >, >=}', + '{10.2.14.231/24, 255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{1, 100, 100, 125, 125}'), + ('inetcol', 'cidr', + '{<, <=, >, >=}', + '{255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{100, 100, 125, 125}'), + ('cidrcol', 'inet', + '{=, <, <=, >, >=}', + '{10.2.14/24, 255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{2, 100, 100, 125, 125}'), + ('cidrcol', 'cidr', + '{=, <, <=, >, >=}', + '{10.2.14/24, 255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{2, 100, 100, 125, 125}'), + ('datecol', 'date', + '{>, >=, =, <=, <}', + '{1995-08-15, 1995-08-15, 2009-12-01, 2022-12-30, 2022-12-30}', + '{100, 100, 1, 100, 100}'), + ('timecol', 'time', + '{>, >=, =, <=, <}', + '{01:20:30, 01:20:30, 02:28:57, 06:28:31.5, 06:28:31.5}', + '{100, 100, 1, 100, 100}'), + ('timestampcol', 'timestamp', + '{>, >=, =, <=, <}', + '{1942-07-23 03:05:09, 1942-07-23 03:05:09, 1964-03-24 19:26:45, 1984-01-20 22:42:21, 1984-01-20 22:42:21}', + '{100, 100, 1, 100, 100}'), + ('timestampcol', 'timestamptz', + '{>, >=, =, <=, <}', + '{1942-07-23 03:05:09, 1942-07-23 03:05:09, 1964-03-24 19:26:45, 1984-01-20 22:42:21, 1984-01-20 22:42:21}', + '{100, 100, 1, 100, 100}'), + ('timestamptzcol', 'timestamptz', + '{>, >=, =, <=, <}', + '{1972-10-10 03:00:00-04, 1972-10-10 03:00:00-04, 1972-10-19 09:00:00-07, 1972-11-20 19:00:00-03, 1972-11-20 19:00:00-03}', + '{100, 100, 1, 100, 100}'), + ('intervalcol', 'interval', + '{>, >=, =, <=, <}', + '{00:00:00, 00:00:00, 1 mons 13 days 12:24, 2 mons 23 days 07:48:00, 1 year}', + '{100, 100, 1, 100, 100}'), + ('timetzcol', 'timetz', + '{>, >=, =, <=, <}', + '{01:30:20+02, 01:30:20+02, 01:35:50+02, 23:55:05+02, 23:55:05+02}', + '{99, 100, 2, 100, 100}'), + ('numericcol', 'numeric', + '{>, >=, =, <=, <}', + '{0.00, 0.01, 2268164.347826086956521739130434782609, 99470151.9, 99470151.9}', + '{100, 100, 1, 100, 100}'), + ('uuidcol', 'uuid', + '{>, >=, =, <=, <}', + '{00040004-0004-0004-0004-000400040004, 00040004-0004-0004-0004-000400040004, 52225222-5222-5222-5222-522252225222, 99989998-9998-9998-9998-999899989998, 99989998-9998-9998-9998-999899989998}', + '{100, 100, 1, 100, 100}'), + ('lsncol', 'pg_lsn', + '{>, >=, =, <=, <, IS, IS NOT}', + '{0/1200, 0/1200, 44/455222, 198/1999799, 198/1999799, NULL, NULL}', + '{100, 100, 1, 100, 100, 25, 100}'); +DO $x$ +DECLARE + r record; + r2 record; + cond text; + idx_ctids tid[]; + ss_ctids tid[]; + count int; + plan_ok bool; + plan_line text; +BEGIN + FOR r IN SELECT colname, oper, typ, value[ordinality], matches[ordinality] FROM brinopers_multi, unnest(op) WITH ORDINALITY AS oper LOOP + + -- prepare the condition + IF r.value IS NULL THEN + cond := format('%I %s %L', r.colname, r.oper, r.value); + ELSE + cond := format('%I %s %L::%s', r.colname, r.oper, r.value, r.typ); + END IF; + + -- run the query using the brin index + SET enable_seqscan = 0; + SET enable_bitmapscan = 1; + + plan_ok := false; + FOR plan_line IN EXECUTE format($y$EXPLAIN SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) LOOP + IF plan_line LIKE '%Bitmap Heap Scan on brintest_multi%' THEN + plan_ok := true; + END IF; + END LOOP; + IF NOT plan_ok THEN + RAISE WARNING 'did not get bitmap indexscan plan for %', r; + END IF; + + EXECUTE format($y$SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) + INTO idx_ctids; + + -- run the query using a seqscan + SET enable_seqscan = 1; + SET enable_bitmapscan = 0; + + plan_ok := false; + FOR plan_line IN EXECUTE format($y$EXPLAIN SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) LOOP + IF plan_line LIKE '%Seq Scan on brintest_multi%' THEN + plan_ok := true; + END IF; + END LOOP; + IF NOT plan_ok THEN + RAISE WARNING 'did not get seqscan plan for %', r; + END IF; + + EXECUTE format($y$SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) + INTO ss_ctids; + + -- make sure both return the same results + count := array_length(idx_ctids, 1); + + IF NOT (count = array_length(ss_ctids, 1) AND + idx_ctids @> ss_ctids AND + idx_ctids <@ ss_ctids) THEN + -- report the results of each scan to make the differences obvious + RAISE WARNING 'something not right in %: count %', r, count; + SET enable_seqscan = 1; + SET enable_bitmapscan = 0; + FOR r2 IN EXECUTE 'SELECT ' || r.colname || ' FROM brintest_multi WHERE ' || cond LOOP + RAISE NOTICE 'seqscan: %', r2; + END LOOP; + + SET enable_seqscan = 0; + SET enable_bitmapscan = 1; + FOR r2 IN EXECUTE 'SELECT ' || r.colname || ' FROM brintest_multi WHERE ' || cond LOOP + RAISE NOTICE 'bitmapscan: %', r2; + END LOOP; + END IF; + + -- make sure we found expected number of matches + IF count != r.matches THEN RAISE WARNING 'unexpected number of results % for %', count, r; END IF; + END LOOP; +END; +$x$; +RESET enable_seqscan; +RESET enable_bitmapscan; +INSERT INTO brintest_multi SELECT + 142857 * tenthous, + thousand, + twothousand, + unique1::oid, + format('(%s,%s)', tenthous, twenty)::tid, + (four + 1.0)/(hundred+1), + odd::float8 / (tenthous + 1), + format('%s:00:%s:00:%s:00', to_hex(odd), to_hex(even), to_hex(hundred))::macaddr, + inet '10.2.3.4' + tenthous, + cidr '10.2.3/24' + tenthous, + date '1995-08-15' + tenthous, + time '01:20:30' + thousand * interval '18.5 second', + timestamp '1942-07-23 03:05:09' + tenthous * interval '36.38 hours', + timestamptz '1972-10-10 03:00' + thousand * interval '1 hour', + justify_days(justify_hours(tenthous * interval '12 minutes')), + timetz '01:30:20' + hundred * interval '15 seconds', + tenthous::numeric(36,30) * fivethous * even / (hundred + 1), + format('%s%s-%s-%s-%s-%s%s%s', to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'))::uuid, + format('%s/%s%s', odd, even, tenthous)::pg_lsn +FROM tenk1 ORDER BY unique2 LIMIT 5 OFFSET 5; +SELECT brin_desummarize_range('brinidx_multi', 0); + brin_desummarize_range +------------------------ + +(1 row) + +VACUUM brintest_multi; -- force a summarization cycle in brinidx +UPDATE brintest_multi SET int8col = int8col * int4col; +-- Tests for brin_summarize_new_values +SELECT brin_summarize_new_values('brintest_multi'); -- error, not an index +ERROR: "brintest_multi" is not an index +SELECT brin_summarize_new_values('tenk1_unique1'); -- error, not a BRIN index +ERROR: "tenk1_unique1" is not a BRIN index +SELECT brin_summarize_new_values('brinidx_multi'); -- ok, no change expected + brin_summarize_new_values +--------------------------- + 0 +(1 row) + +-- Tests for brin_desummarize_range +SELECT brin_desummarize_range('brinidx_multi', -1); -- error, invalid range +ERROR: block number out of range: -1 +SELECT brin_desummarize_range('brinidx_multi', 0); + brin_desummarize_range +------------------------ + +(1 row) + +SELECT brin_desummarize_range('brinidx_multi', 0); + brin_desummarize_range +------------------------ + +(1 row) + +SELECT brin_desummarize_range('brinidx_multi', 100000000); + brin_desummarize_range +------------------------ + +(1 row) + +-- Test brin_summarize_range +CREATE TABLE brin_summarize_multi ( + value int +) WITH (fillfactor=10, autovacuum_enabled=false); +CREATE INDEX brin_summarize_multi_idx ON brin_summarize_multi USING brin (value) WITH (pages_per_range=2); +-- Fill a few pages +DO $$ +DECLARE curtid tid; +BEGIN + LOOP + INSERT INTO brin_summarize_multi VALUES (1) RETURNING ctid INTO curtid; + EXIT WHEN curtid > tid '(2, 0)'; + END LOOP; +END; +$$; +-- summarize one range +SELECT brin_summarize_range('brin_summarize_multi_idx', 0); + brin_summarize_range +---------------------- + 0 +(1 row) + +-- nothing: already summarized +SELECT brin_summarize_range('brin_summarize_multi_idx', 1); + brin_summarize_range +---------------------- + 0 +(1 row) + +-- summarize one range +SELECT brin_summarize_range('brin_summarize_multi_idx', 2); + brin_summarize_range +---------------------- + 1 +(1 row) + +-- nothing: page doesn't exist in table +SELECT brin_summarize_range('brin_summarize_multi_idx', 4294967295); + brin_summarize_range +---------------------- + 0 +(1 row) + +-- invalid block number values +SELECT brin_summarize_range('brin_summarize_multi_idx', -1); +ERROR: block number out of range: -1 +SELECT brin_summarize_range('brin_summarize_multi_idx', 4294967296); +ERROR: block number out of range: 4294967296 +-- test brin cost estimates behave sanely based on correlation of values +CREATE TABLE brin_test_multi (a INT, b INT); +INSERT INTO brin_test_multi SELECT x/100,x%100 FROM generate_series(1,10000) x(x); +CREATE INDEX brin_test_multi_a_idx ON brin_test_multi USING brin (a) WITH (pages_per_range = 2); +CREATE INDEX brin_test_multi_b_idx ON brin_test_multi USING brin (b) WITH (pages_per_range = 2); +VACUUM ANALYZE brin_test_multi; +-- Ensure brin index is used when columns are perfectly correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test_multi WHERE a = 1; + QUERY PLAN +-------------------------------------------------- + Bitmap Heap Scan on brin_test_multi + Recheck Cond: (a = 1) + -> Bitmap Index Scan on brin_test_multi_a_idx + Index Cond: (a = 1) +(4 rows) + +-- Ensure brin index is not used when values are not correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test_multi WHERE b = 1; + QUERY PLAN +----------------------------- + Seq Scan on brin_test_multi + Filter: (b = 1) +(2 rows) + diff --git a/src/test/regress/expected/psql.out b/src/test/regress/expected/psql.out index a7a5b22d4f..76050af797 100644 --- a/src/test/regress/expected/psql.out +++ b/src/test/regress/expected/psql.out @@ -4990,12 +4990,13 @@ List of access methods (0 rows) \dAc brin pg*.oid* - List of operator classes - AM | Input type | Storage type | Operator class | Default? -------+------------+--------------+----------------+---------- - brin | oid | | oid_bloom_ops | no - brin | oid | | oid_minmax_ops | yes -(2 rows) + List of operator classes + AM | Input type | Storage type | Operator class | Default? +------+------------+--------------+----------------------+---------- + brin | oid | | oid_bloom_ops | no + brin | oid | | oid_minmax_multi_ops | no + brin | oid | | oid_minmax_ops | yes +(3 rows) \dAf spgist List of operator families diff --git a/src/test/regress/expected/type_sanity.out b/src/test/regress/expected/type_sanity.out index a44bde2e6e..0ca2671910 100644 --- a/src/test/regress/expected/type_sanity.out +++ b/src/test/regress/expected/type_sanity.out @@ -67,14 +67,15 @@ WHERE p1.typtype not in ('p') AND p1.typname NOT LIKE E'\\_%' WHERE p2.typname = ('_' || p1.typname)::name AND p2.typelem = p1.oid and p1.typarray = p2.oid) ORDER BY p1.oid; - oid | typname -------+----------------------- + oid | typname +------+------------------------------ 194 | pg_node_tree 3361 | pg_ndistinct 3402 | pg_dependencies 5017 | pg_mcv_list 9034 | pg_brin_bloom_summary -(5 rows) + 9039 | pg_brin_minmax_multi_summary +(6 rows) -- Make sure typarray points to a "true" array type of our own base SELECT p1.oid, p1.typname as basetype, p2.typname as arraytype, diff --git a/src/test/regress/parallel_schedule b/src/test/regress/parallel_schedule index ef372281ef..db078e5201 100644 --- a/src/test/regress/parallel_schedule +++ b/src/test/regress/parallel_schedule @@ -80,7 +80,7 @@ test: brin gin gist spgist privileges init_privs security_label collate matview # ---------- # Additional BRIN tests # ---------- -test: brin_bloom +test: brin_bloom brin_multi # ---------- # Another group of parallel tests diff --git a/src/test/regress/serial_schedule b/src/test/regress/serial_schedule index fdddc48f62..daf2e898cb 100644 --- a/src/test/regress/serial_schedule +++ b/src/test/regress/serial_schedule @@ -110,6 +110,7 @@ test: namespace test: prepared_xacts test: brin test: brin_bloom +test: brin_multi test: gin test: gist test: spgist diff --git a/src/test/regress/sql/brin_multi.sql b/src/test/regress/sql/brin_multi.sql new file mode 100644 index 0000000000..9de6ddc6d7 --- /dev/null +++ b/src/test/regress/sql/brin_multi.sql @@ -0,0 +1,371 @@ +CREATE TABLE brintest_multi ( + int8col bigint, + int2col smallint, + int4col integer, + oidcol oid, + tidcol tid, + float4col real, + float8col double precision, + macaddrcol macaddr, + inetcol inet, + cidrcol cidr, + datecol date, + timecol time without time zone, + timestampcol timestamp without time zone, + timestamptzcol timestamp with time zone, + intervalcol interval, + timetzcol time with time zone, + numericcol numeric, + uuidcol uuid, + lsncol pg_lsn +) WITH (fillfactor=10); + +INSERT INTO brintest_multi SELECT + 142857 * tenthous, + thousand, + twothousand, + unique1::oid, + format('(%s,%s)', tenthous, twenty)::tid, + (four + 1.0)/(hundred+1), + odd::float8 / (tenthous + 1), + format('%s:00:%s:00:%s:00', to_hex(odd), to_hex(even), to_hex(hundred))::macaddr, + inet '10.2.3.4/24' + tenthous, + cidr '10.2.3/24' + tenthous, + date '1995-08-15' + tenthous, + time '01:20:30' + thousand * interval '18.5 second', + timestamp '1942-07-23 03:05:09' + tenthous * interval '36.38 hours', + timestamptz '1972-10-10 03:00' + thousand * interval '1 hour', + justify_days(justify_hours(tenthous * interval '12 minutes')), + timetz '01:30:20+02' + hundred * interval '15 seconds', + tenthous::numeric(36,30) * fivethous * even / (hundred + 1), + format('%s%s-%s-%s-%s-%s%s%s', to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'))::uuid, + format('%s/%s%s', odd, even, tenthous)::pg_lsn +FROM tenk1 ORDER BY unique2 LIMIT 100; + +-- throw in some NULL's and different values +INSERT INTO brintest_multi (inetcol, cidrcol) SELECT + inet 'fe80::6e40:8ff:fea9:8c46' + tenthous, + cidr 'fe80::6e40:8ff:fea9:8c46' + tenthous +FROM tenk1 ORDER BY thousand, tenthous LIMIT 25; + +-- test minmax-multi specific index options +-- number of values must be >= 16 +CREATE INDEX brinidx_multi ON brintest_multi USING brin ( + int8col int8_minmax_multi_ops(values_per_range = 15) +); +-- number of values must be <= 256 +CREATE INDEX brinidx_multi ON brintest_multi USING brin ( + int8col int8_minmax_multi_ops(values_per_range = 257) +); + +CREATE INDEX brinidx_multi ON brintest_multi USING brin ( + int8col int8_minmax_multi_ops, + int2col int2_minmax_multi_ops, + int4col int4_minmax_multi_ops, + oidcol oid_minmax_multi_ops, + tidcol tid_minmax_multi_ops, + float4col float4_minmax_multi_ops, + float8col float8_minmax_multi_ops, + macaddrcol macaddr_minmax_multi_ops, + inetcol inet_minmax_multi_ops, + cidrcol inet_minmax_multi_ops, + datecol date_minmax_multi_ops, + timecol time_minmax_multi_ops, + timestampcol timestamp_minmax_multi_ops, + timestamptzcol timestamptz_minmax_multi_ops, + intervalcol interval_minmax_multi_ops, + timetzcol timetz_minmax_multi_ops, + numericcol numeric_minmax_multi_ops, + uuidcol uuid_minmax_multi_ops, + lsncol pg_lsn_minmax_multi_ops +) with (pages_per_range = 1); + +CREATE TABLE brinopers_multi (colname name, typ text, + op text[], value text[], matches int[], + check (cardinality(op) = cardinality(value)), + check (cardinality(op) = cardinality(matches))); + +INSERT INTO brinopers_multi VALUES + ('int2col', 'int2', + '{>, >=, =, <=, <}', + '{0, 0, 800, 999, 999}', + '{100, 100, 1, 100, 100}'), + ('int2col', 'int4', + '{>, >=, =, <=, <}', + '{0, 0, 800, 999, 1999}', + '{100, 100, 1, 100, 100}'), + ('int2col', 'int8', + '{>, >=, =, <=, <}', + '{0, 0, 800, 999, 1428427143}', + '{100, 100, 1, 100, 100}'), + ('int4col', 'int2', + '{>, >=, =, <=, <}', + '{0, 0, 800, 1999, 1999}', + '{100, 100, 1, 100, 100}'), + ('int4col', 'int4', + '{>, >=, =, <=, <}', + '{0, 0, 800, 1999, 1999}', + '{100, 100, 1, 100, 100}'), + ('int4col', 'int8', + '{>, >=, =, <=, <}', + '{0, 0, 800, 1999, 1428427143}', + '{100, 100, 1, 100, 100}'), + ('int8col', 'int2', + '{>, >=}', + '{0, 0}', + '{100, 100}'), + ('int8col', 'int4', + '{>, >=}', + '{0, 0}', + '{100, 100}'), + ('int8col', 'int8', + '{>, >=, =, <=, <}', + '{0, 0, 1257141600, 1428427143, 1428427143}', + '{100, 100, 1, 100, 100}'), + ('oidcol', 'oid', + '{>, >=, =, <=, <}', + '{0, 0, 8800, 9999, 9999}', + '{100, 100, 1, 100, 100}'), + ('tidcol', 'tid', + '{>, >=, =, <=, <}', + '{"(0,0)", "(0,0)", "(8800,0)", "(9999,19)", "(9999,19)"}', + '{100, 100, 1, 100, 100}'), + ('float4col', 'float4', + '{>, >=, =, <=, <}', + '{0.0103093, 0.0103093, 1, 1, 1}', + '{100, 100, 4, 100, 96}'), + ('float4col', 'float8', + '{>, >=, =, <=, <}', + '{0.0103093, 0.0103093, 1, 1, 1}', + '{100, 100, 4, 100, 96}'), + ('float8col', 'float4', + '{>, >=, =, <=, <}', + '{0, 0, 0, 1.98, 1.98}', + '{99, 100, 1, 100, 100}'), + ('float8col', 'float8', + '{>, >=, =, <=, <}', + '{0, 0, 0, 1.98, 1.98}', + '{99, 100, 1, 100, 100}'), + ('macaddrcol', 'macaddr', + '{>, >=, =, <=, <}', + '{00:00:01:00:00:00, 00:00:01:00:00:00, 2c:00:2d:00:16:00, ff:fe:00:00:00:00, ff:fe:00:00:00:00}', + '{99, 100, 2, 100, 100}'), + ('inetcol', 'inet', + '{=, <, <=, >, >=}', + '{10.2.14.231/24, 255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{1, 100, 100, 125, 125}'), + ('inetcol', 'cidr', + '{<, <=, >, >=}', + '{255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{100, 100, 125, 125}'), + ('cidrcol', 'inet', + '{=, <, <=, >, >=}', + '{10.2.14/24, 255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{2, 100, 100, 125, 125}'), + ('cidrcol', 'cidr', + '{=, <, <=, >, >=}', + '{10.2.14/24, 255.255.255.255, 255.255.255.255, 0.0.0.0, 0.0.0.0}', + '{2, 100, 100, 125, 125}'), + ('datecol', 'date', + '{>, >=, =, <=, <}', + '{1995-08-15, 1995-08-15, 2009-12-01, 2022-12-30, 2022-12-30}', + '{100, 100, 1, 100, 100}'), + ('timecol', 'time', + '{>, >=, =, <=, <}', + '{01:20:30, 01:20:30, 02:28:57, 06:28:31.5, 06:28:31.5}', + '{100, 100, 1, 100, 100}'), + ('timestampcol', 'timestamp', + '{>, >=, =, <=, <}', + '{1942-07-23 03:05:09, 1942-07-23 03:05:09, 1964-03-24 19:26:45, 1984-01-20 22:42:21, 1984-01-20 22:42:21}', + '{100, 100, 1, 100, 100}'), + ('timestampcol', 'timestamptz', + '{>, >=, =, <=, <}', + '{1942-07-23 03:05:09, 1942-07-23 03:05:09, 1964-03-24 19:26:45, 1984-01-20 22:42:21, 1984-01-20 22:42:21}', + '{100, 100, 1, 100, 100}'), + ('timestamptzcol', 'timestamptz', + '{>, >=, =, <=, <}', + '{1972-10-10 03:00:00-04, 1972-10-10 03:00:00-04, 1972-10-19 09:00:00-07, 1972-11-20 19:00:00-03, 1972-11-20 19:00:00-03}', + '{100, 100, 1, 100, 100}'), + ('intervalcol', 'interval', + '{>, >=, =, <=, <}', + '{00:00:00, 00:00:00, 1 mons 13 days 12:24, 2 mons 23 days 07:48:00, 1 year}', + '{100, 100, 1, 100, 100}'), + ('timetzcol', 'timetz', + '{>, >=, =, <=, <}', + '{01:30:20+02, 01:30:20+02, 01:35:50+02, 23:55:05+02, 23:55:05+02}', + '{99, 100, 2, 100, 100}'), + ('numericcol', 'numeric', + '{>, >=, =, <=, <}', + '{0.00, 0.01, 2268164.347826086956521739130434782609, 99470151.9, 99470151.9}', + '{100, 100, 1, 100, 100}'), + ('uuidcol', 'uuid', + '{>, >=, =, <=, <}', + '{00040004-0004-0004-0004-000400040004, 00040004-0004-0004-0004-000400040004, 52225222-5222-5222-5222-522252225222, 99989998-9998-9998-9998-999899989998, 99989998-9998-9998-9998-999899989998}', + '{100, 100, 1, 100, 100}'), + ('lsncol', 'pg_lsn', + '{>, >=, =, <=, <, IS, IS NOT}', + '{0/1200, 0/1200, 44/455222, 198/1999799, 198/1999799, NULL, NULL}', + '{100, 100, 1, 100, 100, 25, 100}'); + +DO $x$ +DECLARE + r record; + r2 record; + cond text; + idx_ctids tid[]; + ss_ctids tid[]; + count int; + plan_ok bool; + plan_line text; +BEGIN + FOR r IN SELECT colname, oper, typ, value[ordinality], matches[ordinality] FROM brinopers_multi, unnest(op) WITH ORDINALITY AS oper LOOP + + -- prepare the condition + IF r.value IS NULL THEN + cond := format('%I %s %L', r.colname, r.oper, r.value); + ELSE + cond := format('%I %s %L::%s', r.colname, r.oper, r.value, r.typ); + END IF; + + -- run the query using the brin index + SET enable_seqscan = 0; + SET enable_bitmapscan = 1; + + plan_ok := false; + FOR plan_line IN EXECUTE format($y$EXPLAIN SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) LOOP + IF plan_line LIKE '%Bitmap Heap Scan on brintest_multi%' THEN + plan_ok := true; + END IF; + END LOOP; + IF NOT plan_ok THEN + RAISE WARNING 'did not get bitmap indexscan plan for %', r; + END IF; + + EXECUTE format($y$SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) + INTO idx_ctids; + + -- run the query using a seqscan + SET enable_seqscan = 1; + SET enable_bitmapscan = 0; + + plan_ok := false; + FOR plan_line IN EXECUTE format($y$EXPLAIN SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) LOOP + IF plan_line LIKE '%Seq Scan on brintest_multi%' THEN + plan_ok := true; + END IF; + END LOOP; + IF NOT plan_ok THEN + RAISE WARNING 'did not get seqscan plan for %', r; + END IF; + + EXECUTE format($y$SELECT array_agg(ctid) FROM brintest_multi WHERE %s $y$, cond) + INTO ss_ctids; + + -- make sure both return the same results + count := array_length(idx_ctids, 1); + + IF NOT (count = array_length(ss_ctids, 1) AND + idx_ctids @> ss_ctids AND + idx_ctids <@ ss_ctids) THEN + -- report the results of each scan to make the differences obvious + RAISE WARNING 'something not right in %: count %', r, count; + SET enable_seqscan = 1; + SET enable_bitmapscan = 0; + FOR r2 IN EXECUTE 'SELECT ' || r.colname || ' FROM brintest_multi WHERE ' || cond LOOP + RAISE NOTICE 'seqscan: %', r2; + END LOOP; + + SET enable_seqscan = 0; + SET enable_bitmapscan = 1; + FOR r2 IN EXECUTE 'SELECT ' || r.colname || ' FROM brintest_multi WHERE ' || cond LOOP + RAISE NOTICE 'bitmapscan: %', r2; + END LOOP; + END IF; + + -- make sure we found expected number of matches + IF count != r.matches THEN RAISE WARNING 'unexpected number of results % for %', count, r; END IF; + END LOOP; +END; +$x$; + +RESET enable_seqscan; +RESET enable_bitmapscan; + +INSERT INTO brintest_multi SELECT + 142857 * tenthous, + thousand, + twothousand, + unique1::oid, + format('(%s,%s)', tenthous, twenty)::tid, + (four + 1.0)/(hundred+1), + odd::float8 / (tenthous + 1), + format('%s:00:%s:00:%s:00', to_hex(odd), to_hex(even), to_hex(hundred))::macaddr, + inet '10.2.3.4' + tenthous, + cidr '10.2.3/24' + tenthous, + date '1995-08-15' + tenthous, + time '01:20:30' + thousand * interval '18.5 second', + timestamp '1942-07-23 03:05:09' + tenthous * interval '36.38 hours', + timestamptz '1972-10-10 03:00' + thousand * interval '1 hour', + justify_days(justify_hours(tenthous * interval '12 minutes')), + timetz '01:30:20' + hundred * interval '15 seconds', + tenthous::numeric(36,30) * fivethous * even / (hundred + 1), + format('%s%s-%s-%s-%s-%s%s%s', to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'), to_char(tenthous, 'FM0000'))::uuid, + format('%s/%s%s', odd, even, tenthous)::pg_lsn +FROM tenk1 ORDER BY unique2 LIMIT 5 OFFSET 5; + +SELECT brin_desummarize_range('brinidx_multi', 0); +VACUUM brintest_multi; -- force a summarization cycle in brinidx + +UPDATE brintest_multi SET int8col = int8col * int4col; + +-- Tests for brin_summarize_new_values +SELECT brin_summarize_new_values('brintest_multi'); -- error, not an index +SELECT brin_summarize_new_values('tenk1_unique1'); -- error, not a BRIN index +SELECT brin_summarize_new_values('brinidx_multi'); -- ok, no change expected + +-- Tests for brin_desummarize_range +SELECT brin_desummarize_range('brinidx_multi', -1); -- error, invalid range +SELECT brin_desummarize_range('brinidx_multi', 0); +SELECT brin_desummarize_range('brinidx_multi', 0); +SELECT brin_desummarize_range('brinidx_multi', 100000000); + +-- Test brin_summarize_range +CREATE TABLE brin_summarize_multi ( + value int +) WITH (fillfactor=10, autovacuum_enabled=false); +CREATE INDEX brin_summarize_multi_idx ON brin_summarize_multi USING brin (value) WITH (pages_per_range=2); +-- Fill a few pages +DO $$ +DECLARE curtid tid; +BEGIN + LOOP + INSERT INTO brin_summarize_multi VALUES (1) RETURNING ctid INTO curtid; + EXIT WHEN curtid > tid '(2, 0)'; + END LOOP; +END; +$$; + +-- summarize one range +SELECT brin_summarize_range('brin_summarize_multi_idx', 0); +-- nothing: already summarized +SELECT brin_summarize_range('brin_summarize_multi_idx', 1); +-- summarize one range +SELECT brin_summarize_range('brin_summarize_multi_idx', 2); +-- nothing: page doesn't exist in table +SELECT brin_summarize_range('brin_summarize_multi_idx', 4294967295); +-- invalid block number values +SELECT brin_summarize_range('brin_summarize_multi_idx', -1); +SELECT brin_summarize_range('brin_summarize_multi_idx', 4294967296); + + +-- test brin cost estimates behave sanely based on correlation of values +CREATE TABLE brin_test_multi (a INT, b INT); +INSERT INTO brin_test_multi SELECT x/100,x%100 FROM generate_series(1,10000) x(x); +CREATE INDEX brin_test_multi_a_idx ON brin_test_multi USING brin (a) WITH (pages_per_range = 2); +CREATE INDEX brin_test_multi_b_idx ON brin_test_multi USING brin (b) WITH (pages_per_range = 2); +VACUUM ANALYZE brin_test_multi; + +-- Ensure brin index is used when columns are perfectly correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test_multi WHERE a = 1; +-- Ensure brin index is not used when values are not correlated +EXPLAIN (COSTS OFF) SELECT * FROM brin_test_multi WHERE b = 1; -- 2.26.2 --------------D21F32E0F9E7408E9BE1AF2E Content-Type: text/x-patch; charset=UTF-8; name="0006-Ignore-correlation-for-new-BRIN-opclasses-20210114.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename*0="0006-Ignore-correlation-for-new-BRIN-opclasses-20210114.patc"; filename*1="h" ^ permalink raw reply [nested|flat] 30+ messages in thread
* [PATCH v3 1/6] Define PG_REPLSLOT_DIR @ 2024-08-14 09:16 Bertrand Drouvot <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-14 09:16 UTC (permalink / raw) Replace most of the places where "pg_replslot" is used in .c files with a new PG_REPLSLOT_DIR define. The places where it is not done is for consistency with the existing PG_STAT_TMP_DIR define. --- src/backend/backup/basebackup.c | 3 +- .../replication/logical/reorderbuffer.c | 17 ++++----- src/backend/replication/slot.c | 36 +++++++++---------- src/backend/utils/adt/genfile.c | 3 +- src/bin/initdb/initdb.c | 2 +- src/bin/pg_rewind/filemap.c | 2 +- src/include/replication/slot.h | 2 ++ 7 files changed, 35 insertions(+), 30 deletions(-) 27.5% src/backend/replication/logical/ 60.8% src/backend/replication/ 3.9% src/backend/utils/adt/ 4.2% src/bin/ 3.3% src/ diff --git a/src/backend/backup/basebackup.c b/src/backend/backup/basebackup.c index 01b35e26bd..de16afac74 100644 --- a/src/backend/backup/basebackup.c +++ b/src/backend/backup/basebackup.c @@ -36,6 +36,7 @@ #include "port.h" #include "postmaster/syslogger.h" #include "postmaster/walsummarizer.h" +#include "replication/slot.h" #include "replication/walsender.h" #include "replication/walsender_private.h" #include "storage/bufpage.h" @@ -161,7 +162,7 @@ static const char *const excludeDirContents[] = * even if the intention is to restore to another primary. See backup.sgml * for a more detailed description. */ - "pg_replslot", + PG_REPLSLOT_DIR, /* Contents removed on startup, see dsm_cleanup_for_mmap(). */ PG_DYNSHMEM_DIR, diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index 00a8327e77..78166b6ab7 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -4571,9 +4571,9 @@ ReorderBufferCleanupSerializedTXNs(const char *slotname) DIR *spill_dir; struct dirent *spill_de; struct stat statbuf; - char path[MAXPGPATH * 2 + 12]; + char path[MAXPGPATH * 2 + sizeof(PG_REPLSLOT_DIR)]; - sprintf(path, "pg_replslot/%s", slotname); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, slotname); /* we're only handling directories here, skip if it's not ours */ if (lstat(path, &statbuf) == 0 && !S_ISDIR(statbuf.st_mode)) @@ -4586,14 +4586,14 @@ ReorderBufferCleanupSerializedTXNs(const char *slotname) if (strncmp(spill_de->d_name, "xid", 3) == 0) { snprintf(path, sizeof(path), - "pg_replslot/%s/%s", slotname, + "%s/%s/%s", PG_REPLSLOT_DIR, slotname, spill_de->d_name); if (unlink(path) != 0) ereport(ERROR, (errcode_for_file_access(), - errmsg("could not remove file \"%s\" during removal of pg_replslot/%s/xid*: %m", - path, slotname))); + errmsg("could not remove file \"%s\" during removal of %s/%s/xid*: %m", + path, PG_REPLSLOT_DIR, slotname))); } } FreeDir(spill_dir); @@ -4612,7 +4612,8 @@ ReorderBufferSerializedPath(char *path, ReplicationSlot *slot, TransactionId xid XLogSegNoOffsetToRecPtr(segno, 0, wal_segment_size, recptr); - snprintf(path, MAXPGPATH, "pg_replslot/%s/xid-%u-lsn-%X-%X.spill", + snprintf(path, MAXPGPATH, "%s/%s/xid-%u-lsn-%X-%X.spill", + PG_REPLSLOT_DIR, NameStr(MyReplicationSlot->data.name), xid, LSN_FORMAT_ARGS(recptr)); } @@ -4627,8 +4628,8 @@ StartupReorderBuffer(void) DIR *logical_dir; struct dirent *logical_de; - logical_dir = AllocateDir("pg_replslot"); - while ((logical_de = ReadDir(logical_dir, "pg_replslot")) != NULL) + logical_dir = AllocateDir(PG_REPLSLOT_DIR); + while ((logical_de = ReadDir(logical_dir, PG_REPLSLOT_DIR)) != NULL) { if (strcmp(logical_de->d_name, ".") == 0 || strcmp(logical_de->d_name, "..") == 0) diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index c290339af5..1299d92696 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -916,8 +916,8 @@ ReplicationSlotDropPtr(ReplicationSlot *slot) LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE); /* Generate pathnames. */ - sprintf(path, "pg_replslot/%s", NameStr(slot->data.name)); - sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(slot->data.name)); + sprintf(tmppath, "%s/%s.tmp", PG_REPLSLOT_DIR, NameStr(slot->data.name)); /* * Rename the slot directory on disk, so that we'll no longer recognize @@ -938,7 +938,7 @@ ReplicationSlotDropPtr(ReplicationSlot *slot) */ START_CRIT_SECTION(); fsync_fname(tmppath, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); } else @@ -1016,7 +1016,7 @@ ReplicationSlotSave(void) Assert(MyReplicationSlot != NULL); - sprintf(path, "pg_replslot/%s", NameStr(MyReplicationSlot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(MyReplicationSlot->data.name)); SaveSlotToPath(MyReplicationSlot, path, ERROR); } @@ -1881,7 +1881,7 @@ CheckPointReplicationSlots(bool is_shutdown) continue; /* save the slot to disk, locking is handled in SaveSlotToPath() */ - sprintf(path, "pg_replslot/%s", NameStr(s->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(s->data.name)); /* * Slot's data is not flushed each time the confirmed_flush LSN is @@ -1922,17 +1922,17 @@ StartupReplicationSlots(void) elog(DEBUG1, "starting up replication slots"); /* restore all slots by iterating over all on-disk entries */ - replication_dir = AllocateDir("pg_replslot"); - while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL) + replication_dir = AllocateDir(PG_REPLSLOT_DIR); + while ((replication_de = ReadDir(replication_dir, PG_REPLSLOT_DIR)) != NULL) { - char path[MAXPGPATH + 12]; + char path[MAXPGPATH + sizeof(PG_REPLSLOT_DIR)]; PGFileType de_type; if (strcmp(replication_de->d_name, ".") == 0 || strcmp(replication_de->d_name, "..") == 0) continue; - snprintf(path, sizeof(path), "pg_replslot/%s", replication_de->d_name); + snprintf(path, sizeof(path), "%s/%s", PG_REPLSLOT_DIR, replication_de->d_name); de_type = get_dirent_type(path, replication_de, false, DEBUG1); /* we're only creating directories here, skip if it's not our's */ @@ -1949,7 +1949,7 @@ StartupReplicationSlots(void) path))); continue; } - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); continue; } @@ -1987,8 +1987,8 @@ CreateSlotOnDisk(ReplicationSlot *slot) * takes out the lock, if we'd take the lock here, we'd deadlock. */ - sprintf(path, "pg_replslot/%s", NameStr(slot->data.name)); - sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(slot->data.name)); + sprintf(tmppath, "%s/%s.tmp", PG_REPLSLOT_DIR, NameStr(slot->data.name)); /* * It's just barely possible that some previous effort to create or drop a @@ -2027,7 +2027,7 @@ CreateSlotOnDisk(ReplicationSlot *slot) START_CRIT_SECTION(); fsync_fname(path, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); } @@ -2170,7 +2170,7 @@ SaveSlotToPath(ReplicationSlot *slot, const char *dir, int elevel) fsync_fname(path, false); fsync_fname(dir, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); @@ -2195,8 +2195,8 @@ RestoreSlotFromDisk(const char *name) { ReplicationSlotOnDisk cp; int i; - char slotdir[MAXPGPATH + 12]; - char path[MAXPGPATH + 22]; + char slotdir[MAXPGPATH + sizeof(PG_REPLSLOT_DIR)]; + char path[MAXPGPATH + sizeof(PG_REPLSLOT_DIR) + 10]; int fd; bool restored = false; int readBytes; @@ -2205,7 +2205,7 @@ RestoreSlotFromDisk(const char *name) /* no need to lock here, no concurrent access allowed yet */ /* delete temp file if it exists */ - sprintf(slotdir, "pg_replslot/%s", name); + sprintf(slotdir, "%s/%s", PG_REPLSLOT_DIR, name); sprintf(path, "%s/state.tmp", slotdir); if (unlink(path) < 0 && errno != ENOENT) ereport(PANIC, @@ -2332,7 +2332,7 @@ RestoreSlotFromDisk(const char *name) (errmsg("could not remove directory \"%s\"", slotdir))); } - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); return; } diff --git a/src/backend/utils/adt/genfile.c b/src/backend/utils/adt/genfile.c index 0d82557417..d95683d041 100644 --- a/src/backend/utils/adt/genfile.c +++ b/src/backend/utils/adt/genfile.c @@ -728,6 +728,7 @@ pg_ls_replslotdir(PG_FUNCTION_ARGS) errmsg("replication slot \"%s\" does not exist", slotname))); - snprintf(path, sizeof(path), "pg_replslot/%s", slotname); + snprintf(path, sizeof(path), "%s/%s", PG_REPLSLOT_DIR, slotname); + return pg_ls_dir_files(fcinfo, path, false); } diff --git a/src/bin/initdb/initdb.c b/src/bin/initdb/initdb.c index f00718a015..2ee55eced0 100644 --- a/src/bin/initdb/initdb.c +++ b/src/bin/initdb/initdb.c @@ -242,7 +242,7 @@ static const char *const subdirs[] = { "pg_multixact/offsets", "base", "base/1", - "pg_replslot", + "pg_replslot", /* defined as PG_REPLSLOT_DIR */ "pg_tblspc", "pg_stat", "pg_stat_tmp", diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c index 4458324c9d..00e644d988 100644 --- a/src/bin/pg_rewind/filemap.c +++ b/src/bin/pg_rewind/filemap.c @@ -97,7 +97,7 @@ static const char *const excludeDirContents[] = * even if the intention is to restore to another primary. See backup.sgml * for a more detailed description. */ - "pg_replslot", + "pg_replslot", /* defined as PG_REPLSLOT_DIR */ /* Contents removed on startup, see dsm_cleanup_for_mmap(). */ "pg_dynshmem", /* defined as PG_DYNSHMEM_DIR */ diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h index c2ee149fd6..9665faac1c 100644 --- a/src/include/replication/slot.h +++ b/src/include/replication/slot.h @@ -17,6 +17,8 @@ #include "storage/spin.h" #include "replication/walreceiver.h" +#define PG_REPLSLOT_DIR "pg_replslot" + /* * Behaviour of replication slots, upon release or crash. * -- 2.34.1 --Q6rxrhKDN6RKlQzQ Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v3-0002-Define-REPLSLOT_DIR_ARGS.patch" ^ permalink raw reply [nested|flat] 30+ messages in thread
* [PATCH v2 1/5] Define PG_REPLSLOT_DIR @ 2024-08-14 09:16 Bertrand Drouvot <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-14 09:16 UTC (permalink / raw) Replace most of the places where "pg_replslot" is used in .c files with a new PG_REPLSLOT_DIR define. The places where it is not done is for consistency with the existing PG_STAT_TMP_DIR define. --- src/backend/backup/basebackup.c | 3 +- .../replication/logical/reorderbuffer.c | 15 ++++---- src/backend/replication/slot.c | 38 +++++++++---------- src/backend/utils/adt/genfile.c | 5 ++- src/bin/initdb/initdb.c | 2 +- src/bin/pg_rewind/filemap.c | 2 +- src/include/replication/slot.h | 2 + 7 files changed, 36 insertions(+), 31 deletions(-) 24.0% src/backend/replication/logical/ 59.8% src/backend/replication/ 8.7% src/backend/utils/adt/ 4.1% src/bin/ 3.2% src/ diff --git a/src/backend/backup/basebackup.c b/src/backend/backup/basebackup.c index 01b35e26bd..de16afac74 100644 --- a/src/backend/backup/basebackup.c +++ b/src/backend/backup/basebackup.c @@ -36,6 +36,7 @@ #include "port.h" #include "postmaster/syslogger.h" #include "postmaster/walsummarizer.h" +#include "replication/slot.h" #include "replication/walsender.h" #include "replication/walsender_private.h" #include "storage/bufpage.h" @@ -161,7 +162,7 @@ static const char *const excludeDirContents[] = * even if the intention is to restore to another primary. See backup.sgml * for a more detailed description. */ - "pg_replslot", + PG_REPLSLOT_DIR, /* Contents removed on startup, see dsm_cleanup_for_mmap(). */ PG_DYNSHMEM_DIR, diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index 00a8327e77..6f98115d1e 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -4573,7 +4573,7 @@ ReorderBufferCleanupSerializedTXNs(const char *slotname) struct stat statbuf; char path[MAXPGPATH * 2 + 12]; - sprintf(path, "pg_replslot/%s", slotname); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, slotname); /* we're only handling directories here, skip if it's not ours */ if (lstat(path, &statbuf) == 0 && !S_ISDIR(statbuf.st_mode)) @@ -4586,14 +4586,14 @@ ReorderBufferCleanupSerializedTXNs(const char *slotname) if (strncmp(spill_de->d_name, "xid", 3) == 0) { snprintf(path, sizeof(path), - "pg_replslot/%s/%s", slotname, + "%s/%s/%s", PG_REPLSLOT_DIR, slotname, spill_de->d_name); if (unlink(path) != 0) ereport(ERROR, (errcode_for_file_access(), - errmsg("could not remove file \"%s\" during removal of pg_replslot/%s/xid*: %m", - path, slotname))); + errmsg("could not remove file \"%s\" during removal of %s/%s/xid*: %m", + PG_REPLSLOT_DIR, path, slotname))); } } FreeDir(spill_dir); @@ -4612,7 +4612,8 @@ ReorderBufferSerializedPath(char *path, ReplicationSlot *slot, TransactionId xid XLogSegNoOffsetToRecPtr(segno, 0, wal_segment_size, recptr); - snprintf(path, MAXPGPATH, "pg_replslot/%s/xid-%u-lsn-%X-%X.spill", + snprintf(path, MAXPGPATH, "%s/%s/xid-%u-lsn-%X-%X.spill", + PG_REPLSLOT_DIR, NameStr(MyReplicationSlot->data.name), xid, LSN_FORMAT_ARGS(recptr)); } @@ -4627,8 +4628,8 @@ StartupReorderBuffer(void) DIR *logical_dir; struct dirent *logical_de; - logical_dir = AllocateDir("pg_replslot"); - while ((logical_de = ReadDir(logical_dir, "pg_replslot")) != NULL) + logical_dir = AllocateDir(PG_REPLSLOT_DIR); + while ((logical_de = ReadDir(logical_dir, PG_REPLSLOT_DIR)) != NULL) { if (strcmp(logical_de->d_name, ".") == 0 || strcmp(logical_de->d_name, "..") == 0) diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index c290339af5..55e161f8c9 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -20,7 +20,7 @@ * on standbys (to support cascading setups). The requirement that slots be * usable on standbys precludes storing them in the system catalogs. * - * Each replication slot gets its own directory inside the $PGDATA/pg_replslot + * Each replication slot gets its own directory inside the $PGDATA/PG_REPLSLOT_DIR * directory. Inside that directory the state file will contain the slot's * own data. Additional data can be stored alongside that file if required. * While the server is running, the state data is also cached in memory for @@ -916,8 +916,8 @@ ReplicationSlotDropPtr(ReplicationSlot *slot) LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE); /* Generate pathnames. */ - sprintf(path, "pg_replslot/%s", NameStr(slot->data.name)); - sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(slot->data.name)); + sprintf(tmppath, "%s/%s.tmp", PG_REPLSLOT_DIR, NameStr(slot->data.name)); /* * Rename the slot directory on disk, so that we'll no longer recognize @@ -938,7 +938,7 @@ ReplicationSlotDropPtr(ReplicationSlot *slot) */ START_CRIT_SECTION(); fsync_fname(tmppath, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); } else @@ -1016,7 +1016,7 @@ ReplicationSlotSave(void) Assert(MyReplicationSlot != NULL); - sprintf(path, "pg_replslot/%s", NameStr(MyReplicationSlot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(MyReplicationSlot->data.name)); SaveSlotToPath(MyReplicationSlot, path, ERROR); } @@ -1881,7 +1881,7 @@ CheckPointReplicationSlots(bool is_shutdown) continue; /* save the slot to disk, locking is handled in SaveSlotToPath() */ - sprintf(path, "pg_replslot/%s", NameStr(s->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(s->data.name)); /* * Slot's data is not flushed each time the confirmed_flush LSN is @@ -1922,17 +1922,17 @@ StartupReplicationSlots(void) elog(DEBUG1, "starting up replication slots"); /* restore all slots by iterating over all on-disk entries */ - replication_dir = AllocateDir("pg_replslot"); - while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL) + replication_dir = AllocateDir(PG_REPLSLOT_DIR); + while ((replication_de = ReadDir(replication_dir, PG_REPLSLOT_DIR)) != NULL) { - char path[MAXPGPATH + 12]; + char path[MAXPGPATH + sizeof(PG_REPLSLOT_DIR)]; PGFileType de_type; if (strcmp(replication_de->d_name, ".") == 0 || strcmp(replication_de->d_name, "..") == 0) continue; - snprintf(path, sizeof(path), "pg_replslot/%s", replication_de->d_name); + snprintf(path, sizeof(path), "%s/%s", PG_REPLSLOT_DIR, replication_de->d_name); de_type = get_dirent_type(path, replication_de, false, DEBUG1); /* we're only creating directories here, skip if it's not our's */ @@ -1949,7 +1949,7 @@ StartupReplicationSlots(void) path))); continue; } - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); continue; } @@ -1987,8 +1987,8 @@ CreateSlotOnDisk(ReplicationSlot *slot) * takes out the lock, if we'd take the lock here, we'd deadlock. */ - sprintf(path, "pg_replslot/%s", NameStr(slot->data.name)); - sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(slot->data.name)); + sprintf(tmppath, "%s/%s.tmp", PG_REPLSLOT_DIR, NameStr(slot->data.name)); /* * It's just barely possible that some previous effort to create or drop a @@ -2027,7 +2027,7 @@ CreateSlotOnDisk(ReplicationSlot *slot) START_CRIT_SECTION(); fsync_fname(path, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); } @@ -2170,7 +2170,7 @@ SaveSlotToPath(ReplicationSlot *slot, const char *dir, int elevel) fsync_fname(path, false); fsync_fname(dir, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); @@ -2195,8 +2195,8 @@ RestoreSlotFromDisk(const char *name) { ReplicationSlotOnDisk cp; int i; - char slotdir[MAXPGPATH + 12]; - char path[MAXPGPATH + 22]; + char slotdir[MAXPGPATH + sizeof(PG_REPLSLOT_DIR)]; + char path[MAXPGPATH + sizeof(PG_REPLSLOT_DIR) + 10]; int fd; bool restored = false; int readBytes; @@ -2205,7 +2205,7 @@ RestoreSlotFromDisk(const char *name) /* no need to lock here, no concurrent access allowed yet */ /* delete temp file if it exists */ - sprintf(slotdir, "pg_replslot/%s", name); + sprintf(slotdir, "%s/%s", PG_REPLSLOT_DIR, name); sprintf(path, "%s/state.tmp", slotdir); if (unlink(path) < 0 && errno != ENOENT) ereport(PANIC, @@ -2332,7 +2332,7 @@ RestoreSlotFromDisk(const char *name) (errmsg("could not remove directory \"%s\"", slotdir))); } - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); return; } diff --git a/src/backend/utils/adt/genfile.c b/src/backend/utils/adt/genfile.c index 0d82557417..e645e6b85a 100644 --- a/src/backend/utils/adt/genfile.c +++ b/src/backend/utils/adt/genfile.c @@ -708,7 +708,7 @@ pg_ls_logicalmapdir(PG_FUNCTION_ARGS) } /* - * Function to return the list of files in the pg_replslot/<replication_slot> + * Function to return the list of files in the PG_REPLSLOT_DIR/<replication_slot> * directory. */ Datum @@ -728,6 +728,7 @@ pg_ls_replslotdir(PG_FUNCTION_ARGS) errmsg("replication slot \"%s\" does not exist", slotname))); - snprintf(path, sizeof(path), "pg_replslot/%s", slotname); + snprintf(path, sizeof(path), "%s/%s", PG_REPLSLOT_DIR, slotname); + return pg_ls_dir_files(fcinfo, path, false); } diff --git a/src/bin/initdb/initdb.c b/src/bin/initdb/initdb.c index f00718a015..2ee55eced0 100644 --- a/src/bin/initdb/initdb.c +++ b/src/bin/initdb/initdb.c @@ -242,7 +242,7 @@ static const char *const subdirs[] = { "pg_multixact/offsets", "base", "base/1", - "pg_replslot", + "pg_replslot", /* defined as PG_REPLSLOT_DIR */ "pg_tblspc", "pg_stat", "pg_stat_tmp", diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c index 4458324c9d..00e644d988 100644 --- a/src/bin/pg_rewind/filemap.c +++ b/src/bin/pg_rewind/filemap.c @@ -97,7 +97,7 @@ static const char *const excludeDirContents[] = * even if the intention is to restore to another primary. See backup.sgml * for a more detailed description. */ - "pg_replslot", + "pg_replslot", /* defined as PG_REPLSLOT_DIR */ /* Contents removed on startup, see dsm_cleanup_for_mmap(). */ "pg_dynshmem", /* defined as PG_DYNSHMEM_DIR */ diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h index c2ee149fd6..9665faac1c 100644 --- a/src/include/replication/slot.h +++ b/src/include/replication/slot.h @@ -17,6 +17,8 @@ #include "storage/spin.h" #include "replication/walreceiver.h" +#define PG_REPLSLOT_DIR "pg_replslot" + /* * Behaviour of replication slots, upon release or crash. * -- 2.34.1 --2N+tbir8xF9qUTGa Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v2-0002-Define-PG_LOGICAL_MAPPINGS_DIR.patch" ^ permalink raw reply [nested|flat] 30+ messages in thread
* [PATCH v1] Define PG_REPLSLOT_DIR @ 2024-08-14 09:16 Bertrand Drouvot <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-14 09:16 UTC (permalink / raw) Replace most of the places where "pg_replslot" is used in .c files with a new PG_REPLSLOT_DIR define. The places where it is not done is for consistency with the existing PG_STAT_TMP_DIR define. --- src/backend/backup/basebackup.c | 3 +- .../replication/logical/reorderbuffer.c | 15 +++++---- src/backend/replication/slot.c | 32 +++++++++---------- src/backend/utils/adt/genfile.c | 5 +-- src/bin/initdb/initdb.c | 2 +- src/bin/pg_rewind/filemap.c | 2 +- src/include/replication/slot.h | 2 ++ 7 files changed, 33 insertions(+), 28 deletions(-) 25.9% src/backend/replication/logical/ 56.5% src/backend/replication/ 9.4% src/backend/utils/adt/ 4.4% src/bin/ 3.5% src/ diff --git a/src/backend/backup/basebackup.c b/src/backend/backup/basebackup.c index 01b35e26bd..de16afac74 100644 --- a/src/backend/backup/basebackup.c +++ b/src/backend/backup/basebackup.c @@ -36,6 +36,7 @@ #include "port.h" #include "postmaster/syslogger.h" #include "postmaster/walsummarizer.h" +#include "replication/slot.h" #include "replication/walsender.h" #include "replication/walsender_private.h" #include "storage/bufpage.h" @@ -161,7 +162,7 @@ static const char *const excludeDirContents[] = * even if the intention is to restore to another primary. See backup.sgml * for a more detailed description. */ - "pg_replslot", + PG_REPLSLOT_DIR, /* Contents removed on startup, see dsm_cleanup_for_mmap(). */ PG_DYNSHMEM_DIR, diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index 00a8327e77..6f98115d1e 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -4573,7 +4573,7 @@ ReorderBufferCleanupSerializedTXNs(const char *slotname) struct stat statbuf; char path[MAXPGPATH * 2 + 12]; - sprintf(path, "pg_replslot/%s", slotname); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, slotname); /* we're only handling directories here, skip if it's not ours */ if (lstat(path, &statbuf) == 0 && !S_ISDIR(statbuf.st_mode)) @@ -4586,14 +4586,14 @@ ReorderBufferCleanupSerializedTXNs(const char *slotname) if (strncmp(spill_de->d_name, "xid", 3) == 0) { snprintf(path, sizeof(path), - "pg_replslot/%s/%s", slotname, + "%s/%s/%s", PG_REPLSLOT_DIR, slotname, spill_de->d_name); if (unlink(path) != 0) ereport(ERROR, (errcode_for_file_access(), - errmsg("could not remove file \"%s\" during removal of pg_replslot/%s/xid*: %m", - path, slotname))); + errmsg("could not remove file \"%s\" during removal of %s/%s/xid*: %m", + PG_REPLSLOT_DIR, path, slotname))); } } FreeDir(spill_dir); @@ -4612,7 +4612,8 @@ ReorderBufferSerializedPath(char *path, ReplicationSlot *slot, TransactionId xid XLogSegNoOffsetToRecPtr(segno, 0, wal_segment_size, recptr); - snprintf(path, MAXPGPATH, "pg_replslot/%s/xid-%u-lsn-%X-%X.spill", + snprintf(path, MAXPGPATH, "%s/%s/xid-%u-lsn-%X-%X.spill", + PG_REPLSLOT_DIR, NameStr(MyReplicationSlot->data.name), xid, LSN_FORMAT_ARGS(recptr)); } @@ -4627,8 +4628,8 @@ StartupReorderBuffer(void) DIR *logical_dir; struct dirent *logical_de; - logical_dir = AllocateDir("pg_replslot"); - while ((logical_de = ReadDir(logical_dir, "pg_replslot")) != NULL) + logical_dir = AllocateDir(PG_REPLSLOT_DIR); + while ((logical_de = ReadDir(logical_dir, PG_REPLSLOT_DIR)) != NULL) { if (strcmp(logical_de->d_name, ".") == 0 || strcmp(logical_de->d_name, "..") == 0) diff --git a/src/backend/replication/slot.c b/src/backend/replication/slot.c index c290339af5..2e7366ef5f 100644 --- a/src/backend/replication/slot.c +++ b/src/backend/replication/slot.c @@ -20,7 +20,7 @@ * on standbys (to support cascading setups). The requirement that slots be * usable on standbys precludes storing them in the system catalogs. * - * Each replication slot gets its own directory inside the $PGDATA/pg_replslot + * Each replication slot gets its own directory inside the $PGDATA/PG_REPLSLOT_DIR * directory. Inside that directory the state file will contain the slot's * own data. Additional data can be stored alongside that file if required. * While the server is running, the state data is also cached in memory for @@ -916,8 +916,8 @@ ReplicationSlotDropPtr(ReplicationSlot *slot) LWLockAcquire(ReplicationSlotAllocationLock, LW_EXCLUSIVE); /* Generate pathnames. */ - sprintf(path, "pg_replslot/%s", NameStr(slot->data.name)); - sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(slot->data.name)); + sprintf(tmppath, "%s/%s.tmp", PG_REPLSLOT_DIR, NameStr(slot->data.name)); /* * Rename the slot directory on disk, so that we'll no longer recognize @@ -938,7 +938,7 @@ ReplicationSlotDropPtr(ReplicationSlot *slot) */ START_CRIT_SECTION(); fsync_fname(tmppath, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); } else @@ -1016,7 +1016,7 @@ ReplicationSlotSave(void) Assert(MyReplicationSlot != NULL); - sprintf(path, "pg_replslot/%s", NameStr(MyReplicationSlot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(MyReplicationSlot->data.name)); SaveSlotToPath(MyReplicationSlot, path, ERROR); } @@ -1881,7 +1881,7 @@ CheckPointReplicationSlots(bool is_shutdown) continue; /* save the slot to disk, locking is handled in SaveSlotToPath() */ - sprintf(path, "pg_replslot/%s", NameStr(s->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(s->data.name)); /* * Slot's data is not flushed each time the confirmed_flush LSN is @@ -1922,8 +1922,8 @@ StartupReplicationSlots(void) elog(DEBUG1, "starting up replication slots"); /* restore all slots by iterating over all on-disk entries */ - replication_dir = AllocateDir("pg_replslot"); - while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL) + replication_dir = AllocateDir(PG_REPLSLOT_DIR); + while ((replication_de = ReadDir(replication_dir, PG_REPLSLOT_DIR)) != NULL) { char path[MAXPGPATH + 12]; PGFileType de_type; @@ -1932,7 +1932,7 @@ StartupReplicationSlots(void) strcmp(replication_de->d_name, "..") == 0) continue; - snprintf(path, sizeof(path), "pg_replslot/%s", replication_de->d_name); + snprintf(path, sizeof(path), "%s/%s", PG_REPLSLOT_DIR, replication_de->d_name); de_type = get_dirent_type(path, replication_de, false, DEBUG1); /* we're only creating directories here, skip if it's not our's */ @@ -1949,7 +1949,7 @@ StartupReplicationSlots(void) path))); continue; } - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); continue; } @@ -1987,8 +1987,8 @@ CreateSlotOnDisk(ReplicationSlot *slot) * takes out the lock, if we'd take the lock here, we'd deadlock. */ - sprintf(path, "pg_replslot/%s", NameStr(slot->data.name)); - sprintf(tmppath, "pg_replslot/%s.tmp", NameStr(slot->data.name)); + sprintf(path, "%s/%s", PG_REPLSLOT_DIR, NameStr(slot->data.name)); + sprintf(tmppath, "%s/%s.tmp", PG_REPLSLOT_DIR, NameStr(slot->data.name)); /* * It's just barely possible that some previous effort to create or drop a @@ -2027,7 +2027,7 @@ CreateSlotOnDisk(ReplicationSlot *slot) START_CRIT_SECTION(); fsync_fname(path, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); } @@ -2170,7 +2170,7 @@ SaveSlotToPath(ReplicationSlot *slot, const char *dir, int elevel) fsync_fname(path, false); fsync_fname(dir, true); - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); END_CRIT_SECTION(); @@ -2205,7 +2205,7 @@ RestoreSlotFromDisk(const char *name) /* no need to lock here, no concurrent access allowed yet */ /* delete temp file if it exists */ - sprintf(slotdir, "pg_replslot/%s", name); + sprintf(slotdir, "%s/%s", PG_REPLSLOT_DIR, name); sprintf(path, "%s/state.tmp", slotdir); if (unlink(path) < 0 && errno != ENOENT) ereport(PANIC, @@ -2332,7 +2332,7 @@ RestoreSlotFromDisk(const char *name) (errmsg("could not remove directory \"%s\"", slotdir))); } - fsync_fname("pg_replslot", true); + fsync_fname(PG_REPLSLOT_DIR, true); return; } diff --git a/src/backend/utils/adt/genfile.c b/src/backend/utils/adt/genfile.c index 0d82557417..e645e6b85a 100644 --- a/src/backend/utils/adt/genfile.c +++ b/src/backend/utils/adt/genfile.c @@ -708,7 +708,7 @@ pg_ls_logicalmapdir(PG_FUNCTION_ARGS) } /* - * Function to return the list of files in the pg_replslot/<replication_slot> + * Function to return the list of files in the PG_REPLSLOT_DIR/<replication_slot> * directory. */ Datum @@ -728,6 +728,7 @@ pg_ls_replslotdir(PG_FUNCTION_ARGS) errmsg("replication slot \"%s\" does not exist", slotname))); - snprintf(path, sizeof(path), "pg_replslot/%s", slotname); + snprintf(path, sizeof(path), "%s/%s", PG_REPLSLOT_DIR, slotname); + return pg_ls_dir_files(fcinfo, path, false); } diff --git a/src/bin/initdb/initdb.c b/src/bin/initdb/initdb.c index f00718a015..2ee55eced0 100644 --- a/src/bin/initdb/initdb.c +++ b/src/bin/initdb/initdb.c @@ -242,7 +242,7 @@ static const char *const subdirs[] = { "pg_multixact/offsets", "base", "base/1", - "pg_replslot", + "pg_replslot", /* defined as PG_REPLSLOT_DIR */ "pg_tblspc", "pg_stat", "pg_stat_tmp", diff --git a/src/bin/pg_rewind/filemap.c b/src/bin/pg_rewind/filemap.c index 4458324c9d..00e644d988 100644 --- a/src/bin/pg_rewind/filemap.c +++ b/src/bin/pg_rewind/filemap.c @@ -97,7 +97,7 @@ static const char *const excludeDirContents[] = * even if the intention is to restore to another primary. See backup.sgml * for a more detailed description. */ - "pg_replslot", + "pg_replslot", /* defined as PG_REPLSLOT_DIR */ /* Contents removed on startup, see dsm_cleanup_for_mmap(). */ "pg_dynshmem", /* defined as PG_DYNSHMEM_DIR */ diff --git a/src/include/replication/slot.h b/src/include/replication/slot.h index c2ee149fd6..9665faac1c 100644 --- a/src/include/replication/slot.h +++ b/src/include/replication/slot.h @@ -17,6 +17,8 @@ #include "storage/spin.h" #include "replication/walreceiver.h" +#define PG_REPLSLOT_DIR "pg_replslot" + /* * Behaviour of replication slots, upon release or crash. * -- 2.34.1 --5CsiXv77sjBcVIcJ-- ^ permalink raw reply [nested|flat] 30+ messages in thread
* define PG_REPLSLOT_DIR @ 2024-08-14 11:32 Bertrand Drouvot <[email protected]> 0 siblings, 3 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-14 11:32 UTC (permalink / raw) To: [email protected] Hi hackers, while working on a replication slot tool (idea is to put it in contrib, not shared yet), I realized that "pg_replslot" is being used > 25 times in .c files. I think it would make sense to replace those occurrences with a $SUBJECT, attached a patch doing so. There is 2 places where it is not done: src/bin/initdb/initdb.c src/bin/pg_rewind/filemap.c for consistency with the existing PG_STAT_TMP_DIR define. Out of curiosity, checking the sizes of affected files (O2, no debug): with patch: text data bss dec hex filename 20315 224 17 20556 504c src/backend/backup/basebackup.o 30304 0 8 30312 7668 src/backend/replication/logical/reorderbuffer.o 23812 36 40 23888 5d50 src/backend/replication/slot.o 6367 0 0 6367 18df src/backend/utils/adt/genfile.o 40997 2574 2528 46099 b413 src/bin/initdb/initdb.o 6963 224 8 7195 1c1b src/bin/pg_rewind/filemap.o without patch: text data bss dec hex filename 20315 224 17 20556 504c src/backend/backup/basebackup.o 30286 0 8 30294 7656 src/backend/replication/logical/reorderbuffer.o 23766 36 40 23842 5d22 src/backend/replication/slot.o 6363 0 0 6363 18db src/backend/utils/adt/genfile.o 40997 2574 2528 46099 b413 src/bin/initdb/initdb.o 6963 224 8 7195 1c1b src/bin/pg_rewind/filemap.o Also, I think we could do the same for: pg_notify pg_serial pg_subtrans pg_wal pg_multixact pg_tblspc pg_logical And I volunteer to do so if you think that makes sense. Looking forward to your feedback, Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-16 00:40 Alvaro Herrera <[email protected]> parent: Bertrand Drouvot <[email protected]> 2 siblings, 1 reply; 30+ messages in thread From: Alvaro Herrera @ 2024-08-16 00:40 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: [email protected] On 2024-Aug-14, Bertrand Drouvot wrote: > Out of curiosity, checking the sizes of affected files (O2, no debug): > > with patch: > > text data bss dec hex filename > 30304 0 8 30312 7668 src/backend/replication/logical/reorderbuffer.o > without patch: > 30286 0 8 30294 7656 src/backend/replication/logical/reorderbuffer.o Hmm, I suppose this delta can be explained because because the literal string is used inside larger snprintf() format strings or similar, so things like snprintf(path, sizeof(path), - "pg_replslot/%s/%s", slotname, + "%s/%s/%s", PG_REPLSLOT_DIR, slotname, spill_de->d_name); and ereport(ERROR, (errcode_for_file_access(), - errmsg("could not remove file \"%s\" during removal of pg_replslot/%s/xid*: %m", - path, slotname))); + errmsg("could not remove file \"%s\" during removal of %s/%s/xid*: %m", + PG_REPLSLOT_DIR, path, slotname))); I don't disagree with making this change, but changing some of the other directory names you suggest, such as > pg_notify > pg_serial > pg_subtrans > pg_multixact > pg_wal would probably make no difference, since there are no literal strings that contain that as a substring(*). It might some sense to handle pg_tblspc similarly. As for pg_logical, I think you'll want separate defines for pg_logical/mappings, pg_logical/snapshots and so on. (*) I hope you're not going to suggest this kind of change (word-diff): if (GetOldestSnapshot()) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("[-pg_wal-]{+%s+}_replay_wait() must be only called without an active or registered snapshot"{+, PG_WAL_DIR+}), errdetail("Make sure [-pg_wal-]{+%s+}_replay_wait() isn't called within a transaction with an isolation level higher than READ COMMITTED, another procedure, or a function."{+, PG_WAL_DIR+}))); -- Álvaro Herrera 48°01'N 7°57'E — https://www.EnterpriseDB.com/ "Los trabajadores menos efectivos son sistematicamente llevados al lugar donde pueden hacer el menor daño posible: gerencia." (El principio Dilbert) ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-16 04:31 Yugo Nagata <[email protected]> parent: Bertrand Drouvot <[email protected]> 2 siblings, 1 reply; 30+ messages in thread From: Yugo Nagata @ 2024-08-16 04:31 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: [email protected] On Wed, 14 Aug 2024 11:32:14 +0000 Bertrand Drouvot <[email protected]> wrote: > Hi hackers, > > while working on a replication slot tool (idea is to put it in contrib, not > shared yet), I realized that "pg_replslot" is being used > 25 times in > .c files. > > I think it would make sense to replace those occurrences with a $SUBJECT, attached > a patch doing so. > > There is 2 places where it is not done: > > src/bin/initdb/initdb.c > src/bin/pg_rewind/filemap.c > > for consistency with the existing PG_STAT_TMP_DIR define. > > Out of curiosity, checking the sizes of affected files (O2, no debug): > > with patch: > > text data bss dec hex filename > 20315 224 17 20556 504c src/backend/backup/basebackup.o > 30304 0 8 30312 7668 src/backend/replication/logical/reorderbuffer.o > 23812 36 40 23888 5d50 src/backend/replication/slot.o > 6367 0 0 6367 18df src/backend/utils/adt/genfile.o > 40997 2574 2528 46099 b413 src/bin/initdb/initdb.o > 6963 224 8 7195 1c1b src/bin/pg_rewind/filemap.o > > without patch: > > text data bss dec hex filename > 20315 224 17 20556 504c src/backend/backup/basebackup.o > 30286 0 8 30294 7656 src/backend/replication/logical/reorderbuffer.o > 23766 36 40 23842 5d22 src/backend/replication/slot.o > 6363 0 0 6363 18db src/backend/utils/adt/genfile.o > 40997 2574 2528 46099 b413 src/bin/initdb/initdb.o > 6963 224 8 7195 1c1b src/bin/pg_rewind/filemap.o > > Also, I think we could do the same for: > > pg_notify > pg_serial > pg_subtrans > pg_wal > pg_multixact > pg_tblspc > pg_logical > > And I volunteer to do so if you think that makes sense. > > Looking forward to your feedback, /* restore all slots by iterating over all on-disk entries */ - replication_dir = AllocateDir("pg_replslot"); - while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL) + replication_dir = AllocateDir(PG_REPLSLOT_DIR); + while ((replication_de = ReadDir(replication_dir, PG_REPLSLOT_DIR)) != NULL) { char path[MAXPGPATH + 12]; PGFileType de_type; I think the size of path can be rewritten to "MAXPGPATH + sizeof(PG_REPLSLOT_DIR)" and it seems easier to understand the reason why this size is used. (That said, I wonder the path would never longer than MAXPGPATH...) Regards, Yugo Nagata > > Regards, > > -- > Bertrand Drouvot > PostgreSQL Contributors Team > RDS Open Source Databases > Amazon Web Services: https://aws.amazon.com -- Yugo Nagata <[email protected]> ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-19 10:41 Ashutosh Bapat <[email protected]> parent: Bertrand Drouvot <[email protected]> 2 siblings, 1 reply; 30+ messages in thread From: Ashutosh Bapat @ 2024-08-19 10:41 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: [email protected] On Wed, Aug 14, 2024 at 5:02 PM Bertrand Drouvot <[email protected]> wrote: > > Hi hackers, > > while working on a replication slot tool (idea is to put it in contrib, not > shared yet), I realized that "pg_replslot" is being used > 25 times in > .c files. > > I think it would make sense to replace those occurrences with a $SUBJECT, attached > a patch doing so. Many of these places are slot specific directory/file names within pg_replslot. I think we can further improve the code by creating macro on the lines of LSN_FORMAT_ARGS #define SLOT_DIRNAME_ARGS(slotname) (PG_REPLSLOT_DIR, slotname) this way we "codify" method to construct the slot directory name everywhere. We may add another macro #define SLOT_DIRNAME_FORMAT "%s/%s" to further enforce the same. But I didn't find similar LSN_FORMAT macro defined as "%X/%X". I don't remember exactly why we didn't add it. May be because of trouble with translations. -- Best Wishes, Ashutosh Bapat ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-19 14:11 Bertrand Drouvot <[email protected]> parent: Alvaro Herrera <[email protected]> 0 siblings, 2 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-19 14:11 UTC (permalink / raw) To: Alvaro Herrera <[email protected]>; +Cc: [email protected] Hi, On Thu, Aug 15, 2024 at 08:40:42PM -0400, Alvaro Herrera wrote: > On 2024-Aug-14, Bertrand Drouvot wrote: > > > Out of curiosity, checking the sizes of affected files (O2, no debug): > > > > with patch: > > > > text data bss dec hex filename > > 30304 0 8 30312 7668 src/backend/replication/logical/reorderbuffer.o > > > without patch: > > 30286 0 8 30294 7656 src/backend/replication/logical/reorderbuffer.o > > Hmm, I suppose this delta can be explained because because the literal > string is used inside larger snprintf() format strings or similar, so > things like > > snprintf(path, sizeof(path), > - "pg_replslot/%s/%s", slotname, > + "%s/%s/%s", PG_REPLSLOT_DIR, slotname, > spill_de->d_name); > > and > > ereport(ERROR, > (errcode_for_file_access(), > - errmsg("could not remove file \"%s\" during removal of pg_replslot/%s/xid*: %m", > - path, slotname))); > + errmsg("could not remove file \"%s\" during removal of %s/%s/xid*: %m", > + PG_REPLSLOT_DIR, path, slotname))); > I did not look in details, but yeah that could probably be explained that way. > I don't disagree with making this change, but changing some of the other > directory names you suggest, such as > > > pg_notify > > pg_serial > > pg_subtrans > > pg_multixact > > pg_wal > > would probably make no difference, since there are no literal strings > that contain that as a substring(*). It might some sense to handle > pg_tblspc similarly. As for pg_logical, I think you'll want separate > defines for pg_logical/mappings, pg_logical/snapshots and so on. > > > (*) I hope you're not going to suggest this kind of change (word-diff): > > if (GetOldestSnapshot()) > ereport(ERROR, > (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), > errmsg("[-pg_wal-]{+%s+}_replay_wait() must be only called without an active or registered snapshot"{+, PG_WAL_DIR+}), > errdetail("Make sure [-pg_wal-]{+%s+}_replay_wait() isn't called within a transaction with an isolation level higher than READ COMMITTED, another procedure, or a function."{+, PG_WAL_DIR+}))); > Yeah, would not cross my mind ;-). I might have been tempted to do the change in pg_combinebackup.c though. Having said that, I agree to focus only on: pg_replslot pg_tblspc pg_logical/* I made the changes for pg_tblspc in pg_combinebackup.c as the number of occurences are greater that the "pg_wal" ones and we were to define PG_TBLSPC_DIR in any case. Please find attached the related patches. Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-19 14:13 Bertrand Drouvot <[email protected]> parent: Yugo Nagata <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-19 14:13 UTC (permalink / raw) To: Yugo Nagata <[email protected]>; +Cc: [email protected] Hi, On Fri, Aug 16, 2024 at 01:31:11PM +0900, Yugo Nagata wrote: > On Wed, 14 Aug 2024 11:32:14 +0000 > Bertrand Drouvot <[email protected]> wrote: > > Looking forward to your feedback, > > /* restore all slots by iterating over all on-disk entries */ > - replication_dir = AllocateDir("pg_replslot"); > - while ((replication_de = ReadDir(replication_dir, "pg_replslot")) != NULL) > + replication_dir = AllocateDir(PG_REPLSLOT_DIR); > + while ((replication_de = ReadDir(replication_dir, PG_REPLSLOT_DIR)) != NULL) > { > char path[MAXPGPATH + 12]; > PGFileType de_type; > > I think the size of path can be rewritten to "MAXPGPATH + sizeof(PG_REPLSLOT_DIR)" > and it seems easier to understand the reason why this size is used. Thanks for the feedback! Yeah, fully agree, it has been done that way in v2 that I just shared up-thread. Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-19 14:17 Bertrand Drouvot <[email protected]> parent: Ashutosh Bapat <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-19 14:17 UTC (permalink / raw) To: Ashutosh Bapat <[email protected]>; +Cc: [email protected] Hi, On Mon, Aug 19, 2024 at 04:11:31PM +0530, Ashutosh Bapat wrote: > On Wed, Aug 14, 2024 at 5:02 PM Bertrand Drouvot > <[email protected]> wrote: > > > > Hi hackers, > > > > while working on a replication slot tool (idea is to put it in contrib, not > > shared yet), I realized that "pg_replslot" is being used > 25 times in > > .c files. > > > > I think it would make sense to replace those occurrences with a $SUBJECT, attached > > a patch doing so. > > Many of these places are slot specific directory/file names within > pg_replslot. I think we can further improve the code by creating macro > on the lines of LSN_FORMAT_ARGS > #define SLOT_DIRNAME_ARGS(slotname) (PG_REPLSLOT_DIR, slotname) > this way we "codify" method to construct the slot directory name > everywhere. Thanks for the feedback! I think that could make sense. As the already proposed mechanical changes are error prone (from my point of view), I would suggest to have a look at your proposal once the proposed changes go in. Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 03:56 Ashutosh Bapat <[email protected]> parent: Bertrand Drouvot <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Ashutosh Bapat @ 2024-08-20 03:56 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: [email protected] On Mon, Aug 19, 2024 at 7:47 PM Bertrand Drouvot <[email protected]> wrote: > > Hi, > > On Mon, Aug 19, 2024 at 04:11:31PM +0530, Ashutosh Bapat wrote: > > On Wed, Aug 14, 2024 at 5:02 PM Bertrand Drouvot > > <[email protected]> wrote: > > > > > > Hi hackers, > > > > > > while working on a replication slot tool (idea is to put it in contrib, not > > > shared yet), I realized that "pg_replslot" is being used > 25 times in > > > .c files. > > > > > > I think it would make sense to replace those occurrences with a $SUBJECT, attached > > > a patch doing so. > > > > Many of these places are slot specific directory/file names within > > pg_replslot. I think we can further improve the code by creating macro > > on the lines of LSN_FORMAT_ARGS > > #define SLOT_DIRNAME_ARGS(slotname) (PG_REPLSLOT_DIR, slotname) > > this way we "codify" method to construct the slot directory name > > everywhere. > > Thanks for the feedback! > > I think that could make sense. As the already proposed mechanical changes are > error prone (from my point of view), I would suggest to have a look at your > proposal once the proposed changes go in. What do you mean by error prone? -- Best Wishes, Ashutosh Bapat ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 05:19 Bertrand Drouvot <[email protected]> parent: Ashutosh Bapat <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-20 05:19 UTC (permalink / raw) To: Ashutosh Bapat <[email protected]>; +Cc: [email protected] Hi, On Tue, Aug 20, 2024 at 09:26:59AM +0530, Ashutosh Bapat wrote: > On Mon, Aug 19, 2024 at 7:47 PM Bertrand Drouvot > <[email protected]> wrote: > > > > Hi, > > > > On Mon, Aug 19, 2024 at 04:11:31PM +0530, Ashutosh Bapat wrote: > > > On Wed, Aug 14, 2024 at 5:02 PM Bertrand Drouvot > > > <[email protected]> wrote: > > > > > > > > Hi hackers, > > > > > > > > while working on a replication slot tool (idea is to put it in contrib, not > > > > shared yet), I realized that "pg_replslot" is being used > 25 times in > > > > .c files. > > > > > > > > I think it would make sense to replace those occurrences with a $SUBJECT, attached > > > > a patch doing so. > > > > > > Many of these places are slot specific directory/file names within > > > pg_replslot. I think we can further improve the code by creating macro > > > on the lines of LSN_FORMAT_ARGS > > > #define SLOT_DIRNAME_ARGS(slotname) (PG_REPLSLOT_DIR, slotname) > > > this way we "codify" method to construct the slot directory name > > > everywhere. > > > > Thanks for the feedback! > > > > I think that could make sense. As the already proposed mechanical changes are > > error prone (from my point of view), I would suggest to have a look at your > > proposal once the proposed changes go in. > > What do you mean by error prone? I meant to say that it is "easy" to make mistakes when doing those manual mechanical changes. Also I think it's not that fun/easy to review, that's why I think it's better to do one change at a time. Does that make sense to you? Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 05:40 Ashutosh Bapat <[email protected]> parent: Bertrand Drouvot <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Ashutosh Bapat @ 2024-08-20 05:40 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: [email protected] On Tue, Aug 20, 2024 at 10:49 AM Bertrand Drouvot <[email protected]> wrote: > > Hi, > > On Tue, Aug 20, 2024 at 09:26:59AM +0530, Ashutosh Bapat wrote: > > On Mon, Aug 19, 2024 at 7:47 PM Bertrand Drouvot > > <[email protected]> wrote: > > > > > > Hi, > > > > > > On Mon, Aug 19, 2024 at 04:11:31PM +0530, Ashutosh Bapat wrote: > > > > On Wed, Aug 14, 2024 at 5:02 PM Bertrand Drouvot > > > > <[email protected]> wrote: > > > > > > > > > > Hi hackers, > > > > > > > > > > while working on a replication slot tool (idea is to put it in contrib, not > > > > > shared yet), I realized that "pg_replslot" is being used > 25 times in > > > > > .c files. > > > > > > > > > > I think it would make sense to replace those occurrences with a $SUBJECT, attached > > > > > a patch doing so. > > > > > > > > Many of these places are slot specific directory/file names within > > > > pg_replslot. I think we can further improve the code by creating macro > > > > on the lines of LSN_FORMAT_ARGS > > > > #define SLOT_DIRNAME_ARGS(slotname) (PG_REPLSLOT_DIR, slotname) > > > > this way we "codify" method to construct the slot directory name > > > > everywhere. > > > > > > Thanks for the feedback! > > > > > > I think that could make sense. As the already proposed mechanical changes are > > > error prone (from my point of view), I would suggest to have a look at your > > > proposal once the proposed changes go in. > > > > What do you mean by error prone? > > I meant to say that it is "easy" to make mistakes when doing those manual > mechanical changes. Also I think it's not that fun/easy to review, that's why > I think it's better to do one change at a time. Does that make sense to you? Since these are all related changes, doing them at once might make it faster. You may use multiple commits (one for each change) to "contain" errors. -- Best Wishes, Ashutosh Bapat ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 08:41 Michael Paquier <[email protected]> parent: Ashutosh Bapat <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Michael Paquier @ 2024-08-20 08:41 UTC (permalink / raw) To: Ashutosh Bapat <[email protected]>; +Cc: Bertrand Drouvot <[email protected]>; [email protected] On Tue, Aug 20, 2024 at 11:10:46AM +0530, Ashutosh Bapat wrote: > Since these are all related changes, doing them at once might make it > faster. You may use multiple commits (one for each change) Doing multiple commits with individual definitions for each path would be the way to go for me. All that is mechanical, still that feels slightly cleaner. > to "contain" errors. I am not sure what you mean by that. -- Michael Attachments: [application/pgp-signature] signature.asc (833B, ../../[email protected]/2-signature.asc) download ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 08:47 Michael Paquier <[email protected]> parent: Bertrand Drouvot <[email protected]> 1 sibling, 2 replies; 30+ messages in thread From: Michael Paquier @ 2024-08-20 08:47 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; [email protected] On Mon, Aug 19, 2024 at 02:11:55PM +0000, Bertrand Drouvot wrote: > I made the changes for pg_tblspc in pg_combinebackup.c as the number of occurences > are greater that the "pg_wal" ones and we were to define PG_TBLSPC_DIR in any > case. > > Please find attached the related patches. No real objection about the replslot and pg_logical bits. - * $PGDATA/pg_tblspc/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber + * $PGDATA/PG_TBLSPC_DIR/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber For the tablespace parts, I am not sure that I would update the comments to reflect the variables, TBH. Somebody reading the comments would need to refer back to pg_tblspc/ in the header. -- Michael Attachments: [application/pgp-signature] signature.asc (833B, ../../[email protected]/2-signature.asc) download ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 12:06 Bertrand Drouvot <[email protected]> parent: Michael Paquier <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-20 12:06 UTC (permalink / raw) To: Michael Paquier <[email protected]>; +Cc: Ashutosh Bapat <[email protected]>; [email protected] Hi, On Tue, Aug 20, 2024 at 05:41:48PM +0900, Michael Paquier wrote: > On Tue, Aug 20, 2024 at 11:10:46AM +0530, Ashutosh Bapat wrote: > > Since these are all related changes, doing them at once might make it > > faster. You may use multiple commits (one for each change) > > Doing multiple commits with individual definitions for each path would > be the way to go for me. All that is mechanical, still that feels > slightly cleaner. Right, that's what v2 has done. If there is a need for v3 then I'll add one dedicated patch for Ashutosh's proposal in the v3 series. Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 12:16 Bertrand Drouvot <[email protected]> parent: Michael Paquier <[email protected]> 1 sibling, 0 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-20 12:16 UTC (permalink / raw) To: Michael Paquier <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; [email protected] Hi, On Tue, Aug 20, 2024 at 05:47:57PM +0900, Michael Paquier wrote: > On Mon, Aug 19, 2024 at 02:11:55PM +0000, Bertrand Drouvot wrote: > > I made the changes for pg_tblspc in pg_combinebackup.c as the number of occurences > > are greater that the "pg_wal" ones and we were to define PG_TBLSPC_DIR in any > > case. > > > > Please find attached the related patches. > > No real objection about the replslot and pg_logical bits. Thanks for looking at it! > > - * $PGDATA/pg_tblspc/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber > + * $PGDATA/PG_TBLSPC_DIR/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber > > For the tablespace parts, I am not sure that I would update the > comments to reflect the variables, TBH. Somebody reading the comments > would need to refer back to pg_tblspc/ in the header. I'm not sure as, for example, for PG_STAT_TMP_DIR we have those ones: src/backend/backup/basebackup.c: * Skip temporary statistics files. PG_STAT_TMP_DIR must be skipped src/bin/pg_rewind/filemap.c: * Skip temporary statistics files. PG_STAT_TMP_DIR must be skipped so I thought it would be better to be consistent. That said, I don't have a strong opinion about it, but then I guess you'd want to do the same for the ones related to replslot: src/backend/replication/slot.c: * Each replication slot gets its own directory inside the $PGDATA/PG_REPLSLOT_DIR src/backend/utils/adt/genfile.c: * Function to return the list of files in the PG_REPLSLOT_DIR/<replication_slot> and pg_logical: src/backend/utils/adt/genfile.c: * Function to return the list of files in the PG_LOGICAL_SNAPSHOTS_DIR directory. src/backend/utils/adt/genfile.c: * Function to return the list of files in the PG_LOGICAL_MAPPINGS_DIR directory. , right? Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 12:30 Yugo Nagata <[email protected]> parent: Michael Paquier <[email protected]> 1 sibling, 1 reply; 30+ messages in thread From: Yugo Nagata @ 2024-08-20 12:30 UTC (permalink / raw) To: Michael Paquier <[email protected]>; +Cc: Bertrand Drouvot <[email protected]>; Alvaro Herrera <[email protected]>; [email protected] On Tue, 20 Aug 2024 17:47:57 +0900 Michael Paquier <[email protected]> wrote: > On Mon, Aug 19, 2024 at 02:11:55PM +0000, Bertrand Drouvot wrote: > > I made the changes for pg_tblspc in pg_combinebackup.c as the number of occurences > > are greater that the "pg_wal" ones and we were to define PG_TBLSPC_DIR in any > > case. > > > > Please find attached the related patches. > > No real objection about the replslot and pg_logical bits. > > - * $PGDATA/pg_tblspc/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber > + * $PGDATA/PG_TBLSPC_DIR/spcoid/PG_MAJORVER_CATVER/dboid/relfilenumber > > For the tablespace parts, I am not sure that I would update the > comments to reflect the variables, TBH. Somebody reading the comments > would need to refer back to pg_tblspc/ in the header. I also think that it is not necessary to change the comments even for pg_replslot. - * Each replication slot gets its own directory inside the $PGDATA/pg_replslot + * Each replication slot gets its own directory inside the $PGDATA/PG_REPLSLOT_DIR For example, I found that comments in xlog.c use "pg_wal" even though XLOGDIR is used in the codes as below, and I don't feel any problem for this. > static void > ValidateXLOGDirectoryStructure(void) > { > char path[MAXPGPATH]; > struct stat stat_buf; > > /* Check for pg_wal; if it doesn't exist, error out */ > if (stat(XLOGDIR, &stat_buf) != 0 || > !S_ISDIR(stat_buf.st_mode)) Should be the follwing also rewritten using sizeof(PG_REPLSLOT_DIR)? struct stat statbuf; char path[MAXPGPATH * 2 + 12]; Regards, Yugo Nagata -- Yugo Nagata <[email protected]> ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 14:15 Alvaro Herrera <[email protected]> parent: Bertrand Drouvot <[email protected]> 1 sibling, 1 reply; 30+ messages in thread From: Alvaro Herrera @ 2024-08-20 14:15 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: [email protected] On 2024-Aug-19, Bertrand Drouvot wrote: > diff --git a/src/include/common/relpath.h b/src/include/common/relpath.h > index 6f006d5a93..a6cb091635 100644 > --- a/src/include/common/relpath.h > +++ b/src/include/common/relpath.h > @@ -33,6 +33,10 @@ typedef Oid RelFileNumber; > #define TABLESPACE_VERSION_DIRECTORY "PG_" PG_MAJORVERSION "_" \ > CppAsString2(CATALOG_VERSION_NO) > > +#define PG_TBLSPC_DIR "pg_tblspc" This one is missing some commentary along the lines of "This must not be changed, unless you want to break every tool in the universe". As is, it's quite tempting. > +#define PG_TBLSPC_DIR_SLASH PG_TBLSPC_DIR "/" I would make this simply "pg_tblspc/", since it's not really possible to change pg_tblspc anyway. Also, have a comment explaining why we have it. -- Álvaro Herrera PostgreSQL Developer — https://www.EnterpriseDB.com/ "Los dioses no protegen a los insensatos. Éstos reciben protección de otros insensatos mejor dotados" (Luis Wu, Mundo Anillo) ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 16:23 Bertrand Drouvot <[email protected]> parent: Alvaro Herrera <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-20 16:23 UTC (permalink / raw) To: Alvaro Herrera <[email protected]>; +Cc: [email protected] Hi, On Tue, Aug 20, 2024 at 10:15:44AM -0400, Alvaro Herrera wrote: > On 2024-Aug-19, Bertrand Drouvot wrote: > > > diff --git a/src/include/common/relpath.h b/src/include/common/relpath.h > > index 6f006d5a93..a6cb091635 100644 > > --- a/src/include/common/relpath.h > > +++ b/src/include/common/relpath.h > > @@ -33,6 +33,10 @@ typedef Oid RelFileNumber; > > #define TABLESPACE_VERSION_DIRECTORY "PG_" PG_MAJORVERSION "_" \ > > CppAsString2(CATALOG_VERSION_NO) > > > > +#define PG_TBLSPC_DIR "pg_tblspc" > > This one is missing some commentary along the lines of "This must not be > changed, unless you want to break every tool in the universe". As is, > it's quite tempting. Yeah, makes sense, thanks. > > +#define PG_TBLSPC_DIR_SLASH PG_TBLSPC_DIR "/" > > I would make this simply "pg_tblspc/", since it's not really possible to > change pg_tblspc anyway. Also, have a comment explaining why we have > it. Please find attached v3 that: - takes care of your comments (and also removed the use of PG_TBLSPC_DIR in RELATIVE_PG_TBLSPC_DIR). - removes the new macros from the comments (see Michael's and Yugo-San's comments in [0] resp. [1]). - adds a missing sizeof() (see [1]). - implements Ashutosh's idea of adding a new SLOT_DIRNAME_ARGS (see [2]). It's done in 0002 (I used REPLSLOT_DIR_ARGS though). - fixed a macro usage in ReorderBufferCleanupSerializedTXNs() (was not at the right location, discovered while implementing 0002). [0]: https://www.postgresql.org/message-id/ZsRYPcOtoqbWzjGG%40paquier.xyz [1]: https://www.postgresql.org/message-id/20240820213048.207aade6a75e0dc1fe4d1067%40sraoss.co.jp [2]: https://www.postgresql.org/message-id/CAExHW5vkjxuvyQ1fPPnuDW4nAT5jqox09ie36kciOV2%2BrhjbHA%40mail.g... Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 16:26 Bertrand Drouvot <[email protected]> parent: Yugo Nagata <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-20 16:26 UTC (permalink / raw) To: Yugo Nagata <[email protected]>; +Cc: Michael Paquier <[email protected]>; Alvaro Herrera <[email protected]>; [email protected] Hi, On Tue, Aug 20, 2024 at 09:30:48PM +0900, Yugo Nagata wrote: > Should be the follwing also rewritten using sizeof(PG_REPLSLOT_DIR)? > > struct stat statbuf; > char path[MAXPGPATH * 2 + 12]; > > Yeah, done in v3 that I just shared up-thread (also removed the macros from the comments). Thanks! Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-20 16:28 Bertrand Drouvot <[email protected]> parent: Bertrand Drouvot <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-20 16:28 UTC (permalink / raw) To: Michael Paquier <[email protected]>; +Cc: Ashutosh Bapat <[email protected]>; [email protected] Hi, On Tue, Aug 20, 2024 at 12:06:52PM +0000, Bertrand Drouvot wrote: > Hi, > > On Tue, Aug 20, 2024 at 05:41:48PM +0900, Michael Paquier wrote: > > On Tue, Aug 20, 2024 at 11:10:46AM +0530, Ashutosh Bapat wrote: > > > Since these are all related changes, doing them at once might make it > > > faster. You may use multiple commits (one for each change) > > > > Doing multiple commits with individual definitions for each path would > > be the way to go for me. All that is mechanical, still that feels > > slightly cleaner. > > Right, that's what v2 has done. If there is a need for v3 then I'll add one > dedicated patch for Ashutosh's proposal in the v3 series. Ashutosh's idea is implemented in v3 that I just shared up-thread (I used REPLSLOT_DIR_ARGS though). Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-21 04:44 Ashutosh Bapat <[email protected]> parent: Bertrand Drouvot <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Ashutosh Bapat @ 2024-08-21 04:44 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: Michael Paquier <[email protected]>; [email protected] If this isn't in commitfest already, please add it there. On Tue, Aug 20, 2024 at 9:58 PM Bertrand Drouvot <[email protected]> wrote: > > Hi, > > On Tue, Aug 20, 2024 at 12:06:52PM +0000, Bertrand Drouvot wrote: > > Hi, > > > > On Tue, Aug 20, 2024 at 05:41:48PM +0900, Michael Paquier wrote: > > > On Tue, Aug 20, 2024 at 11:10:46AM +0530, Ashutosh Bapat wrote: > > > > Since these are all related changes, doing them at once might make it > > > > faster. You may use multiple commits (one for each change) > > > > > > Doing multiple commits with individual definitions for each path would > > > be the way to go for me. All that is mechanical, still that feels > > > slightly cleaner. > > > > Right, that's what v2 has done. If there is a need for v3 then I'll add one > > dedicated patch for Ashutosh's proposal in the v3 series. > > Ashutosh's idea is implemented in v3 that I just shared up-thread (I used > REPLSLOT_DIR_ARGS though). > > Regards, > > -- > Bertrand Drouvot > PostgreSQL Contributors Team > RDS Open Source Databases > Amazon Web Services: https://aws.amazon.com -- Best Wishes, Ashutosh Bapat ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-21 05:03 Bertrand Drouvot <[email protected]> parent: Ashutosh Bapat <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-21 05:03 UTC (permalink / raw) To: Ashutosh Bapat <[email protected]>; +Cc: Michael Paquier <[email protected]>; [email protected] Hi, On Wed, Aug 21, 2024 at 10:14:20AM +0530, Ashutosh Bapat wrote: > If this isn't in commitfest already, please add it there. > Done in [0]. [0]: https://commitfest.postgresql.org/49/5193/ Thanks! Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-30 06:34 Michael Paquier <[email protected]> parent: Bertrand Drouvot <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Michael Paquier @ 2024-08-30 06:34 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; [email protected] On Tue, Aug 20, 2024 at 04:23:06PM +0000, Bertrand Drouvot wrote: > Please find attached v3 that: > > - takes care of your comments (and also removed the use of PG_TBLSPC_DIR in > RELATIVE_PG_TBLSPC_DIR). > - removes the new macros from the comments (see Michael's and Yugo-San's > comments in [0] resp. [1]). > - adds a missing sizeof() (see [1]). > - implements Ashutosh's idea of adding a new SLOT_DIRNAME_ARGS (see [2]). It's > done in 0002 (I used REPLSLOT_DIR_ARGS though). > - fixed a macro usage in ReorderBufferCleanupSerializedTXNs() (was not at the > right location, discovered while implementing 0002). I was looking at that, and applied 0001 for pg_replslot and merged 0003~0005 together for pg_logical. For the first one, at the end I have updated the comments in genfile.c. For the second one, it looked a bit strange to ignore "pg_logical/", which is the base for all the others, so I have added a variable for it. Locating them in reorderbuffer.h with the GUCs was OK, but perhaps there was an argument for logical.h. The paths in origin.c refer to files, not directories. Not sure that 0002 is an improvement overall, so I have left this part out. In 0006, I am not sure that RELATIVE_PG_TBLSPC_DIR is really something we should have. Sure, that's a special case for base backups when sending a directory, but we have also pg_wal/ and its XLOGDIR so that's inconsistent. Perhaps this part should be left as-is. -- Michael Attachments: [application/pgp-signature] signature.asc (833B, ../../[email protected]/2-signature.asc) download ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-08-30 12:21 Bertrand Drouvot <[email protected]> parent: Michael Paquier <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Bertrand Drouvot @ 2024-08-30 12:21 UTC (permalink / raw) To: Michael Paquier <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; [email protected] Hi, On Fri, Aug 30, 2024 at 03:34:56PM +0900, Michael Paquier wrote: > On Tue, Aug 20, 2024 at 04:23:06PM +0000, Bertrand Drouvot wrote: > > Please find attached v3 that: > > > > - takes care of your comments (and also removed the use of PG_TBLSPC_DIR in > > RELATIVE_PG_TBLSPC_DIR). > > - removes the new macros from the comments (see Michael's and Yugo-San's > > comments in [0] resp. [1]). > > - adds a missing sizeof() (see [1]). > > - implements Ashutosh's idea of adding a new SLOT_DIRNAME_ARGS (see [2]). It's > > done in 0002 (I used REPLSLOT_DIR_ARGS though). > > - fixed a macro usage in ReorderBufferCleanupSerializedTXNs() (was not at the > > right location, discovered while implementing 0002). > > I was looking at that, and applied 0001 for pg_replslot and merged > 0003~0005 together for pg_logical. Thanks! > In 0006, I am not sure that RELATIVE_PG_TBLSPC_DIR is really something > we should have. Sure, that's a special case for base backups when > sending a directory, but we have also pg_wal/ and its XLOGDIR so > that's inconsistent. That's right but OTOH there is no (for good reason) PG_WAL_DIR or such defined. That said, I don't have a strong opinion on this one, I think that also makes sense to leave it as it is. Please find attached v4 doing so. Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-09-03 00:15 Michael Paquier <[email protected]> parent: Bertrand Drouvot <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Michael Paquier @ 2024-09-03 00:15 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; [email protected] On Fri, Aug 30, 2024 at 12:21:29PM +0000, Bertrand Drouvot wrote: > That said, I don't have a strong opinion on this one, I think that also makes > sense to leave it as it is. Please find attached v4 doing so. The changes in astreamer_file.c are actually wrong regarding the fact that should_allow_existing_directory() needs to be able to work with the branch where this code is located as well as back-branches, because pg_basebackup from version N supports ~(N-1) versions down to a certain version, so changing it is not right. This is why pg_xlog and pg_wal are both listed there. Perhaps we should to more for the two entries in basebackup.c with the relative paths, but I'm not sure that's worth bothering, either. At the end, I got no objections about the remaining pieces, so applied. How do people feel about the suggestions to update the comments at the end? With the comment in relpath.h suggesting to not change that, the current state of HEAD is fine by me. -- Michael Attachments: [application/pgp-signature] signature.asc (833B, ../../[email protected]/2-signature.asc) download ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-09-03 04:35 Bertrand Drouvot <[email protected]> parent: Michael Paquier <[email protected]> 0 siblings, 1 reply; 30+ messages in thread From: Bertrand Drouvot @ 2024-09-03 04:35 UTC (permalink / raw) To: Michael Paquier <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; [email protected] Hi, On Tue, Sep 03, 2024 at 09:15:50AM +0900, Michael Paquier wrote: > On Fri, Aug 30, 2024 at 12:21:29PM +0000, Bertrand Drouvot wrote: > > That said, I don't have a strong opinion on this one, I think that also makes > > sense to leave it as it is. Please find attached v4 doing so. > > The changes in astreamer_file.c are actually wrong regarding the fact > that should_allow_existing_directory() needs to be able to work with > the branch where this code is located as well as back-branches, > because pg_basebackup from version N supports ~(N-1) versions down to > a certain version, so changing it is not right. This is why pg_xlog > and pg_wal are both listed there. I understand why pg_xlog and pg_wal both need to be listed here, but I don't get why the proposed changes were "wrong". Or, are you saying that if for any reason PG_TBLSPC_DIR needs to be changed that would not work anymore? If that's the case, then I guess we'd have to add a new define and test like: strcmp(filename, PG_TBLSPC_DIR) == 0) || strcmp(filename, NEW_PG_TBLSPC_DIR) == 0) , no? The question is more out of curiosity, not saying the changes should be applied in astreamer_file.c though. > Perhaps we should to more for the two entries in basebackup.c with the > relative paths, but I'm not sure that's worth bothering, either. I don't have a strong opinon on those ones. > At > the end, I got no objections about the remaining pieces, so applied. Thanks! > How do people feel about the suggestions to update the comments at the > end? With the comment in relpath.h suggesting to not change that, the > current state of HEAD is fine by me. Yeah, I think that's fine and specially because there is still some places ( outside of the comments) that don't rely on the define(s). Regards, -- Bertrand Drouvot PostgreSQL Contributors Team RDS Open Source Databases Amazon Web Services: https://aws.amazon.com ^ permalink raw reply [nested|flat] 30+ messages in thread
* Re: define PG_REPLSLOT_DIR @ 2024-09-03 06:27 Michael Paquier <[email protected]> parent: Bertrand Drouvot <[email protected]> 0 siblings, 0 replies; 30+ messages in thread From: Michael Paquier @ 2024-09-03 06:27 UTC (permalink / raw) To: Bertrand Drouvot <[email protected]>; +Cc: Alvaro Herrera <[email protected]>; [email protected] On Tue, Sep 03, 2024 at 04:35:28AM +0000, Bertrand Drouvot wrote: > I understand why pg_xlog and pg_wal both need to be listed here, but I don't > get why the proposed changes were "wrong". Or, are you saying that if for any > reason PG_TBLSPC_DIR needs to be changed that would not work > anymore? Yes. Folks are not going to do that, but changing PG_TBLSPC_DIR would change the decision-making when streaming from versions older than v17 with clients tools from v18~. -- Michael Attachments: [application/pgp-signature] signature.asc (833B, ../../[email protected]/2-signature.asc) download ^ permalink raw reply [nested|flat] 30+ messages in thread
end of thread, other threads:[~2024-09-03 06:27 UTC | newest] Thread overview: 30+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2020-12-16 20:32 [PATCH 5/6] BRIN minmax-multi indexes Tomas Vondra <[email protected]> 2024-08-14 09:16 [PATCH v2 1/5] Define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-14 09:16 [PATCH v1] Define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-14 09:16 [PATCH v3 1/6] Define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-14 11:32 define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-16 00:40 ` Re: define PG_REPLSLOT_DIR Alvaro Herrera <[email protected]> 2024-08-19 14:11 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-20 08:47 ` Re: define PG_REPLSLOT_DIR Michael Paquier <[email protected]> 2024-08-20 12:16 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-20 12:30 ` Re: define PG_REPLSLOT_DIR Yugo Nagata <[email protected]> 2024-08-20 16:26 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-20 14:15 ` Re: define PG_REPLSLOT_DIR Alvaro Herrera <[email protected]> 2024-08-20 16:23 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-30 06:34 ` Re: define PG_REPLSLOT_DIR Michael Paquier <[email protected]> 2024-08-30 12:21 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-09-03 00:15 ` Re: define PG_REPLSLOT_DIR Michael Paquier <[email protected]> 2024-09-03 04:35 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-09-03 06:27 ` Re: define PG_REPLSLOT_DIR Michael Paquier <[email protected]> 2024-08-16 04:31 ` Re: define PG_REPLSLOT_DIR Yugo Nagata <[email protected]> 2024-08-19 14:13 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-19 10:41 ` Re: define PG_REPLSLOT_DIR Ashutosh Bapat <[email protected]> 2024-08-19 14:17 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-20 03:56 ` Re: define PG_REPLSLOT_DIR Ashutosh Bapat <[email protected]> 2024-08-20 05:19 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-20 05:40 ` Re: define PG_REPLSLOT_DIR Ashutosh Bapat <[email protected]> 2024-08-20 08:41 ` Re: define PG_REPLSLOT_DIR Michael Paquier <[email protected]> 2024-08-20 12:06 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-20 16:28 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]> 2024-08-21 04:44 ` Re: define PG_REPLSLOT_DIR Ashutosh Bapat <[email protected]> 2024-08-21 05:03 ` Re: define PG_REPLSLOT_DIR Bertrand Drouvot <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox