prestogres 0.1.0

data/pgpool2/test/parser/input/cursor.sql

@@ -0,0 +1,37 @@
+DECLARE xx CURSOR FOR SELECT * FROM t;
+DECLARE xx BINARY CURSOR FOR SELECT * FROM t;
+DECLARE xx INSENSITIVE CURSOR FOR SELECT * FROM t;
+DECLARE xx SCROLL CURSOR FOR SELECT * FROM t;
+DECLARE xx CURSOR WITH HOLD FOR SELECT * FROM t;
+DECLARE xx CURSOR WITHOUT HOLD FOR SELECT * FROM t;
+CLOSE xx;
+FETCH IN xx;
+FETCH NEXT IN xx;
+FETCH PRIOR IN xx;
+FETCH LAST IN xx;
+FETCH ABSOLUTE 2 IN xx;
+FETCH RELATIVE 2 IN xx;
+FETCH 1 IN xx;
+FETCH ALL IN xx;
+FETCH FORWARD IN xx;
+FETCH FORWARD 2 IN xx;
+FETCH FORWARD ALL IN xx;
+FETCH BACKWARD IN xx;
+FETCH BACKWARD 3 IN xx;
+FETCH BACKWARD ALL IN xx;
+FETCH BACKWARD ALL FROM xx;
+MOVE IN xx;
+MOVE NEXT IN xx;
+MOVE PRIOR IN xx;
+MOVE LAST IN xx;
+MOVE ABSOLUTE 2 IN xx;
+MOVE RELATIVE 2 IN xx;
+MOVE 1 IN xx;
+MOVE ALL IN xx;
+MOVE FORWARD IN xx;
+MOVE FORWARD 2 IN xx;
+MOVE FORWARD ALL IN xx;
+MOVE BACKWARD IN xx;
+MOVE BACKWARD 3 IN xx;
+MOVE BACKWARD ALL IN xx;
+MOVE BACKWARD ALL FROM xx;

data/pgpool2/test/parser/input/delete.sql

@@ -0,0 +1,10 @@
+DELETE FROM t;
+DELETE ;
+DELETE FROM ONLY xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx;
+DELETE FROM t WHERE x = 3;
+DELETE FROM t WHERE x IN (select * from t1);
+DELETE FROM foo WHERE a = 1 RETURNING *;
+DELETE FROM foo WHERE a = 1 RETURNING a;
+DELETE FROM foo WHERE a = 1 RETURNING a,b;
+DELETE FROM foo WHERE CURRENT OF $1
+DELETE FROM foo WHERE CURRENT OF cur

data/pgpool2/test/parser/input/drop.sql

@@ -0,0 +1,12 @@
+DROP TABLE foo
+DROP OWNED BY role_a
+DROP OWNED BY role_a CASCADE
+DROP OWNED BY role_a RESTRICT
+DROP OWNED BY role_a, role_b, role_c
+REASSIGN OWNED BY role_a TO role_b
+REASSIGN OWNED BY role_a, role1 TO role_b
+DROP OPERATOR FAMILY foo USING bar
+DROP OPERATOR FAMILY IF EXISTS foo USING bar
+DROP OPERATOR FAMILY foo USING
+DROP ROLE foo
+DROP ROLE IF EXISTS foo

data/pgpool2/test/parser/input/insert.sql

@@ -0,0 +1,13 @@
+INSERT INTO t values (1);
+INSERT INTO t(a) VALUES (2);
+INSERT INTO t(a,b,c) VALUES (2,2);
+INSERT INTO t(a,b,c) VALUES (2,2,3);
+INSERT INTO t(a,b,c) VALUES (2,DEFAULT,'3');
+INSERT INTO t DEFAULT VALUES;
+INSERT INTO t SELECT  * FROM t;
+INSERT INTO t values (func(x, y));
+INSERT INTO t(a,b,c) VALUES (2,DEFAULT,'\'\\');
+INSERT INTO foo(a,b) VALUES (1, 2) RETURNING *;
+INSERT INTO foo(a,b) VALUES (1, 2) RETURNING a;
+INSERT INTO foo(a,b) VALUES (1, 2) RETURNING a,b;
+INSERT INTO foo(a,b) VALUES (1, 2), (3, 4), (5, 6);

data/pgpool2/test/parser/input/misc.sql

@@ -0,0 +1,28 @@
+VACUUM;
+VACUUM FULL;
+VACUUM FULL FREEZE;
+VACUUM FULL FREEZE VERBOSE;
+VACUUM FULL FREEZE VERBOSE ANALYZE;
+VACUUM FULL t;
+ANALYZE
+ANALYZE VERBOSE
+ANALYZE VERBOSE x
+ANALYZE VERBOSE x(a,b,c);
+EXPLAIN SELECT * FROM t;
+EXPLAIN ANALYZE SELECT * FROM t;
+EXPLAIN ANALYZE VERBOSE SELECT * FROM t;
+REINDEX INDEX x
+REINDEX INDEX x force
+REINDEX TABLE x
+REINDEX TABLE x force
+REINDEX DATABASE x
+REINDEX DATABASE x force
+REINDEX SYSTEM x
+REINDEX SYSTEM x force
+LISTEN x
+NOTIFY x
+DISCARD ALL
+DISCARD TEMP
+DISCARD TEMPORARY
+DISCARD PLANS
+DISCARD xxx

data/pgpool2/test/parser/input/prepare.sql

@@ -0,0 +1,4 @@
+PREPARE xx(integer, text) AS INSERT INTO foo VALUES ($1, $2);
+EXECUTE xx(1, 'xxx');
+DEALLOCATE xx;
+DEALLOCATE PREPARE xx;

data/pgpool2/test/parser/input/privileges.sql

@@ -0,0 +1,31 @@
+GRANT SELECT, INSERT, UPDATE, DELETE, RULE, REFERENCES, TRIGGER on t1, t2 to x;
+GRANT SELECT, INSERT, UPDATE, DELETE, RULE, REFERENCES, TRIGGER on t1, t2 to x WITH GRANT OPTION;
+GRANT SELECT, INSERT, UPDATE, DELETE, RULE, REFERENCES, TRIGGER on t1, t2 to GROUP x WITH GRANT OPTION;
+GRANT SELECT, INSERT, UPDATE, DELETE, RULE, REFERENCES, TRIGGER on t1, t2 to PUBLIC;
+GRANT ALL on t1, t2 to x;
+GRANT CREATE on DATABASE db1, db2 TO x,y;
+GRANT TEMPORARY on DATABASE db1, db2 TO x,y;
+GRANT TEMP on DATABASE db1, db2 TO x,y;
+GRANT EXECUTE on FUNCTION func(int, text) TO x,y;
+GRANT USAGE ON LANGUAGE lang TO x, y;
+GRANT CREATE ON SCHEMA s TO x, y;
+GRANT USAGE ON SCHEMA s TO x, y;
+GRANT CREATE ON TABLESPACE tblspc TO x, y;
+GRANT role1 to role2;
+REVOKE SELECT,INSERT,UPDATE,DELETE,RULE,REFERENCES,TRIGGER on t1, t2 FROM x, y;
+REVOKE SELECT,INSERT,UPDATE,DELETE,RULE,REFERENCES,TRIGGER on t1, t2 FROM x, y CASCADE;
+REVOKE SELECT,INSERT,UPDATE,DELETE,RULE,REFERENCES,TRIGGER on t1, t2 FROM x, y RESTRICT;
+REVOKE ALL on t1, t2 FROM x, y;
+REVOKE ALL on t1, t2 FROM PUBLIC;
+REVOKE GRANT OPTION FOR ALL on t1, t2 FROM PUBLIC;
+REVOKE GRANT OPTION FOR CREATE on DATABASE db1,db2 FROM x,y;
+REVOKE CREATE on DATABASE db1,db2 FROM x,y;
+REVOKE TEMPORARY on DATABASE db1,db2 FROM x,y;
+REVOKE TEMP on DATABASE db1,db2 FROM x,y;
+REVOKE EXECUTE on FUNCTION foo(int,text) db1,db2 FROM x,y;
+REVOKE USAGE ON LANGUAGE lang FROM x,y;
+REVOKE CREATE ON SCHEMA s1,s2 FROM x,y;
+REVOKE USAGE ON SCHEMA s1,s2 FROM x,y;
+REVOKE CREATE ON TABLESPACE tblspc FROM x,y;
+REVOKE ADMIN OPTION FOR role1, role2 FROM x,y;
+REVOKE role1, role2 FROM x,y;

data/pgpool2/test/parser/input/scanner.sql

@@ -0,0 +1,34 @@
+\pset standard_conforming_strings off
+SELECT '\'';
+SELECT '''';
+SELECT 'A\nBC';
+SELECT E'A\nBC';
+SELECT U&'d\0061t\+000061'; --error
+\pset standard_conforming_strings on
+SELECT '\''; -- error
+SELECT '''';
+SELECT 'A\nBC';
+SELECT E'A\nBC';
+
+\pset server_encoding SQL_ASCII
+# unicode ident
+SELECT * FROM U&"d\0061t\+000061";
+# unicode literal
+SELECT E'd\u0061t\U00000061';
+SELECT U&'d\0061t\+000061';
+SELECT U&'d!0061t!+000061' UESCAPE '!';
+SELECT E'\u3042\u3044\u3046\u3048\u304a'; -- error
+SELECT U&'\3042\3044\3046\3048\304a'; -- error
+
+\pset server_encoding UTF8
+# unicode ident
+SELECT * FROM U&"d\0061t\+000061";
+# unicode literal
+SELECT E'd\u0061t\U00000061';
+SELECT U&'d\0061t\+000061';
+SELECT U&'d!0061t!+000061' UESCAPE '!';
+SELECT E'\u3042\u3044\u3046\u3048\u304a';
+SELECT U&'\3042\3044\3046\3048\304a';
+# surrogate pair
+SELECT E'\ud800\udc00';
+SELECT U&'\d800\dc00';

data/pgpool2/test/parser/input/select.sql

@@ -0,0 +1,89 @@
+SELECT 1;
+SELECT * FROM t;
+SELECT x FROM a;
+SELECT x.y FROM a;
+SELECT x FROM a.b;
+SeLeCt foo();
+SELECT y FROM foo();
+SELECT * FROM (SELECT * FROM foo);
+select a as t from x;
+SELECT x FROM a as b;
+SELECT a as tttttttttttttttttttttttttttttttttttttttttttttttttttttttt, b as uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu from zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz;
+SELECT ;
+SELECT * FROM t FOR UPDATE
+SELECT * FROM t FOR SHARE
+SELECT distinct * FROM t
+select distinct on (x) x from t;
+select distinct on (foo(x)) x from t;
+SELECT ALL * FROM t;
+SELECT x FROM t WHERE x > 3;
+SELECT count(*) FROM t GROUP BY x HAVING x > 111;
+SELECT count(*) FROM t GROUP BY x HAVING x > 111 ORDER BY y;
+SELECT count(*) FROM t GROUP BY x HAVING x > 111 ORDER BY y DESC;
+SELECT count(*) FROM t GROUP BY x HAVING x > 111 ORDER BY y ASC;
+SELECT x FROM t LIMIT ALL;
+SELECT x FROM t LIMIT 1;
+SELECT * from t offset 1;
+SELECT * from t limit 2 offset 1;
+SELECT * from t offset 1 limit 2;
+SELECT * FROM t left outer join t1 on (x = y);
+SELECT * FROM t right outer join t1 on (x = y);
+SELECT * FROM t full outer join t1 on (x = y);
+SELECT * FROM t left outer join t1 using (x);
+SELECT * FROM t right outer join t1 using (x);
+SELECT * FROM t full outer join t1 using (x);
+SELECT * FROM t inner join t1 on x;
+SELECT * FROM t natural left outer join t1;
+SELECT * FROM t natural right outer join t1;
+SELECT * FROM t natural full outer join t1;
+select * from t where a IS NULL
+select * from t where a IS NOT NULL
+select * from t where a like 'abc';
+select * from t where a not like 'abc';
+SELECT * FROM t where a between 1 and 4;
+SELECT * FROM t where a In (1,2,3,4);
+SELECT * FROM t where a not In (1,2,3,4);
+SELECT * FROM t WHERE EXISTS (select * from tt);
+SELECT * FROM t WHERE NOT EXISTS (select * from tt);
+(SELECT * FROM t1) UNION (SELECT * FROM t2);
+(SELECT * FROM t1) UNION ALL (SELECT * FROM t2);
+(SELECT * FROM t1) INTERSECT (SELECT * FROM t2);
+(SELECT * FROM t1) INTERSECT ALL (SELECT * FROM t2);
+(SELECT * FROM t1) EXCEPT (SELECT * FROM t2);
+(SELECT * FROM t1) EXCEPT ALL (SELECT * FROM t2);
+SELECT * INTO x FROM t;
+select * from t1 where i <> ALL (select i from t2);
+SELECT * FROM t1 UNION ALL SELECT * FROM t2 ORDER BY a;
+SELECT * FROM t1 UNION ALL (SELECT * FROM t2 ORDER BY a);
+select max(i)::int from test
+select max(i)::int from test where a = 'aaa''bbb\\ccc'
+select max(i)::int from test where a = 'aaa\'bbb\\ccc'
+SELECT * FROM t WHERE 1 = any(arr)
+SELECT * FROM t WHERE 1 = all(arr)
+SELECT * FROM t WHERE 1 IS OF (int)
+SELECT * FROM t WHERE 1 IS NOT OF (int)
+SELECT * FROM t WHERE a IN ('a','b',1);
+SELECT * FROM t WHERE a NOT IN ('a','b',1);
+SELECT * FROM t WHERE a IS DOCUMENT;
+SELECT * FROM t WHERE a IS NOT DOCUMENT;
+SELECT XMLCONCAT(a,b);
+SELECT XMLELEMENT(NAME a);
+SELECT XMLELEMENT(NAME a,b,c);
+SELECT XMLFOREST(a)
+SELECT XMLPARSE(DOCUMENT 1 STRIP WHITESPACE)
+SELECT XMLPARSE(DOCUMENT 1 PRESERVE WHITESPACE)
+SELECT day '1900-1-1'
+SELECT interval '1 year'
+SELECT interval '1 year' YEAR
+SELECT interval '1 year' MONTH
+SELECT interval '1 year' DAY
+SELECT interval '1 year' HOUR
+SELECT interval '1 year' MINUTE
+SELECT interval '1 year' SECOND
+SELECT interval '1 year' YEAR TO MONTH
+SELECT interval '1 year' DAY TO HOUR
+SELECT interval '1 year' DAY TO MINUTE
+SELECT interval '1 year' DAY TO SECOND
+SELECT interval '1 year' HOUR TO MINUTE
+SELECT interval '1 year' HOUR TO SECOND
+VALUES (1, 2), (3, 4), (5, 6);

data/pgpool2/test/parser/input/transaction.sql

@@ -0,0 +1,38 @@
+BEGIN;
+BEGIN WORK;
+BEGIN TRANSACTION;
+BEGIN ISOLATION LEVEL READ COMMITTED;
+BEGIN ISOLATION LEVEL SERIALIZABLE;
+BEGIN READ WRITE;
+BEGIN READ ONLY;
+START TRANSACTION;
+COMMIT;
+COMMIT WORK;
+COMMIT TRANSACTION;
+END;
+END WORK;
+END TRANSACTION;
+ROLLBACK;
+ROLLBACK WORK;
+ROLLBACK TRANSACTION;
+ABORT;
+ABORT WORK;
+ABORT TRANSACTION;
+SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
+SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
+SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL READ COMMITTED;
+SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL SERIALIZABLE;
+SET CONSTRAINTS ALL DEFERRED;
+SET CONSTRAINTS ALL IMMEDIATE;
+SET CONSTRAINTS x DEFERRED;
+SET CONSTRAINTS x IMMEDIATE;
+LOCK TABLE t1,t2;
+LOCK t1,t2;
+LOCK TABLE t1,t2 IN ACCESS SHARE MODE;
+LOCK TABLE t1,t2 IN ROW SHARE MODE;
+LOCK TABLE t1,t2 IN ROW EXCLUSIVE MODE;
+LOCK TABLE t1,t2 IN SHARE UPDATE EXCLUSIVE MODE;
+LOCK TABLE t1,t2 IN SHARE MODE;
+LOCK TABLE t1,t2 IN SHARE ROW EXCLUSIVE MODE;
+LOCK TABLE t1,t2 IN EXCLUSIVE MODE;
+LOCK TABLE t1,t2 IN ACCESS EXCLUSIVE MODE;

data/pgpool2/test/parser/input/update.sql

@@ -0,0 +1,11 @@
+UPDATE t set a = 1;
+UPDATE t set a = 3, b = 'a', c = NULL, d = DEFAULT;
+UPDATE t set a = 1 FROM x;
+UPDATE t set a = 1 FROM x,y,z;
+UPDATE t set a = 1 FROM x where x < 100 and y > 200;
+UPDATE ONLY t set a = 1;
+UPDATE foo SET a = 1 RETURNING *;
+UPDATE foo SET a = 1 RETURNING a;
+UPDATE foo SET a = 1 RETURNING a,b;
+UPDATE foo SET a = 1 WHERE CURRENT OF $1
+UPDATE foo SET a = 1 WHERE CURRENT OF cur

data/pgpool2/test/parser/input/v84.sql

@@ -0,0 +1,37 @@
+SELECT INTERVAL(0) '1.23' SECOND;
+SELECT INTERVAL '1 year' HOUR TO SECOND(2)
+SELECT char 'ABC';
+SELECT "char" 'ABC';
+SELECT avg(c1) OVER (PARTITION BY depname RANGE UNBOUNDED PRECEDING) FROM r1;
+SELECT avg(c1) OVER (PARTITION BY depname ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) FROM r1;
+SELECT sum(c1) OVER w1 FROM r1 WINDOW w1 AS (PARTITION BY c2 ORDER BY c3), w2 AS (w1 PARTITION BY c4);
+WITH w1(n) AS (SELECT 1), w2(n) AS (SELECT 2) SELECT sum(n) FROM r1;
+WITH RECURSIVE t(n) AS (VALUES (1) UNION ALL SELECT n+1 FROM t WHERE n  < 100) SELECT sum(n) FROM t;
+ALTER AGGREGATE FOO(int) OWNER TO BAR;
+ALTER CONVERSION FOO OWNER TO BAR;
+ALTER DATABASE FOO OWNER TO BAR;
+ALTER DOMAIN FOO OWNER TO BAR;
+ALTER FUNCTION FOO() OWNER TO BAR;
+ALTER LANGUAGE FOO OWNER TO BAR;
+ALTER OPERATOR + (int, int) OWNER TO BAR;
+ALTER OPERATOR CLASS FOO USING BAZ OWNER TO BAR;
+ALTER OPERATOR FAMILY FOO USING BAZ OWNER TO BAR;
+ALTER TYPE FOO OWNER TO BAR;
+ALTER TABLESPACE FOO OWNER TO BAR;
+ALTER TEXT SEARCH DICTIONARY FOO OWNER TO BAR;
+ALTER TEXT SEARCH CONFIGURATION FOO OWNER TO BAR;
+ALTER FOREIGN DATA WRAPPER FOO OWNER TO BAR;
+ALTER SERVER FOO OWNER TO BAR;
+ALTER SCHEMA FOO OWNER TO BAR;
+LISTEN x
+NOTIFY x
+UNLISTEN x
+UNLISTEN *
+CREATE TRIGGER t1 BEFORE INSERT OR UPDATE OR DELETE OR TRUNCATE ON r1 EXECUTE PROCEDURE p1();
+GRANT ALL ON r1 TO PUBLIC;
+GRANT ALL ON SEQUENCE r1 TO PUBLIC;
+GRANT ALL ON FUNCTION r1() TO PUBLIC;
+GRANT ALL ON DATABASE r1 TO PUBLIC;
+GRANT ALL ON LANGUAGE r1 TO PUBLIC;
+GRANT ALL ON SCHEMA r1 TO PUBLIC;
+GRANT ALL ON TABLESPACE r1 TO PUBLIC;

data/pgpool2/test/parser/input/v90.sql

@@ -0,0 +1,38 @@
+# named parameter
+SELECT func(a := 7, b := 12);
+# order by aggrigator
+SELECT array_agg(a ORDER BY b, c);
+# variadic from html/xfunc-sql.html
+SELECT mleast(VARIADIC ARRAY[10, -1, 5, 4.4]);
+# window function
+SELECT avg(c1) OVER (ROWS 1 PRECEDING) FROM r1;
+SELECT avg(c1) OVER w1 FROM r1 WINDOW w1 AS (ROWS BETWEEN 1 FOLLOWING AND 2 FOLLOWING);
+# offset
+SELECT * FROM t1 OFFSET 1 ROWS FETCH FIRST 2 ROWS ONLY;
+SELECT * FROM t1 FETCH NEXT 2 ROWS ONLY;
+# DO
+DO LANGUAGE PLPGSQL $$BEGIN RAISE NOTICE 'hello'; END$$;
+
+\pset server_version 9.0.0
+# explain
+# old syntax
+EXPLAIN ANALYZE VERBOSE SELECT 1;
+# new syntax
+EXPLAIN (ANALYZE true,VERBOSE true,COSTS true,BUFFERS true,FORMAT XML) SELECT 1;
+EXPLAIN (ANALYZE false,VERBOSE false,COSTS false,BUFFERS false,FORMAT JSON) SELECT 1;
+# copy
+# old syntax
+COPY t FROM stdin;
+COPY t FROM 'xxx' BINARY;
+COPY t FROM 'xxx' CSV HEADER QUOTE AS '#' ESCAPE AS '$' FORCE NOT NULL foo,bar;
+COPY t FROM 'xxx' OIDS;
+COPY t FROM 'xxx' DELIMITER ',';
+COPY t FROM 'xxx' NULL 'x';
+# new syntax
+COPY t FROM stdin (FORMAT 'text');
+COPY t FROM stdin (FORMAT 'csv');
+COPY t FROM stdin (FORMAT 'binary');
+COPY t FROM 'f' (OIDS false);
+COPY t FROM 'f' (OIDS true, DELIMITER '|', NULL '<N>', HEADER false);
+COPY t FROM 'f' (HEADER true, QUOTE '"', ESCAPE '@');
+COPY t FROM 'f' (FORCE_QUOTE *, FORCE_NOT_NULL(one, two, three));

data/pgpool2/test/parser/input/var.sql

@@ -0,0 +1,22 @@
+SET var TO val
+SET var TO 'val'
+SET var TO DEFAULT
+SET var = DEFAULT
+SET TIME ZONE val
+SET TIME ZONE 'val'
+SET TIME ZONE local
+SET TIME ZONE default
+SET local TIME ZONE default
+SET session TIME ZONE default
+SET var FROM CURRENT
+SET XML OPTION DOCUMENT
+SET XML OPTION CONTENT
+show 'x';
+show x;
+show all;
+reset x;
+reset all;
+reset time zone;
+reset transaction isolation level
+reset session authorization
+reset 'x';

data/pgpool2/test/parser/main.c

@@ -0,0 +1,96 @@
+/* $Header$ */
+#include "pool.h"
+#include "pool_memory.h"
+#include "parsenodes.h"
+#include "gramparse.h"
+#include "parser.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+enum {
+	TEST_CONTINUE,
+	TEST_QUIT
+};
+
+extern int GetDatabaseEncoding(void);
+
+int
+command(const char *cmd)
+{
+	char		name[1024], value[1024];
+
+	if (*cmd == 'q')
+		return TEST_QUIT;
+
+	if (sscanf(cmd, "pset %s %s", name, value) == 2)
+	{
+		if (strcmp(name, "standard_conforming_strings") == 0)
+		{
+			parser_set_param(name, value);
+			fprintf(stdout, "pset %d\n", standard_conforming_strings);
+		}
+		else if (strcmp(name, "server_version") == 0)
+		{
+			parser_set_param(name, value);
+			fprintf(stdout, "pset %d\n", server_version_num);
+		}
+		else if (strcmp(name, "server_encoding") == 0)
+		{
+			parser_set_param(name, value);
+			fprintf(stdout, "pset %d\n", GetDatabaseEncoding());
+		}
+		else
+			fprintf(stdout, "ERROR: pset %s\n", name);
+	}
+	return TEST_CONTINUE;
+}
+
+int main(int argc, char **argv)
+{
+	List *tree;
+	ListCell *l;
+	int		state = TEST_CONTINUE;
+	int		notty = (!isatty(fileno(stdin)) || !isatty(fileno(stdout)));
+	char	line[1024];
+
+	while (state != TEST_QUIT)
+	{
+		if (!notty)
+			fprintf(stdout, "> ");
+		
+		if (!fgets(line, 1024, stdin))
+			break;
+
+		*(strchr(line, (int) '\n')) = '\0';
+
+		if (line[0] == '#' || line[0] == '\0')
+			continue;
+
+		if (line[0] == '\\')
+		{
+			state = command(line + 1);
+			continue;
+		}
+
+		tree = raw_parser(line);
+
+		if (tree == NULL)
+		{
+			printf("syntax error: %s\n", line);
+		}
+		else
+		{
+			foreach(l, tree)
+			{
+				Node *node = (Node *) lfirst(l);
+				printf("%s\n", nodeToString(node));
+			}
+		}
+
+		free_parser();
+	}
+
+	return 0;
+}