Skip to content

P
Postgres FD Implementation
Commit ab596105 authored by Tomas Vondra's avatar Tomas Vondra
Browse files
Options

BRIN minmax-multi indexes 

Adds BRIN opclasses similar to the existing minmax, except that instead
of summarizing the page range into a single [min,max] range, the summary
consists of multiple ranges and/or points, allowing gaps. This allows
more efficient handling of data with poor correlation to physical
location within the table and/or outlier values, for which the regular
minmax opclassed tend to work poorly.

It's possible to specify the number of values kept for each page range,
either as a single point or an interval boundary.

  CREATE TABLE t (a int);
  CREATE INDEX ON t
   USING brin (a int4_minmax_multi_ops(values_per_range=16));

When building the summary, the values are combined into intervals with
the goal to minimize the "covering" (sum of interval lengths), using a
support procedure computing distance between two values.

Bump catversion, due to various catalog changes.

Author: Tomas Vondra <tomas.vondra@postgresql.org>
Reviewed-by: default avatarAlvaro Herrera <alvherre@alvh.no-ip.org>
Reviewed-by: default avatarAlexander Korotkov <aekorotkov@gmail.com>
Reviewed-by: default avatarSokolov Yura <y.sokolov@postgrespro.ru>
Reviewed-by: default avatarJohn Naylor <john.naylor@enterprisedb.com>
Discussion: https://postgr.es/m/c1138ead-7668-f0e1-0638-c3be3237e812@2ndquadrant.com
Discussion: https://postgr.es/m/5d78b774-7e9c-c94e-12cf-fef51cc89b1a%402ndquadrant.com
parent 77b88cd1
Show whitespace changes
Inline Side-by-side
Showing with 5286 additions and 26 deletions
doc/src/sgml/brin.sgml
View file @ ab596105
......@@ -116,7 +116,10 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
in the indexed column within the range. The <firstterm>inclusion</firstterm>
operator classes store a value which includes the values in the indexed
column within the range. The <firstterm>bloom</firstterm> operator
classes build a Bloom filter for all values in the range.
classes build a Bloom filter for all values in the range. The
<firstterm>minmax-multi</firstterm> operator classes store multiple
minimum and maximum values, representing values appearing in the indexed
column within the range.
</para>
<table id="brin-builtin-opclasses-table">
......@@ -211,6 +214,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (date,date)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (date,date)</literal></entry></row>
<row><entry><literal>&lt;= (date,date)</literal></entry></row>
<row><entry><literal>&gt; (date,date)</literal></entry></row>
<row><entry><literal>&gt;= (date,date)</literal></entry></row>
<row>
<entry valign="middle"><literal>float4_bloom_ops</literal></entry>
<entry><literal>= (float4,float4)</literal></entry>
......@@ -225,6 +237,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (float4,float4)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (float4,float4)</literal></entry></row>
<row><entry><literal>&gt; (float4,float4)</literal></entry></row>
<row><entry><literal>&lt;= (float4,float4)</literal></entry></row>
<row><entry><literal>&gt;= (float4,float4)</literal></entry></row>
<row>
<entry valign="middle"><literal>float8_bloom_ops</literal></entry>
<entry><literal>= (float8,float8)</literal></entry>
......@@ -239,6 +260,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (float8,float8)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (float8,float8)</literal></entry></row>
<row><entry><literal>&lt;= (float8,float8)</literal></entry></row>
<row><entry><literal>&gt; (float8,float8)</literal></entry></row>
<row><entry><literal>&gt;= (float8,float8)</literal></entry></row>
<row>
<entry valign="middle" morerows="5"><literal>inet_inclusion_ops</literal></entry>
<entry><literal>&lt;&lt; (inet,inet)</literal></entry>
......@@ -263,6 +293,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (inet,inet)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (inet,inet)</literal></entry></row>
<row><entry><literal>&lt;= (inet,inet)</literal></entry></row>
<row><entry><literal>&gt; (inet,inet)</literal></entry></row>
<row><entry><literal>&gt;= (inet,inet)</literal></entry></row>
<row>
<entry valign="middle"><literal>int2_bloom_ops</literal></entry>
<entry><literal>= (int2,int2)</literal></entry>
......@@ -277,6 +316,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (int2,int2)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (int2,int2)</literal></entry></row>
<row><entry><literal>&gt; (int2,int2)</literal></entry></row>
<row><entry><literal>&lt;= (int2,int2)</literal></entry></row>
<row><entry><literal>&gt;= (int2,int2)</literal></entry></row>
<row>
<entry valign="middle"><literal>int4_bloom_ops</literal></entry>
<entry><literal>= (int4,int4)</literal></entry>
......@@ -291,6 +339,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (int4,int4)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (int4,int4)</literal></entry></row>
<row><entry><literal>&gt; (int4,int4)</literal></entry></row>
<row><entry><literal>&lt;= (int4,int4)</literal></entry></row>
<row><entry><literal>&gt;= (int4,int4)</literal></entry></row>
<row>
<entry valign="middle"><literal>int8_bloom_ops</literal></entry>
<entry><literal>= (bigint,bigint)</literal></entry>
......@@ -305,6 +362,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (bigint,bigint)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (bigint,bigint)</literal></entry></row>
<row><entry><literal>&gt; (bigint,bigint)</literal></entry></row>
<row><entry><literal>&lt;= (bigint,bigint)</literal></entry></row>
<row><entry><literal>&gt;= (bigint,bigint)</literal></entry></row>
<row>
<entry valign="middle"><literal>interval_bloom_ops</literal></entry>
<entry><literal>= (interval,interval)</literal></entry>
......@@ -319,6 +385,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (interval,interval)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (interval,interval)</literal></entry></row>
<row><entry><literal>&lt;= (interval,interval)</literal></entry></row>
<row><entry><literal>&gt; (interval,interval)</literal></entry></row>
<row><entry><literal>&gt;= (interval,interval)</literal></entry></row>
<row>
<entry valign="middle"><literal>macaddr_bloom_ops</literal></entry>
<entry><literal>= (macaddr,macaddr)</literal></entry>
......@@ -333,6 +408,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (macaddr,macaddr)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (macaddr,macaddr)</literal></entry></row>
<row><entry><literal>&lt;= (macaddr,macaddr)</literal></entry></row>
<row><entry><literal>&gt; (macaddr,macaddr)</literal></entry></row>
<row><entry><literal>&gt;= (macaddr,macaddr)</literal></entry></row>
<row>
<entry valign="middle"><literal>macaddr8_bloom_ops</literal></entry>
<entry><literal>= (macaddr8,macaddr8)</literal></entry>
......@@ -347,6 +431,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (macaddr8,macaddr8)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (macaddr8,macaddr8)</literal></entry></row>
<row><entry><literal>&lt;= (macaddr8,macaddr8)</literal></entry></row>
<row><entry><literal>&gt; (macaddr8,macaddr8)</literal></entry></row>
<row><entry><literal>&gt;= (macaddr8,macaddr8)</literal></entry></row>
<row>
<entry valign="middle"><literal>name_bloom_ops</literal></entry>
<entry><literal>= (name,name)</literal></entry>
......@@ -375,6 +468,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (numeric,numeric)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (numeric,numeric)</literal></entry></row>
<row><entry><literal>&lt;= (numeric,numeric)</literal></entry></row>
<row><entry><literal>&gt; (numeric,numeric)</literal></entry></row>
<row><entry><literal>&gt;= (numeric,numeric)</literal></entry></row>
<row>
<entry valign="middle"><literal>oid_bloom_ops</literal></entry>
<entry><literal>= (oid,oid)</literal></entry>
......@@ -389,6 +491,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (oid,oid)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (oid,oid)</literal></entry></row>
<row><entry><literal>&gt; (oid,oid)</literal></entry></row>
<row><entry><literal>&lt;= (oid,oid)</literal></entry></row>
<row><entry><literal>&gt;= (oid,oid)</literal></entry></row>
<row>
<entry valign="middle"><literal>pg_lsn_bloom_ops</literal></entry>
<entry><literal>= (pg_lsn,pg_lsn)</literal></entry>
......@@ -403,6 +514,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (pg_lsn,pg_lsn)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (pg_lsn,pg_lsn)</literal></entry></row>
<row><entry><literal>&gt; (pg_lsn,pg_lsn)</literal></entry></row>
<row><entry><literal>&lt;= (pg_lsn,pg_lsn)</literal></entry></row>
<row><entry><literal>&gt;= (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>
......@@ -449,6 +569,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (tid,tid)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (tid,tid)</literal></entry></row>
<row><entry><literal>&gt; (tid,tid)</literal></entry></row>
<row><entry><literal>&lt;= (tid,tid)</literal></entry></row>
<row><entry><literal>&gt;= (tid,tid)</literal></entry></row>
<row>
<entry valign="middle"><literal>timestamp_bloom_ops</literal></entry>
<entry><literal>= (timestamp,timestamp)</literal></entry>
......@@ -463,6 +592,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (timestamp,timestamp)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (timestamp,timestamp)</literal></entry></row>
<row><entry><literal>&lt;= (timestamp,timestamp)</literal></entry></row>
<row><entry><literal>&gt; (timestamp,timestamp)</literal></entry></row>
<row><entry><literal>&gt;= (timestamp,timestamp)</literal></entry></row>
<row>
<entry valign="middle"><literal>timestamptz_bloom_ops</literal></entry>
<entry><literal>= (timestamptz,timestamptz)</literal></entry>
......@@ -477,6 +615,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (timestamptz,timestamptz)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (timestamptz,timestamptz)</literal></entry></row>
<row><entry><literal>&lt;= (timestamptz,timestamptz)</literal></entry></row>
<row><entry><literal>&gt; (timestamptz,timestamptz)</literal></entry></row>
<row><entry><literal>&gt;= (timestamptz,timestamptz)</literal></entry></row>
<row>
<entry valign="middle"><literal>time_bloom_ops</literal></entry>
<entry><literal>= (time,time)</literal></entry>
......@@ -491,6 +638,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (time,time)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (time,time)</literal></entry></row>
<row><entry><literal>&lt;= (time,time)</literal></entry></row>
<row><entry><literal>&gt; (time,time)</literal></entry></row>
<row><entry><literal>&gt;= (time,time)</literal></entry></row>
<row>
<entry valign="middle"><literal>timetz_bloom_ops</literal></entry>
<entry><literal>= (timetz,timetz)</literal></entry>
......@@ -505,6 +661,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&gt; (timetz,timetz)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (timetz,timetz)</literal></entry></row>
<row><entry><literal>&lt;= (timetz,timetz)</literal></entry></row>
<row><entry><literal>&gt; (timetz,timetz)</literal></entry></row>
<row><entry><literal>&gt;= (timetz,timetz)</literal></entry></row>
<row>
<entry valign="middle"><literal>uuid_bloom_ops</literal></entry>
<entry><literal>= (uuid,uuid)</literal></entry>
......@@ -519,6 +684,15 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<row><entry><literal>&lt;= (uuid,uuid)</literal></entry></row>
<row><entry><literal>&gt;= (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>&lt; (uuid,uuid)</literal></entry></row>
<row><entry><literal>&gt; (uuid,uuid)</literal></entry></row>
<row><entry><literal>&lt;= (uuid,uuid)</literal></entry></row>
<row><entry><literal>&gt;= (uuid,uuid)</literal></entry></row>
<row>
<entry valign="middle" morerows="4"><literal>varbit_minmax_ops</literal></entry>
<entry><literal>= (varbit,varbit)</literal></entry>
......@@ -537,8 +711,8 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
<para>
Some of the built-in operator classes allow specifying parameters affecting
behavior of the operator class. Each operator class has its own set of
allowed parameters. Only the <literal>bloom</literal> operator class
allows specifying parameters:
allowed parameters. Only the <literal>bloom</literal> and <literal>minmax-multi</literal>
operator classes allow specifying parameters:
</para>
<para>
......@@ -577,6 +751,25 @@ LOG: request for BRIN range summarization for index "brin_wi_idx" page 128 was
</varlistentry>
</variablelist>
<para>
<acronym>minmax-multi</acronym> operator classes accept these parameters:
</para>
<variablelist>
<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
either a point, or a boundary of an interval. Values must be between
8 and 256, and the default value is 32.
</para>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>
......@@ -715,13 +908,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, minmax-multi, 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>
......@@ -1018,6 +1212,72 @@ typedef struct BrinOpcInfo
and return a hash of the value.
</para>
<para>
The minmax-multi 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, minmax-multi allows summarization
into multiple smaller intervals to improve handling of outlier values.
It is possible to use the minmax-multi support procedures alongside the
corresponding operators, as shown in
<xref linkend="brin-extensibility-minmax-multi-table"/>.
All operator class members (procedures and operators) are mandatory.
</para>
<table id="brin-extensibility-minmax-multi-table">
<title>Procedure and Support Numbers for minmax-multi 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.
......
src/backend/access/brin/Makefile
View file @ ab596105
......@@ -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 \
......
src/backend/access/brin/brin_minmax_multi.c 0 → 100644
View file @ ab596105
/*
* 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 make 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 minmax-multi 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 32 (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 50% 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.
*
* The compactions (reducing the number of values) is fairly expensive, as
* it requires calling the distance functions, sorting etc. So when building
* the summary, we use a significantly larger buffer, and only enforce the
* exact limit at the very end. This improves performance, and it also helps
* with building better ranges (due to the greedy approach).
*
*
* IDENTIFICATION
* src/backend/access/brin/brin_minmax_multi.c
*/
#include "postgres.h"
/* needef for PGSQL_AF_INET */
#include <sys/socket.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_am.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/timestamp.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
/*
* Sizing the insert buffer - we use 10x the number of values specified
* in the reloption, but we cap it to 8192 not to get too large. When
* the buffer gets full, we reduce the number of values by half.
*/
#define MINMAX_BUFFER_FACTOR 10
#define MINMAX_BUFFER_MIN 256
#define MINMAX_BUFFER_MAX 8192
#define MINMAX_BUFFER_LOAD_FACTOR 0.5
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 MinMaxMultiOptions
{
int32 vl_len_; /* varlena header (do not touch directly!) */
int valuesPerRange; /* number of values per range */
} MinMaxMultiOptions;
#define MINMAX_MULTI_DEFAULT_VALUES_PER_PAGE 32
#define MinMaxMultiGetValuesPerRange(opts) \
((opts) && (((MinMaxMultiOptions *) (opts))->valuesPerRange != 0) ? \
((MinMaxMultiOptions *) (opts))->valuesPerRange : \
MINMAX_MULTI_DEFAULT_VALUES_PER_PAGE)
#define SAMESIGN(a,b) (((a) < 0) == ((b) < 0))
/*
* The summary of minmax-multi 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
{
/* Cache information that we need quite often. */
Oid typid;
Oid colloid;
AttrNumber attno;
FmgrInfo *cmp;
/* (2*nranges + nvalues) <= maxvalues */
int nranges; /* number of ranges in the array (stored) */
int nsorted; /* number of sorted values (ranges + points) */
int nvalues; /* number of values in the data array (all) */
int maxvalues; /* maximum number of values (reloption) */
/*
* We simply add the values into a large buffer, without any expensive
* steps (sorting, deduplication, ...). The buffer is a multiple of the
* target number of values, so the compaction happen less often,
* amortizing the costs. We keep the actual target and compact to the
* requested number of values at the very end, before serializing to
* on-disk representation.
*/
/* requested number of values */
int target_maxvalues;
/* 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, with a simple header
* with basic metadata, followed by the boundary values. It has a varlena
* header, so can be treated as varlena directly.
*
* See range_serialize/range_deserialize 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(int maxvalues, SerializedRanges *range);
/*
* Used to represent ranges expanded to make merging and combining easier.
*
* Each expanded range is essentially an interval, represented by min/max
* values, along with a flag whether it's a collapsed range (in which case
* the min and max values are equal). We have the flag to handle by-ref
* data types - we can't simply compare the datums, and this saves some
* calls to the type-specific comparator function.
*/
typedef struct ExpandedRange
{
Datum minval; /* lower boundary */
Datum maxval; /* upper boundary */
bool collapsed; /* true if minval==maxval */
} ExpandedRange;
/*
* Represents a distance between two ranges (identified by index into
* an array of extended ranges).
*/
typedef struct DistanceValue
{
int index;
double value;
} DistanceValue;
/* 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);
typedef struct compare_context
{
FmgrInfo *cmpFn;
Oid colloid;
} compare_context;
static int compare_values(const void *a, const void *b, void *arg);
#ifdef USE_ASSERT_CHECKING
/*
* 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)
{
int i;
Datum lt;
for (i = 0; i < (nvalues - 1); i++)
{
lt = FunctionCall2Coll(cmp, colloid, values[i], values[i + 1]);
Assert(DatumGetBool(lt));
}
}
#endif
/*
* Comprehensive check of the Ranges structure.
*/
static void
AssertCheckRanges(Ranges *ranges, FmgrInfo *cmpFn, Oid colloid)
{
#ifdef USE_ASSERT_CHECKING
int i;
/* some basic sanity checks */
Assert(ranges->nranges >= 0);
Assert(ranges->nsorted >= 0);
Assert(ranges->nvalues >= ranges->nsorted);
Assert(ranges->maxvalues >= 2 * ranges->nranges + ranges->nvalues);
Assert(ranges->typid != InvalidOid);
/*
* First the ranges - there are 2*nranges boundary values, and the values
* have to be strictly ordered (equal values would mean the range is
* collapsed, and should be stored as a point). This also guarantees that
* the ranges do not overlap.
*/
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->nsorted);
/*
* Check that none of the values are not covered by ranges (both sorted
* and unsorted)
*/
for (i = 0; i < ranges->nvalues; i++)
{
Datum compar;
int start,
end;
Datum minvalue,
maxvalue;
Datum value = ranges->values[2 * ranges->nranges + i];
if (ranges->nranges == 0)
break;
minvalue = ranges->values[0];
maxvalue = ranges->values[2 * ranges->nranges - 1];
/*
* Is the value smaller than the minval? If yes, we'll recurse to the
* left side of range array.
*/
compar = FunctionCall2Coll(cmpFn, colloid, value, minvalue);
/* smaller than the smallest value in the first range */
if (DatumGetBool(compar))
continue;
/*
* Is the value greater than the maxval? If yes, we'll recurse to the
* right side of range array.
*/
compar = FunctionCall2Coll(cmpFn, colloid, maxvalue, value);
/* larger than the largest value in the last range */
if (DatumGetBool(compar))
continue;
start = 0; /* first range */
end = ranges->nranges - 1; /* last range */
while (true)
{
int midpoint = (start + end) / 2;
/* this means we ran out of ranges in the last step */
if (start > end)
break;
/* copy the min/max values from the ranges */
minvalue = ranges->values[2 * midpoint];
maxvalue = ranges->values[2 * midpoint + 1];
/*
* Is the value smaller than the minval? If yes, we'll recurse to
* the left side of range array.
*/
compar = FunctionCall2Coll(cmpFn, colloid, value, minvalue);
/* smaller than the smallest value in this range */
if (DatumGetBool(compar))
{
end = (midpoint - 1);
continue;
}
/*
* Is the value greater than the minval? If yes, we'll recurse to
* the right side of range array.
*/
compar = FunctionCall2Coll(cmpFn, colloid, maxvalue, value);
/* larger than the largest value in this range */
if (DatumGetBool(compar))
{
start = (midpoint + 1);
continue;
}
/* hey, we found a matching range */
Assert(false);
}
}
/* and values in the unsorted part must not be in sorted part */
for (i = ranges->nsorted; i < ranges->nvalues; i++)
{
compare_context cxt;
Datum value = ranges->values[2 * ranges->nranges + i];
if (ranges->nsorted == 0)
break;
cxt.colloid = ranges->colloid;
cxt.cmpFn = ranges->cmp;
Assert(bsearch_arg(&value, &ranges->values[2 * ranges->nranges],
ranges->nsorted, sizeof(Datum),
compare_values, (void *) &cxt) == NULL);
}
#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
AssertCheckExpandedRanges(BrinDesc *bdesc, Oid colloid, AttrNumber attno,
Form_pg_attribute attr, ExpandedRange *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
}
/*
* minmax_multi_init
* Initialize the deserialized range list, allocate all the memory.
*
* This is only in-memory representation of the ranges, so we allocate
* 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_deduplicate_values
* Deduplicate the part with values in the simple points.
*
* This is meant to be a cheaper way of reducing the size of the ranges. It
* does not touch the ranges, and only sorts the other values - it does not
* call the distance functions, which may be quite expensive, etc.
*
* We do know the values are not duplicate with the ranges, because we check
* that before adding a new value. Same for the sorted part of values.
*/
static void
range_deduplicate_values(Ranges *range)
{
int i,
n;
int start;
compare_context cxt;
/*
* If there are no unsorted values, we're done (this probably can't
* happen, as we're adding values to unsorted part).
*/
if (range->nsorted == range->nvalues)
return;
/* sort the values */
cxt.colloid = range->colloid;
cxt.cmpFn = range->cmp;
/* the values start right after the ranges (which are always sorted) */
start = 2 * range->nranges;
/*
* XXX This might do a merge sort, to leverage that the first part of the
* array is already sorted. If the sorted part is large, it might be quite
* a bit faster.
*/
qsort_arg(&range->values[start],
range->nvalues, sizeof(Datum),
compare_values, (void *) &cxt);
n = 1;
for (i = 1; i < range->nvalues; i++)
{
/* same as preceding value, so store it */
if (compare_values(&range->values[start + i - 1],
&range->values[start + i],
(void *) &cxt) == 0)
continue;
range->values[start + n] = range->values[start + i];
n++;
}
/* now all the values are sorted */
range->nvalues = n;
range->nsorted = n;
AssertCheckRanges(range, range->cmp, range->colloid);
}
/*
* 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->nsorted >= 0);
Assert(range->nvalues >= 0);
Assert(range->maxvalues > 0);
Assert(range->target_maxvalues > 0);
/* at this point the range should be compacted to the target size */
Assert(2 * range->nranges + range->nvalues <= range->target_maxvalues);
Assert(range->target_maxvalues <= range->maxvalues);
/* range boundaries are always sorted */
Assert(range->nvalues >= range->nsorted);
/* deduplicate values, if there's unsorted part */
range_deduplicate_values(range);
/* see how many Datum values we actually have */
nvalues = 2 * range->nranges + range->nvalues;
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->target_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(int maxvalues, 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);
Assert(serialized->maxvalues <= maxvalues);
range = minmax_multi_init(maxvalues);
/* copy the header info */
range->nranges = serialized->nranges;
range->nvalues = serialized->nvalues;
range->nsorted = serialized->nvalues;
range->maxvalues = maxvalues;
range->target_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;
}
/*
* compare_expanded_ranges
* Compare the expanded 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_expanded_ranges(const void *a, const void *b, void *arg)
{
ExpandedRange *ra = (ExpandedRange *) a;
ExpandedRange *rb = (ExpandedRange *) 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;
}
/*
* compare_values
* Compare the values.
*/
static int
compare_values(const void *a, const void *b, void *arg)
{
Datum *da = (Datum *) a;
Datum *db = (Datum *) b;
Datum r;
compare_context *cxt = (compare_context *) arg;
r = FunctionCall2Coll(cxt->cmpFn, cxt->colloid, *da, *db);
if (DatumGetBool(r))
return -1;
r = FunctionCall2Coll(cxt->cmpFn, cxt->colloid, *db, *da);
if (DatumGetBool(r))
return 1;
return 0;
}
/*
* Check if the new value matches one of the existing ranges.
*/
static bool
has_matching_range(BrinDesc *bdesc, Oid colloid, Ranges *ranges,
Datum newval, AttrNumber attno, Oid typid)
{
Datum compar;
Datum minvalue = ranges->values[0];
Datum maxvalue = ranges->values[2 * ranges->nranges - 1];
FmgrInfo *cmpLessFn;
FmgrInfo *cmpGreaterFn;
/* binary search on ranges */
int start,
end;
if (ranges->nranges == 0)
return 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.
*/
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))
return 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.
*/
cmpGreaterFn = minmax_multi_get_strategy_procinfo(bdesc, attno, typid,
BTGreaterStrategyNumber);
compar = FunctionCall2Coll(cmpGreaterFn, colloid, newval, maxvalue);
if (DatumGetBool(compar))
return false;
/*
* So we know it's in the general min/max, the question is whether it
* falls in one of the ranges or gaps. We'll do a binary search on
* individual ranges - for each range we check equality (value falls into
* the range), and then check ranges either above or below the current
* range.
*/
start = 0; /* first range */
end = (ranges->nranges - 1); /* last range */
while (true)
{
int midpoint = (start + end) / 2;
/* this means we ran out of ranges in the last step */
if (start > end)
return false;
/* copy the min/max values from the ranges */
minvalue = ranges->values[2 * midpoint];
maxvalue = ranges->values[2 * midpoint + 1];
/*
* Is the value smaller than the minval? If yes, we'll recurse to the
* left side of range array.
*/
compar = FunctionCall2Coll(cmpLessFn, colloid, newval, minvalue);
/* smaller than the smallest value in this range */
if (DatumGetBool(compar))
{
end = (midpoint - 1);
continue;
}
/*
* Is the value greater than the minval? If yes, we'll recurse to the
* right side of range array.
*/
compar = FunctionCall2Coll(cmpGreaterFn, colloid, newval, maxvalue);
/* larger than the largest value in this range */
if (DatumGetBool(compar))
{
start = (midpoint + 1);
continue;
}
/* hey, we found a matching range */
return true;
}
return false;
}
/*
* 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.
*
* The last parameter (full) determines whether we need to search all the
* values, including the unsorted part. With full=false, the unsorted part
* is not searched, which may produce false negatives and duplicate values
* (in the unsorted part only), but when we're building the range that's
* fine - we'll deduplicate before serialization, and it can only happen
* if there already are unsorted values (so it was already modified).
*
* Serialized ranges don't have any unsorted values, so this can't cause
* false negatives during querying.
*/
static bool
range_contains_value(BrinDesc *bdesc, Oid colloid,
AttrNumber attno, Form_pg_attribute attr,
Ranges *ranges, Datum newval, bool full)
{
int i;
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 (has_matching_range(bdesc, colloid, ranges, newval, attno, typid))
return true;
cmpEqualFn = minmax_multi_get_strategy_procinfo(bdesc, attno, typid,
BTEqualStrategyNumber);
/*
* There is no matching range, so let's inspect the sorted values.
*
* We do a sequential search for small number of values, and binary search
* once we have more than 16 values. This threshold is somewhat arbitrary,
* as it depends on how expensive the comparison function is.
*
* XXX If we use the threshold here, maybe we should do the same thing in
* has_matching_range? Or maybe we should do the bin search all the time?
*
* XXX We could use the same optimization as for ranges, to check if the
* value is between min/max, to maybe rule out all sorted values without
* having to inspect all of them.
*/
if (ranges->nsorted >= 16)
{
compare_context cxt;
cxt.colloid = ranges->colloid;
cxt.cmpFn = ranges->cmp;
if (bsearch_arg(&newval, &ranges->values[2 * ranges->nranges],
ranges->nsorted, sizeof(Datum),
compare_values, (void *) &cxt) != NULL)
return true;
}
else
{
for (i = 2 * ranges->nranges; i < 2 * ranges->nranges + ranges->nsorted; i++)
{
Datum compar;
compar = FunctionCall2Coll(cmpEqualFn, colloid, newval, ranges->values[i]);
/* found an exact match */
if (DatumGetBool(compar))
return true;
}
}
/* If not asked to inspect the unsorted part, we're done. */
if (!full)
return false;
/* Inspect the unsorted part. */
for (i = 2 * ranges->nranges + ranges->nsorted; 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;
}
/*
* Expand ranges from Ranges into ExpandedRange array. This expects the
* eranges to be pre-allocated and with the correct size - there needs to be
* (nranges + nvalues) elements.
*
* The order of expanded ranges is arbitrary. We do expand the ranges first,
* and this part is sorted. But then we expand the values, and this part may
* be unsorted.
*/
static void
fill_expanded_ranges(ExpandedRange *eranges, int neranges, Ranges *ranges)
{
int idx;
int i;
/* Check that the output array has the right size. */
Assert(neranges == (ranges->nranges + ranges->nvalues));
idx = 0;
for (i = 0; i < ranges->nranges; i++)
{
eranges[idx].minval = ranges->values[2 * i];
eranges[idx].maxval = ranges->values[2 * i + 1];
eranges[idx].collapsed = false;
idx++;
Assert(idx <= neranges);
}
for (i = 0; i < ranges->nvalues; i++)
{
eranges[idx].minval = ranges->values[2 * ranges->nranges + i];
eranges[idx].maxval = ranges->values[2 * ranges->nranges + i];
eranges[idx].collapsed = true;
idx++;
Assert(idx <= neranges);
}
/* Did we produce the expected number of elements? */
Assert(idx == neranges);
return;
}
/*
* Sort and deduplicate expanded ranges.
*
* The ranges may be deduplicated - we're simply appending values, without
* checking for duplicates etc. So maybe the deduplication will reduce the
* number of ranges enough, and we won't have to compute the distances etc.
*
* Returns the number of expanded ranges.
*/
static int
sort_expanded_ranges(FmgrInfo *cmp, Oid colloid,
ExpandedRange *eranges, int neranges)
{
int n;
int i;
compare_context cxt;
Assert(neranges > 0);
/* sort the values */
cxt.colloid = colloid;
cxt.cmpFn = cmp;
/*
* XXX We do qsort on all the values, but we could also leverage the fact
* that some of the input data is already sorted (all the ranges and maybe
* some of the points) and do merge sort.
*/
qsort_arg(eranges, neranges, sizeof(ExpandedRange),
compare_expanded_ranges, (void *) &cxt);
/*
* Deduplicate the ranges - simply compare each range to the preceding
* one, and skip the duplicate ones.
*/
n = 1;
for (i = 1; i < neranges; i++)
{
/* if the current range is equal to the preceding one, do nothing */
if (!compare_expanded_ranges(&eranges[i - 1], &eranges[i], (void *) &cxt))
continue;
/* otherwise copy it to n-th place (if not already there) */
if (i != n)
memcpy(&eranges[n], &eranges[i], sizeof(ExpandedRange));
n++;
}
Assert((n > 0) && (n <= neranges));
return n;
}
/*
* 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 expanded ranges were previously sorted (by minval
* and then maxval). We leverage this when detecting overlap.
*/
static int
merge_overlapping_ranges(FmgrInfo *cmp, Oid colloid,
ExpandedRange *eranges, int neranges)
{
int idx;
/* Merge ranges (idx) and (idx+1) if they overlap. */
idx = 0;
while (idx < (neranges - 1))
{
Datum r;
/*
* comparing [?,maxval] vs. [minval,?] - the ranges overlap if (minval
* < maxval)
*/
r = FunctionCall2Coll(cmp, colloid,
eranges[idx].maxval,
eranges[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 overlap only partially.
* So compare the upper bounds and keep the larger one.
*/
r = FunctionCall2Coll(cmp, colloid,
eranges[idx].maxval,
eranges[idx + 1].maxval);
if (DatumGetBool(r))
eranges[idx].maxval = eranges[idx + 1].maxval;
/*
* The range certainly is no longer collapsed (irrespectively of the
* previous state).
*/
eranges[idx].collapsed = false;
/*
* Now get rid of the (idx+1) range entirely by shifting the remaining
* ranges by 1. There are neranges elements, and we need to move
* elements from (idx+2). That means the number of elements to move is
* [ncranges - (idx+2)].
*/
memmove(&eranges[idx + 1], &eranges[idx + 2],
(neranges - (idx + 2)) * sizeof(ExpandedRange));
/*
* Decrease the number of ranges, and repeat (with the same range, as
* it might overlap with additional ranges thanks to the merge).
*/
neranges--;
}
return neranges;
}
/*
* Simple comparator for distance values, comparing the double value.
* This is intentionally sorting the distances in descending order, i.e.
* the longer gaps will be at the front.
*/
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 expanded 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 (max-min) for pairs
* of consecutive ranges. 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_expanded_ranges for details.
*/
static DistanceValue *
build_distances(FmgrInfo *distanceFn, Oid colloid,
ExpandedRange *eranges, int neranges)
{
int i;
int ndistances;
DistanceValue *distances;
Assert(neranges >= 2);
ndistances = (neranges - 1);
distances = (DistanceValue *) palloc0(sizeof(DistanceValue) * ndistances);
/*
* Walk though the ranges once and compute distance between the ranges so
* that we can sort them once.
*/
for (i = 0; i < ndistances; i++)
{
Datum a1,
a2,
r;
a1 = eranges[i].maxval;
a2 = eranges[i + 1].minval;
/* compute length of the gap (between max/min) */
r = FunctionCall2Coll(distanceFn, colloid, a1, a2);
/* remember the index of the gap the distance is for */
distances[i].index = i;
distances[i].value = DatumGetFloat8(r);
}
/*
* Sort the distances in descending order, so that the longest gaps are at
* the front.
*/
pg_qsort(distances, ndistances, sizeof(DistanceValue), compare_distances);
return distances;
}
/*
* Builds expanded ranges for the existing ranges (and single-point ranges),
* and also the new value (which did not fit into the array). This expanded
* representation makes the processing a bit easier, as it allows handling
* ranges and points the same way.
*
* We sort and deduplicate the expanded ranges - this is necessary, because
* the points may be unsorted. And moreover the two parts (ranges and
* points) are sorted on their own.
*/
static ExpandedRange *
build_expanded_ranges(FmgrInfo *cmp, Oid colloid, Ranges *ranges,
int *nranges)
{
int neranges;
ExpandedRange *eranges;
/* both ranges and points are expanded into a separate element */
neranges = ranges->nranges + ranges->nvalues;
eranges = (ExpandedRange *) palloc0(neranges * sizeof(ExpandedRange));
/* fill the expanded ranges */
fill_expanded_ranges(eranges, neranges, ranges);
/* sort and deduplicate the expanded ranges */
neranges = sort_expanded_ranges(cmp, colloid, eranges, neranges);
/* remember how many cranges we built */
*nranges = neranges;
return eranges;
}
#ifdef USE_ASSERT_CHECKING
/*
* Counts boundary 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(ExpandedRange *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;
}
#endif
/*
* reduce_expanded_ranges
* reduce the ranges until the number of values is low enough
*
* Combines ranges until the number of boundary values drops below the
* threshold specified by max_values. This happens by merging enough
* ranges by distance between them.
*
* Returns the number of result ranges.
*
* We simply use the global min/max and then add boundaries for enough
* largest gaps. Each gap adds 2 values, so we simply use (target/2-1)
* distances. Then we simply sort all the values - each two values are
* a boundary of a range (possibly collapsed).
*
* XXX Some of the ranges may be collapsed (i.e. the min/max values are
* equal), but we ignore that for now. We could repeat the process,
* adding a couple more gaps recursively.
*
* 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).
*
* XXX Or maybe we could just handle this by using random value as a
* tie-break, or by adding random noise to the actual distance.
*/
static int
reduce_expanded_ranges(ExpandedRange *eranges, int neranges,
DistanceValue *distances, int max_values,
FmgrInfo *cmp, Oid colloid)
{
int i;
int nvalues;
Datum *values;
compare_context cxt;
/* total number of gaps between ranges */
int ndistances = (neranges - 1);
/* number of gaps to keep */
int keep = (max_values / 2 - 1);
/*
* Maybe we have sufficiently low number of ranges already?
*
* XXX This should happen before we actually do the expensive stuff like
* sorting, so maybe this should be just an assert.
*/
if (keep >= ndistances)
return neranges;
/* sort the values */
cxt.colloid = colloid;
cxt.cmpFn = cmp;
/* allocate space for the boundary values */
nvalues = 0;
values = (Datum *) palloc(sizeof(Datum) * max_values);
/* add the global min/max values, from the first/last range */
values[nvalues++] = eranges[0].minval;
values[nvalues++] = eranges[neranges - 1].maxval;
/* add boundary values for enough gaps */
for (i = 0; i < keep; i++)
{
/* index of the gap between (index) and (index+1) ranges */
int index = distances[i].index;
Assert((index >= 0) && ((index + 1) < neranges));
/* add max from the preceding range, minval from the next one */
values[nvalues++] = eranges[index].maxval;
values[nvalues++] = eranges[index + 1].minval;
Assert(nvalues <= max_values);
}
/* We should have even number of range values. */
Assert(nvalues % 2 == 0);
/*
* Sort the values using the comparator function, and form ranges from the
* sorted result.
*/
qsort_arg(values, nvalues, sizeof(Datum),
compare_values, (void *) &cxt);
/* We have nvalues boundary values, which means nvalues/2 ranges. */
for (i = 0; i < (nvalues / 2); i++)
{
eranges[i].minval = values[2 * i];
eranges[i].maxval = values[2 * i + 1];
/* if the boundary values are the same, it's a collapsed range */
eranges[i].collapsed = (compare_values(&values[2 * i],
&values[2 * i + 1],
&cxt) == 0);
}
return (nvalues / 2);
}
/*
* Store the boundary values from ExpandedRanges back into Range (using
* only the minimal number of values needed).
*/
static void
store_expanded_ranges(Ranges *ranges, ExpandedRange *eranges, int neranges)
{
int i;
int idx = 0;
/* first copy in the regular ranges */
ranges->nranges = 0;
for (i = 0; i < neranges; i++)
{
if (!eranges[i].collapsed)
{
ranges->values[idx++] = eranges[i].minval;
ranges->values[idx++] = eranges[i].maxval;
ranges->nranges++;
}
}
/* now copy in the collapsed ones */
ranges->nvalues = 0;
for (i = 0; i < neranges; i++)
{
if (eranges[i].collapsed)
{
ranges->values[idx++] = eranges[i].minval;
ranges->nvalues++;
}
}
/* all the values are sorted */
ranges->nsorted = ranges->nvalues;
Assert(count_values(eranges, neranges) == 2 * ranges->nranges + ranges->nvalues);
Assert(2 * ranges->nranges + ranges->nvalues <= ranges->maxvalues);
}
/*
* Consider freeing space in the ranges. Checks if there's space for at least
* one new value, and performs compaction if needed.
*
* Returns true if the value was actually modified.
*/
static bool
ensure_free_space_in_buffer(BrinDesc *bdesc, Oid colloid,
AttrNumber attno, Form_pg_attribute attr,
Ranges *range)
{
MemoryContext ctx;
MemoryContext oldctx;
FmgrInfo *cmpFn,
*distanceFn;
/* expanded ranges */
ExpandedRange *eranges;
int neranges;
DistanceValue *distances;
/*
* If there is free space in the buffer, we're done without having to
* modify anything.
*/
if (2 * range->nranges + range->nvalues < range->maxvalues)
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);
/* deduplicate values, if there's unsorted part */
range_deduplicate_values(range);
/*
* did we reduce enough free space by just the deduplication?
*
* We don't simply check against range->maxvalues again. The deduplication
* might have freed very little space (e.g. just one value), forcing us to
* do depuplication very often. In that case it's better to do compaction
* and reduce more space.
*/
if (2 * range->nranges + range->nvalues <= range->maxvalues * MINMAX_BUFFER_LOAD_FACTOR)
return true;
/*
* We need to combine some of the existing ranges, to reduce the number of
* values we have to store.
*
* The distanceFn calls (which may internally call e.g. numeric_le) may
* allocate quite a bit of memory, and we must not leak it (we might have
* to do this repeatedly, even for a single BRIN page range). Otherwise
* we'd have problems e.g. when building new indexes. So we use a memory
* context and make sure we free the memory at the end (so if we call the
* distance function many times, it might be an issue, but meh).
*/
ctx = AllocSetContextCreate(CurrentMemoryContext,
"minmax-multi context",
ALLOCSET_DEFAULT_SIZES);
oldctx = MemoryContextSwitchTo(ctx);
/* build the expanded ranges */
eranges = build_expanded_ranges(cmpFn, colloid, range, &neranges);
/* and we'll also need the 'distance' procedure */
distanceFn = minmax_multi_get_procinfo(bdesc, attno, PROCNUM_DISTANCE);
/* build array of gap distances and sort them in ascending order */
distances = build_distances(distanceFn, colloid, eranges, neranges);
/*
* Combine ranges until we release at least 50% of the space. This
* threshold is somewhat arbitrary, perhaps needs tuning. We must not use
* too low or high value.
*/
neranges = reduce_expanded_ranges(eranges, neranges, distances,
range->maxvalues * MINMAX_BUFFER_LOAD_FACTOR,
cmpFn, colloid);
/* Make sure we've sufficiently reduced the number of ranges. */
Assert(count_values(eranges, neranges) <= range->maxvalues * MINMAX_BUFFER_LOAD_FACTOR);
/* decompose the expanded ranges into regular ranges and single values */
store_expanded_ranges(range, eranges, neranges);
MemoryContextSwitchTo(oldctx);
MemoryContextDelete(ctx);
/* Did we break the ranges somehow? */
AssertCheckRanges(range, cmpFn, colloid);
return true;
}
/*
* range_add_value
* Add the new value to the minmax-multi range.
*/
static bool
range_add_value(BrinDesc *bdesc, Oid colloid,
AttrNumber attno, Form_pg_attribute attr,
Ranges *ranges, Datum newval)
{
FmgrInfo *cmpFn;
bool modified = false;
/* we'll certainly need the comparator, so just look it up now */
cmpFn = minmax_multi_get_strategy_procinfo(bdesc, attno, attr->atttypid,
BTLessStrategyNumber);
/* comprehensive checks of the input ranges */
AssertCheckRanges(ranges, cmpFn, colloid);
/*
* Make sure there's enough free space in the buffer. We only trigger this
* when the buffer is full, which means it had to be modified as we size
* it to be larger than what is stored on disk.
*
* This needs to happen before we check if the value is contained in the
* range, because the value might be in the unsorted part, and we don't
* check that in range_contains_value. The deduplication would then move
* it to the sorted part, and we'd add the value too, which violates the
* rule that we never have duplicates with the ranges or sorted values.
*
* We might also deduplicate and recheck if the value is contained, but
* that seems like an overkill. We'd need to deduplicate anyway, so why
* not do it now.
*/
modified = ensure_free_space_in_buffer(bdesc, colloid,
attno, attr, ranges);
/*
* 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 the values array can't contain duplicate values.
*/
if (range_contains_value(bdesc, colloid, attno, attr, ranges, newval, false))
return modified;
/* Make a copy of the value, if needed. */
newval = datumCopy(newval, attr->attbyval, attr->attlen);
/*
* 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.
*/
ranges->values[2 * ranges->nranges + ranges->nvalues] = newval;
ranges->nvalues++;
/* If we added the first value, we can consider it as sorted. */
if (ranges->nvalues == 1)
ranges->nsorted = 1;
/*
* Check we haven't broken the ordering of boundary values (checks both
* parts, but that doesn't hurt).
*/
AssertCheckRanges(ranges, cmpFn, colloid);
/* Check the range contains the value we just added. */
Assert(range_contains_value(bdesc, colloid, attno, attr, ranges, newval, true));
/* yep, we've modified the range */
return true;
}
/*
* Generate range representation of data collected during "batch mode".
* This is similar to reduce_expanded_ranges, except that we can't assume
* the values are sorted and there may be duplicate values.
*/
static void
compactify_ranges(BrinDesc *bdesc, Ranges *ranges, int max_values)
{
FmgrInfo *cmpFn,
*distanceFn;
/* expanded ranges */
ExpandedRange *eranges;
int neranges;
DistanceValue *distances;
MemoryContext ctx;
MemoryContext oldctx;
/*
* Do we need to actually compactify anything?
*
* There are two reasons why compaction may be needed - firstly, there may
* be too many values, or some of the values may be unsorted.
*/
if ((ranges->nranges * 2 + ranges->nvalues <= max_values) &&
(ranges->nsorted == ranges->nvalues))
return;
/* we'll certainly need the comparator, so just look it up now */
cmpFn = minmax_multi_get_strategy_procinfo(bdesc, ranges->attno, ranges->typid,
BTLessStrategyNumber);
/* and we'll also need the 'distance' procedure */
distanceFn = minmax_multi_get_procinfo(bdesc, ranges->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);
/* build the expanded ranges */
eranges = build_expanded_ranges(cmpFn, ranges->colloid, ranges, &neranges);
/* build array of gap distances and sort them in ascending order */
distances = build_distances(distanceFn, ranges->colloid,
eranges, neranges);
/*
* Combine ranges until we get below max_values. We don't use any scale
* factor, because this is used during serialization, and we don't expect
* more tuples to be inserted anytime soon.
*/
neranges = reduce_expanded_ranges(eranges, neranges, distances,
max_values, cmpFn, ranges->colloid);
Assert(count_values(eranges, neranges) <= max_values);
/* transform back into regular ranges and single values */
store_expanded_ranges(ranges, eranges, neranges);
/* check all the range invariants */
AssertCheckRanges(ranges, cmpFn, ranges->colloid);
MemoryContextSwitchTo(oldctx);
MemoryContextDelete(ctx);
}
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);
/*
* We use the no-check variants here, because user-supplied values may
* have (ip_posid == 0). See ItemPointerCompare.
*/
da1 = ItemPointerGetBlockNumberNoCheck(pa1) * MaxHeapTuplesPerPage +
ItemPointerGetOffsetNumberNoCheck(pa1);
da2 = ItemPointerGetBlockNumberNoCheck(pa2) * MaxHeapTuplesPerPage +
ItemPointerGetOffsetNumberNoCheck(pa2);
PG_RETURN_FLOAT8(da2 - da1);
}
/*
* Computes 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;
float8 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);
}
/*
* Compute approximate distance between two dates.
*/
Datum
brin_minmax_multi_distance_date(PG_FUNCTION_ARGS)
{
DateADT dateVal1 = PG_GETARG_DATEADT(0);
DateADT dateVal2 = PG_GETARG_DATEADT(1);
if (DATE_NOT_FINITE(dateVal1) || DATE_NOT_FINITE(dateVal2))
PG_RETURN_FLOAT8(0);
PG_RETURN_FLOAT8(dateVal1 - dateVal2);
}
/*
* 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)
{
float8 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.
*/
Datum
brin_minmax_multi_distance_timetz(PG_FUNCTION_ARGS)
{
float8 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);
}
Datum
brin_minmax_multi_distance_timestamp(PG_FUNCTION_ARGS)
{
float8 delta = 0;
Timestamp dt1 = PG_GETARG_TIMESTAMP(0);
Timestamp dt2 = PG_GETARG_TIMESTAMP(1);
if (TIMESTAMP_NOT_FINITE(dt1) || TIMESTAMP_NOT_FINITE(dt2))
PG_RETURN_FLOAT8(0);
delta = dt2 - dt1;
Assert(delta >= 0);
PG_RETURN_FLOAT8(delta);
}
/*
* Computes distance between two interval values.
*/
Datum
brin_minmax_multi_distance_interval(PG_FUNCTION_ARGS)
{
float8 delta = 0;
Interval *ia = PG_GETARG_INTERVAL_P(0);
Interval *ib = PG_GETARG_INTERVAL_P(1);
Interval *result;
result = (Interval *) palloc(sizeof(Interval));
result->month = ib->month - ia->month;
/* overflow check copied from int4mi */
if (!SAMESIGN(ib->month, ia->month) &&
!SAMESIGN(result->month, ib->month))
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("interval out of range")));
result->day = ib->day - ia->day;
if (!SAMESIGN(ib->day, ia->day) &&
!SAMESIGN(result->day, ib->day))
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("interval out of range")));
result->time = ib->time - ia->time;
if (!SAMESIGN(ib->time, ia->time) &&
!SAMESIGN(result->time, ib->time))
ereport(ERROR,
(errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
errmsg("interval out of range")));
/*
* We assume months have 31 days - we don't need to be precise, in the
* worst case we'll build somewhat less efficient ranges.
*/
delta = (float8) (result->month * 31 + result->day);
/* convert to microseconds (just like the time part) */
delta = 24L * 3600L * delta;
/* and add the time part */
delta += result->time / (float8) 1000000.0;
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)
{
float8 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)
{
float8 delta;
macaddr *a = PG_GETARG_MACADDR_P(0);
macaddr *b = PG_GETARG_MACADDR_P(1);
delta = ((float8) b->f - (float8) a->f);
delta /= 256;
delta += ((float8) b->e - (float8) a->e);
delta /= 256;
delta += ((float8) b->d - (float8) a->d);
delta /= 256;
delta += ((float8) b->c - (float8) a->c);
delta /= 256;
delta += ((float8) b->b - (float8) a->b);
delta /= 256;
delta += ((float8) b->a - (float8) 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)
{
float8 delta;
macaddr8 *a = PG_GETARG_MACADDR8_P(0);
macaddr8 *b = PG_GETARG_MACADDR8_P(1);
delta = ((float8) b->h - (float8) a->h);
delta /= 256;
delta += ((float8) b->g - (float8) a->g);
delta /= 256;
delta += ((float8) b->f - (float8) a->f);
delta /= 256;
delta += ((float8) b->e - (float8) a->e);
delta /= 256;
delta += ((float8) b->d - (float8) a->d);
delta /= 256;
delta += ((float8) b->c - (float8) a->c);
delta /= 256;
delta += ((float8) b->b - (float8) a->b);
delta /= 256;
delta += ((float8) b->a - (float8) 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 different families are considered 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)
{
float8 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))
PG_RETURN_FLOAT8(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 += (float8) addrb[i] - (float8) addra[i];
delta /= 256;
}
Assert((delta >= 0) && (delta <= 1));
PG_RETURN_FLOAT8(delta);
}
static void
brin_minmax_multi_serialize(BrinDesc *bdesc, Datum src, Datum *dst)
{
Ranges *ranges = (Ranges *) DatumGetPointer(src);
SerializedRanges *s;
/*
* In batch mode, we need to compress the accumulated values to the
* actually requested number of values/ranges.
*/
compactify_ranges(bdesc, ranges, ranges->target_maxvalues);
/* At this point everything has to be fully sorted. */
Assert(ranges->nsorted == ranges->nvalues);
s = range_serialize(ranges);
dst[0] = PointerGetDatum(s);
}
static int
brin_minmax_multi_get_values(BrinDesc *bdesc, MinMaxMultiOptions *opts)
{
return MinMaxMultiGetValuesPerRange(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);
MinMaxMultiOptions *opts = (MinMaxMultiOptions *) 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, if 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.
*
* When starting with an empty range, we assume this is a batch mode and
* we use a larger buffer. The buffer size is derived from the BRIN range
* size, number of rows per page, with some sensible min/max values. Small
* buffer would be bad for performance, but large buffer might require a
* lot of memory (because of keeping all the values).
*/
if (column->bv_allnulls)
{
MemoryContext oldctx;
int target_maxvalues;
int maxvalues;
BlockNumber pagesPerRange = BrinGetPagesPerRange(bdesc->bd_index);
/* what was specified as a reloption? */
target_maxvalues = brin_minmax_multi_get_values(bdesc, opts);
/*
* Determine the insert buffer size - we use 10x the target, capped to
* the maximum number of values in the heap range. This is more than
* enough, considering the actual number of rows per page is likely
* much lower, but meh.
*/
maxvalues = Min(target_maxvalues * MINMAX_BUFFER_FACTOR,
MaxHeapTuplesPerPage * pagesPerRange);
/* but always at least the original value */
maxvalues = Max(maxvalues, target_maxvalues);
/* always cap by MIN/MAX */
maxvalues = Max(maxvalues, MINMAX_BUFFER_MIN);
maxvalues = Min(maxvalues, MINMAX_BUFFER_MAX);
oldctx = MemoryContextSwitchTo(column->bv_context);
ranges = minmax_multi_init(maxvalues);
ranges->attno = attno;
ranges->colloid = colloid;
ranges->typid = attr->atttypid;
ranges->target_maxvalues = target_maxvalues;
/* we'll certainly need the comparator, so just look it up now */
ranges->cmp = minmax_multi_get_strategy_procinfo(bdesc, attno, attr->atttypid,
BTLessStrategyNumber);
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;
int maxvalues;
BlockNumber pagesPerRange = BrinGetPagesPerRange(bdesc->bd_index);
oldctx = MemoryContextSwitchTo(column->bv_context);
serialized = (SerializedRanges *) PG_DETOAST_DATUM(column->bv_values[0]);
/*
* Determine the insert buffer size - we use 10x the target, capped to
* the maximum number of values in the heap range. This is more than
* enough, considering the actual number of rows per page is likely
* much lower, but meh.
*/
maxvalues = Min(serialized->maxvalues * MINMAX_BUFFER_FACTOR,
MaxHeapTuplesPerPage * pagesPerRange);
/* but always at least the original value */
maxvalues = Max(maxvalues, serialized->maxvalues);
/* always cap by MIN/MAX */
maxvalues = Max(maxvalues, MINMAX_BUFFER_MIN);
maxvalues = Min(maxvalues, MINMAX_BUFFER_MAX);
ranges = range_deserialize(maxvalues, serialized);
ranges->attno = attno;
ranges->colloid = colloid;
ranges->typid = attr->atttypid;
/* we'll certainly need the comparator, so just look it up now */
ranges->cmp = minmax_multi_get_strategy_procinfo(bdesc, attno, attr->atttypid,
BTLessStrategyNumber);
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 updated summary later.
*/
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);
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->maxvalues, 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. We don't bother with doing a binary search
* here, because we're dealing with serialized / fully compacted ranges,
* so there should be only very few 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);
Oid colloid = PG_GET_COLLATION();
SerializedRanges *serialized_a;
SerializedRanges *serialized_b;
Ranges *ranges_a;
Ranges *ranges_b;
AttrNumber attno;
Form_pg_attribute attr;
ExpandedRange *eranges;
int neranges;
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->maxvalues, serialized_a);
ranges_b = range_deserialize(serialized_b->maxvalues, serialized_b);
/* make sure neither of the ranges is NULL */
Assert(ranges_a && ranges_b);
neranges = (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 */
eranges = (ExpandedRange *) palloc0(neranges * sizeof(ExpandedRange));
/* fill the expanded ranges with entries for the first range */
fill_expanded_ranges(eranges, ranges_a->nranges + ranges_a->nvalues,
ranges_a);
/* and now add combine ranges for the second range */
fill_expanded_ranges(&eranges[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 expanded ranges */
sort_expanded_ranges(cmpFn, colloid, eranges, neranges);
/*
* We've loaded two different lists of expanded ranges, so some of them
* may be overlapping. So walk through them and merge them.
*/
neranges = merge_overlapping_ranges(cmpFn, colloid, eranges, neranges);
/* check that the combine ranges are correct (no overlaps, ordering) */
AssertCheckExpandedRanges(bdesc, colloid, attno, attr, eranges, neranges);
/*
* If needed, reduce some of the ranges.
*
* XXX This may be fairly expensive, so maybe we should do it only when
* it's actually needed (when we have too many ranges).
*/
/* 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, eranges, neranges);
/*
* See how many values would be needed to store the current ranges, and if
* needed combine as many of them to get below the threshold. The
* collapsed ranges will be stored as a single value.
*
* XXX This does not apply the load factor, as we don't expect to add more
* values to the range, so we prefer to keep as many ranges as possible.
*
* XXX Can the maxvalues be different in the two ranges? Perhaps we should
* use maximum of those?
*/
neranges = reduce_expanded_ranges(eranges, neranges, distances,
ranges_a->maxvalues,
cmpFn, colloid);
/* update the first range summary */
store_expanded_ranges(ranges_a, eranges, neranges);
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 does not exist.
*/
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(MinMaxMultiOptions));
add_local_int_reloption(relopts, "values_per_range", "desc",
MINMAX_MULTI_DEFAULT_VALUES_PER_PAGE, 8, 256,
offsetof(MinMaxMultiOptions, 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->maxvalues, 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);
}
src/backend/access/brin/brin_tuple.c
View file @ ab596105
......@@ -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(brdesc,
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
......@@ -512,6 +520,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;
}
......@@ -591,6 +604,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);
......
src/include/access/brin_tuple.h
View file @ ab596105
......@@ -14,6 +14,11 @@
#include "access/brin_internal.h"
#include "access/tupdesc.h"
/*
* The BRIN opclasses may register serialization callback, in case the on-disk
* and in-memory representations differ (e.g. for performance reasons).
*/
typedef void (*brin_serialize_callback_type) (BrinDesc *bdesc, Datum src, Datum *dst);
/*
* A BRIN index stores one index tuple per page range. Each index tuple
......@@ -27,6 +32,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;
/*
......
src/include/access/transam.h
View file @ ab596105
......@@ -161,18 +161,18 @@ FullTransactionIdAdvance(FullTransactionId *dest)
* development purposes (such as in-progress patches and forks);
* they should not appear in released versions.
*
* OIDs 10000-11999 are reserved for assignment by genbki.pl, for use
* OIDs 10000-12999 are reserved for assignment by genbki.pl, for use
* when the .dat files in src/include/catalog/ do not specify an OID
* for a catalog entry that requires one.
*
* OIDS 12000-16383 are reserved for assignment during initdb
* using the OID generator. (We start the generator at 12000.)
* OIDS 13000-16383 are reserved for assignment during initdb
* using the OID generator. (We start the generator at 13000.)
*
* OIDs beginning at 16384 are assigned from the OID generator
* during normal multiuser operation. (We force the generator up to
* 16384 as soon as we are in normal operation.)
*
* The choices of 8000, 10000 and 12000 are completely arbitrary, and can be
* The choices of 8000, 10000 and 13000 are completely arbitrary, and can be
* moved if we run low on OIDs in any category. Changing the macros below,
* and updating relevant documentation (see bki.sgml and RELEASE_CHANGES),
* should be sufficient to do this. Moving the 16384 boundary between
......@@ -186,7 +186,7 @@ FullTransactionIdAdvance(FullTransactionId *dest)
* ----------
*/
#define FirstGenbkiObjectId 10000
#define FirstBootstrapObjectId 12000
#define FirstBootstrapObjectId 13000
#define FirstNormalObjectId 16384
/*
......
src/include/catalog/catversion.h
View file @ ab596105
......@@ -53,6 +53,6 @@
*/
/* yyyymmddN */
#define CATALOG_VERSION_NO 202103263
#define CATALOG_VERSION_NO 202103264
#endif
src/include/catalog/pg_amop.dat
View file @ ab596105
......@@ -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',
......@@ -2062,6 +2208,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)',
......@@ -2088,6 +2251,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)
......@@ -2155,6 +2334,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)',
......@@ -2180,6 +2425,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',
......@@ -2202,6 +2464,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',
......@@ -2224,6 +2503,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)',
......@@ -2288,6 +2584,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)',
......@@ -2439,6 +2752,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',
......@@ -2470,6 +2929,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',
......@@ -2492,6 +2968,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)',
......@@ -2548,6 +3041,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',
......@@ -2570,6 +3080,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)',
......@@ -2636,6 +3163,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)',
......
src/include/catalog/pg_amproc.dat
View file @ ab596105
......@@ -922,6 +922,58 @@
{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4',
amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_union' },
# minmax multi integer: int2, int4, 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 => '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 => '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' },
# bloom integer: int2, int4, int8
{ amprocfamily => 'brin/integer_bloom_ops', amproclefttype => 'int8',
amprocrighttype => 'int8', amprocnum => '1',
......@@ -1017,6 +1069,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' },
......@@ -1063,6 +1132,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',
......@@ -1090,6 +1176,45 @@
amprocrighttype => 'float8', 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 => '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' },
# bloom float
{ amprocfamily => 'brin/float_bloom_ops', amproclefttype => 'float4',
amprocrighttype => 'float4', amprocnum => '1',
......@@ -1143,6 +1268,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',
......@@ -1177,6 +1322,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',
......@@ -1210,6 +1375,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',
......@@ -1295,6 +1480,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',
......@@ -1352,6 +1556,64 @@
{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date',
amprocrighttype => 'date', 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_timestamp' },
{ 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_timestamp' },
{ 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_date' },
# bloom datetime (date, timestamp, timestamptz)
{ amprocfamily => 'brin/datetime_bloom_ops', amproclefttype => 'timestamp',
amprocrighttype => 'timestamp', amprocnum => '1',
......@@ -1422,6 +1684,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',
......@@ -1456,6 +1738,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',
......@@ -1516,6 +1818,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',
......@@ -1549,6 +1871,26 @@
{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid',
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',
amprocrighttype => 'uuid', amprocnum => '1',
......@@ -1604,6 +1946,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',
......
src/include/catalog/pg_opclass.dat
View file @ ab596105
......@@ -284,18 +284,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' },
......@@ -307,6 +316,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' },
......@@ -315,33 +327,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' },
......@@ -357,36 +387,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' },
......@@ -398,6 +446,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' },
......@@ -407,6 +458,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' },
......@@ -416,6 +470,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' },
......
src/include/catalog/pg_opfamily.dat
View file @ ab596105
......@@ -182,10 +182,14 @@
opfmethod => 'gin', opfname => 'jsonb_path_ops' },
{ oid => '4054',
opfmethod => 'brin', opfname => 'integer_minmax_ops' },
{ oid => '4602',
opfmethod => 'brin', opfname => 'integer_minmax_multi_ops' },
{ oid => '4572',
opfmethod => 'brin', opfname => 'integer_bloom_ops' },
{ oid => '4055',
opfmethod => 'brin', opfname => 'numeric_minmax_ops' },
{ oid => '4603',
opfmethod => 'brin', opfname => 'numeric_minmax_multi_ops' },
{ oid => '4056',
opfmethod => 'brin', opfname => 'text_minmax_ops' },
{ oid => '4573',
......@@ -194,10 +198,14 @@
opfmethod => 'brin', opfname => 'numeric_bloom_ops' },
{ oid => '4058',
opfmethod => 'brin', opfname => 'timetz_minmax_ops' },
{ oid => '4604',
opfmethod => 'brin', opfname => 'timetz_minmax_multi_ops' },
{ oid => '4575',
opfmethod => 'brin', opfname => 'timetz_bloom_ops' },
{ oid => '4059',
opfmethod => 'brin', opfname => 'datetime_minmax_ops' },
{ oid => '4605',
opfmethod => 'brin', opfname => 'datetime_minmax_multi_ops' },
{ oid => '4576',
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 => '4606',
opfmethod => 'brin', opfname => 'oid_minmax_multi_ops' },
{ oid => '4580',
opfmethod => 'brin', opfname => 'oid_bloom_ops' },
{ oid => '4069',
opfmethod => 'brin', opfname => 'tid_minmax_ops' },
{ oid => '4581',
opfmethod => 'brin', opfname => 'tid_bloom_ops' },
{ oid => '4607',
opfmethod => 'brin', opfname => 'tid_minmax_multi_ops' },
{ oid => '4070',
opfmethod => 'brin', opfname => 'float_minmax_ops' },
{ oid => '4608',
opfmethod => 'brin', opfname => 'float_minmax_multi_ops' },
{ oid => '4582',
opfmethod => 'brin', opfname => 'float_bloom_ops' },
{ oid => '4074',
opfmethod => 'brin', opfname => 'macaddr_minmax_ops' },
{ oid => '4609',
opfmethod => 'brin', opfname => 'macaddr_minmax_multi_ops' },
{ oid => '4583',
opfmethod => 'brin', opfname => 'macaddr_bloom_ops' },
{ oid => '4109',
opfmethod => 'brin', opfname => 'macaddr8_minmax_ops' },
{ oid => '4610',
opfmethod => 'brin', opfname => 'macaddr8_minmax_multi_ops' },
{ oid => '4584',
opfmethod => 'brin', opfname => 'macaddr8_bloom_ops' },
{ oid => '4075',
opfmethod => 'brin', opfname => 'network_minmax_ops' },
{ oid => '4611',
opfmethod => 'brin', opfname => 'network_minmax_multi_ops' },
{ oid => '4102',
opfmethod => 'brin', opfname => 'network_inclusion_ops' },
{ oid => '4585',
......@@ -244,10 +264,14 @@
opfmethod => 'brin', opfname => 'bpchar_bloom_ops' },
{ oid => '4077',
opfmethod => 'brin', opfname => 'time_minmax_ops' },
{ oid => '4612',
opfmethod => 'brin', opfname => 'time_minmax_multi_ops' },
{ oid => '4587',
opfmethod => 'brin', opfname => 'time_bloom_ops' },
{ oid => '4078',
opfmethod => 'brin', opfname => 'interval_minmax_ops' },
{ oid => '4613',
opfmethod => 'brin', opfname => 'interval_minmax_multi_ops' },
{ oid => '4588',
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 => '4614',
opfmethod => 'brin', opfname => 'uuid_minmax_multi_ops' },
{ oid => '4589',
opfmethod => 'brin', opfname => 'uuid_bloom_ops' },
{ oid => '4103',
opfmethod => 'brin', opfname => 'range_inclusion_ops' },
{ oid => '4082',
opfmethod => 'brin', opfname => 'pg_lsn_minmax_ops' },
{ oid => '4615',
opfmethod => 'brin', opfname => 'pg_lsn_minmax_multi_ops' },
{ oid => '4590',
opfmethod => 'brin', opfname => 'pg_lsn_bloom_ops' },
{ oid => '4104',
......
src/include/catalog/pg_proc.dat
View file @ ab596105
......@@ -8238,6 +8238,77 @@
proname => 'brin_minmax_union', prorettype => 'bool',
proargtypes => 'internal internal internal', prosrc => 'brin_minmax_union' },
# BRIN minmax multi
{ oid => '4616', descr => 'BRIN multi minmax support',
proname => 'brin_minmax_multi_opcinfo', prorettype => 'internal',
proargtypes => 'internal', prosrc => 'brin_minmax_multi_opcinfo' },
{ oid => '4617', 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 => '4618', descr => 'BRIN multi minmax support',
proname => 'brin_minmax_multi_consistent', prorettype => 'bool',
proargtypes => 'internal internal internal int4',
prosrc => 'brin_minmax_multi_consistent' },
{ oid => '4619', descr => 'BRIN multi minmax support',
proname => 'brin_minmax_multi_union', prorettype => 'bool',
proargtypes => 'internal internal internal', prosrc => 'brin_minmax_multi_union' },
{ oid => '4620', descr => 'BRIN multi minmax support',
proname => 'brin_minmax_multi_options', prorettype => 'void', proisstrict => 'f',
proargtypes => 'internal', prosrc => 'brin_minmax_multi_options' },
{ oid => '4621', descr => 'BRIN multi minmax int2 distance',
proname => 'brin_minmax_multi_distance_int2', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_int2' },
{ oid => '4622', descr => 'BRIN multi minmax int4 distance',
proname => 'brin_minmax_multi_distance_int4', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_int4' },
{ oid => '4623', descr => 'BRIN multi minmax int8 distance',
proname => 'brin_minmax_multi_distance_int8', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_int8' },
{ oid => '4624', descr => 'BRIN multi minmax float4 distance',
proname => 'brin_minmax_multi_distance_float4', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_float4' },
{ oid => '4625', descr => 'BRIN multi minmax float8 distance',
proname => 'brin_minmax_multi_distance_float8', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_float8' },
{ oid => '4626', descr => 'BRIN multi minmax numeric distance',
proname => 'brin_minmax_multi_distance_numeric', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_numeric' },
{ oid => '4627', descr => 'BRIN multi minmax tid distance',
proname => 'brin_minmax_multi_distance_tid', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_tid' },
{ oid => '4628', descr => 'BRIN multi minmax uuid distance',
proname => 'brin_minmax_multi_distance_uuid', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_uuid' },
{ oid => '4629', descr => 'BRIN multi minmax date distance',
proname => 'brin_minmax_multi_distance_date', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_date' },
{ oid => '4630', descr => 'BRIN multi minmax time distance',
proname => 'brin_minmax_multi_distance_time', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_time' },
{ oid => '4631', descr => 'BRIN multi minmax interval distance',
proname => 'brin_minmax_multi_distance_interval', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_interval' },
{ oid => '4632', descr => 'BRIN multi minmax timetz distance',
proname => 'brin_minmax_multi_distance_timetz', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_timetz' },
{ oid => '4633', 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 => '4634', descr => 'BRIN multi minmax macaddr distance',
proname => 'brin_minmax_multi_distance_macaddr', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_macaddr' },
{ oid => '4635', descr => 'BRIN multi minmax macaddr8 distance',
proname => 'brin_minmax_multi_distance_macaddr8', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_macaddr8' },
{ oid => '4636', descr => 'BRIN multi minmax inet distance',
proname => 'brin_minmax_multi_distance_inet', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_inet' },
{ oid => '4637', descr => 'BRIN multi minmax timestamp distance',
proname => 'brin_minmax_multi_distance_timestamp', prorettype => 'float8',
proargtypes => 'internal internal', prosrc => 'brin_minmax_multi_distance_timestamp' },
# BRIN inclusion
{ oid => '4105', descr => 'BRIN inclusion support',
proname => 'brin_inclusion_opcinfo', prorettype => 'internal',
......@@ -11462,4 +11533,18 @@
proname => 'brin_bloom_summary_send', provolatile => 's', prorettype => 'bytea',
proargtypes => 'pg_brin_bloom_summary', prosrc => 'brin_bloom_summary_send' },
{ oid => '4638', descr => 'I/O',
proname => 'brin_minmax_multi_summary_in', prorettype => 'pg_brin_minmax_multi_summary',
proargtypes => 'cstring', prosrc => 'brin_minmax_multi_summary_in' },
{ oid => '4639', descr => 'I/O',
proname => 'brin_minmax_multi_summary_out', prorettype => 'cstring',
proargtypes => 'pg_brin_minmax_multi_summary', prosrc => 'brin_minmax_multi_summary_out' },
{ oid => '4640', 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 => '4641', 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' },
]
src/include/catalog/pg_type.dat
View file @ ab596105
......@@ -685,4 +685,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 => '4601',
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' },
]
src/test/regress/expected/brin_multi.out 0 → 100644
View file @ ab596105
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 = 7)
);
ERROR: value 7 out of bounds for option "values_per_range"
DETAIL: Valid values are between "8" 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 "8" and "256".
-- first create an index with a single page range, to force compaction
-- due to exceeding the number of values per summary
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
);
DROP INDEX brinidx_multi;
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 building an index with many values, to force compaction of the buffer
CREATE TABLE brin_large_range (a int4);
INSERT INTO brin_large_range SELECT i FROM generate_series(1,10000) s(i);
CREATE INDEX brin_large_range_idx ON brin_large_range USING brin (a int4_minmax_multi_ops);
DROP TABLE brin_large_range;
-- 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)
src/test/regress/expected/psql.out
View file @ ab596105
......@@ -4992,10 +4992,11 @@ List of access methods
\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_multi_ops | no
brin | oid | | oid_minmax_ops | yes
(2 rows)
(3 rows)
\dAf spgist
List of operator families
......
src/test/regress/expected/type_sanity.out
View file @ ab596105
......@@ -68,13 +68,14 @@ WHERE p1.typtype not in ('p') AND p1.typname NOT LIKE E'\\_%'
p2.typelem = p1.oid and p1.typarray = p2.oid)
ORDER BY p1.oid;
oid | typname
------+-----------------------
------+------------------------------
194 | pg_node_tree
3361 | pg_ndistinct
3402 | pg_dependencies
4600 | pg_brin_bloom_summary
4601 | pg_brin_minmax_multi_summary
5017 | pg_mcv_list
(5 rows)
(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,
......
src/test/regress/parallel_schedule
View file @ ab596105
......@@ -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
......
src/test/regress/serial_schedule
View file @ ab596105
......@@ -109,6 +109,7 @@ test: namespace
test: prepared_xacts
test: brin
test: brin_bloom
test: brin_multi
test: gin
test: gist
test: spgist
......
src/test/regress/sql/brin_multi.sql 0 → 100644
View file @ ab596105
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 = 7)
);
-- number of values must be <= 256
CREATE INDEX brinidx_multi ON brintest_multi USING brin (
int8col int8_minmax_multi_ops(values_per_range = 257)
);
-- first create an index with a single page range, to force compaction
-- due to exceeding the number of values per summary
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
);
DROP INDEX brinidx_multi;
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 building an index with many values, to force compaction of the buffer
CREATE TABLE brin_large_range (a int4);
INSERT INTO brin_large_range SELECT i FROM generate_series(1,10000) s(i);
CREATE INDEX brin_large_range_idx ON brin_large_range USING brin (a int4_minmax_multi_ops);
DROP TABLE brin_large_range;
-- 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;
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment