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

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

PG_LESSLOG_VER =  1.4
CLOG_TRUNCATE_OPTION = n
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
Original Tablespace Dir = /var/postgresql/tablespace.org
pg_compresslog = pg_compresslog
pg_compresslog
pg_decompresslog = pg_decompresslog
pg_decompresslog
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/max_fsm_pages ... 32MB/204800
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 29271 waits for ShareLock on transaction 402; blocked by process 29270.
Process 29270 waits for ShareLock on transaction 403; blocked by process 29271.
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
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  
-------+---------
 10 MB | 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);
ERROR:  unrecognized parameter "autovacuum_enabled"
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}');
ERROR:  relation "foo" does not exist
CREATE OR REPLACE FUNCTION dupcontent() 
RETURNS VOID AS
$$
INSERT INTO foo (SELECT * FROM foo);
$$ 
LANGUAGE SQL VOLATILE;
ERROR:  relation "foo" does not exist
CONTEXT:  SQL function "dupcontent"
CREATE INDEX foo_bar_idx ON foo USING gin (bar) WITH (fastupdate=off);
ERROR:  relation "foo" does not exist
SELECT dupcontent() FROM generate_series(1, 8);
ERROR:  function dupcontent() does not exist
LINE 1: SELECT dupcontent() FROM generate_series(1, 8);
               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
DROP TABLE IF EXISTS foo;
NOTICE:  table "foo" does not exist, skipping
DROP TABLE
CREATE TABLE foo (
    bar int[]
) WITH (autovacuum_enabled = off);
ERROR:  unrecognized parameter "autovacuum_enabled"
INSERT INTO foo VALUES
('{0,1,2}'),
('{0,1}'),
('{0}');
ERROR:  relation "foo" does not exist
CREATE OR REPLACE FUNCTION dupcontent() 
RETURNS VOID AS
$$
INSERT INTO foo (SELECT * FROM foo);
$$ 
LANGUAGE SQL VOLATILE;
ERROR:  relation "foo" does not exist
CONTEXT:  SQL function "dupcontent"
SELECT dupcontent() FROM generate_series(1, 11);
ERROR:  function dupcontent() does not exist
LINE 1: SELECT dupcontent() FROM generate_series(1, 11);
               ^
HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
CREATE INDEX foo_bar_idx ON foo USING gin (bar);
ERROR:  relation "foo" does not exist
DELETE FROM foo;
ERROR:  relation "foo" does not exist
VACUUM foo;
ERROR:  relation "foo" does not exist
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/20AC32F8
(1 row)

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

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

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

CHECKPOINT
CHECKPOINT
select pg_switch_xlog()
 pg_switch_xlog 
----------------
 0/24000088
(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
=== Testing compressed XLOG ===
RM_XLOG_ID OK
XLOG_CHECKPOINT_SHUTDOWN OK
XLOG_CHECKPOINT_ONLINE OK
XLOG_NOOP OK
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 NOT FOUND
XLOG_GIN_INSERT OK
XLOG_GIN_SPLIT OK
XLOG_GIN_VACUUM_PAGE NOT FOUND
XLOG_GIN_DELETE_PAGE NOT FOUND
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
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 ============

