
===================================================
       PG_LESSLOG TEST
       VERSION =  1.4
       Date:  2010年 5月 12日 水曜日 13:27:23 JST
===================================================

===== Parameter Check ===================

PG_LESSLOG_VER =  1.4
CLOG_TRUNCATE_OPTION = n
Temporary Dir = /home/common/pg_lesslog/tmp
Archive Log Dir = /var/postgresql/archivedir
Base Backup Dir = /var/postgresql/basebackup
PostgreSQL Log Dir = /var/postgresql/pg_log
PostgreSQL Source Dir = /home/common/PostgreSQL/postgresql-8.4.3
PostgreSQL btree_gist source Dir = /home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist
PostgreSQL btree_gin source Dir = /home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gin
Original Tablespace Dir = /var/postgresql/tablespace.org
pg_compresslog = cp
cp
pg_decompresslog = cp
cp
pg_ctl
psql
initdb
createdb
dropdb

===== Parameter Check Complete ==========


===== Initialize the database from the scartch =============

pg_ctl stop
pg_ctl: PID file "/usr/local/pgsql/data/postmaster.pid" does not exist
Is server running?
pg_ctl stop -- complete
removing $ARCHLOGDIR/*	--- complete
removing $BASEBACKUPDIR/*	--- complete
removing $PGDATA	--- complete
removing $TABLESPACE/*	--- complete
---- Building WAL record list file --- Done.
---- Building Transaction Generator for CLOG_TRUNCATE test --- Done.
initdb
The files belonging to this database system will be owned by user "koichi".
This user must also own the server process.

The database cluster will be initialized with locale ja_JP.UTF-8.
The default database encoding has accordingly been set to UTF8.
initdb: could not find suitable text search configuration for locale ja_JP.UTF-8
The default text search configuration will be set to "simple".

creating directory /usr/local/pgsql/data ... ok
creating subdirectories ... ok
selecting default max_connections ... 100
selecting default shared_buffers ... 32MB
creating configuration files ... ok
creating template1 database in /usr/local/pgsql/data/base/1 ... ok
initializing pg_authid ... ok
initializing dependencies ... ok
creating system views ... ok
loading system objects' descriptions ... ok
creating conversions ... ok
creating dictionaries ... ok
setting privileges on built-in objects ... ok
creating information schema ... ok
vacuuming database template1 ... ok
copying template1 to template0 ... ok
copying template1 to postgres ... ok

WARNING: enabling "trust" authentication for local connections
You can change this by editing pg_hba.conf or using the -A option the
next time you run initdb.

Success. You can now start the database server using:

    postgres -D /usr/local/pgsql/data
or
    pg_ctl -D /usr/local/pgsql/data -l logfile start

	--- complete
Setting server parameters in postgresql.org
	--- complete
pg_ctl start
server starting
	--- complete

===== Database Initialization Complete ===============

SELECT pg_start_backup('test');
 pg_start_backup 
-----------------
 0/1000020
(1 row)

\q
SELECT pg_stop_backup();
 pg_stop_backup 
----------------
 0/1000088
(1 row)

\q
CREATE DATABASE koichi2;
CREATE DATABASE
DROP DATABASE koichi2
DROP DATABASE
DROP TABLE IF EXISTS T1
NOTICE:  table "t1" does not exist, skipping
DROP TABLE
CREATE TABLE T1 
	(A INTEGER PRIMARY KEY, 
         B CHAR(128), 
	 C VARCHAR(256), 
         D INTEGER);
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t1_pkey" for table "t1"
CREATE TABLE
CREATE INDEX T1_D_IDX ON T1 USING BTREE (D);
CREATE INDEX
CHECKPOINT;
CHECKPOINT
INSERT INTO T1(A) 
	SELECT * FROM generate_series(1, 50000);
INSERT 0 50000
CHECKPOINT;
CHECKPOINT
UPDATE T1 
	SET B = 'xxxxxxxxxx', C = 'yyyyyyyyyyyyyyyyyyy', D = A;
UPDATE 50000
DELETE FROM T1 WHERE A%10=0;
DELETE 5000
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
SELECT * FROM T1 WHERE A%1=1 FOR UPDATE;
 a | b | c | d 
---+---+---+---
(0 rows)

UPDATE T1 
	SET B = 'zzzZZZZZZZ', C = 'zzzuyyyyyyyyyyyyyyy' 
	WHERE A%10=1;
UPDATE 5000
COMMIT;
COMMIT
UPDATE T1 
	SET B = 'zzzxxxxxxx', C = 'zzzuyyyyyyyyyyyyyyy' 
	WHERE A%10=1;
UPDATE 5000
FOR SHARE: turn (1)
FOR SHARE: turn (2)
FOR SHARE: turn (3)
FOR SHARE: turn (4)
FOR SHARE: turn (5)
FOR UPDATE: turn (1)
FOR UPDATE: turn (2)
FOR UPDATE: turn (3)
ERROR:  deadlock detected
DETAIL:  Process 2692 waits for ShareLock on transaction 672; blocked by process 2691.
Process 2691 waits for ShareLock on transaction 673; blocked by process 2692.
HINT:  See server log for query details.
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
DELETE FROM T1;
DELETE 45000
ABORT;
ROLLBACK
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
UPDATE T1 
	SET B = 'xxxxxxxxxx', C = 'wwwwwwwwwwwwwwwwwww', D = A;
UPDATE 45000
DELETE FROM T1 WHERE A%10=2;
DELETE 5000
PREPARE TRANSACTION  'foobar';
PREPARE TRANSACTION
ROLLBACK PREPARED 'foobar';
ROLLBACK PREPARED
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
SAVEPOINT foobar2;
SAVEPOINT
UPDATE T1 
	SET B = 'xxxxxxxxxx', C = 'wwwwwwwwwwwwwwwwwww', D = A;
UPDATE 45000
DELETE FROM T1 WHERE A%10=2;
DELETE 5000
ROLLBACK TO SAVEPOINT foobar2;
ROLLBACK
ABORT;
ROLLBACK
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
UPDATE T1 
	SET B = 'xxxxxxxxxx', C = 'wwwwwwwwwwwwwwwwwww', D = A;
UPDATE 45000
DELETE FROM T1 WHERE A%10=2;
DELETE 5000
PREPARE TRANSACTION  'foobar1';
PREPARE TRANSACTION
COMMIT PREPARED 'foobar1';
COMMIT PREPARED
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
SAVEPOINT foobar3;
SAVEPOINT
UPDATE T1 
	SET B = 'xxxxxxxxxx', C = 'wwwwwwwwwwwwwwwwwww', D = A;
UPDATE 40000
DELETE FROM T1 WHERE A%10=3;
DELETE 5000
RELEASE SAVEPOINT foobar3;
RELEASE
COMMIT;
COMMIT
BEGIN;
BEGIN
LOCK TABLE T1;
LOCK TABLE
SELECT COUNT(*) FROM T1;
 count 
-------
 35000
(1 row)

COMMIT;
COMMIT
BEGIN;
BEGIN
DELETE FROM T1;
DELETE 35000
COMMIT;
COMMIT
CHECKPOINT;
CHECKPOINT
VACUUM T1;
VACUUM
VACUUM T1;
VACUUM
DROP TABLE IF EXISTS T2
NOTICE:  table "t2" does not exist, skipping
DROP TABLE
CHECKPOINT;
CHECKPOINT
CREATE TABLE T2
	(A INTEGER PRIMARY KEY, 
	 B CHAR(128),
	 C VARCHAR(256), 
         d INTEGER);
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t2_pkey" for table "t2"
CREATE TABLE
CREATE	INDEX T2_D_IDX ON T2
	USING HASH (D);
CREATE INDEX
INSERT INTO T2(A) 
	SELECT * 
          FROM generate_series(1, 50000);
INSERT 0 50000
CHECKPOINT;
CHECKPOINT
UPDATE T2 
        SET B = 'xxxxxxxxxx', C = 'yyyyyyyyyyyyyyyyyyy', D = A;
UPDATE 50000
DELETE FROM T2 WHERE A%10=0;
DELETE 5000
CHECKPOINT;
CHECKPOINT
UPDATE T2 
        SET B = 'zzzxxxxxxx', C = 'zzzzyyyyyyyyyyyyyyy' 
          WHERE A%10=1;
UPDATE 5000
CHECKPOINT;
CHECKPOINT
/* $PostgreSQL: pgsql/contrib/btree_gist/btree_gist.sql.in,v 1.21 2009/06/11 18:30:03 tgl Exp $ */
-- Adjust this setting to control where the objects get created.
SET search_path = public;
SET
CREATE OR REPLACE FUNCTION gbtreekey4_in(cstring)
RETURNS gbtreekey4
AS '$libdir/btree_gist', 'gbtreekey_in'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:9: NOTICE:  type "gbtreekey4" is not yet defined
DETAIL:  Creating a shell type definition.
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbtreekey4_out(gbtreekey4)
RETURNS cstring
AS '$libdir/btree_gist', 'gbtreekey_out'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:14: NOTICE:  argument type gbtreekey4 is only a shell
CREATE FUNCTION
CREATE TYPE gbtreekey4 (
	INTERNALLENGTH = 4,
	INPUT  = gbtreekey4_in,
	OUTPUT = gbtreekey4_out
);
CREATE TYPE
CREATE OR REPLACE FUNCTION gbtreekey8_in(cstring)
RETURNS gbtreekey8
AS '$libdir/btree_gist', 'gbtreekey_in'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:25: NOTICE:  type "gbtreekey8" is not yet defined
DETAIL:  Creating a shell type definition.
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbtreekey8_out(gbtreekey8)
RETURNS cstring
AS '$libdir/btree_gist', 'gbtreekey_out'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:30: NOTICE:  argument type gbtreekey8 is only a shell
CREATE FUNCTION
CREATE TYPE gbtreekey8 (
	INTERNALLENGTH = 8,
	INPUT  = gbtreekey8_in,
	OUTPUT = gbtreekey8_out
);
CREATE TYPE
CREATE OR REPLACE FUNCTION gbtreekey16_in(cstring)
RETURNS gbtreekey16
AS '$libdir/btree_gist', 'gbtreekey_in'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:41: NOTICE:  type "gbtreekey16" is not yet defined
DETAIL:  Creating a shell type definition.
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbtreekey16_out(gbtreekey16)
RETURNS cstring
AS '$libdir/btree_gist', 'gbtreekey_out'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:46: NOTICE:  argument type gbtreekey16 is only a shell
CREATE FUNCTION
CREATE TYPE gbtreekey16 (
	INTERNALLENGTH = 16,
	INPUT  = gbtreekey16_in,
	OUTPUT = gbtreekey16_out
);
CREATE TYPE
CREATE OR REPLACE FUNCTION gbtreekey32_in(cstring)
RETURNS gbtreekey32
AS '$libdir/btree_gist', 'gbtreekey_in'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:57: NOTICE:  type "gbtreekey32" is not yet defined
DETAIL:  Creating a shell type definition.
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbtreekey32_out(gbtreekey32)
RETURNS cstring
AS '$libdir/btree_gist', 'gbtreekey_out'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:62: NOTICE:  argument type gbtreekey32 is only a shell
CREATE FUNCTION
CREATE TYPE gbtreekey32 (
	INTERNALLENGTH = 32,
	INPUT  = gbtreekey32_in,
	OUTPUT = gbtreekey32_out
);
CREATE TYPE
CREATE OR REPLACE FUNCTION gbtreekey_var_in(cstring)
RETURNS gbtreekey_var
AS '$libdir/btree_gist', 'gbtreekey_in'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:73: NOTICE:  type "gbtreekey_var" is not yet defined
DETAIL:  Creating a shell type definition.
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbtreekey_var_out(gbtreekey_var)
RETURNS cstring
AS '$libdir/btree_gist', 'gbtreekey_out'
LANGUAGE C IMMUTABLE STRICT;
psql:/home/common/PostgreSQL/postgresql-8.4.3/contrib/btree_gist/btree_gist.sql:78: NOTICE:  argument type gbtreekey_var is only a shell
CREATE FUNCTION
CREATE TYPE gbtreekey_var (
	INTERNALLENGTH = VARIABLE,
	INPUT  = gbtreekey_var_in,
	OUTPUT = gbtreekey_var_out,
	STORAGE = EXTENDED
);
CREATE TYPE
--
--
--
-- oid ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_oid_consistent(internal,oid,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_oid_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_decompress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_var_decompress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_oid_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_oid_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_oid_union(bytea, internal)
RETURNS gbtreekey8
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_oid_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_oid_ops
DEFAULT FOR TYPE oid USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_oid_consistent (internal, oid, int2, oid, internal),
	FUNCTION	2	gbt_oid_union (bytea, internal),
	FUNCTION	3	gbt_oid_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_oid_penalty (internal, internal, internal),
	FUNCTION	6	gbt_oid_picksplit (internal, internal),
	FUNCTION	7	gbt_oid_same (internal, internal, internal),
	STORAGE		gbtreekey8;
CREATE OPERATOR CLASS
--
--
--
-- int2 ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_int2_consistent(internal,int2,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int2_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int2_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int2_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int2_union(bytea, internal)
RETURNS gbtreekey4
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int2_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_int2_ops
DEFAULT FOR TYPE int2 USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_int2_consistent (internal, int2, int2, oid, internal),
	FUNCTION	2	gbt_int2_union (bytea, internal),
	FUNCTION	3	gbt_int2_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_int2_penalty (internal, internal, internal),
	FUNCTION	6	gbt_int2_picksplit (internal, internal),
	FUNCTION	7	gbt_int2_same (internal, internal, internal),
	STORAGE		gbtreekey4;
CREATE OPERATOR CLASS
--
--
--
-- int4 ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_int4_consistent(internal,int4,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int4_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int4_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int4_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int4_union(bytea, internal)
RETURNS gbtreekey8
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int4_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_int4_ops
DEFAULT FOR TYPE int4 USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_int4_consistent (internal, int4, int2, oid, internal),
	FUNCTION	2	gbt_int4_union (bytea, internal),
	FUNCTION	3	gbt_int4_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_int4_penalty (internal, internal, internal),
	FUNCTION	6	gbt_int4_picksplit (internal, internal),
	FUNCTION	7	gbt_int4_same (internal, internal, internal),
	STORAGE		gbtreekey8;
CREATE OPERATOR CLASS
--
--
--
-- int8 ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_int8_consistent(internal,int8,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int8_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int8_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int8_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int8_union(bytea, internal)
RETURNS gbtreekey16
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_int8_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_int8_ops
DEFAULT FOR TYPE int8 USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_int8_consistent (internal, int8, int2, oid, internal),
	FUNCTION	2	gbt_int8_union (bytea, internal),
	FUNCTION	3	gbt_int8_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_int8_penalty (internal, internal, internal),
	FUNCTION	6	gbt_int8_picksplit (internal, internal),
	FUNCTION	7	gbt_int8_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
--
--
--
-- float4 ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_float4_consistent(internal,float4,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float4_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float4_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float4_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float4_union(bytea, internal)
RETURNS gbtreekey8
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float4_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_float4_ops
DEFAULT FOR TYPE float4 USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_float4_consistent (internal, float4, int2, oid, internal),
	FUNCTION	2	gbt_float4_union (bytea, internal),
	FUNCTION	3	gbt_float4_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_float4_penalty (internal, internal, internal),
	FUNCTION	6	gbt_float4_picksplit (internal, internal),
	FUNCTION	7	gbt_float4_same (internal, internal, internal),
	STORAGE		gbtreekey8;
CREATE OPERATOR CLASS
--
--
--
-- float8 ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_float8_consistent(internal,float8,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float8_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float8_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float8_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float8_union(bytea, internal)
RETURNS gbtreekey16
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_float8_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_float8_ops
DEFAULT FOR TYPE float8 USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_float8_consistent (internal, float8, int2, oid, internal),
	FUNCTION	2	gbt_float8_union (bytea, internal),
	FUNCTION	3	gbt_float8_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_float8_penalty (internal, internal, internal),
	FUNCTION	6	gbt_float8_picksplit (internal, internal),
	FUNCTION	7	gbt_float8_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
--
--
--
-- timestamp ops
-- 
--
--
CREATE OR REPLACE FUNCTION gbt_ts_consistent(internal,timestamp,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_tstz_consistent(internal,timestamptz,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
      
CREATE OR REPLACE FUNCTION gbt_ts_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_tstz_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_ts_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
   
CREATE OR REPLACE FUNCTION gbt_ts_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
      
CREATE OR REPLACE FUNCTION gbt_ts_union(bytea, internal)
RETURNS gbtreekey16
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_ts_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_timestamp_ops
DEFAULT FOR TYPE timestamp USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_ts_consistent (internal, timestamp, int2, oid, internal),
	FUNCTION	2	gbt_ts_union (bytea, internal),
	FUNCTION	3	gbt_ts_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_ts_penalty (internal, internal, internal),
	FUNCTION	6	gbt_ts_picksplit (internal, internal),
	FUNCTION	7	gbt_ts_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
-- Create the operator class
CREATE OPERATOR CLASS gist_timestamptz_ops
DEFAULT FOR TYPE timestamptz USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_tstz_consistent (internal, timestamptz, int2, oid, internal),
	FUNCTION	2	gbt_ts_union (bytea, internal),
	FUNCTION	3	gbt_tstz_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_ts_penalty (internal, internal, internal),
	FUNCTION	6	gbt_ts_picksplit (internal, internal),
	FUNCTION	7	gbt_ts_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
--
--
--
-- time ops
-- 
--
--
CREATE OR REPLACE FUNCTION gbt_time_consistent(internal,time,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_timetz_consistent(internal,timetz,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_time_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_timetz_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_time_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
   
CREATE OR REPLACE FUNCTION gbt_time_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
      
CREATE OR REPLACE FUNCTION gbt_time_union(bytea, internal)
RETURNS gbtreekey16
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_time_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_time_ops
DEFAULT FOR TYPE time USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_time_consistent (internal, time, int2, oid, internal),
	FUNCTION	2	gbt_time_union (bytea, internal),
	FUNCTION	3	gbt_time_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_time_penalty (internal, internal, internal),
	FUNCTION	6	gbt_time_picksplit (internal, internal),
	FUNCTION	7	gbt_time_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
CREATE OPERATOR CLASS gist_timetz_ops
DEFAULT FOR TYPE timetz USING gist 
AS
	OPERATOR	1	<   ,
	OPERATOR	2	<=  ,
	OPERATOR	3	=   ,
	OPERATOR	4	>=  ,
	OPERATOR	5	>   ,
	FUNCTION	1	gbt_timetz_consistent (internal, timetz, int2, oid, internal),
	FUNCTION	2	gbt_time_union (bytea, internal),
	FUNCTION	3	gbt_timetz_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_time_penalty (internal, internal, internal),
	FUNCTION	6	gbt_time_picksplit (internal, internal),
	FUNCTION	7	gbt_time_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
--
--
--
-- date ops
-- 
--
--
CREATE OR REPLACE FUNCTION gbt_date_consistent(internal,date,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_date_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_date_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
   
CREATE OR REPLACE FUNCTION gbt_date_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
      
CREATE OR REPLACE FUNCTION gbt_date_union(bytea, internal)
RETURNS gbtreekey8
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_date_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_date_ops
DEFAULT FOR TYPE date USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_date_consistent (internal, date, int2, oid, internal),
	FUNCTION	2	gbt_date_union (bytea, internal),
	FUNCTION	3	gbt_date_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_date_penalty (internal, internal, internal),
	FUNCTION	6	gbt_date_picksplit (internal, internal),
	FUNCTION	7	gbt_date_same (internal, internal, internal),
	STORAGE		gbtreekey8;
CREATE OPERATOR CLASS
--
--
--
-- interval ops
-- 
--
--
CREATE OR REPLACE FUNCTION gbt_intv_consistent(internal,interval,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_intv_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_intv_decompress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_intv_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
   
CREATE OR REPLACE FUNCTION gbt_intv_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
      
CREATE OR REPLACE FUNCTION gbt_intv_union(bytea, internal)
RETURNS gbtreekey32
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_intv_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_interval_ops
DEFAULT FOR TYPE interval USING gist 
AS
	OPERATOR	1	< ,
	OPERATOR	2	<= ,
	OPERATOR	3	= ,
	OPERATOR	4	>= ,
	OPERATOR	5	> ,
	FUNCTION	1	gbt_intv_consistent (internal, interval, int2, oid, internal),
	FUNCTION	2	gbt_intv_union (bytea, internal),
	FUNCTION	3	gbt_intv_compress (internal),
	FUNCTION	4	gbt_intv_decompress (internal),
	FUNCTION	5	gbt_intv_penalty (internal, internal, internal),
	FUNCTION	6	gbt_intv_picksplit (internal, internal),
	FUNCTION	7	gbt_intv_same (internal, internal, internal),
	STORAGE		gbtreekey32;
CREATE OPERATOR CLASS
--
--
--
-- cash ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_cash_consistent(internal,money,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_cash_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_cash_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_cash_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_cash_union(bytea, internal)
RETURNS gbtreekey8
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_cash_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_cash_ops
DEFAULT FOR TYPE money USING gist 
AS
	OPERATOR	1	< ,
	OPERATOR	2	<= ,
	OPERATOR	3	= ,
	OPERATOR	4	>= ,
	OPERATOR	5	> ,
	FUNCTION	1	gbt_cash_consistent (internal, money, int2, oid, internal),
	FUNCTION	2	gbt_cash_union (bytea, internal),
	FUNCTION	3	gbt_cash_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_cash_penalty (internal, internal, internal),
	FUNCTION	6	gbt_cash_picksplit (internal, internal),
	FUNCTION	7	gbt_cash_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
--
--
--
-- macaddr ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_macad_consistent(internal,macaddr,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_macad_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_macad_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_macad_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_macad_union(bytea, internal)
RETURNS gbtreekey16
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_macad_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_macaddr_ops
DEFAULT FOR TYPE macaddr USING gist 
AS
	OPERATOR	1	< ,
	OPERATOR	2	<= ,
	OPERATOR	3	= ,
	OPERATOR	4	>= ,
	OPERATOR	5	> ,
	FUNCTION	1	gbt_macad_consistent (internal, macaddr, int2, oid, internal),
	FUNCTION	2	gbt_macad_union (bytea, internal),
	FUNCTION	3	gbt_macad_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_macad_penalty (internal, internal, internal),
	FUNCTION	6	gbt_macad_picksplit (internal, internal),
	FUNCTION	7	gbt_macad_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
--
--
--
-- text/ bpchar ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_text_consistent(internal,text,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bpchar_consistent(internal,bpchar,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_text_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bpchar_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_text_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_text_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_text_union(bytea, internal)
RETURNS gbtreekey_var
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_text_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_text_ops
DEFAULT FOR TYPE text USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_text_consistent (internal, text, int2, oid, internal),
	FUNCTION	2	gbt_text_union (bytea, internal),
	FUNCTION	3	gbt_text_compress (internal),
	FUNCTION	4	gbt_var_decompress (internal),
	FUNCTION	5	gbt_text_penalty (internal, internal, internal),
	FUNCTION	6	gbt_text_picksplit (internal, internal),
	FUNCTION	7	gbt_text_same (internal, internal, internal),
	STORAGE	                gbtreekey_var;
CREATE OPERATOR CLASS
---- Create the operator class
CREATE OPERATOR CLASS gist_bpchar_ops
DEFAULT FOR TYPE bpchar USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_bpchar_consistent (internal, bpchar , int2, oid, internal),
	FUNCTION	2	gbt_text_union (bytea, internal),
	FUNCTION	3	gbt_bpchar_compress (internal),
	FUNCTION	4	gbt_var_decompress (internal),
	FUNCTION	5	gbt_text_penalty (internal, internal, internal),
	FUNCTION	6	gbt_text_picksplit (internal, internal),
	FUNCTION	7	gbt_text_same (internal, internal, internal),
	STORAGE	                gbtreekey_var;
CREATE OPERATOR CLASS
--
--
-- bytea ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_bytea_consistent(internal,bytea,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bytea_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bytea_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bytea_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bytea_union(bytea, internal)
RETURNS gbtreekey_var
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bytea_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_bytea_ops
DEFAULT FOR TYPE bytea USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_bytea_consistent (internal, bytea, int2, oid, internal),
	FUNCTION	2	gbt_bytea_union (bytea, internal),
	FUNCTION	3	gbt_bytea_compress (internal),
	FUNCTION	4	gbt_var_decompress (internal),
	FUNCTION	5	gbt_bytea_penalty (internal, internal, internal),
	FUNCTION	6	gbt_bytea_picksplit (internal, internal),
	FUNCTION	7	gbt_bytea_same (internal, internal, internal),
	STORAGE	                gbtreekey_var;
CREATE OPERATOR CLASS
--
--
--
-- numeric ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_numeric_consistent(internal,numeric,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_numeric_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_numeric_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_numeric_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_numeric_union(bytea, internal)
RETURNS gbtreekey_var
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_numeric_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_numeric_ops
DEFAULT FOR TYPE numeric USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_numeric_consistent (internal, numeric, int2, oid, internal),
	FUNCTION	2	gbt_numeric_union (bytea, internal),
	FUNCTION	3	gbt_numeric_compress (internal),
	FUNCTION	4	gbt_var_decompress (internal),
	FUNCTION	5	gbt_numeric_penalty (internal, internal, internal),
	FUNCTION	6	gbt_numeric_picksplit (internal, internal),
	FUNCTION	7	gbt_numeric_same (internal, internal, internal),
	STORAGE	                gbtreekey_var;
CREATE OPERATOR CLASS
--
--
-- bit ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_bit_consistent(internal,bit,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bit_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bit_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bit_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bit_union(bytea, internal)
RETURNS gbtreekey_var
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_bit_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_bit_ops
DEFAULT FOR TYPE bit USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_bit_consistent (internal, bit, int2, oid, internal),
	FUNCTION	2	gbt_bit_union (bytea, internal),
	FUNCTION	3	gbt_bit_compress (internal),
	FUNCTION	4	gbt_var_decompress (internal),
	FUNCTION	5	gbt_bit_penalty (internal, internal, internal),
	FUNCTION	6	gbt_bit_picksplit (internal, internal),
	FUNCTION	7	gbt_bit_same (internal, internal, internal),
	STORAGE	                gbtreekey_var;
CREATE OPERATOR CLASS
-- Create the operator class
CREATE OPERATOR CLASS gist_vbit_ops
DEFAULT FOR TYPE varbit USING gist 
AS
	OPERATOR	1	<  ,
	OPERATOR	2	<= ,
	OPERATOR	3	=  ,
	OPERATOR	4	>= ,
	OPERATOR	5	>  ,
	FUNCTION	1	gbt_bit_consistent (internal, bit, int2, oid, internal),
	FUNCTION	2	gbt_bit_union (bytea, internal),
	FUNCTION	3	gbt_bit_compress (internal),
	FUNCTION	4	gbt_var_decompress (internal),
	FUNCTION	5	gbt_bit_penalty (internal, internal, internal),
	FUNCTION	6	gbt_bit_picksplit (internal, internal),
	FUNCTION	7	gbt_bit_same (internal, internal, internal),
	STORAGE	                gbtreekey_var;
CREATE OPERATOR CLASS
--
--
--
-- inet/cidr ops
--
--
--
-- define the GiST support methods
CREATE OR REPLACE FUNCTION gbt_inet_consistent(internal,inet,int2,oid,internal)
RETURNS bool
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_inet_compress(internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_inet_penalty(internal,internal,internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_inet_picksplit(internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_inet_union(bytea, internal)
RETURNS gbtreekey16
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gbt_inet_same(internal, internal, internal)
RETURNS internal
AS '$libdir/btree_gist'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION
-- Create the operator class
CREATE OPERATOR CLASS gist_inet_ops
DEFAULT FOR TYPE inet USING gist 
AS
	OPERATOR	1	<   ,
	OPERATOR	2	<=  ,
	OPERATOR	3	=   ,
	OPERATOR	4	>=  ,
	OPERATOR	5	>   ,
	FUNCTION	1	gbt_inet_consistent (internal, inet, int2, oid, internal),
	FUNCTION	2	gbt_inet_union (bytea, internal),
	FUNCTION	3	gbt_inet_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_inet_penalty (internal, internal, internal),
	FUNCTION	6	gbt_inet_picksplit (internal, internal),
	FUNCTION	7	gbt_inet_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
-- Create the operator class
CREATE OPERATOR CLASS gist_cidr_ops
DEFAULT FOR TYPE cidr USING gist 
AS
	OPERATOR	1	<  (inet, inet)  ,
	OPERATOR	2	<= (inet, inet)  ,
	OPERATOR	3	=  (inet, inet)  ,
	OPERATOR	4	>= (inet, inet)  ,
	OPERATOR	5	>  (inet, inet)  ,
	FUNCTION	1	gbt_inet_consistent (internal, inet, int2, oid, internal),
	FUNCTION	2	gbt_inet_union (bytea, internal),
	FUNCTION	3	gbt_inet_compress (internal),
	FUNCTION	4	gbt_decompress (internal),
	FUNCTION	5	gbt_inet_penalty (internal, internal, internal),
	FUNCTION	6	gbt_inet_picksplit (internal, internal),
	FUNCTION	7	gbt_inet_same (internal, internal, internal),
	STORAGE		gbtreekey16;
CREATE OPERATOR CLASS
DROP TABLE IF EXISTS T3
NOTICE:  table "t3" does not exist, skipping
DROP TABLE
CREATE TABLE T3
	(A INTEGER PRIMARY KEY, 
         B CHAR(128),
	 C VARCHAR(256), 
         D INTEGER);
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t3_pkey" for table "t3"
CREATE TABLE
CREATE INDEX T3_D_IDX ON T3
	USING GIST(D);
CREATE INDEX
CHECKPOINT;
CHECKPOINT
INSERT INTO T3(A) 
        SELECT * 
          FROM generate_series(1, 50000);
INSERT 0 50000
CHECKPOINT;
CHECKPOINT
UPDATE T3 
        SET B = 'xxxxxxxxxx', C = 'yyyyyyyyyyyyyyyyyyy', D = A;
UPDATE 50000
CHECKPOINT;
CHECKPOINT
DELETE FROM T3 
        WHERE A%10=0;
DELETE 5000
CHECKPOINT;
CHECKPOINT
UPDATE T3 
        SET B = 'zzzxxxxxxx', C = 'zzzuyyyyyyyyyyyyyyy' 
          WHERE A%10=1;
UPDATE 5000
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
DELETE FROM T3;
DELETE 45000
COMMIT;
COMMIT
CHECKPOINT;
CHECKPOINT
VACUUM T3;
VACUUM
VACUUM T3;
VACUUM
VACUUM FULL T3;
VACUUM
VACUUM FULL T3;
VACUUM
/* $PostgreSQL: pgsql/contrib/btree_gin/btree_gin.sql.in,v 1.1 2009/03/25 23:20:01 tgl Exp $ */
-- Adjust this setting to control where the objects get created.
SET search_path = public;
SET
CREATE OR REPLACE FUNCTION gin_btree_consistent(internal, int2, anyelement, int4, internal, internal)
RETURNS bool
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_value_int2(int2, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_int2(int2, int2, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_int2(int2, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS int2_ops
DEFAULT FOR TYPE int2 USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       btint2cmp(int2,int2),
    FUNCTION        2       gin_extract_value_int2(int2, internal),
    FUNCTION        3       gin_extract_query_int2(int2, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_int2(int2,int2,int2, internal),
STORAGE         int2;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_int4(int4, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_int4(int4, int4, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_int4(int4, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS int4_ops
DEFAULT FOR TYPE int4 USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       btint4cmp(int4,int4),
    FUNCTION        2       gin_extract_value_int4(int4, internal),
    FUNCTION        3       gin_extract_query_int4(int4, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_int4(int4,int4,int2, internal),
STORAGE         int4;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_int8(int8, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_int8(int8, int8, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_int8(int8, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS int8_ops
DEFAULT FOR TYPE int8 USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       btint8cmp(int8,int8),
    FUNCTION        2       gin_extract_value_int8(int8, internal),
    FUNCTION        3       gin_extract_query_int8(int8, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_int8(int8,int8,int2, internal),
STORAGE         int8;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_float4(float4, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_float4(float4, float4, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_float4(float4, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS float4_ops
DEFAULT FOR TYPE float4 USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       btfloat4cmp(float4,float4),
    FUNCTION        2       gin_extract_value_float4(float4, internal),
    FUNCTION        3       gin_extract_query_float4(float4, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_float4(float4,float4,int2, internal),
STORAGE         float4;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_float8(float8, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_float8(float8, float8, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_float8(float8, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS float8_ops
DEFAULT FOR TYPE float8 USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       btfloat8cmp(float8,float8),
    FUNCTION        2       gin_extract_value_float8(float8, internal),
    FUNCTION        3       gin_extract_query_float8(float8, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_float8(float8,float8,int2, internal),
STORAGE         float8;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_money(money, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_money(money, money, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_money(money, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS money_ops
DEFAULT FOR TYPE money USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       cash_cmp(money,money),
    FUNCTION        2       gin_extract_value_money(money, internal),
    FUNCTION        3       gin_extract_query_money(money, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_money(money,money,int2, internal),
STORAGE         money;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_oid(oid, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_oid(oid, oid, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_oid(oid, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS oid_ops
DEFAULT FOR TYPE oid USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       btoidcmp(oid,oid),
    FUNCTION        2       gin_extract_value_oid(oid, internal),
    FUNCTION        3       gin_extract_query_oid(oid, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_oid(oid,oid,int2, internal),
STORAGE         oid;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_timestamp(timestamp, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_timestamp(timestamp, timestamp, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_timestamp(timestamp, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS timestamp_ops
DEFAULT FOR TYPE timestamp USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       timestamp_cmp(timestamp,timestamp),
    FUNCTION        2       gin_extract_value_timestamp(timestamp, internal),
    FUNCTION        3       gin_extract_query_timestamp(timestamp, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_timestamp(timestamp,timestamp,int2, internal),
STORAGE         timestamp;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_timestamptz(timestamptz, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_timestamptz(timestamptz, timestamptz, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_timestamptz(timestamptz, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS timestamptz_ops
DEFAULT FOR TYPE timestamptz USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       timestamptz_cmp(timestamptz,timestamptz),
    FUNCTION        2       gin_extract_value_timestamptz(timestamptz, internal),
    FUNCTION        3       gin_extract_query_timestamptz(timestamptz, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_timestamptz(timestamptz,timestamptz,int2, internal),
STORAGE         timestamptz;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_time(time, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_time(time, time, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_time(time, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS time_ops
DEFAULT FOR TYPE time USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       time_cmp(time,time),
    FUNCTION        2       gin_extract_value_time(time, internal),
    FUNCTION        3       gin_extract_query_time(time, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_time(time,time,int2, internal),
STORAGE         time;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_timetz(timetz, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_timetz(timetz, timetz, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_timetz(timetz, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS timetz_ops
DEFAULT FOR TYPE timetz USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       timetz_cmp(timetz,timetz),
    FUNCTION        2       gin_extract_value_timetz(timetz, internal),
    FUNCTION        3       gin_extract_query_timetz(timetz, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_timetz(timetz,timetz,int2, internal),
STORAGE         timetz;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_date(date, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_date(date, date, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_date(date, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS date_ops
DEFAULT FOR TYPE date USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       date_cmp(date,date),
    FUNCTION        2       gin_extract_value_date(date, internal),
    FUNCTION        3       gin_extract_query_date(date, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_date(date,date,int2, internal),
STORAGE         date;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_interval(interval, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_interval(interval, interval, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_interval(interval, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS interval_ops
DEFAULT FOR TYPE interval USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       interval_cmp(interval,interval),
    FUNCTION        2       gin_extract_value_interval(interval, internal),
    FUNCTION        3       gin_extract_query_interval(interval, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_interval(interval,interval,int2, internal),
STORAGE         interval;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_macaddr(macaddr, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_macaddr(macaddr, macaddr, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_macaddr(macaddr, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS macaddr_ops
DEFAULT FOR TYPE macaddr USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       macaddr_cmp(macaddr,macaddr),
    FUNCTION        2       gin_extract_value_macaddr(macaddr, internal),
    FUNCTION        3       gin_extract_query_macaddr(macaddr, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_macaddr(macaddr,macaddr,int2, internal),
STORAGE         macaddr;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_inet(inet, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_inet(inet, inet, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_inet(inet, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS inet_ops
DEFAULT FOR TYPE inet USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       network_cmp(inet,inet),
    FUNCTION        2       gin_extract_value_inet(inet, internal),
    FUNCTION        3       gin_extract_query_inet(inet, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_inet(inet,inet,int2, internal),
STORAGE         inet;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_cidr(cidr, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_cidr(cidr, cidr, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_cidr(cidr, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS cidr_ops
DEFAULT FOR TYPE cidr USING gin
AS
    OPERATOR        1       <(inet,inet),
    OPERATOR        2       <=(inet,inet),
    OPERATOR        3       =(inet,inet),
    OPERATOR        4       >=(inet,inet),
    OPERATOR        5       >(inet,inet),
    FUNCTION        1       network_cmp(inet,inet),
    FUNCTION        2       gin_extract_value_cidr(cidr, internal),
    FUNCTION        3       gin_extract_query_cidr(cidr, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_cidr(cidr,cidr,int2, internal),
STORAGE         cidr;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_text(text, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_text(text, text, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_text(text, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS text_ops
DEFAULT FOR TYPE text USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       bttextcmp(text,text),
    FUNCTION        2       gin_extract_value_text(text, internal),
    FUNCTION        3       gin_extract_query_text(text, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_text(text,text,int2, internal),
STORAGE         text;
CREATE OPERATOR CLASS
CREATE OPERATOR CLASS varchar_ops
DEFAULT FOR TYPE varchar USING gin
AS
    OPERATOR        1       <(text,text),
    OPERATOR        2       <=(text,text),
    OPERATOR        3       =(text,text),
    OPERATOR        4       >=(text,text),
    OPERATOR        5       >(text,text),
    FUNCTION        1       bttextcmp(text,text),
    FUNCTION        2       gin_extract_value_text(text, internal),
    FUNCTION        3       gin_extract_query_text(text, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_text(text,text,int2, internal),
STORAGE         varchar;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_char("char", internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_char("char", "char", int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_char("char", internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS char_ops
DEFAULT FOR TYPE "char" USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       btcharcmp("char","char"),
    FUNCTION        2       gin_extract_value_char("char", internal),
    FUNCTION        3       gin_extract_query_char("char", internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_char("char","char",int2, internal),
STORAGE         "char";
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_bytea(bytea, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_bytea(bytea, bytea, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_bytea(bytea, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS bytea_ops
DEFAULT FOR TYPE bytea USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       byteacmp(bytea,bytea),
    FUNCTION        2       gin_extract_value_bytea(bytea, internal),
    FUNCTION        3       gin_extract_query_bytea(bytea, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_bytea(bytea,bytea,int2, internal),
STORAGE         bytea;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_bit(bit, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_bit(bit, bit, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_bit(bit, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS bit_ops
DEFAULT FOR TYPE bit USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       bitcmp(bit,bit),
    FUNCTION        2       gin_extract_value_bit(bit, internal),
    FUNCTION        3       gin_extract_query_bit(bit, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_bit(bit,bit,int2, internal),
STORAGE         bit;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_varbit(varbit, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_varbit(varbit, varbit, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_varbit(varbit, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS varbit_ops
DEFAULT FOR TYPE varbit USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       varbitcmp(varbit,varbit),
    FUNCTION        2       gin_extract_value_varbit(varbit, internal),
    FUNCTION        3       gin_extract_query_varbit(varbit, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_varbit(varbit,varbit,int2, internal),
STORAGE         varbit;
CREATE OPERATOR CLASS
CREATE OR REPLACE FUNCTION gin_extract_value_numeric(numeric, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_compare_prefix_numeric(numeric, numeric, int2, internal)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_extract_query_numeric(numeric, internal, int2, internal, internal)
RETURNS internal
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OR REPLACE FUNCTION gin_numeric_cmp(numeric, numeric)
RETURNS int4
AS '$libdir/btree_gin'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION
CREATE OPERATOR CLASS numeric_ops
DEFAULT FOR TYPE numeric USING gin
AS
    OPERATOR        1       <,
    OPERATOR        2       <=,
    OPERATOR        3       =,
    OPERATOR        4       >=,
    OPERATOR        5       >,
    FUNCTION        1       gin_numeric_cmp(numeric,numeric),
    FUNCTION        2       gin_extract_value_numeric(numeric, internal),
    FUNCTION        3       gin_extract_query_numeric(numeric, internal, int2, internal, internal),
    FUNCTION        4       gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
    FUNCTION        5       gin_compare_prefix_numeric(numeric,numeric,int2, internal),
STORAGE         numeric;
CREATE OPERATOR CLASS
DROP TABLE IF EXISTS T4
NOTICE:  table "t4" does not exist, skipping
DROP TABLE
CREATE TABLE T4
	(A INTEGER PRIMARY KEY, 
         B char(128),
	 C varchar(256), 
         D INTEGER);
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t4_pkey" for table "t4"
CREATE TABLE
CREATE INDEX T4_D_IDX ON T4
	USING GIN (D);
CREATE INDEX
CHECKPOINT;
CHECKPOINT
INSERT INTO T4(A) 
        SELECT * FROM generate_series(1, 50000);
INSERT 0 50000
CHECKPOINT;
CHECKPOINT
UPDATE T4 
        SET B = 'xxxxxxxxxx', 
            C = 'yyyyyyyyyyyyyyyyyyy', 
            D = A;
UPDATE 50000
CHECKPOINT;
CHECKPOINT
DELETE FROM T4 
        WHERE A%10=0;
DELETE 5000
CHECKPOINT;
CHECKPOINT
UPDATE T4 
        SET B = 'zzzxxxxxxx', C = 'zzzuyyyyyyyyyyyyyyy' 
          WHERE A%10=1;
UPDATE 5000
CHECKPOINT;
CHECKPOINT
BEGIN;
BEGIN
DELETE FROM T4;
DELETE 45000
COMMIT;
COMMIT
CHECKPOINT;
CHECKPOINT
VACUUM T4;
VACUUM
VACUUM T4;
VACUUM
VACUUM FULL T4;
VACUUM
VACUUM FULL T4;
VACUUM
create table a (i1 int, i2 int, i3 int, i4 int, i5 int, i6 int);
CREATE TABLE
insert into a select n, n, n, n, n, n from generate_series(1, 100000) as n;
INSERT 0 100000
create index arr_gin on a using gin ( (array[i1, i2, i3, i4, i5, i6]) );
CREATE INDEX
truncate a;
TRUNCATE TABLE
drop index arr_gin ;
DROP INDEX
create index arr_gin on a using gin ( (array[i1, i2, i3, i4, i5, i6]) );
CREATE INDEX
insert into a select n, n, n, n, n, n from generate_series(1, 100000) as n;
INSERT 0 100000
select pg_size_pretty(pg_total_relation_size('a')) as total,
       pg_size_pretty(pg_relation_size('a')) as table;
  total  |  table  
---------+---------
 9952 kB | 5096 kB
(1 row)

DROP TABLE IF EXISTS foo;
NOTICE:  table "foo" does not exist, skipping
DROP TABLE
CREATE TABLE foo (
    bar int[]
) WITH (autovacuum_enabled = off);
CREATE TABLE
INSERT INTO foo VALUES
('{0,1,2,3,4,5,6,7,8,9}'),
('{0,1,2,3,4,5,6,7,8}'),
('{0,1,2,3,4,5,6,7}'),
('{0,1,2,3,4,5,6}'),
('{0,1,2,3,4,5}'),
('{0,1,2,3,4}'),
('{0,1,2,3}'),
('{0,1,2}'),
('{0,1}'),
('{0,1}');
INSERT 0 10
CREATE OR REPLACE FUNCTION dupcontent() 
RETURNS VOID AS
$$
INSERT INTO foo (SELECT * FROM foo);
$$ 
LANGUAGE SQL VOLATILE;
CREATE FUNCTION
CREATE INDEX foo_bar_idx ON foo USING gin (bar) WITH (fastupdate=off);
CREATE INDEX
SELECT dupcontent() FROM generate_series(1, 8);
 dupcontent 
------------
 
 
 
 
 
 
 
 
(8 rows)

DROP TABLE IF EXISTS foo;
DROP TABLE
CREATE TABLE foo (
    bar int[]
) WITH (autovacuum_enabled = off);
CREATE TABLE
INSERT INTO foo VALUES
('{0,1,2}'),
('{0,1}'),
('{0}');
INSERT 0 3
CREATE OR REPLACE FUNCTION dupcontent() 
RETURNS VOID AS
$$
INSERT INTO foo (SELECT * FROM foo);
$$ 
LANGUAGE SQL VOLATILE;
CREATE FUNCTION
SELECT dupcontent() FROM generate_series(1, 11);
 dupcontent 
------------
 
 
 
 
 
 
 
 
 
 
 
(11 rows)

CREATE INDEX foo_bar_idx ON foo USING gin (bar);
CREATE INDEX
DELETE FROM foo;
DELETE 6144
VACUUM foo;
VACUUM
CREATE TABLESPACE tabspace_test LOCATION '/var/postgresql/tablespace.org'
CREATE TABLESPACE
DROP TABLE IF EXISTS T5
NOTICE:  table "t5" does not exist, skipping
DROP TABLE
DROP TABLE IF EXISTS T5;
NOTICE:  table "t5" does not exist, skipping
DROP TABLE
CREATE TABLE T5 
	(A INTEGER PRIMARY KEY, 
         B CHAR(128), 
	 C VARCHAR(256), 
         D INTEGER)
	TABLESPACE tabspace_test;
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t5_pkey" for table "t5"
CREATE TABLE
CREATE INDEX T5_D_IDX ON T5 USING BTREE (D);
CREATE INDEX
CHECKPOINT;
CHECKPOINT
INSERT INTO T5(A) 
	SELECT * FROM generate_series(1, 50000);
INSERT 0 50000
CHECKPOINT;
CHECKPOINT
UPDATE T5 
	SET B = 'xxxxxxxxxx', C = 'yyyyyyyyyyyyyyyyyyy', D = A;
UPDATE 50000
CHECKPOINT;
CHECKPOINT
DELETE FROM T5 WHERE A%10=0;
DELETE 5000
CHECKPOINT;
CHECKPOINT
UPDATE T5 
	SET B = 'zzzxxxxxxx', C = 'zzzuyyyyyyyyyyyyyyy' 
	WHERE A%10=1;
UPDATE 5000
CHECKPOINT;
CHECKPOINT
ALTER TABLESPACE tabspace_test RENAME TO tabspace_test_new
ALTER TABLESPACE
DROP TABLE T5
DROP TABLE
DROP TABLESPACE tabspace_test_new
DROP TABLESPACE
DROP TABLE IF EXISTS T6
NOTICE:  table "t6" does not exist, skipping
DROP TABLE
DROP TABLE IF EXISTS T6;
NOTICE:  table "t6" does not exist, skipping
DROP TABLE
CREATE TABLE T6 
	(A INTEGER PRIMARY KEY, 
         B CHAR(128), 
	 C VARCHAR(256), 
         D SERIAL);
NOTICE:  CREATE TABLE will create implicit sequence "t6_d_seq" for serial column "t6.d"
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t6_pkey" for table "t6"
CREATE TABLE
CREATE INDEX T6_D_IDX ON T6 USING BTREE (D);
CREATE INDEX
CHECKPOINT;
CHECKPOINT
INSERT INTO T6(A) 
	SELECT * FROM generate_series(1, 50000);
INSERT 0 50000
CHECKPOINT;
CHECKPOINT
UPDATE T6 
	SET B = 'xxxxxxxxxx', C = 'yyyyyyyyyyyyyyyyyyy';
UPDATE 50000
CHECKPOINT;
CHECKPOINT
DELETE FROM T6 WHERE A%10=0;
DELETE 5000
CHECKPOINT;
CHECKPOINT
UPDATE T6 
	SET B = 'zzzxxxxxxx', C = 'zzzuyyyyyyyyyyyyyyy' 
	WHERE A%10=1;
UPDATE 5000
CHECKPOINT;
CHECKPOINT
DROP TABLE T7 IF EXISTS;
ERROR:  syntax error at or near "IF"
LINE 1: DROP TABLE T7 IF EXISTS;
                      ^
CREATE TABLE T7
       (A INTEGER PRIMARY KEY,
	B CHAR(128),
	C VARCHAR(256));
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t7_pkey" for table "t7"
CREATE TABLE
INSERT INTO T7(A)
	SELECT * FROM generate_series(1, 50000);
INSERT 0 50000
DELETE FROM T7;
DELETE 50000
VACUUM T7;
VACUUM
INSERT INTO T7(A)
	SELECT * FROM generate_series(1, 50000);
INSERT 0 50000
VACUUM FREEZE
VACUUM
select pg_switch_xlog()
 pg_switch_xlog 
----------------
 0/25FFEEB8
(1 row)

CHECKPOINT
CHECKPOINT
select pg_switch_xlog()
 pg_switch_xlog 
----------------
 0/260000D0
(1 row)

CHECKPOINT
CHECKPOINT
select pg_switch_xlog()
 pg_switch_xlog 
----------------
 0/27000088
(1 row)

CHECKPOINT
CHECKPOINT
select pg_switch_xlog()
 pg_switch_xlog 
----------------
 0/28000088
(1 row)

CHECKPOINT
CHECKPOINT
select pg_switch_xlog()
 pg_switch_xlog 
----------------
 0/29000088
(1 row)

waiting for server to shut down.... done
server stopped

====== Compression/Decompression Test ===========

decompress:000000010000000000000000 -> 000000010000000000000000.decompressed
decompress:000000010000000000000000.decompressed -> 000000010000000000000000.bak
decompress:000000010000000000000001 -> 000000010000000000000001.decompressed
decompress:000000010000000000000001.decompressed -> 000000010000000000000001.bak
decompress:000000010000000000000002 -> 000000010000000000000002.decompressed
decompress:000000010000000000000002.decompressed -> 000000010000000000000002.bak
decompress:000000010000000000000003 -> 000000010000000000000003.decompressed
decompress:000000010000000000000003.decompressed -> 000000010000000000000003.bak
decompress:000000010000000000000004 -> 000000010000000000000004.decompressed
decompress:000000010000000000000004.decompressed -> 000000010000000000000004.bak
decompress:000000010000000000000005 -> 000000010000000000000005.decompressed
decompress:000000010000000000000005.decompressed -> 000000010000000000000005.bak
decompress:000000010000000000000006 -> 000000010000000000000006.decompressed
decompress:000000010000000000000006.decompressed -> 000000010000000000000006.bak
decompress:000000010000000000000007 -> 000000010000000000000007.decompressed
decompress:000000010000000000000007.decompressed -> 000000010000000000000007.bak
decompress:000000010000000000000008 -> 000000010000000000000008.decompressed
decompress:000000010000000000000008.decompressed -> 000000010000000000000008.bak
decompress:000000010000000000000009 -> 000000010000000000000009.decompressed
decompress:000000010000000000000009.decompressed -> 000000010000000000000009.bak
decompress:00000001000000000000000A -> 00000001000000000000000A.decompressed
decompress:00000001000000000000000A.decompressed -> 00000001000000000000000A.bak
decompress:00000001000000000000000B -> 00000001000000000000000B.decompressed
decompress:00000001000000000000000B.decompressed -> 00000001000000000000000B.bak
decompress:00000001000000000000000C -> 00000001000000000000000C.decompressed
decompress:00000001000000000000000C.decompressed -> 00000001000000000000000C.bak
decompress:00000001000000000000000D -> 00000001000000000000000D.decompressed
decompress:00000001000000000000000D.decompressed -> 00000001000000000000000D.bak
decompress:00000001000000000000000E -> 00000001000000000000000E.decompressed
decompress:00000001000000000000000E.decompressed -> 00000001000000000000000E.bak
decompress:00000001000000000000000F -> 00000001000000000000000F.decompressed
decompress:00000001000000000000000F.decompressed -> 00000001000000000000000F.bak
decompress:000000010000000000000010 -> 000000010000000000000010.decompressed
decompress:000000010000000000000010.decompressed -> 000000010000000000000010.bak
decompress:000000010000000000000011 -> 000000010000000000000011.decompressed
decompress:000000010000000000000011.decompressed -> 000000010000000000000011.bak
decompress:000000010000000000000012 -> 000000010000000000000012.decompressed
decompress:000000010000000000000012.decompressed -> 000000010000000000000012.bak
decompress:000000010000000000000013 -> 000000010000000000000013.decompressed
decompress:000000010000000000000013.decompressed -> 000000010000000000000013.bak
decompress:000000010000000000000014 -> 000000010000000000000014.decompressed
decompress:000000010000000000000014.decompressed -> 000000010000000000000014.bak
decompress:000000010000000000000015 -> 000000010000000000000015.decompressed
decompress:000000010000000000000015.decompressed -> 000000010000000000000015.bak
decompress:000000010000000000000016 -> 000000010000000000000016.decompressed
decompress:000000010000000000000016.decompressed -> 000000010000000000000016.bak
decompress:000000010000000000000017 -> 000000010000000000000017.decompressed
decompress:000000010000000000000017.decompressed -> 000000010000000000000017.bak
decompress:000000010000000000000018 -> 000000010000000000000018.decompressed
decompress:000000010000000000000018.decompressed -> 000000010000000000000018.bak
decompress:000000010000000000000019 -> 000000010000000000000019.decompressed
decompress:000000010000000000000019.decompressed -> 000000010000000000000019.bak
decompress:00000001000000000000001A -> 00000001000000000000001A.decompressed
decompress:00000001000000000000001A.decompressed -> 00000001000000000000001A.bak
decompress:00000001000000000000001B -> 00000001000000000000001B.decompressed
decompress:00000001000000000000001B.decompressed -> 00000001000000000000001B.bak
decompress:00000001000000000000001C -> 00000001000000000000001C.decompressed
decompress:00000001000000000000001C.decompressed -> 00000001000000000000001C.bak
decompress:00000001000000000000001D -> 00000001000000000000001D.decompressed
decompress:00000001000000000000001D.decompressed -> 00000001000000000000001D.bak
decompress:00000001000000000000001E -> 00000001000000000000001E.decompressed
decompress:00000001000000000000001E.decompressed -> 00000001000000000000001E.bak
decompress:00000001000000000000001F -> 00000001000000000000001F.decompressed
decompress:00000001000000000000001F.decompressed -> 00000001000000000000001F.bak
decompress:000000010000000000000020 -> 000000010000000000000020.decompressed
decompress:000000010000000000000020.decompressed -> 000000010000000000000020.bak
decompress:000000010000000000000021 -> 000000010000000000000021.decompressed
decompress:000000010000000000000021.decompressed -> 000000010000000000000021.bak
decompress:000000010000000000000022 -> 000000010000000000000022.decompressed
decompress:000000010000000000000022.decompressed -> 000000010000000000000022.bak
decompress:000000010000000000000023 -> 000000010000000000000023.decompressed
decompress:000000010000000000000023.decompressed -> 000000010000000000000023.bak
decompress:000000010000000000000024 -> 000000010000000000000024.decompressed
decompress:000000010000000000000024.decompressed -> 000000010000000000000024.bak
decompress:000000010000000000000025 -> 000000010000000000000025.decompressed
decompress:000000010000000000000025.decompressed -> 000000010000000000000025.bak
decompress:000000010000000000000026 -> 000000010000000000000026.decompressed
decompress:000000010000000000000026.decompressed -> 000000010000000000000026.bak
decompress:000000010000000000000027 -> 000000010000000000000027.decompressed
decompress:000000010000000000000027.decompressed -> 000000010000000000000027.bak
decompress:000000010000000000000028 -> 000000010000000000000028.decompressed
decompress:000000010000000000000028.decompressed -> 000000010000000000000028.bak
decompress:000000010000000000000029 -> 000000010000000000000029.decompressed
decompress:000000010000000000000029.decompressed -> 000000010000000000000029.bak
=== Testing compressed XLOG ===
RM_XLOG_ID OK
XLOG_CHECKPOINT_SHUTDOWN OK
XLOG_CHECKPOINT_ONLINE OK
XLOG_NOOP NOT FOUND
XLOG_NEXTOID OK
XLOG_SWITCH OK
RM_XACT_ID OK
XLOG_XACT_COMMIT OK
XLOG_XACT_PREPARE OK
XLOG_XACT_ABORT OK
XLOG_XACT_COMMIT_PREPARED OK
XLOG_XACT_ABORT_PREPARED OK
RM_SMGR_ID OK
XLOG_SMGR_CREATE OK
XLOG_SMGR_TRUNCATE OK
XLOG_SMGR_CREATE OK
XLOG_SMGR_TRUNCATE OK
RM_CLOG_ID OK
CLOG_ZEROPAGE OK
CLOG_TRUNCATE NOT FOUND
RM_DBASE_ID OK
XLOG_DBASE_CREATE OK
XLOG_DBASE_DROP OK
RM_TBLSPC_ID OK
XLOG_TBLSPC_CREATE OK
XLOG_TBLSPC_DROP OK
RM_MULTIXACT_ID OK
XLOG_MULTIXACT_ZERO_OFF_PAGE OK
XLOG_MULTIXACT_ZERO_MEM_PAGE OK
XLOG_MULTIXACT_CREATE_ID OK
RM_HEAP2_ID OK
XLOG_HEAP2_FREEZE OK
XLOG_HEAP2_CLEAN OK
XLOG_HEAP2_CLEAN_MOVE OK
RM_HEAP_ID OK
XLOG_HEAP_INSERT OK
XLOG_HEAP_DELETE OK
XLOG_HEAP_UPDATE OK
XLOG_HEAP_MOVE OK
XLOG_HEAP_HOT_UPDATE OK
XLOG_HEAP_NEWPAGE OK
XLOG_HEAP_LOCK OK
XLOG_HEAP_INPLACE OK
XLOG_HEAP_INIT_PAGE NOT FOUND
RM_BTREE_ID OK
XLOG_BTREE_INSERT_LEAF OK
XLOG_BTREE_INSERT_UPPER OK
XLOG_BTREE_INSERT_META OK
XLOG_BTREE_SPLIT_L OK
XLOG_BTREE_SPLIT_R OK
XLOG_BTREE_SPLIT_L_ROOT OK
XLOG_BTREE_SPLIT_R_ROOT OK
XLOG_BTREE_DELETE OK
XLOG_BTREE_DELETE_PAGE OK
XLOG_BTREE_DELETE_PAGE_META OK
XLOG_BTREE_NEWROOT OK
XLOG_BTREE_DELETE_PAGE_HALF OK
RM_HASH_ID NOT FOUND
RM_GIN_ID OK
XLOG_GIN_CREATE_INDEX OK
XLOG_GIN_CREATE_PTREE OK
XLOG_GIN_INSERT OK
XLOG_GIN_SPLIT OK
XLOG_GIN_VACUUM_PAGE OK
XLOG_GIN_DELETE_PAGE OK
XLOG_GIN_UPDATE_META_PAGE OK
XLOG_GIN_INSERT_LISTPAGE OK
XLOG_GIN_DELETE_LISTPAGE OK
RM_GIST_ID OK
XLOG_GIST_PAGE_UPDATE OK
XLOG_GIST_NEW_ROOT OK
XLOG_GIST_PAGE_SPLIT OK
XLOG_GIST_INSERT_COMPLETE OK
XLOG_GIST_CREATE_INDEX OK
XLOG_GIST_PAGE_DELETE OK
RM_SEQ_ID OK
XLOG_SEQ_LOG OK
Unknown WAL record NOT found

*********** Starting Archive Recovery *****************

pg_ctl: another server might be running; trying to start server anyway
server starting
psql: FATAL:  the database system is starting up
WARNING: online backup mode is active
Shutdown will not complete until pg_stop_backup() is called.

waiting for server to shut down.................................. done
server stopped

******************************************************************
Now the recovery has been done.

Depending on the number of tuples inserted (see $NUM_TUPLES value),
it may take very long to replay the WAL and stop PG server.
In this case, please try to run "pg_ctl stop" manually, or
look into /var/postgresql/pg_log log files to see that PG server stopped.

Check /usr/local/pgsql/data as well so that you have recovery.done file.
Detail of the recovery will be found in the operation log in 
/var/postgresql/pg_log
******************************************************************

======== Compression/Decompression Test Finished ============

