<!--

$Header: /cvsroot/pgsql/doc/src/sgml/biblio.sgml,v 1.16 2001/11/21 05:53:40 thomas Exp $

$Header: /cvsroot/pgsql/doc/src/sgml/biblio.sgml,v 1.17 2002/01/07 02:29:11 petere Exp $

-->

<bibliography id="biblio">

<title>PostgreSQL-Specific Documentation</title>

<para>This section is for related documentation.</para>

<biblioentry id="admin-guide">

<title>The <productname>PostgreSQL</productname> Administrator's Guide</title>

<titleabbrev>The Administrator's Guide</titleabbrev>

<editor>

<firstname>Thomas</firstname>

<surname>Lockhart</surname>

</editor>

<pubdate>2001-04-13</pubdate>

<publisher>

<publishername>The PostgreSQL Global Development Group</publishername>

</publisher>

</biblioentry>

<biblioentry id="dev-guide">

<title>The <productname>PostgreSQL</productname> Developer's Guide</title>

<titleabbrev>The Developer's Guide</titleabbrev>

<editor>

<firstname>Thomas</firstname>

<surname>Lockhart</surname>

</editor>

<pubdate>2001-04-13</pubdate>

<publisher>

<publishername>The PostgreSQL Global Development Group</publishername>

</publisher>

</biblioentry>

<biblioentry id="pro-guide">

<title>The <productname>PostgreSQL</productname> Programmer's Guide</title>

<titleabbrev>The Programmer's Guide</titleabbrev>

<editor>

<firstname>Thomas</firstname>

<surname>Lockhart</surname>

</editor>

<pubdate>2001-04-13</pubdate>

<publisher>

<publishername>The PostgreSQL Global Development Group</publishername>

</publisher>

</biblioentry>

<biblioentry id="tutorial-guide">

<title>The <productname>PostgreSQL</productname> Tutorial Introduction</title>

<titleabbrev>The Tutorial</titleabbrev>

<editor>

<firstname>Thomas</firstname>

<surname>Lockhart</surname>

</editor>

<pubdate>2001-04-13</pubdate>

<publisher>

<publishername>The PostgreSQL Global Development Group</publishername>

</publisher>

</biblioentry>

<biblioentry id="users-guide">

<title>The <productname>PostgreSQL</productname> User's Guide</title>

<titleabbrev>The User's Guide</titleabbrev>

<editor>

<firstname>Thomas</firstname>

<surname>Lockhart</surname>

</editor>

<pubdate>2001-04-13</pubdate>

<publisher>

<publishername>The PostgreSQL Global Development Group</publishername>

</publisher>

</biblioentry>

<biblioentry id="SIM98">

<title>Enhancement of the ANSI SQL Implementation of PostgreSQL</title>

<titleabbrev>Simkovics, 1998</titleabbrev>

<!--

$Header: /cvsroot/pgsql/doc/src/sgml/datatype.sgml,v 1.82 2002/01/04 17:02:02 thomas Exp $

$Header: /cvsroot/pgsql/doc/src/sgml/datatype.sgml,v 1.83 2002/01/0702:29:11 petere Exp $

-->

<chapter id="datatype">

paths, or have several possibilities for formats, such as the date

and time types.

Most of the input and output functions corresponding to the

base types (e.g., integers and floatingpoint numbers) do some

base types (e.g., integers and floating-point numbers) do some

error-checking.

Some of the input and output functions are not invertible. That is,

the result of an output function may lose precision when compared to

<para>

Numeric types consist of two-, four-, and eight-byte integers,

four- and eight-byte

floatingpoint numbers and fixed-precision decimals.

floating-point numbers and fixed-precision decimals.

</para>

<para>

numbers and carry out all calculations exactly. It is especially

recommended for storing monetary amounts and other quantities

where exactness is required. However, the <type>numeric</type>

type is very slow compared to the floatingpoint types described

type is very slow compared to the floating-point types described

in the next section.

</para>

<sect2 id="datatype-float">

<title>FloatingPoint Types</title>

<title>Floating-Point Types</title>

<para>

The data types <type>real</type> and <type>double

precision</type> are inexact, variableprecision numeric types.

precision</type> are inexact, variable-precision numeric types.

In practice, these types are usually implementations of <acronym>IEEE</acronym> 754

binary floating point (single and double precision,

respectively), to the extent that the underlying processor,

<listitem>

<para>

Comparing two floatingpoint values for equality may or may

Comparing two floating-point values for equality may or may

not work as expected.

</para>

</listitem>

will never be duplicates, either.

</para>

<important>

<para>

The implicit sequence created for the <type>serial</type> type will

<emphasis>not</emphasis> be automatically removed when the

table is dropped.

</para>

</important>

<para>

The type names <type>serial</type> and <type>serial4</type> are

equivalent: both create <type>integer</type> columns. The type

<para>

Input is accepted in a variety of formats, including integer and

floatingpoint literals, as well as <quote>typical</quote>

floating-point literals, as well as <quote>typical</quote>

currency formatting, such as <literal>'$1,000.00'</literal>.

Output is in the latter form.

</para>

escape character.

</para>

<sect2 id="datatype-binary-compat">

<title>Compatibility</title>

<para>

<type>Bytea</type> provides most of the functionality of the binary

string type per SQL99 section 4.3. A comparison of SQL99 Binary

</tbody>

</tgroup>

</table>

</sect2>

</sect1>

specifies the number of fractional digits retained in the seconds

field. By default, there is no explicit bound on precision. The

effective limit of precision is determined by the underlying double

precision floatingpoint number used to store values (in seconds

precision floating-point number used to store values (in seconds

for <type>interval</type> and

in seconds since 2000-01-01 for <type>timestamp</type>). The

useful range of <replaceable>p</replaceable> is from 0 to about

<!--

$Header: /cvsroot/pgsql/doc/src/sgml/dfunc.sgml,v 1.17 2001/11/21 05:53:41 thomas Exp $

$Header: /cvsroot/pgsql/doc/src/sgml/dfunc.sgml,v 1.18 2002/01/07 02:29:11 petere Exp $

-->

<sect2 id="dfunc">

<para>

In the following examples we assume that your source code is in a

file <filename>foo.c</filename> and we will createan shared library

file <filename>foo.c</filename> and we will createa shared library

<filename>foo.so</filename>. The intermediate object file will be

called <filename>foo.o</filename> unless otherwise noted. A shared

library can contain more than one object file, but we only use one

</varlistentry>

<varlistentry>

<term><productname>Irix</productname></term>

<indexterm><primary>Irix</></>

<term><productname>IRIX</productname></term>

<indexterm><primary>IRIX</></>

<listitem>

<para>

<acronym>PIC</acronym> is the default, no special compiler

<!--

$Header: /cvsroot/pgsql/doc/src/sgml/ecpg.sgml,v 1.32 2002/01/06 17:54:14 momjian Exp $

$Header: /cvsroot/pgsql/doc/src/sgml/ecpg.sgml,v 1.33 2002/01/07 02:29:11 petere Exp $

-->

<chapter id="ecpg">

</varlistentry>

<varlistentry>

<term><computeroutput>-206 (ECPG_FLOAT_FORMAT): Not correctly formatted floatingpoint type: %s line %d.</computeroutput></term>

<term><computeroutput>-206 (ECPG_FLOAT_FORMAT): Not correctly formatted floating-point type: %s line %d.</computeroutput></term>

<listitem>

<para>

This means the host variable is of type <type>float</type> and

<!--

$Header: /cvsroot/pgsql/doc/src/sgml/extend.sgml,v 1.14 2001/11/21 05:53:41 thomas Exp $

$Header: /cvsroot/pgsql/doc/src/sgml/extend.sgml,v 1.15 2002/01/07 02:29:11 petere Exp $

-->

<chapter id="extend">

</listitem>

<listitem>

<para>

types

datatypes

</para>

</listitem>

<listitem>

extended by users. By comparison, conventional

database systems can only be extended by changing hardcoded

procedures within the <acronym>DBMS</acronym> or by loading modules

specially-written by the <acronym>DBMS</acronym> vendor.

speciallywritten by the <acronym>DBMS</acronym> vendor.

</para>

<para>

<productname>PostgreSQL</productname> is also unlike most other data managers in

that the server can incorporate user-written code into

itself through dynamic loading. That is, the user can

specify an object code file (e.g., a compiled .o file

or shared library) that implements a new type or function

specify an object code file (e.g., a shared library) that implements a new type or function

and <productname>PostgreSQL</productname> will load it as required. Code written

in <acronym>SQL</acronym>are even more trivial to add to the server.

in <acronym>SQL</acronym>is even more trivial to add to the server.

This ability to modify its operation <quote>on the fly</quote> makes

<productname>PostgreSQL</productname> uniquely suited for rapid prototyping of new

applications and storage structures.

The <productname>PostgreSQL</productname> type system

can be broken down in several ways.

Types are divided into base types and composite types.

Base types are those, like <firstterm>int4</firstterm>, that are implemented

in a language such as<productname>C</productname>. They generally correspond to

Base types are those, like <type>int4</type>, that are implemented

in a language such asC. They generally correspond to

what are often known as <firstterm>abstract data types</firstterm>; <productname>PostgreSQL</productname>

can only operate on such types through methods provided

by the user and only understands the behavior of such

types to the extent that the user describes them.

Composite types are created whenever the user creates a

table. EMP is an example of a composite type.

table.

</para>

<para>

<productname>PostgreSQL</productname> base types are further

divided into built-in

types and user-defined types. Built-in types (like

<firstterm>int4</firstterm>) are those that are compiled

<type>int4</type>) are those that are compiled

into the system.

User-defined types are those created by the user in the

manner to be describedbelow.

manner to be describedlater.

</para>

</sect1>

information given here, so mark this page for later

reference.

All system catalogs have names that begin with

<firstterm>pg_</firstterm>.

<literal>pg_</literal>.

The following tables contain information that may be

useful to the end user. (There are many other system

catalogs, but there should rarely be a reason to query

</row>

<row>

<entry>pg_index</entry>

<entry>secondaryindexes</entry>

<entry> indexes</entry>

</row>

<row>

<entry>pg_proc</entry>

<entry> procedures (both C and SQL)</entry>

<entry> procedures/functions</entry>

</row>

<row>

<entry>pg_type</entry>

<entry> types (both base and complex)</entry>

<entry>datatypes (both base and complex)</entry>

</row>

<row>

<entry>pg_operator</entry>

<entry> operators</entry>

</row>

<row>

<entry>pg_aggregate</entry>

<entry>aggregates andaggregate functions</entry>

<entry> aggregate functions</entry>

</row>

<row>

<entry>pg_am</entry>

</mediaobject>

</figure>

TheReference Manual gives a more detailed explanation

The<citetitle>Developer's Guide</citetitle> gives a more detailed explanation

of these catalogs and their columns. However,

<xref linkend="EXTEND-CATALOGS">

shows the major entities and their relationships

have obvious meanings, but there are many

(particularly those that have to do with access

methods) that do not. The relationships between

pg_am, pg_amop, pg_amproc, pg_operator and

pg_opclass are particularly hard to understand

and will be described in depth (in the section

on interfacing types and operators to indexes)

<classname>pg_am</>, <classname>pg_amop</>, <classname>pg_amproc</>, <classname>pg_operator</>, and

<classname>pg_opclass</> are particularly hard to understand

and will be described in depth (in <xref linkend="xindex">)

after we have discussed basic extensions.

</para>

</listitem>

<!--

$Header: /cvsroot/pgsql/doc/src/sgml/func.sgml,v 1.89 2001/12/27 21:36:57 tgl Exp $

$Header: /cvsroot/pgsql/doc/src/sgml/func.sgml,v 1.90 2002/01/07 02:29:12 petere Exp $

PostgreSQL documentation

-->

<type>bigint</type>, <type>real</type>, <type>double

precision</type>, <type>numeric</type>, <type>interval</type>.

The result is of type <type>numeric</type> for any integer type

input, <type>double precision</type> for floatingpoint input,

input, <type>double precision</type> for floating-point input,

otherwise the same as the input data type.

</entry>

</row>

data types: <type>smallint</type>, <type>integer</type>,

<type>bigint</type>, <type>real</type>, <type>double

precision</type>, <type>numeric</type>. The result is of type

<type>double precision</type> for floatingpoint input,

<type>double precision</type> for floating-point input,

otherwise <type>numeric</type>.

</entry>

</row>

The result is of type <type>bigint</type> for <type>smallint</type>

or <type>integer</type> input, <type>numeric</type> for

<type>bigint</type>

input, <type>double precision</type> for floatingpoint input,

input, <type>double precision</type> for floating-point input,

otherwise the same as the input data type.

</entry>

</row>