dnl

m4_pattern_forbid(^PGAC_)dnl to catch undefined macros

AC_INIT([PostgreSQL], [9.6.beta.4], [pgsql-bugs@postgresql.org])

AC_INIT([PostgreSQL], [9.6rc1], [pgsql-bugs@postgresql.org])

m4_if(m4_defn([m4_PACKAGE_VERSION]), [2.69], [], [m4_fatal([Autoconf version 2.69 is required.

Untested combinations of 'autoconf' and PostgreSQL versions are not

AC_SUBST(with_systemd)

AC_MSG_RESULT([$with_systemd])

#

# ICU

#

AC_MSG_CHECKING([whether to build with ICU support])

PGAC_ARG_BOOL(with, icu, no, [ --with-icu build with ICU support],

[AC_DEFINE([USE_ICU], 1, [Define to build with ICU support. (--with-icu)])])

AC_MSG_RESULT([$with_icu])

AC_SUBST(with_icu)

#

# Readline

#

AC_CHECK_FUNCS([SSL_get_current_compression])

fi

if test "$with_icu" = yes ; then

AC_SEARCH_LIBS(ucol_open_57, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_56, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_55, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_54, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_53, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_52, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_50, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_48, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_46, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_44, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_43, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_4_2, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_4_1, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_4_0, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_3_8, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_3_6, [icui18n icuin], [], [

AC_SEARCH_LIBS(ucol_open_3_4, [icui18n icuin], [], [AC_MSG_ERROR([library 'icui18n' is required for ICU])])

])

])

])

])

])

])

])

])

])

])

])

])

])

])

])

])

AC_CHECK_LIB(icuuc, ucnv_fromUChars_57, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_56, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_55, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_54, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_53, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_52, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_50, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_48, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_46, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_44, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_43, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_4_2, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_4_1, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_4_0, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_3_8, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_3_6, [], [

AC_CHECK_LIB(icuuc, ucnv_fromUChars_3_4, [], [AC_MSG_ERROR([library 'icuuc' is required for ICU])])

])

])

])

])

])

])

])

])

])

])

])

])

])

])

])

])

fi

if test "$with_pam" = yes ; then

AC_CHECK_LIB(pam, pam_start, [], [AC_MSG_ERROR([library 'pam' is required for PAM])])

fi

AC_CHECK_HEADER(openssl/err.h, [], [AC_MSG_ERROR([header file <openssl/err.h> is required for OpenSSL])])

fi

if test "$with_icu" = yes ; then

AC_CHECK_HEADER(unicode/utypes.h, [], [AC_MSG_ERROR([header file <unicode/utypes.h> is required for ICU])])

fi

if test "$with_pam" = yes ; then

AC_CHECK_HEADERS(security/pam_appl.h, [],

[AC_CHECK_HEADERS(pam/pam_appl.h, [],

Operating System (example: Linux 2.4.18):

PostgreSQL version (example: PostgreSQL 9.6beta4): PostgreSQL 9.6beta4

PostgreSQL version (example: PostgreSQL 9.6rc1): PostgreSQL 9.6rc1

Compiler used (example: gcc 3.3.5):

</row>

<row>

<entry><literal>box_ops</></entry>

<entry>box</entry>

<entry><type>box</></entry>

<entry>

<literal>&lt;&lt;</>

<literal>&amp;&lt;</>

Inner tuples are more complex, since they are branching points in the

search tree. Each inner tuple contains a set of one or more

<firstterm>nodes</>, which represent groups of similar leaf values.

A node contains a downlink that leadstoeither another, lower-level inner

tuple, or a short list of leaf tuples that all lie on the same index page.

Each node has a <firstterm>label</> that describes it; for example,

A node contains a downlink that leads either to another, lower-level inner

tuple, ortoa short list of leaf tuples that all lie on the same index page.

Each nodenormallyhas a <firstterm>label</> that describes it; for example,

in a radix tree the node label could be the next character of the string

value. Optionally, an inner tuple can have a <firstterm>prefix</> value

value. (Alternatively, an operator class can omit the node labels, if it

works with a fixed set of nodes for all inner tuples;

see <xref linkend="spgist-null-labels">.)

Optionally, an inner tuple can have a <firstterm>prefix</> value

that describes all its members. In a radix tree this could be the common

prefix of the represented strings. The prefix value is not necessarily

really a prefix, but can be any data needed by the operator class;

tuple, so the <acronym>SP-GiST</acronym> core provides the possibility for

operator classes to manage level counting while descending the tree.

There is also support for incrementally reconstructing the represented

value when that is needed.

value when that is needed, and for passing down additional data (called

<firstterm>traverse values</>) during a tree descent.

</para>

<note>

<structfield>prefixDatum</> to the prefix value.

Set <structfield>nNodes</> to indicate the number of nodes that

the new inner tuple will contain, and

set <structfield>nodeLabels</> to an array of their label values.

(If the nodes do not require labels, set <structfield>nodeLabels</>

to NULL; see <xref linkend="spgist-null-labels"> for details.)

set <structfield>nodeLabels</> to an array of their label values,

or to NULL if node labels are not required.

Set <structfield>mapTuplesToNodes</> to an array that gives the index

(from zero) of the node that each leaf tuple should be assigned to.

Set <structfield>leafTupleDatums</> to an array of the values to

Datum reconstructedValue; /* value reconstructed at parent */

void *traversalValue; /* opclass-specific traverse value */

MemoryContext traversalMemoryContext;

MemoryContext traversalMemoryContext; /* put new traverse values here */

int level; /* current level (counting from zero) */

bool returnData; /* original data must be returned? */

int *levelAdds; /* increment level by this much for each */

Datum *reconstructedValues; /* associated reconstructed values */

void **traversalValues; /* opclass-specific traverse values */

} spgInnerConsistentOut;

</programlisting>

parent tuple; it is <literal>(Datum) 0</> at the root level or if the

<function>inner_consistent</> function did not provide a value at the

parent level.

<structfield>traversalValue</> is a pointer to any traverse data

passed down from the previous call of <function>inner_consistent</>

on the parent index tuple, or NULL at the root level.

<structfield>traversalMemoryContext</> is the memory context in which

to store output traverse values (see below).

<structfield>level</> is the current inner tuple's level, starting at

zero for the root level.

<structfield>returnData</> is <literal>true</> if reconstructed data is

inner tuple, and

<structfield>nodeLabels</> is an array of their label values, or

NULL if the nodes do not have labels.

<structfield>traversalValue</> is a pointer to data that

<function>inner_consistent</> gets when called on child nodes from an

outer call of <function>inner_consistent</> on parent nodes.

</para>

<para>

<structfield>reconstructedValues</> to an array of the values

reconstructed for each child node to be visited; otherwise, leave

<structfield>reconstructedValues</> as NULL.

If it is desired to pass down additional out-of-band information

(<quote>traverse values</>) to lower levels of the tree search,

set <structfield>traversalValues</> to an array of the appropriate

traverse values, one for each child node to be visited; otherwise,

leave <structfield>traversalValues</> as NULL.

Note that the <function>inner_consistent</> function is

responsible for palloc'ing the

<structfield>nodeNumbers</>, <structfield>levelAdds</> and

<structfield>reconstructedValues</> arrays.

Sometimes accumulating some information is needed, while

descending from parent to child node was happened. In this case

<structfield>traversalValues</> array keeps pointers to

specific data you need to accumulate for every child node.

Memory for <structfield>traversalValues</> should be allocated in

the default context, but each element of it should be allocated in

<structfield>traversalMemoryContext</>.

<structfield>nodeNumbers</>, <structfield>levelAdds</>,

<structfield>reconstructedValues</>, and

<structfield>traversalValues</> arrays in the current memory context.

However, any output traverse values pointed to by

the <structfield>traversalValues</> array should be allocated

in <structfield>traversalMemoryContext</>.

Each traverse value must be a single palloc'd chunk.

</para>

</listitem>

</varlistentry>

parent tuple; it is <literal>(Datum) 0</> at the root level or if the

<function>inner_consistent</> function did not provide a value at the

parent level.

<structfield>traversalValue</> is a pointer to any traverse data

passed down from the previous call of <function>inner_consistent</>

on the parent index tuple, or NULL at the root level.

<structfield>level</> is the current leaf tuple's level, starting at

zero for the root level.

<structfield>returnData</> is <literal>true</> if reconstructed data is

<para>

The <productname>PostgreSQL</productname> source distribution includes

several examples of index operator classes for

<acronym>SP-GiST</acronym>. The core system currently provides radix

trees over text columns and two types of trees over points: quad-tree and

k-d tree. Look into <filename>src/backend/access/spgist/</> to see the

code.

several examples of index operator classes for <acronym>SP-GiST</acronym>,

as described in <xref linkend="spgist-builtin-opclasses-table">. Look

into <filename>src/backend/access/spgist/</>

and <filename>src/backend/utils/adt/</> to see the code.

</para>

</sect1>

rtli= (TimeLineID)strtoul(item->value,NULL,0);

if (errno==EINVAL||errno==ERANGE)

ereport(FATAL,

(errmsg("recovery_target_timeline is not a valid number: \"%s\"",

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("recovery_target_timeline is not a valid number: \"%s\"",

item->value)));

}

if (rtli)

recoveryTargetXid= (TransactionId)strtoul(item->value,NULL,0);

if (errno==EINVAL||errno==ERANGE)

ereport(FATAL,

(errmsg("recovery_target_xid is not a valid number: \"%s\"",

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("recovery_target_xid is not a valid number: \"%s\"",

item->value)));

ereport(DEBUG2,

(errmsg_internal("recovery_target_xid = %u",

}

ereport(FATAL,

(errmsg("unrecognized recovery parameter \"%s\"",

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("unrecognized recovery parameter \"%s\"",

item->name)));

}

{

if (recoveryRestoreCommand==NULL)

ereport(FATAL,

(errmsg("recovery command file \"%s\" must specify restore_command when standby mode is not enabled",

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("recovery command file \"%s\" must specify restore_command when standby mode is not enabled",

RECOVERY_COMMAND_FILE)));

}

!EnableHotStandby)

recoveryTargetAction=RECOVERY_TARGET_ACTION_SHUTDOWN;

if (StandbyModeRequested&& !IsUnderPostmaster)

ereport(FATAL,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

errmsg("standby mode is not supported by single-user servers")));

ArchiveRecoveryRequested= true;

if (rtli!=1&& !existsTimeLineHistory(rtli))

ereport(FATAL,

(errmsg("recovery target timeline %u does not exist",

(errcode(ERRCODE_INVALID_PARAMETER_VALUE),

errmsg("recovery target timeline %u does not exist",

rtli)));

recoveryTargetTLI=rtli;

recoveryTargetIsLatest= false;