hawq-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From foy...@apache.org
Subject [2/9] incubator-hawq git commit: HAWQ-149. Add orafce, gp_cancel_query, pgbench and extprotocol to HAWQ
Date Thu, 12 Nov 2015 20:25:19 GMT
http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/contrib/orafce/sql/files.sql
----------------------------------------------------------------------
diff --git a/contrib/orafce/sql/files.sql b/contrib/orafce/sql/files.sql
new file mode 100644
index 0000000..d3f5c07
--- /dev/null
+++ b/contrib/orafce/sql/files.sql
@@ -0,0 +1,66 @@
+\set ECHO none
+SET client_min_messages = NOTICE;
+\set ECHO all
+
+INSERT INTO utl_file.utl_file_dir(dir) VALUES(utl_file.tmpdir());
+
+CREATE OR REPLACE FUNCTION gen_file(dir text) RETURNS void AS $$
+DECLARE
+  f utl_file.file_type;
+BEGIN
+  f := utl_file.fopen(dir, 'regress_orafce.txt', 'w');
+  PERFORM utl_file.put_line(f, 'ABC');
+  PERFORM utl_file.put_line(f, '123'::numeric);
+  PERFORM utl_file.put_line(f, '-----');
+  PERFORM utl_file.new_line(f);
+  PERFORM utl_file.put_line(f, '-----');
+  PERFORM utl_file.new_line(f, 0);
+  PERFORM utl_file.put_line(f, '-----');
+  PERFORM utl_file.new_line(f, 2);
+  PERFORM utl_file.put_line(f, '-----');
+  PERFORM utl_file.put(f, 'A');
+  PERFORM utl_file.put(f, 'B');
+  PERFORM utl_file.new_line(f);
+  PERFORM utl_file.putf(f, '[1=%s, 2=%s, 3=%s, 4=%s, 5=%s]', '1', '2', '3', '4', '5');
+  PERFORM utl_file.new_line(f);
+  PERFORM utl_file.put_line(f, '1234567890');
+  f := utl_file.fclose(f);
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION read_file(dir text) RETURNS void AS $$
+DECLARE
+  f utl_file.file_type;
+BEGIN
+  f := utl_file.fopen(dir, 'regress_orafce.txt', 'r');
+  FOR i IN 1..11 LOOP
+    RAISE NOTICE '[%] >>%<<', i, utl_file.get_line(f);
+  END LOOP;
+  RAISE NOTICE '>>%<<', utl_file.get_line(f, 4);
+  RAISE NOTICE '>>%<<', utl_file.get_line(f, 4);
+  RAISE NOTICE '>>%<<', utl_file.get_line(f);
+  RAISE NOTICE '>>%<<', utl_file.get_line(f);
+  EXCEPTION
+    -- WHEN no_data_found THEN,  8.1 plpgsql doesn't know no_data_found
+    WHEN others THEN
+      RAISE NOTICE 'finish % ', sqlerrm;
+      RAISE NOTICE 'is_open = %', utl_file.is_open(f);
+      PERFORM utl_file.fclose_all();
+      RAISE NOTICE 'is_open = %', utl_file.is_open(f);
+END;
+$$ LANGUAGE plpgsql;
+
+SELECT gen_file(utl_file.tmpdir());
+SELECT fexists FROM utl_file.fgetattr(utl_file.tmpdir(), 'regress_orafce.txt');
+SELECT utl_file.fcopy(utl_file.tmpdir(), 'regress_orafce.txt', utl_file.tmpdir(), 'regress_orafce2.txt');
+SELECT fexists FROM utl_file.fgetattr(utl_file.tmpdir(), 'regress_orafce2.txt');
+SELECT utl_file.frename(utl_file.tmpdir(), 'regress_orafce2.txt', utl_file.tmpdir(), 'regress_orafce.txt', true);
+SELECT fexists FROM utl_file.fgetattr(utl_file.tmpdir(), 'regress_orafce.txt');
+SELECT fexists FROM utl_file.fgetattr(utl_file.tmpdir(), 'regress_orafce2.txt');
+SELECT read_file(utl_file.tmpdir());
+SELECT utl_file.fremove(utl_file.tmpdir(), 'regress_orafce.txt');
+SELECT fexists FROM utl_file.fgetattr(utl_file.tmpdir(), 'regress_orafce.txt');
+DROP FUNCTION gen_file(text);
+DROP FUNCTION read_file(text);
+
+DELETE FROM utl_file.utl_file_dir;

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/contrib/orafce/sqlparse.y
----------------------------------------------------------------------
diff --git a/contrib/orafce/sqlparse.y b/contrib/orafce/sqlparse.y
new file mode 100644
index 0000000..ca86d06
--- /dev/null
+++ b/contrib/orafce/sqlparse.y
@@ -0,0 +1,111 @@
+%{
+
+#define YYPARSE_PARAM result  /* need this to pass a pointer (void *) to yyparse */
+#define YYDEBUG 1
+
+#define YYLLOC_DEFAULT(Current, Rhs, N) \
+do { \
+if (N) \
+(Current) = (Rhs)[1]; \
+else \
+(Current) = (Rhs)[0]; \
+} while (0)                      
+
+#include "postgres.h"
+#include "orafunc.h"
+#include "plvlex.h"
+#include "nodes/pg_list.h"
+
+
+#define MOVE_TO_S(src,dest,col)	dest->col = src.col ? pstrdup(src.col) : NULL
+#define MOVE_TO(src,dest,col)	dest->col = src.col
+
+#define FILL_NODE(src,dest)	\
+	MOVE_TO_S(src,dest,str), \
+	MOVE_TO(src,dest,keycode), \
+	MOVE_TO(src,dest,lloc), \
+	MOVE_TO_S(src,dest,sep), \
+	MOVE_TO(src,dest,modificator)
+
+static orafce_lexnode *__node;
+
+#define CREATE_NODE(src,type) 	\
+  ( \
+    __node = (orafce_lexnode*) palloc(sizeof(orafce_lexnode)), \
+    __node->typenode = X_##type, \
+    __node->classname = #type, \
+    FILL_NODE(src,__node), \
+    __node)
+    
+    
+
+
+extern int yylex(void);      /* defined as fdate_yylex in fdatescan.l */
+
+static char *scanbuf;
+static int	scanbuflen;
+
+void orafce_sql_yyerror(const char *message);
+
+
+#define YYLTYPE int
+
+%}
+%name-prefix="orafce_sql_yy" 
+%locations
+
+%union
+{
+    int 	ival;
+    orafce_lexnode	*node;
+    List		*list;
+    struct
+    {
+	    char 	*str;
+	    int		keycode;
+	    int		lloc;
+	    char	*sep;
+	    char *modificator;
+    }				val;
+
+
+}
+    
+/* BISON Declarations */
+%token <val>    X_IDENT X_NCONST X_SCONST X_OP X_PARAM X_COMMENT X_WHITESPACE X_KEYWORD X_OTHERS X_TYPECAST
+
+%type <list> elements
+%type <node> anyelement
+%type <list> root
+
+%start root
+
+
+/* Grammar follows */
+%%
+
+root:
+	    elements { *((void**)result) = $1; }
+	;
+
+elements:
+		anyelement { $$ = list_make1($1);}
+		| elements anyelement { $$ = lappend($1, $2);}
+	;
+
+anyelement:
+		X_IDENT		{ $$ = (orafce_lexnode*) CREATE_NODE($1, IDENT);  }
+		| X_NCONST	{ $$ = (orafce_lexnode*) CREATE_NODE($1, NCONST); }
+		| X_SCONST	{ $$ = (orafce_lexnode*) CREATE_NODE($1, SCONST); }
+		| X_OP		{ $$ = (orafce_lexnode*) CREATE_NODE($1, OP);    }
+		| X_PARAM		{ $$ = (orafce_lexnode*) CREATE_NODE($1, PARAM); }
+		| X_COMMENT	{ $$ = (orafce_lexnode*) CREATE_NODE($1, COMMENT);    }
+		| X_WHITESPACE	{ $$ = (orafce_lexnode*) CREATE_NODE($1, WHITESPACE); }
+		| X_KEYWORD	{ $$ = (orafce_lexnode*) CREATE_NODE($1, KEYWORD); }
+		| X_OTHERS	{ $$ = (orafce_lexnode*) CREATE_NODE($1, OTHERS);  }
+	;
+%%
+
+
+
+#include "sqlscan.c"

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/contrib/orafce/sqlscan.l
----------------------------------------------------------------------
diff --git a/contrib/orafce/sqlscan.l b/contrib/orafce/sqlscan.l
new file mode 100644
index 0000000..dcb3b05
--- /dev/null
+++ b/contrib/orafce/sqlscan.l
@@ -0,0 +1,1061 @@
+%{
+/* 
+** A scanner for EMP-style numeric ranges 
+*/
+
+#include "postgres.h"
+#include "parser/keywords.h"
+
+#ifdef GP_VERSION_NUM
+#define YY_NO_INPUT 1
+#endif
+
+#undef yyparse  /* don't need it now and solve problems with 8.1 */
+
+#include "parser/gramparse.h"                                                                                               
+#include "parser/keywords.h"                                                                                                
+/* Not needed now that this file is compiled as part of gram.y */                                                           
+/* #include "parser/parse.h" */                                                                                             
+#include "parser/scansup.h"      
+#include "mb/pg_wchar.h"
+
+#define unify_version(a,b,c) ((a<<16)+(b<<8)+c)
+
+/* simplified current version */
+#define YY_FLEX_FULL_VERSION \
+  unify_version(YY_FLEX_MAJOR_VERSION,YY_FLEX_MINOR_VERSION,YY_FLEX_SUBMINOR_VERSION)
+
+/* 
+ * Need to define these prototypes to shut GCC up. Flex fixes this from
+ * > 2.5.35
+ */
+#if YY_FLEX_FULL_VERSION < unify_version(2,5,35)
+int orafce_sql_yyget_lineno  (void);
+FILE *orafce_sql_yyget_in  (void);
+FILE *orafce_sql_yyget_out  (void);
+char *orafce_sql_yyget_text  (void);
+void orafce_sql_yyset_lineno (int  line_number );
+void orafce_sql_yyset_in (FILE *  in_str );
+void orafce_sql_yyset_out (FILE *  out_str );
+int orafce_sql_yyget_debug  (void);
+void orafce_sql_yyset_debug (int  bdebug );
+int orafce_sql_yylex_destroy  (void);
+int orafce_sql_yyget_leng(void);
+#endif
+
+#if PG_VERSION_NUM >= 80500
+extern PGDLLIMPORT const ScanKeyword ScanKeywords[];
+extern PGDLLIMPORT const int	NumScanKeywords;
+#define ScanKeywordLookupArgs	, ScanKeywords, NumScanKeywords
+#else
+#define ScanKeywordLookupArgs
+#endif
+
+#undef fprintf
+#define fprintf(file, fmt, msg)  ereport(ERROR, (errmsg_internal("%s", msg)))
+
+static int		xcdepth = 0;	/* depth of nesting in slash-star comments */
+static char    *dolqstart;      /* current $foo$ quote start string */
+static bool extended_string = false;
+
+
+/* No reason to constrain amount of data slurped */
+#define YY_READ_BUF_SIZE 16777216
+
+/* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
+#define fprintf(file, fmt, msg)  ereport(ERROR, (errmsg_internal("%s", msg)))
+
+/* Handles to the buffer that the lexer uses internally */
+
+
+static YY_BUFFER_STATE scanbufhandle;
+
+#define SET_YYLLOC()  (yylval.val.lloc = yylloc = yytext - scanbuf)                                                                                              
+                                                                                                                                               
+/* Handles to the buffer that the lexer uses internally */                                                                                     
+static char *scanbuf;       
+
+/* flex 2.5.4 doesn't bother with a decl for this */
+
+int orafce_sql_yylex(void);
+
+extern YYSTYPE yylval;
+
+void orafce_sql_scanner_init(const char *str);
+void orafce_sql_scanner_finish(void);
+
+/*
+ * literalbuf is used to accumulate literal values when multiple rules
+ * are needed to parse a single literal.  Call startlit to reset buffer
+ * to empty, addlit to add text.  Note that the buffer is palloc'd and
+ * starts life afresh on every parse cycle.
+ */
+static char	   *literalbuf;		/* expandable buffer */
+static int		literallen;		/* actual current length */
+static int		literalalloc;	/* current allocated buffer size */
+
+#define startlit()  (literalbuf[0] = '\0', literallen = 0)
+static void addlit(char *ytext, int yleng);
+static void addlitchar(unsigned char ychar);
+static char *litbufdup(void);
+
+static int	lexer_errposition(void);
+
+/*
+ * Each call to yylex must set yylloc to the location of the found token
+ * (expressed as a byte offset from the start of the input text).
+ * When we parse a token that requires multiple lexer rules to process,
+ * this should be done in the first such rule, else yylloc will point
+ * into the middle of the token.
+ */
+
+/* Handles to the buffer that the lexer uses internally */
+static char *scanbuf;
+
+static unsigned char unescape_single_char(unsigned char c);
+
+#ifndef _pg_mbstrlen_with_len
+#define _pg_mbstrlen_with_len(buf,loc) 	pg_mbstrlen_with_len(buf,loc)
+#endif
+
+%}
+
+%option 8bit
+%option never-interactive
+%option nodefault
+%option nounput
+%option noyywrap
+%option prefix="orafce_sql_yy"
+
+/*
+ * OK, here is a short description of lex/flex rules behavior.
+ * The longest pattern which matches an input string is always chosen.
+ * For equal-length patterns, the first occurring in the rules list is chosen.
+ * INITIAL is the starting state, to which all non-conditional rules apply.
+ * Exclusive states change parsing rules while the state is active.  When in
+ * an exclusive state, only those rules defined for that state apply.
+ *
+ * We use exclusive states for quoted strings, extended comments,
+ * and to eliminate parsing troubles for numeric strings.
+ * Exclusive states:
+ *  <xb> bit string literal
+ *  <xc> extended C-style comments
+ *  <xd> delimited identifiers (double-quoted identifiers)
+ *  <xh> hexadecimal numeric string
+ *  <xq> standard quoted strings
+ *  <xe> extended quoted strings (support backslash escape sequences)
+ *  <xdolq> $foo$ quoted strings
+ */
+
+%x xb
+%x xc
+%x xd
+%x xh
+%x xe
+%x xq
+%x xdolq
+
+
+/*
+ * In order to make the world safe for Windows and Mac clients as well as
+ * Unix ones, we accept either \n or \r as a newline.  A DOS-style \r\n
+ * sequence will be seen as two successive newlines, but that doesn't cause
+ * any problems.  Comments that start with -- and extend to the next
+ * newline are treated as equivalent to a single whitespace character.
+ *
+ * NOTE a fine point: if there is no newline following --, we will absorb
+ * everything to the end of the input as a comment.  This is correct.  Older
+ * versions of Postgres failed to recognize -- as a comment if the input
+ * did not end with a newline.
+ *
+ * XXX perhaps \f (formfeed) should be treated as a newline as well?
+ *
+ * XXX if you change the set of whitespace characters, fix scanner_isspace()
+ * to agree, and see also the plpgsql lexer.
+ */
+
+space			[ \t\n\r\f]
+horiz_space		[ \t\f]
+newline			[\n\r]
+non_newline		[^\n\r]
+
+comment			("--"{non_newline}*)
+
+whitespace		{space}+
+
+/*
+ * SQL requires at least one newline in the whitespace separating
+ * string literals that are to be concatenated.  Silly, but who are we
+ * to argue?  Note that {whitespace_with_newline} should not have * after
+ * it, whereas {whitespace} should generally have a * after it...
+ */
+
+special_whitespace		({space}+|{comment}{newline})
+horiz_whitespace		({horiz_space}|{comment})
+whitespace_with_newline	({horiz_whitespace}*{newline}{special_whitespace}*)
+
+/*
+ * To ensure that {quotecontinue} can be scanned without having to back up
+ * if the full pattern isn't matched, we include trailing whitespace in
+ * {quotestop}.  This matches all cases where {quotecontinue} fails to match,
+ * except for {quote} followed by whitespace and just one "-" (not two,
+ * which would start a {comment}).  To cover that we have {quotefail}.
+ * The actions for {quotestop} and {quotefail} must throw back characters
+ * beyond the quote proper.
+ */
+quote			'
+quotestop		{quote}{whitespace}*
+quotecontinue	{quote}{whitespace_with_newline}{quote}
+quotefail		{quote}{whitespace}*"-"
+
+/* Bit string
+ * It is tempting to scan the string for only those characters
+ * which are allowed. However, this leads to silently swallowed
+ * characters if illegal characters are included in the string.
+ * For example, if xbinside is [01] then B'ABCD' is interpreted
+ * as a zero-length string, and the ABCD' is lost!
+ * Better to pass the string forward and let the input routines
+ * validate the contents.
+ */
+xbstart			[bB]{quote}
+xbinside		[^']*
+
+/* Hexadecimal number */
+xhstart			[xX]{quote}
+xhinside		[^']*
+
+/* National character */
+xnstart			[nN]{quote}
+
+/* Quoted string that allows backslash escapes */
+xestart			[eE]{quote}
+xeinside		[^\\']+
+xeescape		[\\][^0-7]
+xeoctesc		[\\][0-7]{1,3}
+xehexesc		[\\]x[0-9A-Fa-f]{1,2}
+
+/* Extended quote
+ * xqdouble implements embedded quote, ''''
+ */
+xqstart			{quote}
+xqdouble		{quote}{quote}
+xqinside		[^']+
+
+/* $foo$ style quotes ("dollar quoting")
+ * The quoted string starts with $foo$ where "foo" is an optional string
+ * in the form of an identifier, except that it may not contain "$", 
+ * and extends to the first occurrence of an identical string.  
+ * There is *no* processing of the quoted text.
+ *
+ * {dolqfailed} is an error rule to avoid scanner backup when {dolqdelim}
+ * fails to match its trailing "$".
+ */
+dolq_start		[A-Za-z\200-\377_]
+dolq_cont		[A-Za-z\200-\377_0-9]
+dolqdelim		\$({dolq_start}{dolq_cont}*)?\$
+dolqfailed		\${dolq_start}{dolq_cont}*
+dolqinside		[^$]+
+
+/* Double quote
+ * Allows embedded spaces and other special characters into identifiers.
+ */
+dquote			\"
+xdstart			{dquote}
+xdstop			{dquote}
+xddouble		{dquote}{dquote}
+xdinside		[^"]+
+
+/* C-style comments
+ *
+ * The "extended comment" syntax closely resembles allowable operator syntax.
+ * The tricky part here is to get lex to recognize a string starting with
+ * slash-star as a comment, when interpreting it as an operator would produce
+ * a longer match --- remember lex will prefer a longer match!  Also, if we
+ * have something like plus-slash-star, lex will think this is a 3-character
+ * operator whereas we want to see it as a + operator and a comment start.
+ * The solution is two-fold:
+ * 1. append {op_chars}* to xcstart so that it matches as much text as
+ *    {operator} would. Then the tie-breaker (first matching rule of same
+ *    length) ensures xcstart wins.  We put back the extra stuff with yyless()
+ *    in case it contains a star-slash that should terminate the comment.
+ * 2. In the operator rule, check for slash-star within the operator, and
+ *    if found throw it back with yyless().  This handles the plus-slash-star
+ *    problem.
+ * Dash-dash comments have similar interactions with the operator rule.
+ */
+xcstart			\/\*{op_chars}*
+xcstop			\*+\/
+xcinside		[^*/]+
+
+digit			[0-9]
+ident_start		[A-Za-z\200-\377_]
+ident_cont		[A-Za-z\200-\377_0-9\$]
+
+identifier		{ident_start}{ident_cont}*
+
+typecast		"::"
+
+/*
+ * "self" is the set of chars that should be returned as single-character
+ * tokens.  "op_chars" is the set of chars that can make up "Op" tokens,
+ * which can be one or more characters long (but if a single-char token
+ * appears in the "self" set, it is not to be returned as an Op).  Note
+ * that the sets overlap, but each has some chars that are not in the other.
+ *
+ * If you change either set, adjust the character lists appearing in the
+ * rule for "operator"!
+ */
+self			[,()\[\].;\:\+\-\*\/\%\^\<\>\=]
+op_chars		[\~\!\@\#\^\&\|\`\?\+\-\*\/\%\<\>\=]
+operator		{op_chars}+
+
+/* we no longer allow unary minus in numbers. 
+ * instead we pass it separately to parser. there it gets
+ * coerced via doNegate() -- Leon aug 20 1999
+ *
+ * {realfail1} and {realfail2} are added to prevent the need for scanner
+ * backup when the {real} rule fails to match completely.
+ */
+
+integer			{digit}+
+decimal			(({digit}*\.{digit}+)|({digit}+\.{digit}*))
+real			({integer}|{decimal})[Ee][-+]?{digit}+
+realfail1		({integer}|{decimal})[Ee]
+realfail2		({integer}|{decimal})[Ee][-+]
+
+param			\${integer}
+
+other			.
+
+/*
+ * Dollar quoted strings are totally opaque, and no escaping is done on them.
+ * Other quoted strings must allow some special characters such as single-quote
+ *  and newline.
+ * Embedded single-quotes are implemented both in the SQL standard
+ *  style of two adjacent single quotes "''" and in the Postgres/Java style
+ *  of escaped-quote "\'".
+ * Other embedded escaped characters are matched explicitly and the leading
+ *  backslash is dropped from the string.
+ * Note that xcstart must appear before operator, as explained above!
+ *  Also whitespace (comment) must appear before operator.
+ */
+
+%%
+
+{whitespace}	{
+					SET_YYLLOC();
+					yylval.val.str = yytext;
+					yylval.val.modificator = NULL;
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_WHITESPACE;
+				}
+
+{comment}	{
+					SET_YYLLOC();
+					yylval.val.str = yytext;
+					yylval.val.modificator = "sc";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_COMMENT;
+				}
+
+
+{xcstart}		{
+					/* Set location in case of syntax error in comment */
+					SET_YYLLOC();
+					xcdepth = 0;
+					BEGIN(xc);
+					/* Put back any characters past slash-star; see above */
+					startlit();
+					addlitchar('/');
+					addlitchar('*');
+				
+					yyless(2);
+				}
+
+<xc>{xcstart}	{
+					xcdepth++;
+					/* Put back any characters past slash-star; see above */
+					addlitchar('/');
+					addlitchar('*');
+
+					yyless(2);
+				}
+
+<xc>{xcstop}	{
+					if (xcdepth <= 0)
+					{
+						BEGIN(INITIAL);
+						addlitchar('*');
+						addlitchar('/');
+
+						yylval.val.str = litbufdup();
+						yylval.val.modificator = "ec";
+						yylval.val.keycode = -1;
+						yylval.val.sep = NULL;
+						return X_COMMENT;
+					}
+					else
+					{
+						xcdepth--;
+						addlitchar('*');
+						addlitchar('/');
+					}
+
+				}
+
+<xc>{xcinside}	{
+					addlit(yytext, yyleng);
+				}
+
+<xc>{op_chars}	{
+					addlit(yytext, yyleng);
+				}
+
+<xc>\*+			{
+					addlit(yytext, yyleng);
+				}
+
+<xc><<EOF>>		{ 
+					yylval.val.str = litbufdup();
+					yylval.val.modificator = "ecu";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_COMMENT;
+
+				}
+
+{xbstart}		{
+					/* Binary bit type.
+					 * At some point we should simply pass the string
+					 * forward to the parser and label it there.
+					 * In the meantime, place a leading "b" on the string
+					 * to mark it for the input routine as a binary string.
+					 */
+					SET_YYLLOC();
+					BEGIN(xb);
+					startlit();
+					addlitchar('b');
+				}
+<xb>{quotestop}	|
+<xb>{quotefail} {
+					yyless(1);
+					BEGIN(INITIAL);
+					yylval.val.str = litbufdup();
+					yylval.val.modificator = "b";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+<xh>{xhinside}	|
+<xb>{xbinside}	{
+					addlit(yytext, yyleng);
+				}
+<xh>{quotecontinue}	|
+<xb>{quotecontinue}	{
+					/* ignore */
+				}
+<xb><<EOF>>		{ 
+					yylval.val.str = litbufdup();
+					yylval.val.modificator = "bu";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+
+{xhstart}		{
+					/* Hexadecimal bit type.
+					 * At some point we should simply pass the string
+					 * forward to the parser and label it there.
+					 * In the meantime, place a leading "x" on the string
+					 * to mark it for the input routine as a hex string.
+					 */
+					SET_YYLLOC();
+					BEGIN(xh);
+					startlit();
+					addlitchar('x');
+				}
+<xh>{quotestop}	|
+<xh>{quotefail} {
+					yyless(1);
+					BEGIN(INITIAL);
+					yylval.val.str = litbufdup();
+					yylval.val.modificator = "x";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+<xh><<EOF>>		{ 
+					yylval.val.str = litbufdup();
+					yylval.val.modificator = "xu";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+
+{xnstart}		{
+					/* National character.
+					 * We will pass this along as a normal character string,
+					 * but preceded with an internally-generated "NCHAR".
+					 */
+					const ScanKeyword *keyword;
+
+					SET_YYLLOC();
+					yyless(1);				/* eat only 'n' this time */
+					/* nchar had better be a keyword! */
+					keyword = ScanKeywordLookup("nchar" ScanKeywordLookupArgs);
+					Assert(keyword != NULL);
+					yylval.val.str = (char*) keyword->name;
+					yylval.val.keycode = keyword->value;
+					yylval.val.modificator = NULL;
+					yylval.val.sep = NULL;
+					return X_KEYWORD;
+				}
+
+{xqstart}		{
+					SET_YYLLOC();
+					BEGIN(xq);
+					extended_string = false;
+					startlit();
+				}
+{xestart}		{
+					SET_YYLLOC();
+					BEGIN(xe);
+					extended_string = true;
+					startlit();
+				}
+<xq,xe>{quotestop}	|
+<xq,xe>{quotefail} {
+					yyless(1);
+					BEGIN(INITIAL);
+					yylval.val.str = litbufdup();
+					yylval.val.modificator = extended_string ? "es" : "qs";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_SCONST;
+				}
+<xq,xe>{xqdouble} {
+					addlitchar('\'');
+				}
+<xq>{xqinside}  {
+					addlit(yytext, yyleng);
+				}
+<xe>{xeinside}  {
+					addlit(yytext, yyleng);
+				}
+<xe>{xeescape}  {
+					addlitchar(unescape_single_char(yytext[1]));
+				}
+<xe>{xeoctesc}  {
+					unsigned char c = strtoul(yytext+1, NULL, 8);
+
+					addlitchar(c);
+				}
+<xe>{xehexesc}  {
+					unsigned char c = strtoul(yytext+2, NULL, 16);
+
+					addlitchar(c);
+				}
+<xq,xe>{quotecontinue} {
+					/* ignore */
+				}
+<xe>.			{
+					/* This is only needed for \ just before EOF */
+					addlitchar(yytext[0]);
+				}
+<xq,xe><<EOF>>		{ 
+					yylval.val.str = litbufdup();
+					yylval.val.modificator = extended_string ? "esu" : "qsu";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_SCONST;
+				}    
+
+{dolqdelim}		{
+					SET_YYLLOC();
+					dolqstart = pstrdup(yytext);
+					BEGIN(xdolq);
+					startlit();
+				}
+{dolqfailed}	{
+					/* throw back all but the initial "$" */
+					yyless(1);
+					/* and treat it as {other} */
+					yylval.val.str = yytext;
+					yylval.val.modificator = "dolqf";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_OTHERS;
+				}
+<xdolq>{dolqdelim} {
+					if (strcmp(yytext, dolqstart) == 0)
+					{
+						yylval.val.sep = dolqstart;
+						yylval.val.modificator = "dolq";
+						BEGIN(INITIAL);
+						yylval.val.str = litbufdup();
+						yylval.val.keycode = -1;
+						return X_SCONST;
+					}
+					else
+					{
+						/*
+						 * When we fail to match $...$ to dolqstart, transfer
+						 * the $... part to the output, but put back the final
+						 * $ for rescanning.  Consider $delim$...$junk$delim$
+						 */
+						addlit(yytext, yyleng-1);
+						yyless(yyleng-1);
+					}
+				}
+<xdolq>{dolqinside} {
+					addlit(yytext, yyleng);
+				}
+<xdolq>{dolqfailed} {
+					addlit(yytext, yyleng);
+				}
+<xdolq>.		{
+					/* This is only needed for inside the quoted text */
+					addlitchar(yytext[0]);
+				}
+<xdolq><<EOF>>	{ 
+					yylval.val.sep = dolqstart;
+					yylval.val.modificator = "dolqu";
+					yylval.val.str = litbufdup();
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_SCONST;
+				}
+
+{xdstart}		{
+					SET_YYLLOC();
+					BEGIN(xd);
+					startlit();
+				}
+<xd>{xdstop}	{
+					char		   *ident;
+
+					BEGIN(INITIAL);
+					if (literallen == 0)
+						yyerror("zero-length delimited identifier");
+					ident = litbufdup();
+					if (literallen >= NAMEDATALEN)
+						truncate_identifier(ident, literallen, true);
+					yylval.val.modificator = "dq";
+					yylval.val.str = ident;
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_IDENT;
+				}
+<xd>{xddouble}	{
+					addlitchar('"');
+				}
+<xd>{xdinside}	{
+					addlit(yytext, yyleng);
+				}
+<xd><<EOF>>		{ 
+					yylval.val.modificator = "dqu";
+					yylval.val.str = litbufdup();
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_IDENT;
+				}
+{typecast}		{
+					SET_YYLLOC();
+					yylval.val.modificator = "typecast";
+					yylval.val.keycode = X_TYPECAST;
+					yylval.val.sep = NULL;
+					return X_OTHERS;
+				}
+
+{self}			{
+					SET_YYLLOC();
+					yylval.val.str = yytext;
+					yylval.val.modificator = "self";
+					yylval.val.keycode = yytext[0];
+					yylval.val.sep = NULL;
+					return X_OTHERS;
+				}
+
+{operator}		{
+					/*
+					 * Check for embedded slash-star or dash-dash; those
+					 * are comment starts, so operator must stop there.
+					 * Note that slash-star or dash-dash at the first
+					 * character will match a prior rule, not this one.
+					 */
+					int		nchars = yyleng;
+					char   *slashstar = strstr(yytext, "/*");
+					char   *dashdash = strstr(yytext, "--");
+
+					if (slashstar && dashdash)
+					{
+						/* if both appear, take the first one */
+						if (slashstar > dashdash)
+							slashstar = dashdash;
+					}
+					else if (!slashstar)
+						slashstar = dashdash;
+					if (slashstar)
+						nchars = slashstar - yytext;
+
+					/*
+					 * For SQL compatibility, '+' and '-' cannot be the
+					 * last char of a multi-char operator unless the operator
+					 * contains chars that are not in SQL operators.
+					 * The idea is to lex '=-' as two operators, but not
+					 * to forbid operator names like '?-' that could not be
+					 * sequences of SQL operators.
+					 */
+					while (nchars > 1 &&
+						   (yytext[nchars-1] == '+' ||
+							yytext[nchars-1] == '-'))
+					{
+						int		ic;
+
+						for (ic = nchars-2; ic >= 0; ic--)
+						{
+							if (strchr("~!@#^&|`?%", yytext[ic]))
+								break;
+						}
+						if (ic >= 0)
+							break; /* found a char that makes it OK */
+						nchars--; /* else remove the +/-, and check again */
+					}
+
+					SET_YYLLOC();
+
+					if (nchars < yyleng)
+					{
+						/* Strip the unwanted chars from the token */
+						yyless(nchars);
+						/*
+						 * If what we have left is only one char, and it's
+						 * one of the characters matching "self", then
+						 * return it as a character token the same way
+						 * that the "self" rule would have.
+						 */
+						if (nchars == 1 &&
+							strchr(",()[].;:+-*/%^<>=", yytext[0]))
+						{
+							yylval.val.str = yytext;
+							yylval.val.modificator = NULL;
+							yylval.val.keycode = yytext[0];
+							yylval.val.sep = NULL;
+							return X_OTHERS;
+						}
+					}
+
+					/*
+					 * Complain if operator is too long.  Unlike the case
+					 * for identifiers, we make this an error not a notice-
+					 * and-truncate, because the odds are we are looking at
+					 * a syntactic mistake anyway.
+					 */
+					if (nchars >= NAMEDATALEN)
+						yyerror("operator too long");
+
+					/* Convert "!=" operator to "<>" for compatibility */
+					yylval.val.modificator = NULL;
+					if (strcmp(yytext, "!=") == 0)
+						yylval.val.str = pstrdup("<>");
+					else
+						yylval.val.str = pstrdup(yytext);
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_OP;
+				}
+
+{param}			{
+					SET_YYLLOC();
+					yylval.val.modificator = NULL;
+					yylval.val.str = yytext;
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_PARAM;
+				}
+
+{integer}		{
+					long val;
+					char* endptr;
+
+					SET_YYLLOC();
+					errno = 0;
+					val = strtol(yytext, &endptr, 10);
+					if (*endptr != '\0' || errno == ERANGE
+#ifdef HAVE_LONG_INT_64
+						/* if long > 32 bits, check for overflow of int4 */
+						|| val != (long) ((int32) val)
+#endif
+						)
+					{
+						/* integer too large, treat it as a float */
+						yylval.val.str = pstrdup(yytext);
+						yylval.val.modificator = "f";
+						yylval.val.keycode = -1;
+	    					yylval.val.sep = NULL;
+						return X_NCONST;
+					}
+					yylval.val.str = yytext;
+					yylval.val.modificator = "i";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+{decimal}		{
+					SET_YYLLOC();
+					yylval.val.str = pstrdup(yytext);
+					yylval.val.modificator = "f";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+{real}			{
+					SET_YYLLOC();
+					yylval.val.str = pstrdup(yytext);
+					yylval.val.modificator = "f";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+{realfail1}		{
+					/*
+					 * throw back the [Ee], and treat as {decimal}.  Note
+					 * that it is possible the input is actually {integer},
+					 * but since this case will almost certainly lead to a
+					 * syntax error anyway, we don't bother to distinguish.
+					 */
+					yyless(yyleng-1);
+					SET_YYLLOC();
+					yylval.val.str = pstrdup(yytext);
+					yylval.val.modificator = "f";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+{realfail2}		{
+					/* throw back the [Ee][+-], and proceed as above */
+					yyless(yyleng-2);
+					SET_YYLLOC();
+					yylval.val.str = pstrdup(yytext);
+					yylval.val.modificator = "f";
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_NCONST;
+				}
+
+
+{identifier}	{
+					const ScanKeyword *keyword;
+					char		   *ident;
+
+					SET_YYLLOC();
+
+					/* Is it a keyword? */
+					keyword = ScanKeywordLookup(yytext ScanKeywordLookupArgs);
+					if (keyword != NULL)
+					{
+						yylval.val.str = (char*) keyword->name;
+						yylval.val.keycode = keyword->value;
+						yylval.val.modificator = NULL;
+						yylval.val.sep = NULL;
+						return X_KEYWORD;
+					}
+
+					/*
+					 * No.  Convert the identifier to lower case, and truncate
+					 * if necessary.
+					 */
+					ident = downcase_truncate_identifier(yytext, yyleng, true);
+					yylval.val.str = ident;
+					yylval.val.modificator = NULL;
+					yylval.val.keycode = -1;
+					yylval.val.sep = NULL;
+					return X_IDENT;
+				}
+
+{other}			{
+					SET_YYLLOC();
+					yylval.val.str = yytext;
+					yylval.val.modificator = NULL;
+					yylval.val.keycode = yytext[0];
+					yylval.val.sep = NULL;
+					return X_OTHERS;
+				}
+
+<<EOF>>			{
+					SET_YYLLOC();
+					yyterminate();
+				}
+
+%%
+
+/*
+ * lexer_errposition
+ *		Report a lexical-analysis-time cursor position, if possible.
+ *
+ * This is expected to be used within an ereport() call.  The return value
+ * is a dummy (always 0, in fact).
+ *
+ * Note that this can only be used for messages from the lexer itself,
+ * since it depends on scanbuf to still be valid.
+ */
+static int
+lexer_errposition(void)
+{
+	int		pos;
+
+	/* Convert byte offset to character number */
+	pos = _pg_mbstrlen_with_len(scanbuf, yylloc) + 1;
+	/* And pass it to the ereport mechanism */
+	return errposition(pos);
+}
+
+/*
+ * yyerror
+ *		Report a lexer or grammar error.
+ *
+ * The message's cursor position identifies the most recently lexed token.
+ * This is OK for syntax error messages from the Bison parser, because Bison
+ * parsers report error as soon as the first unparsable token is reached.
+ * Beware of using yyerror for other purposes, as the cursor position might
+ * be misleading!
+ */
+void
+yyerror(const char *message)
+{
+	const char *loc = scanbuf + yylloc;
+
+	if (*loc == YY_END_OF_BUFFER_CHAR)
+	{
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 /* translator: %s is typically "syntax error" */
+				 errmsg("%s at end of input", _(message)),
+				 lexer_errposition()));
+	}
+	else
+	{
+		ereport(ERROR,
+				(errcode(ERRCODE_SYNTAX_ERROR),
+				 /* translator: first %s is typically "syntax error" */
+				 errmsg("%s at or near \"%s\"", _(message), loc),
+				 lexer_errposition()));
+	}
+}
+
+
+/*
+ * Called before any actual parsing is done
+ */
+void
+orafce_sql_scanner_init(const char *str)
+{
+	Size	slen = strlen(str);
+
+	/*
+	 * Might be left over after ereport()
+	 */
+	if (YY_CURRENT_BUFFER)
+		yy_delete_buffer(YY_CURRENT_BUFFER);
+
+	/*
+	 * Make a scan buffer with special termination needed by flex.
+	 */
+	scanbuflen = slen;
+	scanbuf = palloc(slen + 2);
+	memcpy(scanbuf, str, slen);
+	scanbuf[slen] = scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
+	scanbufhandle = yy_scan_buffer(scanbuf, slen + 2);
+
+	/* initialize literal buffer to a reasonable but expansible size */
+	literalalloc = 128;
+	literalbuf = (char *) palloc(literalalloc);
+	startlit();
+
+	BEGIN(INITIAL);
+}
+
+
+/*
+ * Called after parsing is done to clean up after fdate_scanner_init()
+ */
+void
+orafce_sql_scanner_finish(void)
+{
+	yy_delete_buffer(scanbufhandle);
+	pfree(scanbuf);
+}
+
+static void
+addlit(char *ytext, int yleng)
+{
+	/* enlarge buffer if needed */
+	if ((literallen+yleng) >= literalalloc)
+	{
+		do {
+			literalalloc *= 2;
+		} while ((literallen+yleng) >= literalalloc);
+		literalbuf = (char *) repalloc(literalbuf, literalalloc);
+	}
+	/* append new data, add trailing null */
+	memcpy(literalbuf+literallen, ytext, yleng);
+	literallen += yleng;
+	literalbuf[literallen] = '\0';
+}
+
+
+static void
+addlitchar(unsigned char ychar)
+{
+	/* enlarge buffer if needed */
+	if ((literallen+1) >= literalalloc)
+	{
+		literalalloc *= 2;
+		literalbuf = (char *) repalloc(literalbuf, literalalloc);
+	}
+	/* append new data, add trailing null */
+	literalbuf[literallen] = ychar;
+	literallen += 1;
+	literalbuf[literallen] = '\0';
+}
+
+
+/*
+ * One might be tempted to write pstrdup(literalbuf) instead of this,
+ * but for long literals this is much faster because the length is
+ * already known.
+ */
+static char *
+litbufdup(void)
+{
+	char *new;
+
+	new = palloc(literallen + 1);
+	memcpy(new, literalbuf, literallen+1);
+	return new;
+}
+
+
+static unsigned char
+unescape_single_char(unsigned char c)
+{
+	switch (c)
+	{
+		case 'b':
+			return '\b';
+		case 'f':
+			return '\f';
+		case 'n':
+			return '\n';
+		case 'r':
+			return '\r';
+		case 't':
+			return '\t';
+		default:
+			return c;
+	}
+}
+
+

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/contrib/orafce/tdhfunc.c
----------------------------------------------------------------------
diff --git a/contrib/orafce/tdhfunc.c b/contrib/orafce/tdhfunc.c
new file mode 100644
index 0000000..d03d81c
--- /dev/null
+++ b/contrib/orafce/tdhfunc.c
@@ -0,0 +1,81 @@
+/* 
+ * Hash three letter week days to some number. The TDH hash table makes this
+ * into a perfect hash for us. See generate_hash.c.
+ */
+static int
+tdhfunc(const char *s)
+{
+	int i = 0;
+	int ret = 0;
+
+	while (i < 3)
+	{
+		int out = 0;
+
+		switch (s[i])
+		{
+			case 'S':
+			case 's':
+				out += (int)'s';
+				break;
+			case 'U':
+			case 'u':
+				out += (int)'u';
+				break;
+			case 'N':
+			case 'n':
+				out += (int)'n';
+				break;
+			case 'M':
+			case 'm':
+				out += (int)'m';
+				break;
+			case 'O':
+			case 'o':
+				out += (int)'o';
+				break;
+			case 'T':
+			case 't':
+				out += (int)'t';
+				break;
+			case 'E':
+			case 'e':
+				out += (int)'e';
+				break;
+			case 'W':
+			case 'w':
+				out += (int)'w';
+				break;
+			case 'D':
+			case 'd':
+				out += (int)'d';
+				break;
+			case 'H':
+			case 'h':
+				out += (int)'h';
+				break;
+			case 'F':
+			case 'f':
+				out += (int)'f';
+				break;
+			case 'R':
+			case 'r':
+				out += (int)'r';
+				break;
+			case 'I':
+			case 'i':
+				out += (int)'i';
+				break;
+			case 'A':
+			case 'a':
+				out += (int)'a';
+				break;
+			default:
+				return -1;
+				break;
+		}
+		ret += out;
+		i++;
+	}
+	return ret;
+}

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/contrib/orafce/uninstall_orafunc.full.sql
----------------------------------------------------------------------
diff --git a/contrib/orafce/uninstall_orafunc.full.sql b/contrib/orafce/uninstall_orafunc.full.sql
new file mode 100644
index 0000000..d894978
--- /dev/null
+++ b/contrib/orafce/uninstall_orafunc.full.sql
@@ -0,0 +1,152 @@
+DROP FUNCTION pg_catalog.trunc(value date, fmt text);
+DROP FUNCTION pg_catalog.round(value date, fmt text);
+DROP FUNCTION pg_catalog.next_day(value date, weekday text);
+DROP FUNCTION pg_catalog.last_day(value date);
+DROP FUNCTION pg_catalog.months_between(date1 date, date2 date);
+DROP FUNCTION pg_catalog.add_months(day date, value int);
+DROP FUNCTION pg_catalog.trunc(value timestamp with time zone, fmt text);
+DROP FUNCTION pg_catalog.round(value timestamp with time zone, fmt text);
+DROP FUNCTION pg_catalog.round(value timestamp with time zone);
+DROP FUNCTION pg_catalog.round(value date);
+DROP FUNCTION pg_catalog.trunc(value timestamp with time zone);
+DROP FUNCTION pg_catalog.trunc(value date);
+DROP FUNCTION pg_catalog.nlssort(text, text);
+DROP FUNCTION pg_catalog.nlssort(text);
+DROP FUNCTION pg_catalog.set_nls_sort(text);
+DROP FUNCTION pg_catalog.instr(str text, patt text, start int, nth int);
+DROP FUNCTION pg_catalog.instr(str text, patt text, start int);
+DROP FUNCTION pg_catalog.instr(str text, patt text);
+DROP FUNCTION pg_catalog.to_char(num int);
+DROP FUNCTION pg_catalog.to_char(num bigint);
+DROP FUNCTION pg_catalog.to_char(num real);
+DROP FUNCTION pg_catalog.to_char(num double precision);
+DROP FUNCTION pg_catalog.to_char(num numeric);
+DROP FUNCTION pg_catalog.to_number(str text);
+DROP FUNCTION pg_catalog.to_date(str text);
+DROP FUNCTION pg_catalog.reverse(str text);
+DROP FUNCTION pg_catalog.lnnvl(bool);
+
+DROP AGGREGATE pg_catalog.listagg(text);
+DROP AGGREGATE pg_catalog.listagg(text, text);
+
+DROP FUNCTION pg_catalog.listagg1_transfn(internal, text);
+DROP FUNCTION pg_catalog.listagg2_transfn(internal, text, text);
+DROP FUNCTION pg_catalog.listagg_finalfn(internal);
+
+DROP AGGREGATE pg_catalog.median(real);
+DROP AGGREGATE pg_catalog.median(double precision);
+
+DROP FUNCTION pg_catalog.median4_transfn(internal, real);
+DROP FUNCTION pg_catalog.median8_transfn(internal, double precision);
+DROP FUNCTION pg_catalog.median4_finalfn(internal);
+DROP FUNCTION pg_catalog.median8_finalfn(internal);
+
+DROP FUNCTION dump("any");
+DROP FUNCTION dump(text);
+DROP FUNCTION dump("any", integer);
+DROP FUNCTION dump(text, integer);
+
+DROP VIEW public.dual CASCADE;
+
+DROP FUNCTION nvl(anyelement, anyelement);
+DROP FUNCTION nvl2(anyelement, anyelement, anyelement);
+
+DROP FUNCTION concat(text, text);
+DROP FUNCTION concat(text, anyarray);
+DROP FUNCTION concat(anyarray, text);
+DROP FUNCTION concat(anyarray, anyarray);
+DROP FUNCTION concat(text, anynonarray);
+DROP FUNCTION concat(anynonarray, text);
+DROP FUNCTION concat(anynonarray, anynonarray);
+DROP FUNCTION concat(text, anyelement);
+DROP FUNCTION concat(anyelement, text);
+DROP FUNCTION concat(anyelement, anyelement);
+
+DROP FUNCTION bitand(bigint, bigint);
+DROP FUNCTION sinh(float8);
+DROP FUNCTION cosh(float8);
+DROP FUNCTION tanh(float8);
+DROP FUNCTION nanvl(float4, float4);
+DROP FUNCTION nanvl(float8, float8);
+DROP FUNCTION nanvl(numeric, numeric);
+DROP FUNCTION to_multi_byte(text);
+
+DROP FUNCTION decode(anyelement, anyelement, text);
+DROP FUNCTION decode(anyelement, anyelement, text, text);
+DROP FUNCTION decode(anyelement, anyelement, text, anyelement, text);
+DROP FUNCTION decode(anyelement, anyelement, text, anyelement, text, text);
+DROP FUNCTION decode(anyelement, anyelement, text, anyelement, text, anyelement, text);
+DROP FUNCTION decode(anyelement, anyelement, text, anyelement, text, anyelement, text, text);
+DROP FUNCTION decode(anyelement, anyelement, bpchar);
+DROP FUNCTION decode(anyelement, anyelement, bpchar, bpchar);
+DROP FUNCTION decode(anyelement, anyelement, bpchar, anyelement, bpchar);
+DROP FUNCTION decode(anyelement, anyelement, bpchar, anyelement, bpchar, bpchar);
+DROP FUNCTION decode(anyelement, anyelement, bpchar, anyelement, bpchar, anyelement, bpchar);
+DROP FUNCTION decode(anyelement, anyelement, bpchar, anyelement, bpchar, anyelement, bpchar, bpchar);
+DROP FUNCTION decode(anyelement, anyelement, integer);
+DROP FUNCTION decode(anyelement, anyelement, integer, integer);
+DROP FUNCTION decode(anyelement, anyelement, integer, anyelement, integer);
+DROP FUNCTION decode(anyelement, anyelement, integer, anyelement, integer, integer);
+DROP FUNCTION decode(anyelement, anyelement, integer, anyelement, integer, anyelement, integer);
+DROP FUNCTION decode(anyelement, anyelement, integer, anyelement, integer, anyelement, integer, integer);
+DROP FUNCTION decode(anyelement, anyelement, bigint);
+DROP FUNCTION decode(anyelement, anyelement, bigint, bigint);
+DROP FUNCTION decode(anyelement, anyelement, bigint, anyelement, bigint);
+DROP FUNCTION decode(anyelement, anyelement, bigint, anyelement, bigint, bigint);
+DROP FUNCTION decode(anyelement, anyelement, bigint, anyelement, bigint, anyelement, bigint);
+DROP FUNCTION decode(anyelement, anyelement, bigint, anyelement, bigint, anyelement, bigint, bigint);
+DROP FUNCTION decode(anyelement, anyelement, numeric);
+DROP FUNCTION decode(anyelement, anyelement, numeric, numeric);
+DROP FUNCTION decode(anyelement, anyelement, numeric, anyelement, numeric);
+DROP FUNCTION decode(anyelement, anyelement, numeric, anyelement, numeric, numeric);
+DROP FUNCTION decode(anyelement, anyelement, numeric, anyelement, numeric, anyelement, numeric);
+DROP FUNCTION decode(anyelement, anyelement, numeric, anyelement, numeric, anyelement, numeric, numeric);
+DROP FUNCTION decode(anyelement, anyelement, date);
+DROP FUNCTION decode(anyelement, anyelement, date, date);
+DROP FUNCTION decode(anyelement, anyelement, date, anyelement, date);
+DROP FUNCTION decode(anyelement, anyelement, date, anyelement, date, date);
+DROP FUNCTION decode(anyelement, anyelement, date, anyelement, date, anyelement, date);
+DROP FUNCTION decode(anyelement, anyelement, date, anyelement, date, anyelement, date, date);
+DROP FUNCTION decode(anyelement, anyelement, time);
+DROP FUNCTION decode(anyelement, anyelement, time, time);
+DROP FUNCTION decode(anyelement, anyelement, time, anyelement, time);
+DROP FUNCTION decode(anyelement, anyelement, time, anyelement, time, time);
+DROP FUNCTION decode(anyelement, anyelement, time, anyelement, time, anyelement, time);
+DROP FUNCTION decode(anyelement, anyelement, time, anyelement, time, anyelement, time, time);
+DROP FUNCTION decode(anyelement, anyelement, timestamp);
+DROP FUNCTION decode(anyelement, anyelement, timestamp, timestamp);
+DROP FUNCTION decode(anyelement, anyelement, timestamp, anyelement, timestamp);
+DROP FUNCTION decode(anyelement, anyelement, timestamp, anyelement, timestamp, timestamp);
+DROP FUNCTION decode(anyelement, anyelement, timestamp, anyelement, timestamp, anyelement, timestamp);
+DROP FUNCTION decode(anyelement, anyelement, timestamp, anyelement, timestamp, anyelement, timestamp, timestamp);
+DROP FUNCTION decode(anyelement, anyelement, timestamptz);
+DROP FUNCTION decode(anyelement, anyelement, timestamptz, timestamptz);
+DROP FUNCTION decode(anyelement, anyelement, timestamptz, anyelement, timestamptz);
+DROP FUNCTION decode(anyelement, anyelement, timestamptz, anyelement, timestamptz, timestamptz);
+DROP FUNCTION decode(anyelement, anyelement, timestamptz, anyelement, timestamptz, anyelement, timestamptz);
+DROP FUNCTION decode(anyelement, anyelement, timestamptz, anyelement, timestamptz, anyelement, timestamptz, timestamptz);
+
+DROP FUNCTION dbms_random.initialize();
+DROP FUNCTION dbms_random.normal();
+DROP FUNCTION dbms_random.random();
+DROP FUNCTION dbms_random.seed(integer);
+DROP FUNCTION dbms_random.seed(text);
+DROP FUNCTION dbms_random.string(opt text, len int);
+DROP FUNCTION dbms_random.terminate();
+DROP FUNCTION dbms_random.value(low double precision, high double precision);
+DROP FUNCTION dbms_random.value();
+
+DROP SCHEMA dbms_alert CASCADE;
+DROP SCHEMA dbms_assert CASCADE;
+DROP SCHEMA dbms_output CASCADE;
+DROP SCHEMA dbms_pipe CASCADE;
+DROP SCHEMA dbms_random CASCADE;
+DROP SCHEMA dbms_utility CASCADE;
+DROP SCHEMA oracle CASCADE;
+DROP SCHEMA plunit CASCADE;
+DROP SCHEMA plvchr CASCADE;
+DROP SCHEMA plvdate CASCADE;
+DROP SCHEMA plvlex CASCADE;
+DROP SCHEMA plvstr CASCADE;
+DROP SCHEMA plvsubst CASCADE;
+DROP SCHEMA utl_file CASCADE;

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/contrib/orafce/uninstall_orafunc.sql
----------------------------------------------------------------------
diff --git a/contrib/orafce/uninstall_orafunc.sql b/contrib/orafce/uninstall_orafunc.sql
new file mode 100644
index 0000000..142f73b
--- /dev/null
+++ b/contrib/orafce/uninstall_orafunc.sql
@@ -0,0 +1,61 @@
+-- Adjust the following if this is not the schema you installed into
+\set ORA_SCHEMA oracompat
+set search_path = :ORA_SCHEMA, pg_catalog;
+
+BEGIN;
+DROP FUNCTION IF EXISTS nvl(anyelement, anyelement);
+
+DROP FUNCTION IF EXISTS add_months(day date, value int);
+
+DROP FUNCTION IF EXISTS last_day(value date);
+
+DROP FUNCTION IF EXISTS next_day(value date, weekday text);
+DROP FUNCTION IF EXISTS next_day(value date, weekday integer);
+
+DROP FUNCTION IF EXISTS months_between(date1 date, date2 date);
+
+DROP FUNCTION IF EXISTS trunc(value date, fmt text);
+DROP FUNCTION IF EXISTS trunc(value timestamp with time zone, fmt text);
+DROP FUNCTION IF EXISTS trunc(value timestamp with time zone);
+DROP FUNCTION IF EXISTS trunc(value date);
+
+DROP FUNCTION IF EXISTS round(value timestamp with time zone, fmt text);
+DROP FUNCTION IF EXISTS round(value timestamp with time zone);
+DROP FUNCTION IF EXISTS round(value date);
+DROP FUNCTION IF EXISTS round(value date, fmt text);
+
+DROP FUNCTION IF EXISTS instr(str text, patt text, start int, nth int);
+DROP FUNCTION IF EXISTS instr(str text, patt text, start int);
+DROP FUNCTION IF EXISTS instr(str text, patt text);
+
+DROP FUNCTION IF EXISTS reverse(text, int, int);
+DROP FUNCTION IF EXISTS reverse(text, int);
+DROP FUNCTION IF EXISTS reverse(text);
+
+DROP FUNCTION IF EXISTS concat(text, text);
+DROP FUNCTION IF EXISTS concat(anyarray, text);
+DROP FUNCTION IF EXISTS concat(text, anyarray);
+DROP FUNCTION IF EXISTS concat(anyarray, anyarray);
+
+DROP FUNCTION IF EXISTS nanvl(float4, float4);
+DROP FUNCTION IF EXISTS nanvl(float8, float8);
+DROP FUNCTION IF EXISTS nanvl(numeric, numeric);
+
+DROP FUNCTION IF EXISTS bitand(bigint, bigint);
+
+DROP FUNCTION IF EXISTS listagg1_transfn(text, text);
+DROP FUNCTION IF EXISTS listagg2_transfn(text, text, text);
+
+DROP FUNCTION IF EXISTS nvl2(anyelement, anyelement, anyelement);
+
+DROP FUNCTION IF EXISTS lnnvl(bool);
+
+DROP FUNCTION IF EXISTS dump("any");
+DROP FUNCTION IF EXISTS dump("any", integer);
+
+DROP FUNCTION IF EXISTS nlssort(text, text);
+
+DROP FUNCTION IF EXISTS substr(text, int, int);
+DROP FUNCTION IF EXISTS substr(text, int);
+
+COMMIT;

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/contrib/orafce/utility.c
----------------------------------------------------------------------
diff --git a/contrib/orafce/utility.c b/contrib/orafce/utility.c
new file mode 100644
index 0000000..3b5b7be
--- /dev/null
+++ b/contrib/orafce/utility.c
@@ -0,0 +1,211 @@
+/*
+  This code implements one part of functonality of
+  free available library PL/Vision. Please look www.quest.com
+
+  Original author: Steven Feuerstein, 1996 - 2002
+  PostgreSQL implementation author: Pavel Stehule, 2006
+
+  This module is under BSD Licence
+
+  History:
+    1.0. first public version 22. September 2006
+
+*/
+
+#include "postgres.h"
+#include "utils/builtins.h"
+#include "utils/numeric.h"
+#include "string.h"
+#include "stdlib.h"
+#include "utils/pg_locale.h"
+#include "mb/pg_wchar.h"
+#include "lib/stringinfo.h"
+
+#include "catalog/pg_type.h"
+#include "libpq/pqformat.h"
+#include "utils/array.h"
+#include "utils/memutils.h"
+#include "utils/lsyscache.h"
+#include "access/tupmacs.h"
+#include "orafunc.h"
+#include "builtins.h"
+
+#include "utils/elog.h"
+
+PG_FUNCTION_INFO_V1(dbms_utility_format_call_stack0);
+PG_FUNCTION_INFO_V1(dbms_utility_format_call_stack1);
+
+static char*
+dbms_utility_format_call_stack(char mode)
+{
+	MemoryContext oldcontext = CurrentMemoryContext;
+	ErrorData *edata;
+	ErrorContextCallback *econtext;
+	StringInfo   sinfo;
+
+#ifdef GP_VERSION_NUM
+	errstart(ERROR, __FILE__, __LINE__, PG_FUNCNAME_MACRO, TEXTDOMAIN);
+#else
+#if PG_VERSION_NUM >= 80400
+	errstart(ERROR, __FILE__, __LINE__, PG_FUNCNAME_MACRO, TEXTDOMAIN);
+#else
+	errstart(ERROR, __FILE__, __LINE__, PG_FUNCNAME_MACRO);
+#endif
+#endif
+
+	MemoryContextSwitchTo(oldcontext);
+
+	for (econtext = error_context_stack;
+		 econtext != NULL;
+		 econtext = econtext->previous)
+		(*econtext->callback) (econtext->arg);
+
+	edata = CopyErrorData();
+
+	FlushErrorState();
+
+	/* Now I wont to parse edata->context to more traditional format */
+	/* I am not sure about order */
+
+	sinfo = makeStringInfo();
+
+	switch (mode)
+	{
+		case 'o':
+			appendStringInfoString(sinfo, "----- PL/pgSQL Call Stack -----\n");
+			appendStringInfoString(sinfo, "  object     line  object\n");
+			appendStringInfoString(sinfo, "  handle   number  name\n");
+			break;
+	}
+
+	if (edata->context)
+	{
+		char *start = edata->context;
+		while (*start)
+		{
+			char *oname =  "anonymous object";
+			char *line  = "";
+			char *eol = strchr(start, '\n');
+			Oid fnoid = InvalidOid;
+
+			/* first, solve multilines */
+			if (eol)
+				*eol = '\0';
+
+			/* first know format */
+			if (strncmp(start, "PL/pgSQL function ",18) == 0)
+			{
+				char *p1, *p2;
+
+				if ((p1 = strstr(start, "function \"")))
+				{
+					p1 += strlen("function \"");
+
+					if ((p2 = strchr(p1, '"')))
+					{
+						*p2++ = '\0';
+						oname = p1;
+						start = p2;
+					}
+				}
+				else if ((p1 = strstr(start, "function ")))
+				{
+					p1 += strlen("function ");
+
+					if ((p2 = strchr(p1, ')')))
+					{
+						char c = *++p2;
+						*p2 = '\0';
+
+						oname = pstrdup(p1);
+						fnoid = DatumGetObjectId(DirectFunctionCall1(regprocedurein,
+							CStringGetDatum(oname)));
+						*p2 = c;
+						start = p2;
+					}
+				}
+
+
+				if ((p1 = strstr(start, "line ")))
+				{
+					int p2i;
+					char c;
+
+					p1 += strlen("line ");
+					p2i = strspn(p1, "0123456789");
+
+					/* safe separator */
+					c = p1[p2i];
+
+					p1[p2i] = '\0';
+					line = pstrdup(p1);
+					p1[p2i] = c;
+
+					start = p1 + p2i;
+				}
+			}
+
+			switch (mode)
+			{
+				case 'o':
+					appendStringInfo(sinfo, "%8x    %5s  function %s", (int)fnoid, line, oname);
+					break;
+
+				case 'p':
+					appendStringInfo(sinfo, "%8d    %5s  function %s", (int)fnoid, line, oname);
+					break;
+
+				case 's':
+					appendStringInfo(sinfo, "%d,%s,%s", (int)fnoid, line, oname);
+					break;
+			}
+
+			if (eol)
+			{
+				start = eol + 1;
+				appendStringInfoChar(sinfo, '\n');
+			}
+			else
+				break;
+		}
+
+	}
+
+	return sinfo->data;
+}
+
+
+Datum
+dbms_utility_format_call_stack0(PG_FUNCTION_ARGS)
+{
+	PG_RETURN_TEXT_P(cstring_to_text(dbms_utility_format_call_stack('o')));
+};
+
+Datum
+dbms_utility_format_call_stack1(PG_FUNCTION_ARGS)
+{
+	text *arg = PG_GETARG_TEXT_P(0);
+	char mode;
+
+	if ((1 != VARSIZE(arg) - VARHDRSZ))
+		ereport(ERROR,
+			(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+			 errmsg("invalid parameter"),
+			 errdetail("Allowed only chars [ops].")));
+
+	mode = *VARDATA(arg);
+	switch (mode)
+	{
+		case 'o':
+		case 'p':
+		case 's':
+			break;
+		default:
+			ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid parameter"),
+				 errdetail("Allowed only chars [ops].")));
+	}
+
+	PG_RETURN_TEXT_P(cstring_to_text(dbms_utility_format_call_stack(mode)));
+}

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/src/bin/Makefile
----------------------------------------------------------------------
diff --git a/src/bin/Makefile b/src/bin/Makefile
index 54159a7..73425b9 100644
--- a/src/bin/Makefile
+++ b/src/bin/Makefile
@@ -13,7 +13,7 @@ subdir = src/bin
 top_builddir = ../..
 include $(top_builddir)/src/Makefile.global
 
-DIRS = initdb ipcclean pg_ctl pg_dump \
+DIRS = initdb ipcclean pg_ctl pg_dump pgbench \
 	psql scripts pg_config pg_controldata pg_resetxlog \
 	gpfilesystem/hdfs gpupgrade \
 	gpfusion gp_workfile_mgr gpcheckhdfs gpfdist

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/src/bin/pgbench/.gitignore
----------------------------------------------------------------------
diff --git a/src/bin/pgbench/.gitignore b/src/bin/pgbench/.gitignore
new file mode 100644
index 0000000..929a08f
--- /dev/null
+++ b/src/bin/pgbench/.gitignore
@@ -0,0 +1 @@
+pgbench

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/src/bin/pgbench/.p4ignore
----------------------------------------------------------------------
diff --git a/src/bin/pgbench/.p4ignore b/src/bin/pgbench/.p4ignore
new file mode 100644
index 0000000..929a08f
--- /dev/null
+++ b/src/bin/pgbench/.p4ignore
@@ -0,0 +1 @@
+pgbench

http://git-wip-us.apache.org/repos/asf/incubator-hawq/blob/e74af545/src/bin/pgbench/Makefile
----------------------------------------------------------------------
diff --git a/src/bin/pgbench/Makefile b/src/bin/pgbench/Makefile
new file mode 100644
index 0000000..8b33b3c
--- /dev/null
+++ b/src/bin/pgbench/Makefile
@@ -0,0 +1,23 @@
+# $PostgreSQL: pgsql/contrib/pgbench/Makefile,v 1.16 2007/11/10 23:59:51 momjian Exp $
+
+PROGRAM = pgbench
+OBJS	= pgbench.o
+
+PG_CPPFLAGS = -I$(libpq_srcdir)
+PG_LIBS = $(libpq_pgport)
+
+ifdef USE_PGXS
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+else
+subdir = src/bin/pgbench
+top_builddir = ../../..
+top_srcdir = $(top_builddir)/../cdb-pg
+include $(top_builddir)/src/Makefile.global
+include $(top_srcdir)/contrib/contrib-global.mk
+endif
+ifneq ($(PORTNAME), win32)
+override CFLAGS += $(PTHREAD_CFLAGS) -pthread
+endif
+


Mime
View raw message