--enable-debug build with debugging symbols (-g)

--enable-profiling build with profiling enabled

--enable-dtrace build with DTrace support

--disable-segmented-files disable data file segmentation (requires largefile support)

--enable-depend turn on automatic dependency tracking

--enable-cassert enable assertion checks (for debugging)

--enable-thread-safety make client libraries thread-safe

--with-includes=DIRS look for additional header files in DIRS

--with-libraries=DIRS look for additional libraries in DIRS

--with-libs=DIRS alternative spelling of --with-libraries

--with-pgport=PORTNUM change default port number [5432]

--with-pgport=PORTNUM set default port number [5432]

--with-blocksize=BLOCKSIZE set block size in kB [8]

--with-segsize=SEGSIZE set segment size in GB [1]

--with-tcl build Tcl modules (PL/Tcl)

--with-tclconfig=DIR tclConfig.sh is in DIR

--with-perl build Perl modules (PL/Perl)

#

#Data file segmentation

#Block size

#

{ echo "$as_me:$LINENO: checking for block size" >&5

echo $ECHO_N "checking for block size... $ECHO_C" >&6; }

pgac_args="$pgac_argsenable_segmented_files"

pgac_args="$pgac_argswith_blocksize"

# Check whether --enable-segmented-files was given.

if test "${enable_segmented_files+set}" = set; then

enableval=$enable_segmented_files;

case $enableval in

# Check whether --with-blocksize was given.

if test "${with_blocksize+set}" = set; then

withval=$with_blocksize;

case $withval in

yes)

:

{ { echo "$as_me:$LINENO: error: argument required for --with-blocksize option" >&5

echo "$as_me: error: argument required for --with-blocksize option" >&2;}

{ (exit 1); exit 1; }; }

;;

no)

:

{ { echo "$as_me:$LINENO: error: argument required for --with-blocksize option" >&5

echo "$as_me: error: argument required for --with-blocksize option" >&2;}

{ (exit 1); exit 1; }; }

;;

*)

{ { echo "$as_me:$LINENO: error: no argument expected for --enable-segmented-files option" >&5

echo "$as_me: error: no argument expected for --enable-segmented-files option" >&2;}

{ (exit 1); exit 1; }; }

blocksize=$withval

;;

esac

else

enable_segmented_files=yes

blocksize=8

fi

case ${blocksize} in

1) BLCKSZ=1024;;

2) BLCKSZ=2048;;

4) BLCKSZ=4096;;

8) BLCKSZ=8192;;

16) BLCKSZ=16384;;

32) BLCKSZ=32768;;

*) { { echo "$as_me:$LINENO: error: Invalid block size. Allowed values are 1,2,4,8,16,32." >&5

echo "$as_me: error: Invalid block size. Allowed values are 1,2,4,8,16,32." >&2;}

{ (exit 1); exit 1; }; }

esac

{ echo "$as_me:$LINENO: result: ${blocksize}kB" >&5

echo "${ECHO_T}${blocksize}kB" >&6; }

cat >>confdefs.h <<_ACEOF

#define BLCKSZ ${BLCKSZ}

_ACEOF

#

# File segment size

#

{ echo "$as_me:$LINENO: checking for segment size" >&5

echo $ECHO_N "checking for segment size... $ECHO_C" >&6; }

pgac_args="$pgac_args with_segsize"

# Check whether --with-segsize was given.

if test "${with_segsize+set}" = set; then

withval=$with_segsize;

case $withval in

yes)

{ { echo "$as_me:$LINENO: error: argument required for --with-segsize option" >&5

echo "$as_me: error: argument required for --with-segsize option" >&2;}

{ (exit 1); exit 1; }; }

;;

no)

{ { echo "$as_me:$LINENO: error: argument required for --with-segsize option" >&5

echo "$as_me: error: argument required for --with-segsize option" >&2;}

{ (exit 1); exit 1; }; }

;;

*)

segsize=$withval

;;

esac

else

segsize=1

fi

# this expression is set up to avoid unnecessary integer overflow

RELSEG_SIZE=`expr '(' 1024 '*' ${segsize} / ${blocksize} ')' '*' 1024`

test $? -eq 0 || exit 1

{ echo "$as_me:$LINENO: result: ${segsize}GB" >&5

echo "${ECHO_T}${segsize}GB" >&6; }

cat >>confdefs.h <<_ACEOF

#define RELSEG_SIZE ${RELSEG_SIZE}

_ACEOF

#

# C compiler

if test "$ac_cv_sizeof_off_t" -lt 8 -o "$enable_segmented_files" = "yes"; then

cat >>confdefs.h <<\_ACEOF

#define USE_SEGMENTED_FILES 1

_ACEOF

# If we don't have largefile support, can't handle segsize >= 2GB.

if test "$ac_cv_sizeof_off_t" -lt 8 -a "$segsize" != "1"; then

{ { echo "$as_me:$LINENO: error: Large file support is not enabled. Segment size cannot be larger than 1GB." >&5

echo "$as_me: error: Large file support is not enabled. Segment size cannot be larger than 1GB." >&2;}

{ (exit 1); exit 1; }; }

fi

# SunOS doesn't handle negative byte comparisons properly with +/- return

dnl Process this file with autoconf to produce a configure script.

dnl $PostgreSQL: pgsql/configure.in,v 1.557 2008/04/28 22:47:03 tgl Exp $

dnl $PostgreSQL: pgsql/configure.in,v 1.558 2008/05/02 01:08:26 tgl Exp $

dnl

dnl Developers, please strive to achieve this order:

dnl

# Default port number (--with-pgport), default 5432

#

AC_MSG_CHECKING([for default port number])

PGAC_ARG_REQ(with, pgport, [ --with-pgport=PORTNUMchange default port number [[5432]]],

PGAC_ARG_REQ(with, pgport, [ --with-pgport=PORTNUMset default port number [[5432]]],

[default_port=$withval],

[default_port=5432])

AC_MSG_RESULT([$default_port])

AC_SUBST(enable_dtrace)

#

# Data file segmentation

#

PGAC_ARG_BOOL(enable, segmented-files, yes,

[ --disable-segmented-files disable data file segmentation (requires largefile support)])

# Block size

#

AC_MSG_CHECKING([for block size])

PGAC_ARG_REQ(with, blocksize, [ --with-blocksize=BLOCKSIZE set block size in kB [[8]]],

[blocksize=$withval],

[blocksize=8])

case ${blocksize} in

1) BLCKSZ=1024;;

2) BLCKSZ=2048;;

4) BLCKSZ=4096;;

8) BLCKSZ=8192;;

16) BLCKSZ=16384;;

32) BLCKSZ=32768;;

*) AC_MSG_ERROR([Invalid block size. Allowed values are 1,2,4,8,16,32.])

esac

AC_MSG_RESULT([${blocksize}kB])

AC_DEFINE_UNQUOTED([BLCKSZ], ${BLCKSZ}, [

Size of a disk block --- this also limits the size of a tuple. You

can set it bigger if you need bigger tuples (although TOAST should

reduce the need to have large tuples, since fields can be spread

across multiple tuples).

BLCKSZ must be a power of 2. The maximum possible value of BLCKSZ

is currently 2^15 (32768). This is determined by the 15-bit widths

of the lp_off and lp_len fields in ItemIdData (see

include/storage/itemid.h).

Changing BLCKSZ requires an initdb.

])

#

# File segment size

#

AC_MSG_CHECKING([for segment size])

PGAC_ARG_REQ(with, segsize, [ --with-segsize=SEGSIZE set segment size in GB [[1]]],

[segsize=$withval],

[segsize=1])

# this expression is set up to avoid unnecessary integer overflow

RELSEG_SIZE=`expr '(' 1024 '*' ${segsize} / ${blocksize} ')' '*' 1024`

test $? -eq 0 || exit 1

AC_MSG_RESULT([${segsize}GB])

AC_DEFINE_UNQUOTED([RELSEG_SIZE], ${RELSEG_SIZE}, [

RELSEG_SIZE is the maximum number of blocks allowed in one disk file.

Thus, the maximum size of a single file is RELSEG_SIZE * BLCKSZ;

relations bigger than that are divided into multiple files.

RELSEG_SIZE * BLCKSZ must be less than your OS' limit on file size.

This is often 2 GB or 4GB in a 32-bit operating system, unless you

have large file support enabled. By default, we make the limit 1 GB

to avoid any possible integer-overflow problems within the OS.

A limit smaller than necessary only means we divide a large

relation into more chunks than necessary, so it seems best to err

in the direction of a small limit.

A power-of-2 value is recommended to save a few cycles in md.c,

but is not absolutely required.

Changing RELSEG_SIZE requires an initdb.

])

#

# C compiler

# Check for largefile support (must be after AC_SYS_LARGEFILE)

AC_CHECK_SIZEOF([off_t])

if test "$ac_cv_sizeof_off_t" -lt 8 -o "$enable_segmented_files" = "yes"; then

AC_DEFINE([USE_SEGMENTED_FILES], 1, [Define to split data files into 1GB segments.])

# If we don't have largefile support, can't handle segsize >= 2GB.

if test "$ac_cv_sizeof_off_t" -lt 8 -a "$segsize" != "1"; then

AC_MSG_ERROR([Large file support is not enabled. Segment size cannot be larger than 1GB.])

fi

# SunOS doesn't handle negative byte comparisons properly with +/- return

<!-- $PostgreSQL: pgsql/doc/src/sgml/installation.sgml,v 1.307 2008/04/21 00:26:44 tgl Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/installation.sgml,v 1.308 2008/05/02 01:08:26 tgl Exp $ -->

<chapter id="installation">

<title><![%standalone-include[<productname>PostgreSQL</>]]>

</varlistentry>

<varlistentry>

<term><option>--disable-segmented-files</option></term>

<term><option>--with-segsize=<replaceable>SEGSIZE</replaceable></option></term>

<listitem>

<para>

Store large tables as single operating-system files, rather than

dividing them into 1GB segments as is the default. This option

is ignored unless the operating system has <quote>largefile</>

support (which most do, nowadays). It can be helpful to reduce

the number of file descriptors consumed when working with very

large tables.

Set the <firstterm>segment size</>, in gigabytes. Large tables are

divided into multiple operating-system files, each of size equal

to the segment size. This avoids problems with file size limits

that exist on many platforms. The default segment size, 1 gigabyte,

is safe on all supported platforms. If your operating system has

<quote>largefile</> support (which most do, nowadays), you can use

a larger segment size. This can be helpful to reduce the number of

file descriptors consumed when working with very large tables.

But be careful not to select a value larger than is supported

by your platform and the filesystem(s) you intend to use. Other

tools you might wish to use, such as <application>tar</>, could

also set limits on the usable file size.

It is recommended, though not absolutely required, that this value

be a power of 2.

Note that changing this value requires an initdb.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><option>--with-blocksize=<replaceable>BLOCKSIZE</replaceable></option></term>

<listitem>

<para>

Set the <firstterm>block size</>, in kilobytes. This is the unit

of storage and I/O within tables. The default, 8 kilobytes,

is suitable for most situations; but other values may be useful

in special cases.

The value must be a power of 2 between 1 and 32 (kilobytes).

Note that changing this value requires an initdb.

</para>

</listitem>

</varlistentry>

<!-- $PostgreSQL: pgsql/doc/src/sgml/storage.sgml,v 1.22 2008/03/10 20:06:27 tgl Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/storage.sgml,v 1.23 2008/05/02 01:08:26 tgl Exp $ -->

<chapter id="storage">

</caution>

<para>

When a table or index exceeds 1 GB, it isnormallydivided into gigabyte-sized

When a table or index exceeds 1 GB, it is divided into gigabyte-sized

<firstterm>segments</>. The first segment's file name is the same as the

filenode; subsequent segments are named filenode.1, filenode.2, etc.

This arrangement avoids problems on platforms that have file size limitations.

(But if the platform does not have such a limitation, and

<option>--disable-segmented-files</option> was specified when

<productname>PostgreSQL</> was built, then each table or index is stored

as a single file, without segmentation.)

(Actually, 1 GB is just the default segment size. The segment size can be

adjusted using the configuration option <option>--with-segsize</option>

when building <productname>PostgreSQL</>.)

The contents of tables and indexes are discussed further in

<xref linkend="storage-page-layout">.

</para>

#defineMAX_PHYSICAL_FILESIZE0x40000000

#defineBUFFILE_SEG_SIZE(MAX_PHYSICAL_FILESIZE / BLCKSZ)