prestogres 0.1.0

data/pgpool2/parser/parser.c

@@ -0,0 +1,262 @@
+/*-------------------------------------------------------------------------
+ *
+ * parser.c
+ *		Main entry point/driver for PostgreSQL grammar
+ *
+ * Note that the grammar is not allowed to perform any table access
+ * (since we need to be able to do basic parsing even while inside an
+ * aborted transaction).  Therefore, the data structures returned by
+ * the grammar are "raw" parsetrees that still need to be analyzed by
+ * analyze.c and related files.
+ *
+ *
+ * Portions Copyright (c) 2003-2009, PgPool Global Development Group
+ * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/parser/parser.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include <string.h>
+#include "pool_parser.h"
+#include "pool_memory.h"
+#include "gramparse.h"	/* required before parser/gram.h! */
+#include "gram.h"
+#include "parser.h"
+#include "pg_wchar.h"
+
+
+List	   *parsetree;			/* result of parsing is left here */
+jmp_buf    jmpbuffer;
+int			server_version_num = 0;
+
+static pg_enc		server_encoding = PG_SQL_ASCII;
+static	bool		in_parser_context = false;
+
+static int
+parse_version(const char *versionString);
+
+/*
+ * raw_parser
+ *		Given a query in string form, do lexical and grammatical analysis.
+ *
+ * Returns a list of raw (un-analyzed) parse trees.
+ */
+List *
+raw_parser(const char *str)
+{
+	core_yyscan_t yyscanner;
+	base_yy_extra_type yyextra;
+	int			yyresult;
+
+	if (pool_memory == NULL)
+		pool_memory = pool_memory_create(PARSER_BLOCK_SIZE);
+
+	parsetree = NIL;			/* in case grammar forgets to set it */
+
+	/* initialize the flex scanner */
+	yyscanner = scanner_init(str, &yyextra.core_yy_extra,
+							 ScanKeywords, NumScanKeywords);
+
+	/* base_yylex() only needs this much initialization */
+	yyextra.have_lookahead = false;
+
+	/* initialize the bison parser */
+	parser_init(&yyextra);
+
+	in_parser_context = true;
+	if (setjmp(jmpbuffer) != 0)
+	{
+		scanner_finish(yyscanner);
+		in_parser_context = false;
+		return NIL; /* error */
+	}
+	else
+	{
+		yyresult = base_yyparse(yyscanner);
+
+		scanner_finish(yyscanner);
+
+		in_parser_context = false;
+		if (yyresult)				/* error */
+			return NIL;
+	}
+	return yyextra.parsetree;
+}
+
+void free_parser(void)
+{
+	pool_memory_delete(pool_memory, 1);
+}
+
+/*
+ * Intermediate filter between parser and base lexer (base_yylex in scan.l).
+ *
+ * The filter is needed because in some cases the standard SQL grammar
+ * requires more than one token lookahead.	We reduce these cases to one-token
+ * lookahead by combining tokens here, in order to keep the grammar LALR(1).
+ *
+ * Using a filter is simpler than trying to recognize multiword tokens
+ * directly in scan.l, because we'd have to allow for comments between the
+ * words.  Furthermore it's not clear how to do it without re-introducing
+ * scanner backtrack, which would cost more performance than this filter
+ * layer does.
+ *
+ * The filter also provides a convenient place to translate between
+ * the core_YYSTYPE and YYSTYPE representations (which are really the
+ * same thing anyway, but notationally they're different).
+ */
+int
+base_yylex(YYSTYPE *lvalp, YYLTYPE *llocp, core_yyscan_t yyscanner)
+{
+	base_yy_extra_type *yyextra = pg_yyget_extra(yyscanner);
+	int			cur_token;
+	int			next_token;
+	core_YYSTYPE cur_yylval;
+	YYLTYPE		cur_yylloc;
+
+	/* Get next token --- we might already have it */
+	if (yyextra->have_lookahead)
+	{
+		cur_token = yyextra->lookahead_token;
+		lvalp->core_yystype = yyextra->lookahead_yylval;
+		*llocp = yyextra->lookahead_yylloc;
+		yyextra->have_lookahead = false;
+	}
+	else
+		cur_token = core_yylex(&(lvalp->core_yystype), llocp, yyscanner);
+
+	/* Do we need to look ahead for a possible multiword token? */
+	switch (cur_token)
+	{
+		case NULLS_P:
+
+			/*
+			 * NULLS FIRST and NULLS LAST must be reduced to one token
+			 */
+			cur_yylval = lvalp->core_yystype;
+			cur_yylloc = *llocp;
+			next_token = core_yylex(&(lvalp->core_yystype), llocp, yyscanner);
+			switch (next_token)
+			{
+				case FIRST_P:
+					cur_token = NULLS_FIRST;
+					break;
+				case LAST_P:
+					cur_token = NULLS_LAST;
+					break;
+				default:
+					/* save the lookahead token for next time */
+					yyextra->lookahead_token = next_token;
+					yyextra->lookahead_yylval = lvalp->core_yystype;
+					yyextra->lookahead_yylloc = *llocp;
+					yyextra->have_lookahead = true;
+					/* and back up the output info to cur_token */
+					lvalp->core_yystype = cur_yylval;
+					*llocp = cur_yylloc;
+					break;
+			}
+			break;
+
+		case WITH:
+
+			/*
+			 * WITH TIME must be reduced to one token
+			 */
+			cur_yylval = lvalp->core_yystype;
+			cur_yylloc = *llocp;
+			next_token = core_yylex(&(lvalp->core_yystype), llocp, yyscanner);
+			switch (next_token)
+			{
+				case TIME:
+					cur_token = WITH_TIME;
+					break;
+				default:
+					/* save the lookahead token for next time */
+					yyextra->lookahead_token = next_token;
+					yyextra->lookahead_yylval = lvalp->core_yystype;
+					yyextra->lookahead_yylloc = *llocp;
+					yyextra->have_lookahead = true;
+					/* and back up the output info to cur_token */
+					lvalp->core_yystype = cur_yylval;
+					*llocp = cur_yylloc;
+					break;
+			}
+			break;
+
+		default:
+			break;
+	}
+
+	return cur_token;
+}
+
+
+void
+pool_parser_error(int level, const char *file, int line)
+{
+#ifdef PARSER_DEBUG
+	fprintf(stderr, "error: %d %s %d\n", level, file, line);
+#endif
+	if (level < ERROR)
+		return;
+	if (in_parser_context)
+		longjmp(jmpbuffer, 1);
+}
+
+static int
+parse_version(const char *versionString)
+{
+	int			cnt;
+	int			vmaj,
+				vmin,
+				vrev;
+
+	cnt = sscanf(versionString, "%d.%d.%d", &vmaj, &vmin, &vrev);
+
+	if (cnt < 2)
+		return -1;
+
+	if (cnt == 2)
+		vrev = 0;
+
+	return (100 * vmaj + vmin) * 100 + vrev;
+}
+
+void
+parser_set_param(const char *name, const char *value)
+{
+	if (strcmp(name, "server_version") == 0)
+	{
+		server_version_num = parse_version(value);
+	}
+	else if (strcmp(name, "server_encoding") == 0)
+	{
+		if (strcmp(value, "UTF8") == 0)
+			server_encoding = PG_UTF8;
+		else
+			server_encoding = PG_SQL_ASCII;
+	}
+	else if (strcmp(name, "standard_conforming_strings") == 0)
+	{
+		if (strcmp(value, "on") == 0)
+			standard_conforming_strings = true;
+		else
+			standard_conforming_strings = false;
+	}
+}
+
+int
+GetDatabaseEncoding(void)
+{
+	return server_encoding;
+}
+
+int
+pg_mblen(const char *mbstr)
+{
+	return pg_utf_mblen((const unsigned char *) mbstr);
+}

data/pgpool2/parser/parser.h

@@ -0,0 +1,46 @@
+/*-------------------------------------------------------------------------
+ *
+ * parser.h
+ *		Definitions for the "raw" parser (flex and bison phases only)
+ *
+ * This is the external API for the raw lexing/parsing functions.
+ *
+ * Portions Copyright (c) 2003-2013, PgPool Global Development Group
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/parser/parser.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "pg_list.h"
+#include "parsenodes.h"
+
+
+typedef enum
+{
+	BACKSLASH_QUOTE_OFF,
+	BACKSLASH_QUOTE_ON,
+	BACKSLASH_QUOTE_SAFE_ENCODING
+}	BackslashQuoteType;
+
+/* GUC variables in scan.l (every one of these is a bad idea :-() */
+extern int	backslash_quote;
+extern bool escape_string_warning;
+extern PGDLLIMPORT bool standard_conforming_strings;
+
+
+/* Primary entry point for the raw parsing functions */
+extern List *raw_parser(const char *str);
+extern void free_parser(void);
+
+/* Utility functions exported by gram.y (perhaps these should be elsewhere) */
+extern List *SystemFuncName(char *name);
+extern TypeName *SystemTypeName(char *name);
+
+extern void parser_set_param(const char *name, const char *value);
+
+#endif   /* PARSER_H */

data/pgpool2/parser/pg_class.h

@@ -0,0 +1,158 @@
+/*-------------------------------------------------------------------------
+ *
+ * pg_class.h
+ *	  definition of the system "relation" relation (pg_class)
+ *	  along with the relation's initial contents.
+ *
+ *
+ * Portions Copyright (c) 2003-2013, PgPool Global Development Group
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/catalog/pg_class.h
+ *
+ * NOTES
+ *	  the genbki.pl script reads this file and generates .bki
+ *	  information from the DATA() statements.
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_CLASS_H
+#define PG_CLASS_H
+
+#if 0
+#include "catalog/genbki.h"
+
+/* ----------------
+ *		pg_class definition.  cpp turns this into
+ *		typedef struct FormData_pg_class
+ * ----------------
+ */
+#define RelationRelationId	1259
+#define RelationRelation_Rowtype_Id  83
+
+CATALOG(pg_class,1259) BKI_BOOTSTRAP BKI_ROWTYPE_OID(83) BKI_SCHEMA_MACRO
+{
+	NameData	relname;		/* class name */
+	Oid			relnamespace;	/* OID of namespace containing this class */
+	Oid			reltype;		/* OID of entry in pg_type for table's
+								 * implicit row type */
+	Oid			reloftype;		/* OID of entry in pg_type for underlying
+								 * composite type */
+	Oid			relowner;		/* class owner */
+	Oid			relam;			/* index access method; 0 if not an index */
+	Oid			relfilenode;	/* identifier of physical storage file */
+
+	/* relfilenode == 0 means it is a "mapped" relation, see relmapper.c */
+	Oid			reltablespace;	/* identifier of table space for relation */
+	int4		relpages;		/* # of blocks (not always up-to-date) */
+	float4		reltuples;		/* # of tuples (not always up-to-date) */
+	int4		relallvisible;	/* # of all-visible blocks (not always
+								 * up-to-date) */
+	Oid			reltoastrelid;	/* OID of toast table; 0 if none */
+	Oid			reltoastidxid;	/* if toast table, OID of chunk_id index */
+	bool		relhasindex;	/* T if has (or has had) any indexes */
+	bool		relisshared;	/* T if shared across databases */
+	char		relpersistence; /* see RELPERSISTENCE_xxx constants below */
+	char		relkind;		/* see RELKIND_xxx constants below */
+	int2		relnatts;		/* number of user attributes */
+
+	/*
+	 * Class pg_attribute must contain exactly "relnatts" user attributes
+	 * (with attnums ranging from 1 to relnatts) for this class.  It may also
+	 * contain entries with negative attnums for system attributes.
+	 */
+	int2		relchecks;		/* # of CHECK constraints for class */
+	bool		relhasoids;		/* T if we generate OIDs for rows of rel */
+	bool		relhaspkey;		/* has (or has had) PRIMARY KEY index */
+	bool		relhasrules;	/* has (or has had) any rules */
+	bool		relhastriggers; /* has (or has had) any TRIGGERs */
+	bool		relhassubclass; /* has (or has had) derived classes */
+	TransactionId relfrozenxid; /* all Xids < this are frozen in this rel */
+
+#ifdef CATALOG_VARLEN			/* variable-length fields start here */
+	/* NOTE: These fields are not present in a relcache entry's rd_rel field. */
+	aclitem		relacl[1];		/* access permissions */
+	text		reloptions[1];	/* access-method-specific options */
+#endif
+} FormData_pg_class;
+
+/* Size of fixed part of pg_class tuples, not counting var-length fields */
+#define CLASS_TUPLE_SIZE \
+	 (offsetof(FormData_pg_class,relfrozenxid) + sizeof(TransactionId))
+
+/* ----------------
+ *		Form_pg_class corresponds to a pointer to a tuple with
+ *		the format of pg_class relation.
+ * ----------------
+ */
+typedef FormData_pg_class *Form_pg_class;
+
+/* ----------------
+ *		compiler constants for pg_class
+ * ----------------
+ */
+
+#define Natts_pg_class					27
+#define Anum_pg_class_relname			1
+#define Anum_pg_class_relnamespace		2
+#define Anum_pg_class_reltype			3
+#define Anum_pg_class_reloftype			4
+#define Anum_pg_class_relowner			5
+#define Anum_pg_class_relam				6
+#define Anum_pg_class_relfilenode		7
+#define Anum_pg_class_reltablespace		8
+#define Anum_pg_class_relpages			9
+#define Anum_pg_class_reltuples			10
+#define Anum_pg_class_relallvisible		11
+#define Anum_pg_class_reltoastrelid		12
+#define Anum_pg_class_reltoastidxid		13
+#define Anum_pg_class_relhasindex		14
+#define Anum_pg_class_relisshared		15
+#define Anum_pg_class_relpersistence	16
+#define Anum_pg_class_relkind			17
+#define Anum_pg_class_relnatts			18
+#define Anum_pg_class_relchecks			19
+#define Anum_pg_class_relhasoids		20
+#define Anum_pg_class_relhaspkey		21
+#define Anum_pg_class_relhasrules		22
+#define Anum_pg_class_relhastriggers	23
+#define Anum_pg_class_relhassubclass	24
+#define Anum_pg_class_relfrozenxid		25
+#define Anum_pg_class_relacl			26
+#define Anum_pg_class_reloptions		27
+
+/* ----------------
+ *		initial contents of pg_class
+ *
+ * NOTE: only "bootstrapped" relations need to be declared here.  Be sure that
+ * the OIDs listed here match those given in their CATALOG macros, and that
+ * the relnatts values are correct.
+ * ----------------
+ */
+
+/* Note: "3" in the relfrozenxid column stands for FirstNormalTransactionId */
+DATA(insert OID = 1247 (  pg_type		PGNSP 71 0 PGUID 0 0 0 0 0 0 0 0 f f p r 30 0 t f f f f 3 _null_ _null_ ));
+DESCR("");
+DATA(insert OID = 1249 (  pg_attribute	PGNSP 75 0 PGUID 0 0 0 0 0 0 0 0 f f p r 21 0 f f f f f 3 _null_ _null_ ));
+DESCR("");
+DATA(insert OID = 1255 (  pg_proc		PGNSP 81 0 PGUID 0 0 0 0 0 0 0 0 f f p r 27 0 t f f f f 3 _null_ _null_ ));
+DESCR("");
+DATA(insert OID = 1259 (  pg_class		PGNSP 83 0 PGUID 0 0 0 0 0 0 0 0 f f p r 27 0 t f f f f 3 _null_ _null_ ));
+DESCR("");
+#endif
+
+#define		  RELKIND_RELATION		  'r'		/* ordinary table */
+#define		  RELKIND_INDEX			  'i'		/* secondary index */
+#define		  RELKIND_SEQUENCE		  'S'		/* sequence object */
+#define		  RELKIND_TOASTVALUE	  't'		/* for out-of-line values */
+#define		  RELKIND_VIEW			  'v'		/* view */
+#define		  RELKIND_COMPOSITE_TYPE  'c'		/* composite type */
+#define		  RELKIND_FOREIGN_TABLE   'f'		/* foreign table */
+#define		  RELKIND_UNCATALOGED	  'u'		/* not yet cataloged */
+
+#define		  RELPERSISTENCE_PERMANENT	'p'		/* regular table */
+#define		  RELPERSISTENCE_UNLOGGED	'u'		/* unlogged permanent table */
+#define		  RELPERSISTENCE_TEMP		't'		/* temporary table */
+
+#endif   /* PG_CLASS_H */