--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]

# Block size

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

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

pgac_args="$pgac_args with_blocksize"

# Check whether --with-blocksize was given.

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

withval=$with_blocksize;

case $withval in

{ { 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: argument required for --with-blocksize option" >&5

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

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

blocksize=$withval

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

# 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

# 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; }; }

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

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

# 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.

])

# 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.])

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

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

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.

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

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

(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</>.)