Index
- ABORT,
    ABORT
  
- aggregate function,
    Aggregate Functions
  
- built-in,
    Aggregate Functions
  
 
- invocation,
    Aggregate Expressions
  
 
- user-defined,
    User-Defined Aggregates
  
 
 
- alias
  
- for table name in query,
    Joins Between Tables
  
 
- in the FROM clause,
    Table and Column Aliases
  
 
- in the select list,
    Column Labels
  
 
 
- ALL,
    Subquery Expressions,
    Row and Array Comparisons
  
- ALTER AGGREGATE,
    ALTER AGGREGATE
  
- ALTER CONVERSION,
    ALTER CONVERSION
  
- ALTER DATABASE,
    ALTER DATABASE
  
- ALTER DOMAIN,
    ALTER DOMAIN
  
- ALTER FUNCTION,
    ALTER FUNCTION
  
- ALTER GROUP,
    ALTER GROUP
  
- ALTER LANGUAGE,
    ALTER LANGUAGE
  
- ALTER OPERATOR CLASS,
    ALTER OPERATOR CLASS
  
- ALTER SCHEMA,
    ALTER SCHEMA
  
- ALTER SEQUENCE,
    ALTER SEQUENCE
  
- ALTER TABLE,
    ALTER TABLE
  
- ALTER TRIGGER,
    ALTER TRIGGER
  
- ALTER USER,
    User Attributes,
    ALTER USER
  
- ANALYZE,
    Updating planner statistics,
    ANALYZE
  
- AND (operator),
    Logical Operators
  
- any,
    Pseudo-Types,
    Subquery Expressions,
    Row and Array Comparisons
  
- anyarray,
    Pseudo-Types
  
- anyelement,
    Pseudo-Types
  
- array,
    Arrays
  
- constant,
    Array Value Input
  
 
- constructor,
    Array Constructors
  
 
- determination of result type,
    UNION, CASE, and ARRAY Constructs
  
 
- of user-defined   type,
    User-Defined Types
  
 
 
- auto-increment
  
- see serial
 
- autocommit,
    Disable Autocommit
  
- average,
    Aggregate Functions,
    Aggregate Functions
  
- B-tree
  
- see index
 
- backslash_quote configuration parameter,
    Previous PostgreSQL Versions
  
- backup,
    Backup and Restore
  
- base type,
    The PostgreSQL Type System
  
- BEGIN,
    BEGIN
  
- between,
    Comparison Operators
  
- bigint,
    Numeric Constants,
    Integer Types
  
- bigserial,
    Serial Types
  
- binary data,
    Binary Data Types
  
- functions,
    Binary String Functions and Operators
  
 
 
- binary string
  
- concatenation,
    Binary String Functions and Operators
  
 
- length,
    Binary String Functions and Operators
  
 
 
- bison,
    Requirements
  
- bit string
  
- constant,
    Bit-String Constants
  
 
- data type,
    Bit String Types
  
 
 
- BLOB
  
- see large object
 
- Boolean
  
- data type,
    Boolean Type
  
 
- operators
  
- see operators, logical
 
 
- booting
  
- starting    the server during,
    Starting the Database Server
  
 
 
- box (data type),
    Boxes
  
- BSD/OS
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
 
- bytea,
    Binary Data Types
  
- in JDBC,
    Storing Binary Data
  
 
- in libpq,
    Escaping Binary Strings for Inclusion in SQL Commands
  
 
 
- C,
    libpq - C Library,
    ECPG - Embedded SQL in C
  
- canceling
  
- SQL command,
    Asynchronous Command Processing
  
 
 
- CASCADE
  
- with DROP,
    Dependency Tracking
  
 
- foreign key action,
    Foreign Keys
  
 
 
- CASE,
    Conditional Expressions
  
- determination of result type,
    UNION, CASE, and ARRAY Constructs
  
 
 
- case sensitivity
  
- of SQL commands,
    Identifiers and Key Words
  
 
 
- char,
    Character Types
  
- character,
    Character Types
  
- character set,
    Locale and Formatting,
    Character Set Support
  
- character string
  
- concatenation,
    String Functions and Operators
  
 
- constant,
    String Constants
  
 
- data types,
    Character Types
  
 
- length,
    String Functions and Operators
  
 
 
- character varying,
    Character Types
  
- check constraint,
    Check Constraints
  
- checkpoint,
    WAL Configuration,
    CHECKPOINT
  
- cid,
    Object Identifier Types
  
- cidr,
    cidr
  
- circle,
    Circles
  
- class path,
    Setting up the Class Path
  
- CLASSPATH,
    Setting up the Class Path
  
- client authentication,
    Client Authentication
  
- timeout during,
    Security and Authentication
  
 
 
- CLOSE,
    CLOSE
  
- CLUSTER,
    CLUSTER
  
- of databases
  
- see database cluster
 
 
- clusterdb,
    clusterdb
  
- cmax,
    System Columns
  
- cmin,
    System Columns
  
- COALESCE,
    COALESCE
  
- column,
    Concepts,
    Table Basics
  
- adding,
    Adding a Column
  
 
- removing,
    Removing a Column
  
 
- renaming,
    Renaming a Column
  
 
- system column,
    System Columns
  
 
 
- column reference,
    Column References
  
- col_description,
    Miscellaneous Functions
  
- COMMENT,
    COMMENT
  
- about database objects,
    Miscellaneous Functions
  
 
- in SQL,
    Comments
  
 
 
- COMMIT,
    COMMIT
  
- comparison
  
- of rows,
    Row-wise Comparison
  
 
- operators,
    Comparison Operators
  
 
 
- compiling
  
- libpq applications,
    Building libpq Programs
  
 
 
- composite type,
    The PostgreSQL Type System
  
- concurrency,
    Concurrency Control
  
- conditional expression,
    Conditional Expressions
  
- configuration
  
- of the server,
    Run-time Configuration
  
 
- of the server
  
- functions,
    Miscellaneous Functions
  
 
 
- configure,
    Installation Procedure
  
- conjunction,
    Logical Operators
  
- connection pool
  
- in JDBC,
    Connection Pools and Data Sources
  
 
 
- constant,
    Constants
  
- constraint,
    Constraints
  
- adding,
    Adding a Constraint
  
 
- check,
    Check Constraints
  
 
- foreign key,
    Foreign Keys
  
 
- name,
    Check Constraints
  
 
- NOT NULL,
    Not-Null Constraints
  
 
- primary key,
    Primary Keys
  
 
- removing,
    Removing a Constraint
  
 
- unique,
    Unique Constraints
  
 
 
- COPY,
    Populating a Table With Rows,
    COPY
  
- with libpq,
    Functions Associated with the COPY Command
  
 
 
- count,
    Aggregate Functions
  
- CREATE AGGREGATE,
    CREATE AGGREGATE
  
- CREATE CAST,
    CREATE CAST
  
- CREATE CONSTRAINT,
    CREATE CONSTRAINT TRIGGER
  
- CREATE CONVERSION,
    CREATE CONVERSION
  
- CREATE DATABASE,
    Creating a Database,
    CREATE DATABASE
  
- CREATE DOMAIN,
    CREATE DOMAIN
  
- CREATE FUNCTION,
    CREATE FUNCTION
  
- CREATE GROUP,
    CREATE GROUP
  
- CREATE INDEX,
    CREATE INDEX
  
- CREATE LANGUAGE,
    CREATE LANGUAGE
  
- CREATE OPERATOR,
    CREATE OPERATOR
  
- CREATE OPERATOR CLASS,
    CREATE OPERATOR CLASS
  
- CREATE RULE,
    CREATE RULE
  
- CREATE SCHEMA,
    CREATE SCHEMA
  
- CREATE SEQUENCE,
    CREATE SEQUENCE
  
- CREATE TABLE,
    Creating a New Table,
    CREATE TABLE
  
- CREATE TABLE AS,
    CREATE TABLE AS
  
- CREATE TRIGGER,
    CREATE TRIGGER
  
- CREATE TYPE,
    CREATE TYPE
  
- CREATE USER,
    Database Users,
    CREATE USER
  
- CREATE VIEW,
    CREATE VIEW
  
- createdb,
    Creating a Database,
    Creating a Database,
    createdb
  
- createlang,
    createlang
  
- createuser,
    Database Users,
    createuser
  
- cross join,
    Joined Tables
  
- crypt,
    Password authentication
  
- thread safety,
    Behavior in Threaded Programs
  
 
 
- cstring,
    Pseudo-Types
  
- ctid,
    System Columns,
    View Rules in Non-SELECT Statements
  
- currval,
    Sequence-Manipulation Functions
  
- cursor
  
- in PL/pgSQL,
    Cursors
  
 
 
- data area
  
- see database cluster
 
- data type,
    Data Types
  
- base,
    The PostgreSQL Type System
  
 
- category,
    Overview
  
 
- composite,
    The PostgreSQL Type System
  
 
- constant,
    Constants of Other Types
  
 
- conversion,
    Type Conversion
  
 
- internal organisation,
    Base Types in C-Language Functions
  
 
- numeric,
    Numeric Types
  
 
- type cast,
    Type Casts
  
 
- user-defined,
    User-Defined Types
  
 
 
- database,
    Managing Databases
  
- creating,
    Creating a Database
  
 
- privilege to create,
    User Attributes
  
 
 
- database activity
  
- monitoring,
    Monitoring Database Activity
  
 
 
- database cluster,
    Concepts,
    Creating a Database Cluster
  
- DataSource,
    Connection Pools and Data Sources
  
- date,
    Date/Time Types,
    Dates
  
- constants,
    Special Values
  
 
- current,
    Current Date/Time
  
 
- output format,
    Date/Time Output
  
- see also formatting
 
 
- date style,
    Locale and Formatting
  
- DBI,
    Database Access from PL/Perl
  
- deadlock,
    Deadlocks
  
- timeout during,
    Lock Management
  
 
 
- DEALLOCATE,
    DEALLOCATE
  
- decimal
  
- see numeric
 
- DECLARE,
    DECLARE
  
- default value,
    Default Values
  
- changing,
    Changing the Default
  
 
 
- DELETE,
    Deletions,
    Deleting Data,
    DELETE
  
- deleting,
    Deleting Data
  
- Digital UNIX
  
- see Tru64 UNIX
 
- dirty read,
    Transaction Isolation
  
- disjunction,
    Logical Operators
  
- disk drive,
    Internals
  
- disk space,
    Recovering disk space
  
- disk usage,
    Determining Disk Usage
  
- DISTINCT,
    Querying a Table,
    DISTINCT
  
- double precision,
    Floating-Point Types
  
- DROP AGGREGATE,
    DROP AGGREGATE
  
- DROP CAST,
    DROP CAST
  
- DROP CONVERSION,
    DROP CONVERSION
  
- DROP DATABASE,
    Destroying a Database,
    DROP DATABASE
  
- DROP DOMAIN,
    DROP DOMAIN
  
- DROP FUNCTION,
    DROP FUNCTION
  
- DROP GROUP,
    DROP GROUP
  
- DROP INDEX,
    DROP INDEX
  
- DROP LANGUAGE,
    DROP LANGUAGE
  
- DROP OPERATOR,
    DROP OPERATOR
  
- DROP OPERATOR CLASS,
    DROP OPERATOR CLASS
  
- DROP RULE,
    DROP RULE
  
- DROP SCHEMA,
    DROP SCHEMA
  
- DROP SEQUENCE,
    DROP SEQUENCE
  
- DROP TABLE,
    Creating a New Table,
    DROP TABLE
  
- DROP TRIGGER,
    DROP TRIGGER
  
- DROP TYPE,
    DROP TYPE
  
- DROP USER,
    Database Users,
    DROP USER
  
- DROP VIEW,
    DROP VIEW
  
- dropdb,
    Destroying a Database,
    dropdb
  
- droplang,
    droplang
  
- dropuser,
    Database Users,
    dropuser
  
- duplicate,
    Querying a Table
  
- duplicates,
    DISTINCT
  
- dynamic loading,
    Other Defaults,
    Dynamic Loading
  
- dynamic_library_path,
    Other Defaults,
    Dynamic Loading
  
- ECPG,
    ECPG - Embedded SQL in C,
    ecpg
  
- elog,
    Reporting Errors Within the Server
  
- in    PL/Python,
    Database Access
  
 
- in PL/Perl,
    Database Access from PL/Perl
  
 
- in PL/Tcl,
    Database Access from PL/Tcl
  
 
 
- embedded SQL
  
- in C,
    ECPG - Embedded SQL in C
  
 
 
- END,
    END
  
- environment variable,
    Environment Variables
  
- ereport,
    Reporting Errors Within the Server
  
- error codes
  
- list of,
    PostgreSQL Error Codes
  
 
 
- error message,
    Connection Status Functions
  
- escaping strings,
    Escaping Strings for Inclusion in SQL Commands
  
- EXCEPT,
    Combining Queries
  
- EXECUTE,
    EXECUTE
  
- EXISTS,
    Subquery Expressions
  
- EXPLAIN,
    Using EXPLAIN,
    EXPLAIN
  
- expression
  
- order of evaluation,
    Expression Evaluation Rules
  
 
- syntax,
    Value Expressions
  
 
 
- extending SQL,
    Extending SQL
  
- false,
    Boolean Type
  
- FAQ,
    Further Information
  
- fast path,
    The Fast-Path Interface
  
- FETCH,
    FETCH
  
- field selection,
    Field Selection
  
- flex,
    Requirements
  
- float4
  
- see real
 
- float8
  
- see double precision
 
- floating point,
    Floating-Point Types
  
- floating-point
  
- display,
    Locale and Formatting
  
 
 
- foreign key,
    Foreign Keys,
    Foreign Keys
  
- formatting,
    Data Type Formatting Functions
  
- FreeBSD
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
- start script,
    Starting the Database Server
  
 
 
- FROM
  
- missing,
    Previous PostgreSQL Versions
  
 
 
- fsync,
    Settings,
    Benefits of WAL
  
- function,
    Functions and Operators
  
- in the FROM clause,
    Table Functions
  
 
- internal,
    Internal Functions
  
 
- invocation,
    Function Calls
  
 
- polymorphic,
    Polymorphic Types
  
 
- type resolution in an invocation,
    Functions
  
 
- user-defined,
    User-Defined Functions
  
- in C,
    Query Language (SQL) Functions
  
- in SQL,
    Query Language (SQL) Functions
  
 
 
- genetic query optimization,
    Genetic Query Optimizer
  
- GEQO
  
- see genetic query optimization
 
- get_bit,
    Binary String Functions and Operators
  
- get_byte,
    Binary String Functions and Operators
  
- global data
  
- in    PL/Python,
    PL/Python Functions
  
 
- in PL/Tcl,
    Global Data in PL/Tcl
  
 
 
- GRANT,
    Privileges,
    GRANT
  
- group,
    Groups
  
- GROUP BY,
    Aggregate Functions,
    The GROUP BY and HAVING Clauses
  
- grouping,
    The GROUP BY and HAVING Clauses
  
- hash
  
- see index
 
- has_database_privilege,
    Miscellaneous Functions
  
- has_function_privilege,
    Miscellaneous Functions
  
- has_language_privilege,
    Miscellaneous Functions
  
- has_schema_privilege,
    Miscellaneous Functions
  
- has_table_privilege,
    Miscellaneous Functions
  
- HAVING,
    Aggregate Functions,
    The GROUP BY and HAVING Clauses
  
- hierarchical database,
    Concepts
  
- history
  
- of PostgreSQL,
    A Brief History of PostgreSQL
  
 
 
- host name,
    Database Connection Control Functions
  
- HP-UX
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
 
- ident,
    Ident-based authentication
  
- identifier
  
- length,
    Identifiers and Key Words
  
 
- syntax of,
    Identifiers and Key Words
  
 
 
- IN,
    Subquery Expressions,
    Row and Array Comparisons
  
- index,
    Indexes
  
- B-tree,
    Index Types
  
 
- examining usage,
    Examining Index Usage
  
 
- on expressions,
    Indexes on Expressions
  
 
- for user-defined data type,
    Interfacing Extensions To Indexes
  
 
- hash,
    Index Types
  
 
- locks,
    Locking and Indexes
  
 
- multicolumn,
    Multicolumn Indexes
  
 
- partial,
    Partial Indexes
  
 
- R-tree,
    Index Types
  
 
- unique,
    Unique Indexes
  
 
 
- index scan,
    Planner Method Configuration
  
- inet (data type),
    inet
  
- information schema,
    The Information Schema
  
- inheritance,
    Inheritance,
    Previous PostgreSQL Versions
  
- initdb,
    Creating a Database Cluster,
    initdb
  
- initlocation,
    Alternative Locations,
    initlocation
  
- input function,
    User-Defined Types
  
- of   a data type,
    User-Defined Types
  
 
 
- INSERT,
    Populating a Table With Rows,
    Inserting Data,
    INSERT
  
- inserting,
    Inserting Data
  
- installation,
      Installation Instructions
  
- on Windows,
    Requirements,
    Installation on Windows
  
 
 
- instr,
    Porting Examples
  
- int2
  
- see smallint
 
- int4
  
- see integer
 
- int8
  
- see bigint
 
- integer,
    Numeric Constants,
    Integer Types
  
- internal,
    Pseudo-Types
  
- INTERSECT,
    Combining Queries
  
- interval,
    Date/Time Types,
    Intervals
  
- ipcclean,
    ipcclean
  
- IRIX
  
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
 
- IS NULL,
    Platform and Client Compatibility
  
- Java,
    JDBC Interface
  
- JDBC,
    JDBC Interface
  
- JNDI,
    Data Sources and JNDI
  
- join,
    Joins Between Tables,
    Joined Tables
  
- controlling the order,
    Controlling the Planner with Explicit JOIN Clauses
  
 
- cross,
    Joined Tables
  
 
- left,
    Joined Tables
  
 
- natural,
    Joined Tables
  
 
- outer,
    Joins Between Tables,
    Joined Tables
  
 
- right,
    Joined Tables
  
 
- self,
    Joins Between Tables
  
 
 
- label
  
- see alias
 
- language_handler,
    Pseudo-Types
  
- large     object
  
- backup,
    Caveats
  
 
 
- large    object
  
- in pgctl,
    Overview
  
 
 
- large object,
    Large Objects
  
- in JDBC,
    Storing Binary Data
  
 
 
- ldconfig,
    Shared Libraries
  
- left join,
    Joined Tables
  
- length
  
- of a binary string
  
- see binary strings, length
 
- of a character string
  
- see character strings, length
 
 
- libperl,
    Requirements
  
- libpgtcl,
    pgtcl - Tcl Binding Library
  
- libpq,
    libpq - C Library
  
- libpq-fe.h,
    libpq - C Library,
    Connection Status Functions
  
- libpq-int.h,
    Connection Status Functions,
    Building libpq Programs
  
- libpython,
    Requirements
  
- LIKE,
    LIKE
  
- LIMIT,
    LIMIT and OFFSET
  
- line segment,
    Line Segments
  
- Linux
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
- start script,
    Starting the Database Server
  
 
 
- LISTEN,
    LISTEN
  
- LOAD,
    LOAD
  
- locale,
    Creating a Database Cluster,
    Locale Support
  
- lock,
    Explicit Locking,
    Table-Level Locks,
    LOCK
  
- monitoring,
    Viewing Locks
  
 
 
- loop
  
- in PL/pgSQL,
    Simple Loops
  
 
 
- lo_close,
    Closing a Large Object Descriptor
  
- lo_creat,
    Creating a Large Object
  
- lo_export,
    Exporting a Large Object,
    Server-Side Functions
  
- lo_import,
    Importing a Large Object,
    Server-Side Functions
  
- lo_lseek,
    Seeking on a Large Object
  
- lo_open,
    Opening an Existing Large Object
  
- lo_read,
    Reading Data from a Large Object
  
- lo_tell,
    Obtaining the Seek Position of a Large Object
  
- lo_unlink,
    Removing a Large Object
  
- lo_write,
    Writing Data to a Large Object
  
- lseg,
    Line Segments
  
- MAC address
  
- see macaddr
 
- macaddr (data type),
    macaddr
  
- MacOS X
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
 
- maintenance,
    Routine Database Maintenance Tasks
  
- make,
    Requirements
  
- MANPATH,
    Environment Variables
  
- max,
    Aggregate Functions
  
- MD5,
    Password authentication
  
- memory    context
  
- in SPI,
    Memory Management
  
 
 
- min,
    Aggregate Functions
  
- monitoring
  
- database activity,
    Monitoring Database Activity
  
 
 
- MOVE,
    MOVE
  
- MVCC,
    Introduction
  
- name
  
- qualified,
    Creating a Schema
  
 
- syntax of,
    Identifiers and Key Words
  
 
- unqualified,
    The Schema Search Path
  
 
 
- natural join,
    Joined Tables
  
- negation,
    Logical Operators
  
- NetBSD
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
- start script,
    Starting the Database Server
  
 
 
- network
  
- data types,
    Network Address Types
  
 
 
- nextval,
    Sequence-Manipulation Functions
  
- nonblocking connection,
    Database Connection Control Functions,
    Asynchronous Command Processing
  
- nonrepeatable read,
    Transaction Isolation
  
- NOT (operator),
    Logical Operators
  
- NOT IN,
    Subquery Expressions,
    Row and Array Comparisons
  
- not-null constraint,
    Not-Null Constraints
  
- notice processing
  
- in libpq,
    Notice Processing
  
 
 
- notice processor,
    Notice Processing
  
- notice receiver,
    Notice Processing
  
- NOTIFY,
    NOTIFY
  
- in libpq,
    Asynchronous Notification
  
 
- in pgtcl,
    Description
  
 
 
- null value
  
- with check constraints,
    Check Constraints
  
 
- comparing,
    Comparison Operators
  
 
- default value,
    Default Values
  
 
- in     DISTINCT,
    DISTINCT
  
 
- in libpq,
    Retrieving Query Result Information
  
 
- in PL/Perl,
    PL/Perl Functions and Arguments
  
 
- in PL/Python,
    PL/Python Functions
  
 
- with unique constraints,
    Unique Constraints
  
 
 
- nullif,
    NULLIF
  
- number
  
- constant,
    Numeric Constants
  
 
 
- numeric,
    Numeric Constants
  
- numeric (data type),
    Arbitrary Precision Numbers
  
- object identifier
  
- data type,
    Object Identifier Types
  
 
 
- object-oriented database,
    Concepts
  
- obj_description,
    Miscellaneous Functions
  
- OFFSET,
    LIMIT and OFFSET
  
- oid,
    Object Identifier Types
  
- column,
    System Columns
  
 
- in           libpq,
    Retrieving Result Information for Other Commands
  
 
 
- ONLY,
    The FROM Clause
  
- opaque,
    Pseudo-Types
  
- OpenBSD
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
- start script,
    Starting the Database Server
  
 
 
- OpenSSL,
    Installation Procedure
  
- see also SSL
 
- operator,
    Functions and Operators
  
- invocation,
    Operator Invocations
  
 
- logical,
    Logical Operators
  
 
- precedence,
    Lexical Precedence
  
 
- syntax,
    Operators
  
 
- type resolution in an invocation,
    Operators
  
 
- user-defined,
    User-Defined Operators
  
 
 
- operator class,
    Operator Classes,
    Index Methods and Operator Classes
  
- OR (operator),
    Logical Operators
  
- Oracle
  
- porting from PL/SQL to PL/pgSQL,
    Porting from Oracle PL/SQL
  
 
 
- ORDER BY,
    Querying a Table,
    Sorting Rows
  
- and locales,
    Benefits
  
 
 
- ordering operator,
    System Dependencies on Operator Classes
  
- outer join,
    Joined Tables
  
- output   function
  
- of a data type,
    User-Defined Types
  
 
 
- output function,
    User-Defined Types
  
- overlay,
    String Functions and Operators
  
- overloading
  
- functions,
    Function Overloading
  
 
- operators,
    User-Defined Operators
  
 
 
- owner,
    Privileges
  
- palloc,
    Writing Code
  
- PAM,
    Installation Procedure,
    PAM Authentication
  
- parameter
  
- syntax,
    Positional Parameters
  
 
 
- parenthesis,
    Value Expressions
  
- password,
    User Attributes
  
- authentication,
    Password authentication
  
 
- of the    superuser,
    Creating a Database Cluster
  
 
 
- password file,
    The Password File
  
- PATH,
    Environment Variables
  
- for schemas,
    Statement Behavior
  
 
 
- path (data type),
    Paths
  
- pattern matching,
    Pattern Matching
  
- Perl,
    PL/Perl - Perl Procedural Language
  
- permission
  
- see privilege
 
- pfree,
    Writing Code
  
- PGCLIENTENCODING,
    Environment Variables
  
- PGconn,
    Database Connection Control Functions
  
- PGCONNECT_TIMEOUT,
    Environment Variables
  
- PGDATA,
    Creating a Database Cluster
  
- PGDATABASE,
    Environment Variables
  
- PGDATESTYLE,
    Environment Variables
  
- PGGEQO,
    Environment Variables
  
- PGHOST,
    Environment Variables
  
- PGHOSTADDR,
    Environment Variables
  
- PGOPTIONS,
    Environment Variables
  
- PGPASSWORD,
    Environment Variables
  
- PGPORT,
    Environment Variables
  
- PGREALM,
    Environment Variables
  
- PGREQUIRESSL,
    Environment Variables
  
- PGresult,
    Main Functions
  
- PGSERVICE,
    Environment Variables
  
- PGSSLMODE,
    Environment Variables
  
- pgtcl,
    pgtcl - Tcl Binding Library
  
- pgtclsh,
    pgtclsh
  
- pgtksh,
    pgtksh
  
- PGTZ,
    Environment Variables
  
- PGUSER,
    Environment Variables
  
- pg_aggregate,
    pg_aggregate
  
- pg_am,
    pg_am
  
- pg_amop,
    pg_amop
  
- pg_amproc,
    pg_amproc
  
- pg_attrdef,
    pg_attrdef
  
- pg_attribute,
    pg_attribute
  
- pg_cast,
    pg_cast
  
- pg_class,
    pg_class
  
- pg_config,
    pg_config
  
- with libpq,
    Building libpq Programs
  
 
- with user-defined C functions,
    Writing Code
  
 
 
- pg_conndefaults,
    pg_conndefaults
  
- pg_connect,
    pg_connect
  
- pg_constraint,
    pg_constraint
  
- pg_controldata,
    pg_controldata
  
- pg_conversion,
    pg_conversion
  
- pg_conversion_is_visible,
    Miscellaneous Functions
  
- pg_ctl,
    Starting the Database Server,
    pg_ctl
  
- pg_database,
    Template Databases,
    pg_database
  
- pg_depend,
    pg_depend
  
- pg_description,
    pg_description
  
- pg_disconnect,
    pg_disconnect
  
- pg_dump,
    pg_dump
  
- pg_dumpall,
    pg_dumpall
  
- use during upgrade,
    If You Are Upgrading
  
 
 
- pg_exec,
    pg_exec
  
- pg_execute,
    pg_execute
  
- pg_function_is_visible,
    Miscellaneous Functions
  
- pg_get_constraintdef,
    Miscellaneous Functions
  
- pg_get_expr,
    Miscellaneous Functions
  
- pg_get_indexdef,
    Miscellaneous Functions
  
- pg_get_ruledef,
    Miscellaneous Functions
  
- pg_get_triggerdef,
    Miscellaneous Functions
  
- pg_get_userbyid,
    Miscellaneous Functions
  
- pg_get_viewdef,
    Miscellaneous Functions
  
- pg_group,
    pg_group
  
- pg_hba.conf,
    The pg_hba.conf file
  
- pg_ident.conf,
    Ident Maps
  
- pg_index,
    pg_index
  
- pg_indexes,
    pg_indexes
  
- pg_inherits,
    pg_inherits
  
- pg_language,
    pg_language
  
- pg_largeobject,
    pg_largeobject
  
- pg_listen,
    pg_listen
  
- pg_listener,
    pg_listener
  
- pg_locks,
    pg_locks
  
- pg_lo_close,
    pg_lo_close
  
- pg_lo_creat,
    pg_lo_creat
  
- pg_lo_export,
    pg_lo_export
  
- pg_lo_import,
    pg_lo_import
  
- pg_lo_lseek,
    pg_lo_lseek
  
- pg_lo_open,
    pg_lo_open
  
- pg_lo_read,
    pg_lo_read
  
- pg_lo_tell,
    pg_lo_tell
  
- pg_lo_unlink,
    pg_lo_unlink
  
- pg_lo_write,
    pg_lo_write
  
- pg_namespace,
    pg_namespace
  
- pg_on_connection_loss,
    pg_on_connection_loss
  
- pg_opclass,
    pg_opclass
  
- pg_opclass_is_visible,
    Miscellaneous Functions
  
- pg_operator,
    pg_operator
  
- pg_operator_is_visible,
    Miscellaneous Functions
  
- pg_proc,
    pg_proc
  
- pg_restore,
    pg_restore
  
- pg_result,
    pg_result
  
- pg_rewrite,
    pg_rewrite
  
- pg_rules,
    pg_rules
  
- pg_select,
    pg_select
  
- pg_settings,
    pg_settings
  
- pg_shadow,
    pg_shadow
  
- pg_statistic,
    Statistics Used by the Planner,
    pg_statistic
  
- pg_stats,
    Statistics Used by the Planner,
    pg_stats
  
- pg_tables,
    pg_tables
  
- pg_table_is_visible,
    Miscellaneous Functions
  
- pg_trigger,
    pg_trigger
  
- pg_type,
    pg_type
  
- pg_type_is_visible,
    Miscellaneous Functions
  
- pg_user,
    pg_user
  
- pg_views,
    pg_views
  
- phantom read,
    Transaction Isolation
  
- PIC,
    Compiling and Linking Dynamically-Loaded Functions
  
- PID
  
- determining PID of        server process
  
- in libpq,
    Connection Status Functions
  
 
 
- PL/Perl,
    PL/Perl - Perl Procedural Language
  
- PL/PerlU,
    Trusted and Untrusted PL/Perl
  
- PL/pgSQL,
    PL/pgSQL - SQL Procedural Language
  
- PL/Python,
    PL/Python - Python Procedural Language
  
- PL/SQL (Oracle)
  
- porting to PL/pgSQL,
    Porting from Oracle PL/SQL
  
 
 
- PL/Tcl,
    PL/Tcl - Tcl Procedural Language
  
- point,
    Points
  
- polygon,
    Polygons
  
- polymorphic function,
    Polymorphic Types
  
- polymorphic type,
    Polymorphic Types
  
- port,
    Connection Settings,
    Database Connection Control Functions
  
- POSTGRES,
    The Berkeley POSTGRES Project
  
- postgres (the program),
    postgres
  
- postgres user,
    The PostgreSQL User Account
  
- Postgres95,
    Postgres95
  
- postgresql.conf,
    Run-time Configuration
  
- postmaster,
    Architectural Fundamentals,
    Starting the Database Server,
    postmaster
  
- PQbackendPID,
    Connection Status Functions
  
- PQbinaryTuples,
    Retrieving Query Result Information
  
- with COPY,
    Functions Associated with the COPY Command
  
 
 
- PQclear,
    Main Functions
  
- PQcmdStatus,
    Retrieving Result Information for Other Commands
  
- PQcmdTuples,
    Retrieving Result Information for Other Commands
  
- PQconndefaults,
    Database Connection Control Functions
  
- PQconnectdb,
    Database Connection Control Functions
  
- PQconnectPoll,
    Database Connection Control Functions
  
- PQconnectStart,
    Database Connection Control Functions
  
- PQconsumeInput,
    Asynchronous Command Processing
  
- PQdb,
    Connection Status Functions
  
- PQendcopy,
    Obsolete Functions for COPY
  
- PQerrorMessage,
    Connection Status Functions
  
- PQescapeBytea,
    Escaping Binary Strings for Inclusion in SQL Commands
  
- PQescapeByteaConn,
    Escaping Binary Strings for Inclusion in SQL Commands
  
- PQescapeString,
    Escaping Strings for Inclusion in SQL Commands
  
- PQescapeStringConn,
    Escaping Strings for Inclusion in SQL Commands
  
- PQexec,
    Main Functions
  
- PQexecParams,
    Main Functions
  
- PQexecPrepared,
    Main Functions
  
- PQfformat,
    Retrieving Query Result Information
  
- with COPY,
    Functions Associated with the COPY Command
  
 
 
- PQfinish,
    Database Connection Control Functions
  
- PQflush,
    Asynchronous Command Processing
  
- PQfmod,
    Retrieving Query Result Information
  
- PQfn,
    The Fast-Path Interface
  
- PQfname,
    Retrieving Query Result Information
  
- PQfnumber,
    Retrieving Query Result Information
  
- PQfreemem,
    Escaping Binary Strings for Inclusion in SQL Commands
  
- PQfsize,
    Retrieving Query Result Information
  
- PQftable,
    Retrieving Query Result Information
  
- PQftablecol,
    Retrieving Query Result Information
  
- PQftype,
    Retrieving Query Result Information
  
- PQgetCopyData,
    Functions for Receiving COPY Data
  
- PQgetisnull,
    Retrieving Query Result Information
  
- PQgetlength,
    Retrieving Query Result Information
  
- PQgetline,
    Obsolete Functions for COPY
  
- PQgetlineAsync,
    Obsolete Functions for COPY
  
- PQgetResult,
    Asynchronous Command Processing
  
- PQgetssl,
    Connection Status Functions
  
- PQgetvalue,
    Retrieving Query Result Information
  
- PQhost,
    Connection Status Functions
  
- PQisBusy,
    Asynchronous Command Processing
  
- PQisnonblocking,
    Asynchronous Command Processing
  
- PQmakeEmptyPGresult,
    Main Functions
  
- PQnfields,
    Retrieving Query Result Information
  
- with COPY,
    Functions Associated with the COPY Command
  
 
 
- PQnotifies,
    Asynchronous Notification
  
- PQntuples,
    Retrieving Query Result Information
  
- PQoidStatus,
    Retrieving Result Information for Other Commands
  
- PQoidValue,
    Retrieving Result Information for Other Commands
  
- PQoptions,
    Connection Status Functions
  
- PQparameterStatus,
    Connection Status Functions
  
- PQpass,
    Connection Status Functions
  
- PQport,
    Connection Status Functions
  
- PQprint,
    Retrieving Query Result Information
  
- PQprotocolVersion,
    Connection Status Functions
  
- PQputCopyData,
    Functions for Sending COPY Data
  
- PQputCopyEnd,
    Functions for Sending COPY Data
  
- PQputline,
    Obsolete Functions for COPY
  
- PQputnbytes,
    Obsolete Functions for COPY
  
- PQrequestCancel,
    Asynchronous Command Processing
  
- PQreset,
    Database Connection Control Functions
  
- PQresetPoll,
    Database Connection Control Functions
  
- PQresetStart,
    Database Connection Control Functions
  
- PQresStatus,
    Main Functions
  
- PQresultErrorField,
    Main Functions
  
- PQresultErrorMessage,
    Main Functions
  
- PQresultStatus,
    Main Functions
  
- PQsendQuery,
    Asynchronous Command Processing
  
- PQsendQueryParams,
    Asynchronous Command Processing
  
- PQsendQueryPrepared,
    Asynchronous Command Processing
  
- PQsetdb,
    Database Connection Control Functions
  
- PQsetdbLogin,
    Database Connection Control Functions
  
- PQsetErrorVerbosity,
    Control Functions
  
- PQsetnonblocking,
    Asynchronous Command Processing
  
- PQsetNoticeProcessor,
    Notice Processing
  
- PQsetNoticeReceiver,
    Notice Processing
  
- PQsocket,
    Connection Status Functions
  
- PQstatus,
    Connection Status Functions
  
- PQtrace,
    Control Functions
  
- PQtransactionStatus,
    Connection Status Functions
  
- PQtty,
    Connection Status Functions
  
- PQunescapeBytea,
    Escaping Binary Strings for Inclusion in SQL Commands
  
- PQuntrace,
    Control Functions
  
- PQuser,
    Connection Status Functions
  
- preload_libraries,
    Kernel Resource Usage
  
- PREPARE,
    PREPARE
  
- PreparedStatement,
    Issuing a Query and Processing the Result
  
- preparing a query
  
- in 	PL/Tcl,
    Database Access from PL/Tcl
  
 
- in     PL/pgSQL,
    Overview
  
 
- in PL/Python,
    Database Access
  
 
 
- primary key,
    Primary Keys
  
- privilege,
    Privileges,
    Privileges
  
- querying,
    Miscellaneous Functions
  
 
- with rules,
    Rules and Privileges
  
 
- for schemas,
    Schemas and Privileges
  
 
- with views,
    Rules and Privileges
  
 
 
- procedural language,
    Procedural Languages
  
- handler for,
    Writing A Procedural Language Handler
  
 
 
- ps
  
- to monitor activity,
    Standard Unix Tools
  
 
 
- psql,
    Accessing a Database,
    psql
  
- Python,
    PL/Python - Python Procedural Language
  
- qualified name,
    Creating a Schema
  
- query,
    Querying a Table,
    Queries
  
- query plan,
    Using EXPLAIN
  
- query tree,
    The Query Tree
  
- quotation marks
  
- and identifiers,
    Identifiers and Key Words
  
 
- escaping,
    String Constants
  
 
 
- quote_ident,
    String Functions and Operators
  
- use      in      PL/pgSQL,
    Executing Dynamic Commands
  
 
 
- quote_literal,
    String Functions and Operators
  
- use      in PL/pgSQL,
    Executing Dynamic Commands
  
 
 
- R-tree
  
- see index
 
- range table,
    The Query Tree
  
- read-only transaction,
    Statement Behavior
  
- readline,
    Requirements
  
- real,
    Floating-Point Types
  
- record,
    Pseudo-Types
  
- rectangle,
    Boxes
  
- referential integrity,
    Foreign Keys,
    Foreign Keys
  
- regclass,
    Object Identifier Types
  
- regoper,
    Object Identifier Types
  
- regoperator,
    Object Identifier Types
  
- regproc,
    Object Identifier Types
  
- regprocedure,
    Object Identifier Types
  
- regression test,
    Installation Procedure
  
- regression tests,
    Regression Tests
  
- regtype,
    Object Identifier Types
  
- regular expression,
    SIMILAR TO and SQL99      Regular Expressions,
    POSIX Regular Expressions
  
- see also pattern matching
 
- regular expressions,
    Previous PostgreSQL Versions
  
- reindex,
    Routine Reindexing,
    REINDEX
  
- relation,
    Concepts
  
- relational database,
    Concepts
  
- RESET,
    RESET
  
- RESTRICT
  
- with DROP,
    Dependency Tracking
  
 
- foreign key action,
    Foreign Keys
  
 
 
- ResultSet,
    Issuing a Query and Processing the Result
  
- REVOKE,
    Privileges,
    REVOKE
  
- right join,
    Joined Tables
  
- ROLLBACK,
    ROLLBACK
  
- row,
    Concepts,
    Table Basics
  
- rule,
    The Rule System
  
- and views,
    Views and the Rule System
  
 
- for DELETE,
    Rules on INSERT, UPDATE, and DELETE
  
 
- for INSERT,
    Rules on INSERT, UPDATE, and DELETE
  
 
- for SELECT,
    How SELECT Rules Work
  
 
- compared with triggers,
    Rules versus Triggers
  
 
- for UPDATE,
    Rules on INSERT, UPDATE, and DELETE
  
 
 
- savepoint,
    Future Benefits
  
- scalar
  
- see expression
 
- schema,
    Schemas,
    Overview
  
- creating,
    Creating a Schema
  
 
- current,
    The Schema Search Path,
    Miscellaneous Functions
  
 
- public,
    The Public Schema
  
 
- removing,
    Creating a Schema
  
 
 
- SCO OpenServer
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
 
- search path,
    The Schema Search Path
  
- current,
    Miscellaneous Functions
  
 
 
- search_path,
    The Schema Search Path,
    Statement Behavior
  
- SELECT,
    Querying a Table,
    Queries,
    SELECT
  
- select list,
    Select Lists
  
 
 
- SELECT INTO,
    SELECT INTO
  
- in PL/pgSQL,
    SELECT INTO
  
 
 
- semaphores,
    Shared Memory and Semaphores
  
- sequence,
    Sequence-Manipulation Functions
  
- and serial type,
    Serial Types
  
 
 
- sequential scan,
    Planner Method Configuration
  
- serial,
    Serial Types
  
- serial4,
    Serial Types
  
- serial8,
    Serial Types
  
- server log,
    Error Reporting and Logging
  
- log file maintenance,
    Log File Maintenance
  
 
 
- SET,
    Miscellaneous Functions,
    SET
  
- SET CONSTRAINTS,
    SET CONSTRAINTS
  
- set difference,
    Combining Queries
  
- set intersection,
    Combining Queries
  
- set operation,
    Combining Queries
  
- SET SESSION AUTHORIZATION,
    SET SESSION AUTHORIZATION
  
- SET TRANSACTION,
    SET TRANSACTION
  
- set union,
    Combining Queries
  
- SETOF,
    Query Language (SQL) Functions
  
- setval,
    Sequence-Manipulation Functions
  
- set_bit,
    Binary String Functions and Operators
  
- set_byte,
    Binary String Functions and Operators
  
- shared library,
    Shared Libraries,
    Compiling and Linking Dynamically-Loaded Functions
  
- shared memory,
    Shared Memory and Semaphores
  
- SHMMAX,
    Shared Memory and Semaphores
  
- SHOW,
    Miscellaneous Functions,
    SHOW
  
- shutdown,
    Shutting Down the Server
  
- SIGHUP,
    Run-time Configuration,
    The pg_hba.conf file,
    Ident Maps
  
- SIGINT,
    Shutting Down the Server
  
- significant digits,
    Locale and Formatting
  
- SIGQUIT,
    Shutting Down the Server
  
- SIGTERM,
    Shutting Down the Server
  
- SIMILAR TO,
    SIMILAR TO and SQL99      Regular Expressions
  
- sliced bread
  
- see TOAST
 
- smallint,
    Integer Types
  
- Solaris
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
- start script,
    Starting the Database Server
  
 
 
- SOME,
    Subquery Expressions,
    Row and Array Comparisons
  
- sorting,
    Sorting Rows
  
- SPI,
    Server Programming Interface
  
- SPI_connect,
    SPI_connect
  
- SPI_copytuple,
    SPI_copytuple
  
- SPI_copytupledesc,
    SPI_copytupledesc
  
- SPI_copytupleintoslot,
    SPI_copytupleintoslot
  
- SPI_cursor_close,
    SPI_cursor_close
  
- SPI_cursor_fetch,
    SPI_cursor_fetch
  
- SPI_cursor_find,
    SPI_cursor_find
  
- SPI_cursor_move,
    SPI_cursor_move
  
- SPI_cursor_open,
    SPI_cursor_open
  
- SPI_exec,
    SPI_exec
  
- SPI_execp,
    SPI_execp
  
- SPI_finish,
    SPI_finish
  
- SPI_fname,
    SPI_fname
  
- SPI_fnumber,
    SPI_fnumber
  
- SPI_freeplan,
    SPI_freeplan
  
- SPI_freetuple,
    SPI_freetuple
  
- SPI_freetuptable,
    SPI_freetuptable
  
- SPI_getbinval,
    SPI_getbinval
  
- SPI_getrelname,
    SPI_getrelname
  
- SPI_gettype,
    SPI_gettype
  
- SPI_gettypeid,
    SPI_gettypeid
  
- SPI_getvalue,
    SPI_getvalue
  
- spi_lastoid,
    Database Access from PL/Tcl
  
- SPI_modifytuple,
    SPI_modifytuple
  
- SPI_palloc,
    SPI_palloc
  
- SPI_pfree,
    SPI_pfree
  
- SPI_prepare,
    SPI_prepare
  
- SPI_repalloc,
    SPI_repalloc
  
- SPI_saveplan,
    SPI_saveplan
  
- ssh,
    Secure TCP/IP Connections with SSH Tunnels
  
- SSL,
    Security and Authentication,
    Secure TCP/IP Connections with SSL
  
- with libpq,
    Database Connection Control Functions,
    Connection Status Functions
  
 
 
- ssl_renegotiation_limit configuration parameter,
    Security and Authentication
  
- standard deviation,
    Aggregate Functions
  
- START TRANSACTION,
    START TRANSACTION
  
- Statement,
    Issuing a Query and Processing the Result
  
- statistics,
    The Statistics Collector
  
- of the planner,
    Statistics Used by the Planner,
    Updating planner statistics
  
 
 
- string
  
- see character string
 
- strings
  
- backslash quotes,
    Previous PostgreSQL Versions
  
 
 
- subquery,
    Aggregate Functions,
    Scalar Subqueries,
    Subqueries,
    Subquery Expressions
  
- subscript,
    Subscripts
  
- substring,
    String Functions and Operators,
    Binary String Functions and Operators,
    SIMILAR TO and SQL99      Regular Expressions
  
- sum,
    Aggregate Functions
  
- superuser,
    Accessing a Database,
    User Attributes
  
- syntax
  
- SQL,
    SQL Syntax
  
 
 
- syslog,
    Syslog
  
- system catalog
  
- schema,
    The System Catalog Schema
  
 
 
- table,
    Concepts,
    Table Basics
  
- creating,
    Table Basics
  
 
- modifying,
    Modifying Tables
  
 
- removing,
    Table Basics
  
 
- renaming,
    Renaming a Table
  
 
 
- table expression,
    Table Expressions
  
- table function,
    Table Functions
  
- tableoid,
    System Columns
  
- target list,
    The Query Tree
  
- Tcl,
    pgtcl - Tcl Binding Library,
    PL/Tcl - Tcl Procedural Language
  
- TCP/IP,
    Starting the Database Server,
    Connection Settings
  
- template0,
    Template Databases
  
- template1,
    Creating a Database,
    Template Databases
  
- test,
    Regression Tests
  
- text,
    Character Types
  
- threads
  
- with JDBC,
    Using the Driver in a Multithreaded or a Servlet Environment
  
 
- with libpq,
    Behavior in Threaded Programs
  
 
 
- tid,
    Object Identifier Types
  
- time,
    Date/Time Types,
    Times
  
- constants,
    Special Values
  
 
- current,
    Current Date/Time
  
 
- output format,
    Date/Time Output
  
- see also formatting
 
 
- time span,
    Date/Time Types
  
- time with time zone,
    Date/Time Types,
    Times
  
- time without time zone,
    Date/Time Types,
    Times
  
- time zone,
    Time Zones,
    Locale and Formatting
  
- abbreviations,
    Date/Time Key Words
  
 
- Australian,
    Locale and Formatting
  
 
- conversion,
    AT TIME ZONE
  
 
 
- timeout
  
- client authentication,
    Security and Authentication
  
 
- deadlock,
    Lock Management
  
 
 
- timestamp,
    Date/Time Types,
    Time Stamps
  
- timestamp with time zone,
    Date/Time Types,
    Time Stamps
  
- timestamp without time zone,
    Date/Time Types,
    Time Stamps
  
- TOAST,
    History
  
- and   user-defined types,
    User-Defined Types
  
 
 
- token,
    Lexical Structure
  
- to_char,
    Data Type Formatting Functions
  
- transaction,
    Transactions
  
- transaction ID
  
- wraparound,
    Preventing transaction ID wraparound failures
  
 
 
- transaction isolation,
    Transaction Isolation
  
- transaction isolation level,
    Transaction Isolation,
    Statement Behavior
  
- read committed,
    Read Committed Isolation Level
  
 
- serializable,
    Serializable Isolation Level
  
 
 
- transaction log
  
- see WAL
 
- trigger,
    Pseudo-Types,
    Triggers
  
- arguments for trigger     functions,
    Overview of Trigger Behavior
  
 
- in       PL/Perl,
    Missing Features
  
 
- in C,
    Writing Trigger Functions in C
  
 
- in PL/pgSQL,
    Trigger Procedures
  
 
- in PL/Python,
    Trigger Functions
  
 
- in PL/Tcl,
    Trigger Procedures in PL/Tcl
  
 
- compared with rules,
    Rules versus Triggers
  
 
 
- Tru64 UNIX
  
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
 
- true,
    Boolean Type
  
- TRUNCATE,
    TRUNCATE
  
- trusted
  
- PL/Perl,
    Trusted and Untrusted PL/Perl
  
 
 
- type
  
- see data type
- polymorphic,
    Polymorphic Types
  
 
- type cast,
    Numeric Constants,
    Type Casts
  
- UNION,
    Combining Queries
  
- determination of result type,
    UNION, CASE, and ARRAY Constructs
  
 
 
- unique constraint,
    Unique Constraints
  
- Unix domain       socket,
    Database Connection Control Functions
  
- UnixWare
  
- IPC configuration,
    Shared Memory and Semaphores
  
 
- shared library,
    Compiling and Linking Dynamically-Loaded Functions
  
 
 
- UNLISTEN,
    UNLISTEN
  
- unqualified name,
    The Schema Search Path
  
- UPDATE,
    Updates,
    Updating Data,
    UPDATE
  
- updating,
    Updating Data
  
- upgrading,
    If You Are Upgrading,
    Migration Between Releases
  
- user,
    Database Users
  
- current,
    Miscellaneous Functions
  
 
 
- vacuum,
    Routine Vacuuming,
    VACUUM
  
- vacuumdb,
    vacuumdb
  
- value expression,
    Value Expressions
  
- varchar,
    Character Types
  
- variance,
    Aggregate Functions
  
- version,
    Accessing a Database,
    Miscellaneous Functions
  
- compatibility,
    Migration Between Releases
  
 
 
- view,
    Views
  
- implementation through rules,
    Views and the Rule System
  
 
- updating,
    Cooperation with Views
  
 
 
- void,
    Pseudo-Types