- Made some chars const as proposed by Stefan Huehner <stefan@huehner.org>.
- Synced parser and keyword lists.
- Copied two token parsing from backend parser to ecpg parser.
- Also added a test case for this.
- Fixed a nasty buffer underrun that only occured when using Informix
no_indicator NULL setting on timestamps and intervals.
-Fr 18. Aug 17:32:54 CEST 2006
+Fr Aug 18 17:32:54 CEST 2006
- Changed lexer to no longer use the default rule.
- Synced parser and keyword list.
- Fixed parsing of CONNECT statement so it accepts a C string again.
- Fixed a buffer overrun that was masked on Linux systems.
-Sa 19. Aug 14:11:32 CEST 2006
+Sa Aug 19 14:11:32 CEST 2006
- More SoC stuff.
-Tu 22. Aug 13:54:08 CEST 2006
+Tu Aug 22 13:54:08 CEST 2006
- Descriptor values were quoted twice.
-We 23. Aug 09:32:14 CEST 2006
+We Aug 23 09:32:14 CEST 2006
- Replaced double-quote-fix with a hopefully better version.
- Use initializer string length as size for character strings.
- Added ecpg_config.h file that is created via configure.
-Th 24. Aug 11:53:29 CEST 2006
+Th Aug 24 11:53:29 CEST 2006
- Fixed of by one variable size.
- Synced parser.
-Su 27. Aug 17:54:36 CEST 2006
+Su Aug 27 17:54:36 CEST 2006
- Enabled single-quoted connection targets.
- Fixed a memory leak/segfault in unsuccessful connection.
-Tu 29. Aug 14:21:31 CEST 2006
+Tu Aug 29 14:21:31 CEST 2006
- Fixed parser and library to allow empty database names.
- Streamlined connection name parsing.
-Su 3. Sep 14:21:29 CEST 2006
+Su Sep 3 14:21:29 CEST 2006
- Synced parser.
- Added another regression test and fixed tcp test.
-Tu 5. Sep 11:49:08 CEST 2006
+Tu Sep 5 11:49:08 CEST 2006
- Synced parser.
- Fixed ecpglib trying to read one character after end-of-string.
- Added some interval checks to regression suite.
- Started to cleanup complex tests.
-Th 14. Sep 09:47:03 CEST 2006
+Th Sep 14 09:47:03 CEST 2006
- Completely removed complex tests.
- Added missing constuctor/destructor for interval and date.
-We 8. Nov 10:53:42 CET 2006
+We Nov 8 10:53:42 CET 2006
- Applied patch by Peter Harris to free auto_mem struct in ECPGconnect.
- Set ecpg library version to 5.2.
- Set ecpg version to 4.2.1.
-Th 25. Jan 17:17:01 CET 2007
+Th Jan 25 17:17:01 CET 2007
- Removed compiler warning due to unneeded unsigned declaration.
- Removed regression test that triggers those libc precision bugs on some archs.
-Fr 2. Feb 09:53:48 CET 2007
+Fr Feb 2 09:53:48 CET 2007
- Cleaned up va_list handling. Hopefully this now works on all archs.
- Applied Magnus Hagander's patch to take away some compiler warnings.
-Su 11. Feb 16:09:31 CET 2007
+Su Feb 11 16:09:31 CET 2007
- Fixed multibyte handling as reported by <harada.toshi@oss.ntt.co.jp>.
- Set ecpg library version to 5.3.
+
+Th Mar 15 08:27:53 CET 2007
+
+ - Made some chars const as proposed by Stefan Huehner <stefan@huehner.org>.
+ - Synced parser and keyword lists.
+ - Copied two token parsing from backend parser to ecpg parser.
+ - Also added a test case for this.
- Set ecpg version to 4.3.1.
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/connect.c,v 1.39 2007/01/12 10:00:12 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/connect.c,v 1.40 2007/03/17 19:25:22 meskes Exp $ */
#define POSTGRES_ECPG_INTERNAL
#include "postgres_fe.h"
if (PQstatus(this->connection) == CONNECTION_BAD)
{
const char *errmsg = PQerrorMessage(this->connection);
- char *db = realname ? realname : "<DEFAULT>";
+ const char *db = realname ? realname : "<DEFAULT>";
ECPGlog("connect: could not open database %s on %s port %s %s%s%s%s in line %d\n\t%s\n",
db,
*/
case 'g':
{
- char *fmt = "%g"; /* Keep compiler quiet about
+ const char *fmt = "%g"; /* Keep compiler quiet about
* 2-digit year */
tm->tm_mon -= 1;
*/
case 'x':
{
- char *fmt = "%x"; /* Keep compiler quiet about
+ const char *fmt = "%x"; /* Keep compiler quiet about
* 2-digit year */
tm->tm_mon -= 1;
#
# Copyright (c) 1998-2007, PostgreSQL Global Development Group
#
-# $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/Makefile,v 1.123 2007/01/05 22:20:00 momjian Exp $
+# $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/Makefile,v 1.124 2007/03/17 19:25:23 meskes Exp $
#
#-------------------------------------------------------------------------
endif
override CFLAGS += $(PTHREAD_CFLAGS)
-OBJS= preproc.o type.o ecpg.o ecpg_keywords.o output.o \
+OBJS= preproc.o type.o ecpg.o ecpg_keywords.o output.o parser.o \
keywords.o c_keywords.o ../ecpglib/typename.o descriptor.o variable.o \
$(WIN32RES)
c_keywords.o ecpg_keywords.o keywords.o preproc.o: preproc.h
+parser.c: $(top_srcdir)/src/backend/parser/parser.c
+ rm -f $@ && $(LN_S) $< .
distprep: $(srcdir)/preproc.c $(srcdir)/preproc.h $(srcdir)/pgc.c
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/ecpg.c,v 1.97 2007/02/01 19:10:29 momjian Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/ecpg.c,v 1.98 2007/03/17 19:25:23 meskes Exp $ */
/* New main for ecpg, the PostgreSQL embedded SQL precompiler. */
/* (C) Michael Meskes <meskes@postgresql.org> Feb 5th, 1998 */
output_line_number();
/* and parse the source */
- yyparse();
+ base_yyparse();
/* check if all cursors were indeed opened */
for (ptr = cur; ptr != NULL;)
* lexical token lookup for reserved words in postgres embedded SQL
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/ecpg_keywords.c,v 1.32 2005/12/02 15:03:57 meskes Exp $
+ * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/ecpg_keywords.c,v 1.33 2007/03/17 19:25:23 meskes Exp $
*
*-------------------------------------------------------------------------
*/
{"key_member", SQL_KEY_MEMBER},
{"length", SQL_LENGTH},
{"long", SQL_LONG},
- {"name", SQL_NAME},
{"nullable", SQL_NULLABLE},
{"octet_length", SQL_OCTET_LENGTH},
{"open", SQL_OPEN},
{"stop", SQL_STOP},
{"struct", SQL_STRUCT},
{"unsigned", SQL_UNSIGNED},
- {"value", SQL_VALUE},
{"var", SQL_VAR},
{"whenever", SQL_WHENEVER},
};
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/extern.h,v 1.64 2007/01/11 15:47:33 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/extern.h,v 1.65 2007/03/17 19:25:23 meskes Exp $ */
#ifndef _ECPG_PREPROC_EXTERN_H
#define _ECPG_PREPROC_EXTERN_H
extern void output_statement(char *, int, char *);
extern void output_simple_statement(char *);
extern char *hashline_number(void);
-extern int yyparse(void);
-extern int yylex(void);
-extern void yyerror(char *);
+extern int base_yyparse(void);
+extern int base_yylex(void);
+extern void base_yyerror(const char *);
extern void *mm_alloc(size_t), *mm_realloc(void *, size_t);
extern char *mm_strdup(const char *);
extern void mmerror(int, enum errortype, char *,...);
extern void remove_variables(int);
extern struct variable *new_variable(const char *, struct ECPGtype *, int);
extern ScanKeyword *ScanKeywordLookup(char *text);
+extern void scanner_init(const char *);
+extern void parser_init(void);
+extern void scanner_finish(void);
+int filtered_base_yylex(void);
/* return codes */
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/keywords.c,v 1.77 2007/01/05 22:20:00 momjian Exp $
+ * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/keywords.c,v 1.78 2007/03/17 19:25:23 meskes Exp $
*
*-------------------------------------------------------------------------
*/
{"cache", CACHE},
{"called", CALLED},
{"cascade", CASCADE},
+ {"cascaded", CASCADED},
{"case", CASE},
{"cast", CAST},
{"chain", CHAIN},
{"commit", COMMIT},
{"committed", COMMITTED},
{"concurrently", CONCURRENTLY},
+ {"concurrently", CONCURRENTLY},
{"connection", CONNECTION},
{"constraint", CONSTRAINT},
{"constraints", CONSTRAINTS},
+ {"content", CONTENT_P},
{"conversion", CONVERSION_P},
{"convert", CONVERT},
{"copy", COPY},
+ {"cost", COST},
{"create", CREATE},
{"createdb", CREATEDB},
{"createrole", CREATEROLE},
{"disable", DISABLE_P},
{"distinct", DISTINCT},
{"do", DO},
+ {"document", DOCUMENT_P},
{"domain", DOMAIN_P},
{"double", DOUBLE_P},
{"drop", DROP},
{"external", EXTERNAL},
{"extract", EXTRACT},
{"false", FALSE_P},
+ {"family", FAMILY},
{"fetch", FETCH},
{"first", FIRST_P},
{"float", FLOAT_P},
{"mode", MODE},
{"month", MONTH_P},
{"move", MOVE},
+ {"name", NAME_P},
{"names", NAMES},
{"national", NATIONAL},
{"natural", NATURAL},
{"nowait", NOWAIT},
{"null", NULL_P},
{"nullif", NULLIF},
+ {"nulls", NULLS_P},
{"numeric", NUMERIC},
{"object", OBJECT_P},
{"of", OF},
{"smallint", SMALLINT},
{"some", SOME},
{"stable", STABLE},
+ {"standalone", STANDALONE_P},
{"start", START},
{"statement", STATEMENT},
{"statistics", STATISTICS},
{"stdout", STDOUT},
{"storage", STORAGE},
{"strict", STRICT_P},
+ {"strip", STRIP_P},
{"substring", SUBSTRING},
{"superuser", SUPERUSER_P},
{"symmetric", SYMMETRIC},
{"vacuum", VACUUM},
{"valid", VALID},
{"validator", VALIDATOR},
+ {"value", VALUE_P},
{"values", VALUES},
{"varchar", VARCHAR},
{"varying", VARYING},
{"verbose", VERBOSE},
+ {"version", VERSION_P},
{"view", VIEW},
{"volatile", VOLATILE},
{"when", WHEN},
{"where", WHERE},
+ {"whitespace", WHITESPACE_P},
{"with", WITH},
{"without", WITHOUT},
{"work", WORK},
{"write", WRITE},
+ {"xml", XML_P},
+ {"xmlattributes", XMLATTRIBUTES},
+ {"xmlconcat", XMLCONCAT},
+ {"xmlelement", XMLELEMENT},
+ {"xmlforest", XMLFOREST},
+ {"xmlparse", XMLPARSE},
+ {"xmlpi", XMLPI},
+ {"xmlroot", XMLROOT},
+ {"xmlserialize", XMLSERIALIZE},
{"year", YEAR_P},
+ {"yes", YES_P},
{"zone", ZONE},
};
--- /dev/null
+The parse.h file has to be in this directory to comply with the backend's source tree.
--- /dev/null
+#include "extern.h"
+#include "preproc.h"
+
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.151 2007/01/05 22:20:00 momjian Exp $
+ * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.152 2007/03/17 19:25:23 meskes Exp $
*
*-------------------------------------------------------------------------
*/
static bool escape_string_warning;
static bool standard_conforming_strings;
static bool warn_on_first_escape;
+static YY_BUFFER_STATE scanbufhandle;
+static char *scanbuf;
/*
* literalbuf is used to accumulate literal values when multiple rules
/* single quote or dollar sign */
addlitchar(yytext[0]);
}
-<xdolq><<EOF>> { yyerror("unterminated dollar-quoted string"); }
+<xdolq><<EOF>> { base_yyerror("unterminated dollar-quoted string"); }
<SQL>{xdstart} {
state_before = YYSTATE;
BEGIN(xd);
return true;
return false;
}
+
+
+/*
+ * Called before any actual parsing is done
+ */
+void
+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.
+ */
+ scanbuf = mm_alloc(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 *) mm_alloc(literalalloc);
+ startlit();
+
+ BEGIN(INITIAL);
+}
+
+
+/*
+ * Called after parsing is done to clean up after scanner_init()
+ */
+void
+scanner_finish(void)
+{
+ yy_delete_buffer(scanbufhandle);
+ free(scanbuf);
+}
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.340 2007/02/01 19:10:29 momjian Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.341 2007/03/17 19:25:23 meskes Exp $ */
/* Copyright comment */
%{
#include "extern.h"
+/* Location tracking support --- simpler than bison's default */
+#define YYLLOC_DEFAULT(Current, Rhs, N) \
+ do { \
+ if (N) \
+ (Current) = (Rhs)[1]; \
+ else \
+ (Current) = (Rhs)[0]; \
+ } while (0)
+
+/*
+ * The %name-prefix option below will make bison call base_yylex, but we
+ * really want it to call filtered_base_yylex (see parser.c).
+ */
+#define base_yylex filtered_base_yylex
+
/*
* Variables containing simple states.
*/
}
%}
+%name-prefix="base_yy"
+%locations
+
%union {
double dval;
char *str;
SQL_DESCRIPTOR SQL_DISCONNECT SQL_ENUM SQL_FOUND
SQL_FREE SQL_GO SQL_GOTO SQL_IDENTIFIED
SQL_INDICATOR SQL_KEY_MEMBER SQL_LENGTH
- SQL_LONG SQL_NAME SQL_NULLABLE SQL_OCTET_LENGTH
+ SQL_LONG SQL_NULLABLE SQL_OCTET_LENGTH
SQL_OPEN SQL_OUTPUT SQL_REFERENCE
SQL_RETURNED_LENGTH SQL_RETURNED_OCTET_LENGTH SQL_SCALE
SQL_SECTION SQL_SHORT SQL_SIGNED SQL_SQL SQL_SQLERROR
SQL_SQLPRINT SQL_SQLWARNING SQL_START SQL_STOP
- SQL_STRUCT SQL_UNSIGNED SQL_VALUE SQL_VAR SQL_WHENEVER
+ SQL_STRUCT SQL_UNSIGNED SQL_VAR SQL_WHENEVER
/* C token */
%token S_ADD S_AND S_ANYTHING S_AUTO S_CONST S_DEC S_DIV
CACHE CALLED CASCADE CASCADED CASE CAST CHAIN CHAR_P
CHARACTER CHARACTERISTICS CHECK CHECKPOINT CLASS CLOSE
CLUSTER COALESCE COLLATE COLUMN COMMENT COMMIT
- COMMITTED CONCURRENTLY CONNECTION CONSTRAINT CONSTRAINTS CONVERSION_P CONVERT COPY CREATE CREATEDB
+ COMMITTED CONCURRENTLY CONNECTION CONSTRAINT CONSTRAINTS
+ CONTENT_P CONVERSION_P CONVERT COPY COST CREATE CREATEDB
CREATEROLE CREATEUSER CROSS CSV CURRENT_DATE CURRENT_ROLE CURRENT_TIME
CURRENT_TIMESTAMP CURRENT_USER CURSOR CYCLE
DATABASE DAY_P DEALLOCATE DEC DECIMAL_P DECLARE DEFAULT DEFAULTS
DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS
- DESC DISABLE_P DISTINCT DO DOMAIN_P DOUBLE_P DROP
+ DESC DISABLE_P DISTINCT DO DOCUMENT_P DOMAIN_P DOUBLE_P DROP
EACH ELSE ENABLE_P ENCODING ENCRYPTED END_P ESCAPE EXCEPT EXCLUSIVE EXCLUDING
EXECUTE EXISTS EXPLAIN EXTERNAL EXTRACT
- FALSE_P FETCH FIRST_P FLOAT_P FOR FORCE FOREIGN FORWARD FREEZE FROM
+ FALSE_P FAMILY FETCH FIRST_P FLOAT_P FOR FORCE FOREIGN FORWARD FREEZE FROM
FULL FUNCTION
GET GLOBAL GRANT GRANTED GREATEST GROUP_P
MATCH MAXVALUE MINUTE_P MINVALUE MODE MONTH_P MOVE
- NAMES NATIONAL NATURAL NCHAR NEW NEXT NO NOCREATEDB
+ NAME_P NAMES NATIONAL NATURAL NCHAR NEW NEXT NO NOCREATEDB
NOCREATEROLE NOCREATEUSER NOINHERIT NOLOGIN_P NONE NOSUPERUSER
- NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF NUMERIC
+ NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF NULLS_P NUMERIC
OBJECT_P OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OR ORDER
OUT_P OUTER_P OVERLAPS OVERLAY OWNED OWNER
SAVEPOINT SCHEMA SCROLL SECOND_P SECURITY SELECT SEQUENCE
SERIALIZABLE SESSION SESSION_USER SET SETOF SHARE
- SHOW SIMILAR SIMPLE SMALLINT SOME STABLE START STATEMENT
- STATISTICS STDIN STDOUT STORAGE STRICT_P SUBSTRING SUPERUSER_P SYMMETRIC
- SYSID SYSTEM_P
+ SHOW SIMILAR SIMPLE SMALLINT SOME STABLE STANDALONE_P START STATEMENT
+ STATISTICS STDIN STDOUT STORAGE STRICT_P STRIP_P SUBSTRING SUPERUSER_P
+ SYMMETRIC SYSID SYSTEM_P
TABLE TABLESPACE TEMP TEMPLATE TEMPORARY THEN TIME TIMESTAMP TO
TRAILING TRANSACTION TREAT TRIGGER TRIM TRUE_P TRUNCATE TRUSTED TYPE_P
UNCOMMITTED UNENCRYPTED UNION UNIQUE UNKNOWN UNLISTEN UNTIL
UPDATE USER USING
- VACUUM VALID VALIDATOR VALUES VARCHAR VARYING VERBOSE VIEW VOLATILE
- WHEN WHERE WITH WITHOUT WORK WRITE
- YEAR_P
+ VACUUM VALID VALIDATOR VALUE_P VALUES VARCHAR VARYING
+ VERBOSE VERSION_P VIEW VOLATILE
+ WHEN WHERE WHITESPACE_P WITH WITHOUT WORK WRITE
+
+ XML_P XMLATTRIBUTES XMLCONCAT XMLELEMENT XMLFOREST XMLPARSE
+ XMLPI XMLROOT XMLSERIALIZE
+
+ YEAR_P YES_P
+
ZONE
/* The grammar thinks these are keywords, but they are not in the keywords.c
* list and so can never be entered directly. The filter in parser.c
* creates these tokens when required.
*/
-%token WITH_CASCADED WITH_LOCAL WITH_CHECK
+%token NULLS_FIRST NULLS_LAST WITH_CASCADED WITH_LOCAL WITH_CHECK
/* Special token types, not actually keywords - see the "lex" file */
%token <str> IDENT SCONST Op CSTRING CVARIABLE CPP_LINE IP BCONST XCONST DOLCONST
%left TYPECAST
%left '.'
%left JOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
+/* kluge to keep xml_whitespace_option from causing shift/reduce conflicts */
+%right PRESERVE STRIP_P
%type <str> Iconst Fconst Sconst TransactionStmt CreateStmt RoleId
%type <str> CreateAsElement OptCreateAs CreateAsList CreateAsStmt
%type <str> key_match ColLabel SpecialRuleRelation ColId columnDef
%type <str> ColConstraint ColConstraintElem drop_type Bconst Iresult
%type <str> TableConstraint OptTableElementList Xconst opt_transaction
-%type <str> ConstraintElem key_actions ColQualList type_name
-%type <str> target_list target_el alias_clause
-%type <str> qualified_name database_name alter_using
+%type <str> ConstraintElem key_actions ColQualList
+%type <str> target_list target_el alias_clause type_func_name_keyword
+%type <str> qualified_name database_name alter_using type_function_name
%type <str> access_method attr_name index_name name func_name
%type <str> file_name AexprConst c_expr ConstTypename var_list
%type <str> a_expr b_expr TruncateStmt CommentStmt OnCommitOption opt_by
%type <str> opt_indirection expr_list extract_list extract_arg
%type <str> position_list substr_list substr_from alter_column_default
%type <str> trim_list in_expr substr_for attrs TableFuncElement
-%type <str> Typename SimpleTypename Numeric opt_float opt_numeric
-%type <str> opt_decimal Character character opt_varying opt_charset
+%type <str> Typename SimpleTypename Numeric opt_float
+%type <str> Character character opt_varying opt_charset
%type <str> opt_timezone opt_interval table_ref fetch_direction
%type <str> ConstDatetime AlterDomainStmt AlterSeqStmt alter_rel_cmds
%type <str> SelectStmt into_clause OptTemp ConstraintAttributeSpec
%type <str> select_limit CheckPointStmt ECPGColId old_aggr_list
%type <str> OptSchemaName OptSchemaEltList schema_stmt opt_drop_behavior
%type <str> handler_name any_name_list any_name opt_as insert_column_list
-%type <str> columnref function_name values_clause AllConstVar
-%type <str> insert_column_item DropRuleStmt ctext_expr
+%type <str> columnref values_clause AllConstVar
+%type <str> insert_column_item DropRuleStmt ctext_expr
%type <str> createfunc_opt_item set_rest var_list_or_default alter_rel_cmd
%type <str> CreateFunctionStmt createfunc_opt_list func_table
%type <str> DropUserStmt copy_from copy_opt_list copy_opt_item
%type <str> ECPGAllocateDescr ECPGDeallocateDescr symbol opt_output
%type <str> ECPGGetDescriptorHeader ECPGColLabel single_var_declaration
%type <str> reserved_keyword unreserved_keyword ecpg_interval opt_ecpg_using
-%type <str> col_name_keyword func_name_keyword precision opt_scale
-%type <str> ECPGTypeName using_list ECPGColLabelCommon UsingConst
-%type <str> using_descriptor into_descriptor
+%type <str> col_name_keyword precision opt_scale
+%type <str> ECPGTypeName using_list ECPGColLabelCommon UsingConst
+%type <str> using_descriptor into_descriptor opt_nulls_order opt_asc_desc
%type <str> prepared_name struct_union_type_with_symbol OptConsTableSpace
%type <str> ECPGunreserved ECPGunreserved_interval cvariable opt_bit_field
%type <str> AlterOwnerStmt OptTableSpaceOwner CreateTableSpaceStmt
%type <str> opt_grant_admin_option AlterFunctionStmt alterfunc_opt_list opt_restrict
%type <str> AlterObjectSchemaStmt alterdb_opt_list for_locking_clause opt_for_locking_clause
%type <str> locked_rels_list opt_granted_by RevokeRoleStmt alterdb_opt_item using_clause
-%type <str> GrantRoleStmt opt_asymmetric aggr_args aggr_args_list old_aggr_definition
+%type <str> GrantRoleStmt opt_asymmetric aggr_args old_aggr_definition
%type <str> old_aggr_elem for_locking_items TableLikeOptionList TableLikeOption
%type <str> set_target_list set_clause_list set_clause multiple_set_clause
-%type <str> ctext_expr_list ctext_row single_set_clause set_target
+%type <str> ctext_expr_list ctext_row single_set_clause set_target opt_type_modifiers
+%type <str> opclass_drop_list opclass_drop DropOpFamilyStmt opt_opfamily
+%type <str> CreateOpFamilyStmt AlterOpFamilyStmt create_as_target
+%type <str> xml_attributes xml_attribute_list document_or_content xml_whitespace_option
+%type <str> opt_xml_root_standalone xml_root_version xml_attribute_el
%type <struct_union> s_struct_union_symbol
| CreateGroupStmt { output_statement($1, 0, connection); }
| CreatePLangStmt { output_statement($1, 0, connection); }
| CreateOpClassStmt { output_statement($1, 0, connection); }
+ | CreateOpFamilyStmt { output_statement($1, 0, connection); }
+ | AlterOpFamilyStmt { output_statement($1, 0, connection); }
| CreateRoleStmt { output_statement($1, 0, connection); }
| CreateSchemaStmt { output_statement($1, 0, connection); }
| CreateSeqStmt { output_statement($1, 0, connection); }
| DropCastStmt { output_statement($1, 0, connection); }
| DropGroupStmt { output_statement($1, 0, connection); }
| DropOpClassStmt { output_statement($1, 0, connection); }
+ | DropOpFamilyStmt { output_statement($1, 0, connection); }
| DropOwnedStmt { output_statement($1, 0, connection); }
| DropPLangStmt { output_statement($1, 0, connection); }
| DropRoleStmt { output_statement($1, 0, connection); }
| DropRuleStmt { output_statement($1, 0, connection); }
- | DropStmt { output_statement($1, 0, connection); }
+ | DropStmt { output_statement($1, 0, connection); }
| DropTableSpaceStmt { output_statement($1, 0, connection); }
| DropTrigStmt { output_statement($1, 0, connection); }
| DropUserStmt { output_statement($1, 0, connection); }
{ $$ = cat2_str(make_str("session authorization"), $3); }
| SESSION AUTHORIZATION DEFAULT
{ $$ = make_str("session authorization default"); }
+ | XML_P OPTION document_or_content
+ { $$ = cat2_str(make_str("xml option"), $3); }
;
var_name: ECPGColId { $$ = $1; }
* SELECT ... INTO.
*/
-CreateAsStmt: CREATE OptTemp TABLE qualified_name OptCreateAs OptWith OnCommitOption OptTableSpace AS
+CreateAsStmt: CREATE OptTemp TABLE create_as_target AS
{ FoundInto = 0; }
SelectStmt
{
if (FoundInto == 1)
mmerror(PARSE_ERROR, ET_ERROR, "CREATE TABLE / AS SELECT cannot specify INTO");
- $$ = cat_str(10, make_str("create"), $2, make_str("table"), $4, $5, $6, $7, $8, make_str("as"), $11);
+ $$ = cat_str(6, make_str("create"), $2, make_str("table"), $4, make_str("as"), $7);
+ }
+ ;
+
+create_as_target: qualified_name OptCreateAs OptWith OnCommitOption OptTableSpace
+ {
+ $$ = cat_str(5, $1, $2, $3, $4, $5);
}
;
/* Note: any simple identifier will be returned as a type name! */
def_arg: func_type { $$ = $1; }
- | func_name_keyword { $$ = $1; }
| reserved_keyword { $$ = $1; }
| qual_all_Op { $$ = $1; }
| AllConst { $$ = $1; }
;
-aggr_args: '(' aggr_args_list ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
+aggr_args: '(' type_list ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
| '(' '*' ')' { $$ = make_str("(*)"); }
;
-aggr_args_list:
- Typename { $$ = $1; }
- | aggr_args_list ',' Typename { $$ = cat_str(3, $1, make_str(","), $3); }
- ;
-
old_aggr_definition: '(' old_aggr_list ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
;
CreateOpClassStmt: CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P Typename
- USING access_method AS opclass_item_list
+ USING access_method opt_opfamily AS opclass_item_list
{
- $$ = cat_str(9, make_str("create operator class"), $4, $5, make_str("for type"), $8, make_str("using"), $10, make_str("as"), $12);
+ $$ = cat_str(10, make_str("create operator class"), $4, $5, make_str("for type"), $8, make_str("using"), $10, $11, make_str("as"), $13);
}
;
{ $$ = cat_str(7, make_str("operator"), $2, $3, make_str("("), $5, make_str(")"), $7); }
| FUNCTION PosIntConst func_name func_args
{ $$ = cat_str(4, make_str("function"), $2, $3, $4); }
+ | FUNCTION PosIntConst '(' type_list ')' func_name func_args
+ { $$ = cat_str(7, make_str("function"), $2, make_str("("), $4, make_str(")"), $6, $7); }
| STORAGE Typename
{ $$ = cat2_str(make_str("storage"), $2); }
;
| /*EMPTY*/ { $$ = EMPTY; }
;
+opt_opfamily: FAMILY any_name { $$ = cat2_str(make_str("family"), $2); }
+ | /*EMPTY*/ { $$ = EMPTY; }
+ ;
+
opt_recheck: RECHECK { $$ = make_str("recheck"); }
| /*EMPTY*/ { $$ = EMPTY; }
;
+CreateOpFamilyStmt: CREATE OPERATOR FAMILY any_name USING access_method
+ { $$ = cat_str(4, make_str("create operator family"), $4, make_str("using"), $6); }
+ ;
+
+AlterOpFamilyStmt: ALTER OPERATOR FAMILY any_name USING access_method ADD_P opclass_item_list
+ { $$ = cat_str(6, make_str("alter operator family"), $4, make_str("using"), $6, make_str("add"), $8); }
+ | ALTER OPERATOR FAMILY any_name USING access_method DROP opclass_drop_list
+ { $$ = cat_str(6, make_str("alter operator family"), $4, make_str("using"), $6, make_str("drop"), $8); }
+ ;
+
+opclass_drop_list: opclass_drop { $$ = $1; }
+ | opclass_drop_list ',' opclass_drop { $$ = cat_str(3, $1, make_str(","), $3); }
+ ;
+
+opclass_drop:
+ OPERATOR PosIntConst '(' type_list ')'
+ { $$ = cat_str(5, make_str("operator"), $2, make_str("("), $4, make_str(")")); }
+ | FUNCTION PosIntConst '(' type_list ')'
+ { $$ = cat_str(5, make_str("function"), $2, make_str("("), $4, make_str(")")); }
+ ;
+
DropOpClassStmt: DROP OPERATOR CLASS any_name USING access_method opt_drop_behavior
{ $$ = cat_str(5,make_str("drop operator class"), $4, make_str("using"), $6, $7); }
| DROP OPERATOR CLASS IF_P EXISTS any_name USING access_method opt_drop_behavior
{ $$ = cat_str(5,make_str("drop operator class if exists"), $6, make_str("using"), $8, $9); }
;
+DropOpFamilyStmt: DROP OPERATOR FAMILY any_name USING access_method opt_drop_behavior
+ { $$ = cat_str(5,make_str("drop operator family"), $4, make_str("using"), $6, $7); }
+ | DROP OPERATOR FAMILY IF_P EXISTS any_name USING access_method opt_drop_behavior
+ { $$ = cat_str(5,make_str("drop operator family if exists"), $6, make_str("using"), $8, $9); }
+ ;
+
/*****************************************************************************
*
* QUERY:
{ $$ = cat_str(4, make_str("comment on rule"), $4, make_str("is"), $6); }
| COMMENT ON OPERATOR CLASS any_name USING access_method IS comment_text
{ $$ = cat_str(6, make_str("comment on operator class"), $5, make_str("using"), $7, make_str("is"), $9); }
+ | COMMENT ON OPERATOR FAMILY any_name USING access_method IS comment_text
+ { $$ = cat_str(6, make_str("comment on operator family"), $5, make_str("using"), $7, make_str("is"), $9); }
| COMMENT ON LARGE_P OBJECT_P NumConst IS comment_text
{ $$ = cat_str(4, make_str("comment on large object"), $5, make_str("is"), $7); }
| COMMENT ON CAST '(' Typename AS Typename ')' IS comment_text
| index_params ',' index_elem { $$ = cat_str(3, $1, make_str(","), $3); }
;
-index_elem: ColId opt_class
- { $$ = cat2_str($1, $2); }
- | func_expr opt_class
- { $$ = cat2_str($1, $2); }
- | '(' a_expr ')' opt_class
- { $$ = cat_str(4, make_str("("), $2, make_str(")"), $4); }
+index_elem: ColId opt_class opt_asc_desc opt_nulls_order
+ { $$ = cat_str(4, $1, $2, $3, $4); }
+ | func_expr opt_class opt_asc_desc opt_nulls_order
+ { $$ = cat_str(4, $1, $2, $3, $4); }
+ | '(' a_expr ')' opt_class opt_asc_desc opt_nulls_order
+ { $$ = cat_str(6, make_str("("), $2, make_str(")"), $4, $5, $6); }
;
opt_class: any_name { $$ = $1; }
| /*EMPTY*/ { $$ = EMPTY; }
;
+opt_asc_desc: ASC { $$ = make_str("asc"); }
+ | DESC { $$ = make_str("desc"); }
+ | /*EMPTY*/ { $$ = EMPTY; }
+ ;
+
+opt_nulls_order: NULLS_FIRST { $$ = make_str("nulls first"); }
+ | NULLS_LAST { $$ = make_str("nulls last"); }
+ | /*EMPTY*/ { $$ = EMPTY; }
+ ;
+
CreateFunctionStmt: CREATE opt_or_replace FUNCTION func_name func_args
RETURNS func_return createfunc_opt_list opt_definition
{ $$ = cat_str(8, make_str("create"), $2, make_str("function"), $4, $5, make_str("returns"), $7, $8); }
{ $$ = cat_str(3, $1, make_str(","), $3); }
;
-param_name: function_name { $$ = $1; };
+param_name: type_function_name { $$ = $1; };
func_return: func_type
{
*/
$$ = $1;
}
- | SETOF type_name attrs '%' TYPE_P
- { $$ = cat_str(4, make_str("setof"), $2, $3, make_str("% type")); }
;
func_type: Typename
{ $$ = $1; }
- | type_name attrs '%' TYPE_P
+ | type_function_name attrs '%' TYPE_P
{ $$ = cat_str(3, $1, $2, make_str("% type")); }
+ | SETOF type_function_name attrs '%' TYPE_P
+ { $$ = cat_str(4, make_str("setof"), $2, $3, make_str("% type")); }
;
{ $$ = make_str("security definer"); }
| SECURITY INVOKER
{ $$ = make_str("security invoker"); }
+ | COST NumConst
+ { $$ = cat2_str(make_str("cost"), $2); }
+ | ROWS NumConst
+ { $$ = cat2_str(make_str("rows"), $2); }
;
createfunc_opt_item: AS func_as
{ $$ = cat2_str(make_str("as"), $2); }
{ $$ = cat_str(4, make_str("alter language"), $3, make_str("rename to"), $6); }
| ALTER OPERATOR CLASS any_name USING access_method RENAME TO name
{ $$ = cat_str(6, make_str("alter operator class"), $4, make_str("using"), $6, make_str("rename to"), $9); }
+ | ALTER OPERATOR FAMILY any_name USING access_method RENAME TO name
+ { $$ = cat_str(6, make_str("alter operator family"), $4, make_str("using"), $6, make_str("rename to"), $9); }
| ALTER SCHEMA name RENAME TO name
{ $$ = cat_str(4, make_str("alter schema"), $3, make_str("rename to"), $6); }
| ALTER TABLE relation_expr RENAME TO name
{ $$ = cat_str(6, make_str("alter operator"), $3, make_str("("), $5, make_str(") owner to"), $9); }
| ALTER OPERATOR CLASS any_name USING access_method OWNER TO RoleId
{ $$ = cat_str(6, make_str("alter operator class"), $4, make_str("using"), $6, make_str("owner to"), $9); }
+ | ALTER OPERATOR FAMILY any_name USING access_method OWNER TO RoleId
+ { $$ = cat_str(6, make_str("alter operator family"), $4, make_str("using"), $6, make_str("owner to"), $9); }
| ALTER SCHEMA name OWNER TO RoleId
{ $$ = cat_str(4, make_str("alter schema"), $3, make_str("owner to"), $6); }
| ALTER TYPE_P any_name OWNER TO RoleId
*/
opt_check_option:
WITH_CHECK OPTION
- { mmerror(PARSE_ERROR, ET_ERROR, "WITH CHECK OPTION not implemented"); }
+ {
+ mmerror(PARSE_ERROR, ET_ERROR, "WITH CHECK OPTION not implemented");
+ $$ = EMPTY;
+ }
| WITH_CASCADED CHECK OPTION
- { mmerror(PARSE_ERROR, ET_ERROR, "WITH CHECK OPTION not implemented"); }
+ {
+ mmerror(PARSE_ERROR, ET_ERROR, "WITH CHECK OPTION not implemented");
+ $$ = EMPTY;
+ }
| WITH_LOCAL CHECK OPTION
- { mmerror(PARSE_ERROR, ET_ERROR, "WITH CHECK OPTION not implemented"); }
+ {
+ mmerror(PARSE_ERROR, ET_ERROR, "WITH CHECK OPTION not implemented");
+ $$ = EMPTY;
+ }
| /* EMPTY */
{ $$ = EMPTY; }
;
| DeleteStmt
;
-prep_type_clause: '(' prep_type_list ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
+prep_type_clause: '(' type_list ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
| /* EMPTY * / { $$ = EMPTY; }
;
-prep_type_list: Typename { $$ = $1; }
- | prep_type_list ',' Typename { $$ = cat_str(3, $1, make_str(","), $3); }
- ;
-
ExecuteStmt: EXECUTE name execute_param_clause
{ $$ = cat_str(3, make_str("execute"), $2, $3); }
- | CREATE OptTemp TABLE qualified_name OptCreateAs
- OptWith OnCommitOption OptTableSpace AS
+ | CREATE OptTemp TABLE create_as_target AS
EXECUTE name execute_param_clause
{ $$ = cat_str(11, make_str("create"), $2, make_str("table"), $4, $5, $6, $7, $8, make_str("as execute"), $11, $12); }
;
| sortby_list ',' sortby { $$ = cat_str(3, $1, make_str(","), $3); }
;
-sortby: a_expr USING qual_all_Op
- { $$ = cat_str(3, $1, make_str("using"), $3); }
- | a_expr ASC
- { $$ = cat2_str($1, make_str("asc")); }
- | a_expr DESC
- { $$ = cat2_str($1, make_str("desc")); }
- | a_expr
- { $$ = $1; }
+sortby: a_expr USING qual_all_Op opt_nulls_order
+ { $$ = cat_str(4, $1, make_str("using"), $3, $4); }
+ | a_expr opt_asc_desc opt_nulls_order
+ { $$ = cat_str(3, $1, $2, $3); }
;
select_limit: LIMIT select_limit_value OFFSET select_offset_value
{ $$ = cat2_str($1, $2); }
| ConstInterval '(' PosIntConst ')' opt_interval
{ $$ = cat_str(5, $1, make_str("("), $3, make_str(")"), $5); }
- | type_name attrs
- { $$ = cat2_str($1, $2);}
;
-ConstTypename: GenericType { $$ = $1; }
- | ConstDatetime { $$ = $1; }
- | Numeric { $$ = $1; }
+ConstTypename: Numeric { $$ = $1; }
| ConstBit { $$ = $1; }
| ConstCharacter { $$ = $1; }
+ | ConstDatetime { $$ = $1; }
;
-GenericType: type_name { $$ = $1; }
+GenericType: type_function_name opt_type_modifiers { $$ = cat2_str($1, $2); }
+ | type_function_name attrs opt_type_modifiers { $$ = cat_str(3, $1, $2, $3); }
;
+opt_type_modifiers: '(' expr_list ')' { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
+ | /* EMPTY */ { $$ = EMPTY; }
+ ;
+
/* SQL92 numeric data types
* Check FLOAT() precision limits assuming IEEE floating types.
* Provide real DECIMAL() and NUMERIC() implementations now - Jan 1998-12-30
{ $$ = cat2_str(make_str("float"), $2); }
| DOUBLE_P PRECISION
{ $$ = make_str("double precision"); }
- | DECIMAL_P opt_decimal
+ | DECIMAL_P opt_type_modifiers
{ $$ = cat2_str(make_str("decimal"), $2); }
- | DEC opt_decimal
+ | DEC opt_type_modifiers
{ $$ = cat2_str(make_str("dec"), $2); }
- | NUMERIC opt_numeric
+ | NUMERIC opt_type_modifiers
{ $$ = cat2_str(make_str("numeric"), $2); }
| BOOLEAN_P
{ $$ = make_str("boolean"); }
{ $$ = EMPTY; }
;
-opt_numeric: '(' PosIntConst ',' PosIntConst ')'
- { $$ = cat_str(5, make_str("("), $2, make_str(","), $4, make_str(")")); }
- | '(' PosIntConst ')'
- { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
- | /*EMPTY*/
- { $$ = EMPTY; }
- ;
-
-opt_decimal: '(' PosIntConst ',' PosIntConst ')'
- { $$ = cat_str(5, make_str("("), $2, make_str(","), $4, make_str(")")); }
- | '(' PosIntConst ')'
- { $$ = cat_str(3, make_str("("), $2, make_str(")")); }
- | /*EMPTY*/
- { $$ = EMPTY; }
- ;
-
/*
* SQL92 bit-field data types
* The following implements BIT() and BIT VARYING().
| BitWithoutLength { $$ = $1; }
;
-BitWithLength: BIT opt_varying '(' PosIntConst ')'
+BitWithLength: BIT opt_varying '(' expr_list ')'
{ $$ = cat_str(5, make_str("bit"), $2, make_str("("), $4, make_str(")")); }
;
{ $$ = cat_str(6, $1, $2, $3, make_str("("), $5, make_str(")")); }
| UNIQUE select_with_parens
{ $$ = cat2_str(make_str("unique"), $2); }
+ | a_expr IS DOCUMENT_P
+ { $$ = cat2_str($1, make_str("is document")); }
+ | a_expr IS NOT DOCUMENT_P
+ { $$ = cat2_str($1, make_str("is not document")); }
;
/* Restricted expressions
{ $$ = cat_str(4, $1, make_str("is of ("), $5, make_str(")")); }
| b_expr IS NOT OF '(' b_expr ')' %prec IS
{ $$ = cat_str(4, $1, make_str("is not of ("), $6, make_str(")")); }
+ | b_expr IS DOCUMENT_P
+ { $$ = cat2_str($1, make_str("is document")); }
+ | b_expr IS NOT DOCUMENT_P
+ { $$ = cat2_str($1, make_str("is not document")); }
;
/*
{ $$ = cat_str(3, make_str("greatest("), $3, make_str(")")); }
| LEAST '(' expr_list ')'
{ $$ = cat_str(3, make_str("least("), $3, make_str(")")); }
+ | XMLCONCAT '(' expr_list ')'
+ { $$ = cat_str(3, make_str("xmlconcat("), $3, make_str(")")); }
+ | XMLELEMENT '(' NAME_P ColLabel ')'
+ { $$ = cat_str(3, make_str("xmlelement( name"), $4, make_str(")")); }
+ | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ')'
+ { $$ = cat_str(5, make_str("xmlelement( name"), $4, make_str(","), $6, make_str(")")); }
+ | XMLELEMENT '(' NAME_P ColLabel ',' expr_list ')'
+ { $$ = cat_str(5, make_str("xmlelement( name"), $4, make_str(","), $6, make_str(")")); }
+ | XMLELEMENT '(' NAME_P ColLabel ',' xml_attributes ',' expr_list ')'
+ { $$ = cat_str(7, make_str("xmlelement( name"), $4, make_str(","), $6, make_str(","), $8, make_str(")")); }
+ | XMLFOREST '(' xml_attribute_list ')'
+ { $$ = cat_str(3, make_str("xmlforest("), $3, make_str(")")); }
+ | XMLPARSE '(' document_or_content a_expr xml_whitespace_option ')'
+ { $$ = cat_str(5, make_str("xmlparse("), $3, $4, $5, make_str(")")); }
+ | XMLPI '(' NAME_P ColLabel ')'
+ { $$ = cat_str(3, make_str("xmlpi( name"), $4, make_str(")")); }
+ | XMLPI '(' NAME_P ColLabel ',' a_expr ')'
+ { $$ = cat_str(5, make_str("xmlpi( name"), $4, make_str(","), $6, make_str(")")); }
+ | XMLROOT '(' a_expr ',' xml_root_version opt_xml_root_standalone ')'
+ { $$ = cat_str(6, make_str("xmlroot("), $3, make_str(","), $5, $6, make_str(")")); }
+ ;
+
+/*
+ * SQL/XML support
+ */
+
+xml_root_version: VERSION_P a_expr
+ { $$ = cat2_str(make_str("version"), $2); }
+ | VERSION_P NO VALUE_P
+ { $$ = make_str("version no value"); }
;
+opt_xml_root_standalone: ',' STANDALONE_P YES_P
+ { $$ = make_str(", standalone yes"); }
+ | ',' STANDALONE_P NO
+ { $$ = make_str(", standalone no"); }
+ | ',' STANDALONE_P NO VALUE_P
+ { $$ = make_str(", standalone no value"); }
+ | /*EMPTY*/
+ { $$ = EMPTY; }
+ ;
+
+xml_attributes: XMLATTRIBUTES '(' xml_attribute_list ')'
+ { $$ = cat_str(3, make_str("xmlattributes("), $3, make_str(")")); }
+ ;
+
+xml_attribute_list: xml_attribute_el
+ { $$ = $1; }
+ | xml_attribute_list ',' xml_attribute_el
+ { $$ = cat_str(3, $1, make_str(","), $3); }
+ ;
+
+xml_attribute_el: a_expr AS ColLabel
+ { $$ = cat_str(3, $1, make_str("as"), $3); }
+ | a_expr
+ { $$ = $1; }
+ ;
+
+document_or_content: DOCUMENT_P { $$ = make_str("document"); }
+ | CONTENT_P { $$ = make_str("content"); }
+ ;
+
+xml_whitespace_option: PRESERVE WHITESPACE_P { $$ = make_str("preserve whitespace"); }
+ | STRIP_P WHITESPACE_P { $$ = make_str("strip whitespace"); }
+ | /*EMPTY*/ { $$ = EMPTY; }
+ ;
row: ROW '(' expr_list ')'
{ $$ = cat_str(3, make_str("row ("), $3, make_str(")")); }
{ $$ = EMPTY; }
;
-type_list: type_list ',' Typename
- { $$ = cat_str(3, $1, ',', $3); }
- | Typename
+type_list: Typename
{ $$ = $1; }
+ | type_list ',' Typename
+ { $$ = cat_str(3, $1, ',', $3); }
;
array_expr_list: array_expr { $$ = $1; }
file_name: StringConst { $$ = $1; };
-func_name: function_name
+func_name: type_function_name
{ $$ = $1; }
| relation_name indirection
{ $$ = cat2_str($1, $2); }
| NumConst { $$ = $1; }
;
-PosAllConst: Sconst { $$ = $1; }
- | Fconst { $$ = $1; }
- | Iconst { $$ = $1; }
- | Bconst { $$ = $1; }
- | Xconst { $$ = $1; }
- | civar { $$ = $1; }
+PosAllConst: Sconst { $$ = $1; }
+ | Fconst { $$ = $1; }
+ | Iconst { $$ = $1; }
+ | Bconst { $$ = $1; }
+ | Xconst { $$ = $1; }
+ | func_name Sconst { $$ = cat2_str($1, $2); }
+ | func_name '(' expr_list ')' Sconst
+ { $$ = cat_str(5, $1, make_str("("), $3, make_str(")"), $5); }
+ | civar { $$ = $1; }
;
RoleId: ColId { $$ = $1;};
ECPGConnect: SQL_CONNECT TO connection_target opt_connection_name opt_user
{ $$ = cat_str(5, $3, make_str(","), $5, make_str(","), $4); }
| SQL_CONNECT TO DEFAULT
- { $$ = make_str("NULL,NULL,NULL,\"DEFAULT\""); }
+ { $$ = make_str("NULL, NULL, NULL, \"DEFAULT\""); }
/* also allow ORACLE syntax */
| SQL_CONNECT ora_user
- { $$ = cat_str(3, make_str("NULL,"), $2, make_str(",NULL")); }
+ { $$ = cat_str(3, make_str("NULL,"), $2, make_str(", NULL")); }
| DATABASE connection_target
- { $$ = cat2_str($2, make_str(",NULL,NULL,NULL")); }
+ { $$ = cat2_str($2, make_str(", NULL, NULL, NULL")); }
;
connection_target: opt_database_name opt_server opt_port
;
opt_user: USER ora_user { $$ = $2; }
- | /*EMPTY*/ { $$ = make_str("NULL,NULL"); }
+ | /*EMPTY*/ { $$ = make_str("NULL, NULL"); }
;
ora_user: user_name
* manipulate a descriptor
*/
-ECPGGetDescriptor: GET SQL_DESCRIPTOR quoted_ident_stringvar SQL_VALUE IntConstVar ECPGGetDescItems
+ECPGGetDescriptor: GET SQL_DESCRIPTOR quoted_ident_stringvar VALUE_P IntConstVar ECPGGetDescItems
{ $$.str = $5; $$.name = $3; }
;
ECPGGetDescItem: cvariable '=' descriptor_item { push_assignment($1, $3); };
-ECPGSetDescriptor: SET SQL_DESCRIPTOR quoted_ident_stringvar SQL_VALUE IntConstVar ECPGSetDescItems
+ECPGSetDescriptor: SET SQL_DESCRIPTOR quoted_ident_stringvar VALUE_P IntConstVar ECPGSetDescItems
{ $$.str = $5; $$.name = $3; }
;
descriptor_item: SQL_CARDINALITY { $$ = ECPGd_cardinality; }
- | SQL_DATA { $$ = ECPGd_data; }
+ | SQL_DATA { $$ = ECPGd_data; }
| SQL_DATETIME_INTERVAL_CODE { $$ = ECPGd_di_code; }
| SQL_DATETIME_INTERVAL_PRECISION { $$ = ECPGd_di_precision; }
- | SQL_INDICATOR { $$ = ECPGd_indicator; }
- | SQL_KEY_MEMBER { $$ = ECPGd_key_member; }
- | SQL_LENGTH { $$ = ECPGd_length; }
- | SQL_NAME { $$ = ECPGd_name; }
- | SQL_NULLABLE { $$ = ECPGd_nullable; }
- | SQL_OCTET_LENGTH { $$ = ECPGd_octet; }
- | PRECISION { $$ = ECPGd_precision; }
- | SQL_RETURNED_LENGTH { $$ = ECPGd_length; }
- | SQL_RETURNED_OCTET_LENGTH { $$ = ECPGd_ret_octet; }
- | SQL_SCALE { $$ = ECPGd_scale; }
- | TYPE_P { $$ = ECPGd_type; }
+ | SQL_INDICATOR { $$ = ECPGd_indicator; }
+ | SQL_KEY_MEMBER { $$ = ECPGd_key_member; }
+ | SQL_LENGTH { $$ = ECPGd_length; }
+ | NAME_P { $$ = ECPGd_name; }
+ | SQL_NULLABLE { $$ = ECPGd_nullable; }
+ | SQL_OCTET_LENGTH { $$ = ECPGd_octet; }
+ | PRECISION { $$ = ECPGd_precision; }
+ | SQL_RETURNED_LENGTH { $$ = ECPGd_length; }
+ | SQL_RETURNED_OCTET_LENGTH { $$ = ECPGd_ret_octet; }
+ | SQL_SCALE { $$ = ECPGd_scale; }
+ | TYPE_P { $$ = ECPGd_type; }
;
| SQL_INDICATOR { $$ = make_str("indicator"); }
| SQL_KEY_MEMBER { $$ = make_str("key_member"); }
| SQL_LENGTH { $$ = make_str("length"); }
- | SQL_NAME { $$ = make_str("name"); }
| SQL_NULLABLE { $$ = make_str("nullable"); }
| SQL_OCTET_LENGTH { $$ = make_str("octet_length"); }
| SQL_RETURNED_LENGTH { $$ = make_str("returned_length"); }
| SQL_SQLPRINT { $$ = make_str("sqlprint"); }
| SQL_SQLWARNING { $$ = make_str("sqlwarning"); }
| SQL_STOP { $$ = make_str("stop"); }
- | SQL_VALUE { $$ = make_str("value"); }
;
ECPGKeywords_rest: SQL_CONNECT { $$ = make_str("connect"); }
| CHAR_P { $$ = make_str("char"); }
| VALUES { $$ = make_str("values"); }
;
-/* Type identifier --- names that can be type names.
+/* Type/function identifier --- names that can be type names.
*/
-type_name: ident { $$ = $1; }
+type_function_name: ident { $$ = $1; }
| unreserved_keyword { $$ = $1; }
+ | type_func_name_keyword { $$ = $1; }
| ECPGKeywords { $$ = $1; }
| ECPGTypeName { $$ = $1; }
| ECPGCKeywords { $$ = $1; }
;
-/* Function identifier --- names that can be function names.
- */
-function_name: ident { $$ = $1; }
- | unreserved_keyword { $$ = $1; }
- | func_name_keyword { $$ = $1; }
- | ECPGKeywords { $$ = $1; }
- | ECPGCKeywords { $$ = $1; }
- ;
-
/* Column label --- allowed labels in "AS" clauses.
* This presently includes *all* Postgres keywords.
*/
ColLabel: ECPGColLabel { $$ = $1; }
- | ECPGTypeName { $$ = $1; }
- | CHAR_P { $$ = make_str("char"); }
- | INPUT_P { $$ = make_str("input"); }
- | INT_P { $$ = make_str("int"); }
- | UNION { $$ = make_str("union"); }
- | TO { $$ = make_str("to"); }
- | ECPGCKeywords { $$ = $1; }
+ | ECPGTypeName { $$ = $1; }
+ | CHAR_P { $$ = make_str("char"); }
+ | INPUT_P { $$ = make_str("input"); }
+ | INT_P { $$ = make_str("int"); }
+ | UNION { $$ = make_str("union"); }
+ | TO { $$ = make_str("to"); }
+ | ECPGCKeywords { $$ = $1; }
| ECPGunreserved_interval { $$ = $1; }
;
ECPGColLabelCommon: ident { $$ = $1; }
| col_name_keyword { $$ = $1; }
- | func_name_keyword { $$ = $1; }
+ | type_func_name_keyword { $$ = $1; }
| ECPGKeywords_vanames { $$ = $1; }
;
| CONCURRENTLY { $$ = make_str("concurrently"); }
/* | CONNECTION { $$ = make_str("connection"); }*/
| CONSTRAINTS { $$ = make_str("constraints"); }
+ | CONTENT_P { $$ = make_str("content"); }
| CONVERSION_P { $$ = make_str("conversion"); }
| COPY { $$ = make_str("copy"); }
+ | COST { $$ = make_str("cost"); }
| CREATEDB { $$ = make_str("createdb"); }
| CREATEROLE { $$ = make_str("createrole"); }
| CREATEUSER { $$ = make_str("createuser"); }
| DELIMITER { $$ = make_str("delimiter"); }
| DELIMITERS { $$ = make_str("delimiters"); }
| DISABLE_P { $$ = make_str("disable"); }
+ | DOCUMENT_P { $$ = make_str("document"); }
| DOMAIN_P { $$ = make_str("domain"); }
| DOUBLE_P { $$ = make_str("double"); }
| DROP { $$ = make_str("drop"); }
| EXCLUSIVE { $$ = make_str("exclusive"); }
| EXECUTE { $$ = make_str("execute"); }
| EXPLAIN { $$ = make_str("explain"); }
+ | EXTERNAL { $$ = make_str("external"); }
+ | FAMILY { $$ = make_str("family"); }
| FETCH { $$ = make_str("fetch"); }
| FIRST_P { $$ = make_str("first"); }
| FORCE { $$ = make_str("force"); }
| MODE { $$ = make_str("mode"); }
/* | MONTH_P { $$ = make_str("month"); }*/
| MOVE { $$ = make_str("move"); }
+ | NAME_P { $$ = make_str("name"); }
| NAMES { $$ = make_str("names"); }
| NEXT { $$ = make_str("next"); }
| NO { $$ = make_str("no"); }
| NOTHING { $$ = make_str("nothing"); }
| NOTIFY { $$ = make_str("notify"); }
| NOWAIT { $$ = make_str("nowait"); }
+ | NULLS_P { $$ = make_str("nulls"); }
| OBJECT_P { $$ = make_str("object"); }
| OF { $$ = make_str("of"); }
| OIDS { $$ = make_str("oids"); }
| SHOW { $$ = make_str("show"); }
| SIMPLE { $$ = make_str("simple"); }
| STABLE { $$ = make_str("stable"); }
+ | STANDALONE_P { $$ = make_str("standalone"); }
| START { $$ = make_str("start"); }
| STATEMENT { $$ = make_str("statement"); }
| STATISTICS { $$ = make_str("statistics"); }
| STDIN { $$ = make_str("stdin"); }
| STDOUT { $$ = make_str("stdout"); }
| STORAGE { $$ = make_str("storage"); }
- | SUPERUSER_P { $$ = make_str("superuser"); }
| STRICT_P { $$ = make_str("strict"); }
+ | STRIP_P { $$ = make_str("strip"); }
+ | SUPERUSER_P { $$ = make_str("superuser"); }
| SYSTEM_P { $$ = make_str("system"); }
| SYSID { $$ = make_str("sysid"); }
| TABLESPACE { $$ = make_str("tablespace"); }
| UPDATE { $$ = make_str("update"); }
| VACUUM { $$ = make_str("vacuum"); }
| VALID { $$ = make_str("valid"); }
+ | VALIDATOR { $$ = make_str("validator"); }
+ | VALUE_P { $$ = make_str("value"); }
| VARYING { $$ = make_str("varying"); }
+ | VERSION_P { $$ = make_str("version"); }
| VIEW { $$ = make_str("view"); }
+ | VOLATILE { $$ = make_str("volatile"); }
+ | WHITESPACE_P { $$ = make_str("whitespace"); }
| WITH { $$ = make_str("with"); }
| WITHOUT { $$ = make_str("without"); }
| WORK { $$ = make_str("work"); }
| WRITE { $$ = make_str("write"); }
+ | XML_P { $$ = make_str("xml"); }
+ | YES_P { $$ = make_str("yes"); }
/* | YEAR_P { $$ = make_str("year"); }*/
| ZONE { $$ = make_str("zone"); }
;
/* VALUES creates a shift/reduce problem if listed here
| VALUES { $$ = make_str("values"); } */
| VARCHAR { $$ = make_str("varchar"); }
+ | XMLATTRIBUTES { $$ = make_str("xmlattributes"); }
+ | XMLCONCAT { $$ = make_str("xmlconcat"); }
+ | XMLELEMENT { $$ = make_str("xmlelement"); }
+ | XMLFOREST { $$ = make_str("xmlforest"); }
+ | XMLPARSE { $$ = make_str("xmlparse"); }
+ | XMLPI { $$ = make_str("xmlpi"); }
+ | XMLROOT { $$ = make_str("xmlroot"); }
+ | XMLSERIALIZE { $$ = make_str("xmlserialize"); }
;
/* Function identifier --- keywords that can be function names.
* productions in a_expr to support the goofy SQL9x argument syntax.
* - thomas 2000-11-28
*/
-func_name_keyword:
+type_func_name_keyword:
AUTHORIZATION { $$ = make_str("authorization"); }
| BETWEEN { $$ = make_str("between"); }
| BINARY { $$ = make_str("binary"); }
%%
-void yyerror( char * error)
+void base_yyerror(const char * error)
{
char buf[1024];
mmerror(PARSE_ERROR, ET_ERROR, buf);
}
+void parser_init(void)
+{
+ /* This function is empty. It only exists for compatibility with the backend parser right now. */
+}
+
+/*
+ * Must undefine base_yylex before including pgc.c, since we want it
+ * to create the function base_yylex not filtered_base_yylex.
+ */
+#undef base_yylex
+
#include "pgc.c"
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/type.c,v 1.71 2006/08/13 10:18:30 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/type.c,v 1.72 2007/03/17 19:25:23 meskes Exp $ */
#include "postgres_fe.h"
break;
default:
if (!IS_SIMPLE_TYPE(type->u.element->type))
- yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
+ base_yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
ECPGdump_a_simple(o, name,
type->u.element->type,
ECPGdump_a_struct(o, name, ind_name, make_str("1"), type, ind_type, NULL, prefix, ind_prefix);
break;
case ECPGt_union: /* cannot dump a complete union */
- yyerror("Type of union has to be specified");
+ base_yyerror("Type of union has to be specified");
break;
case ECPGt_char_variable:
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
switch (type->u.element->type)
{
case ECPGt_array:
- yyerror("internal error, found multidimensional array\n");
+ base_yyerror("internal error, found multidimensional array\n");
break;
case ECPGt_struct:
case ECPGt_union:
break;
default:
if (!IS_SIMPLE_TYPE(type->u.element->type))
- yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
+ base_yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
free(type->u.element);
}
#line 27 "rnull.pgc"
- { ECPGconnect(__LINE__, 1, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 1, "regress1" , NULL, NULL , NULL, 0);
#line 29 "rnull.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
#line 29 "rnull.pgc"
- { ECPGdo(__LINE__, 1, 0, NULL, "create table test ( id int , c char ( 10 ) , s smallint , i int , b bool , f float , l bigint , dbl double precision , dec decimal , dat date , tmp timestamptz ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 1, 0, NULL, "create table test ( id int , c char ( 10 ) , s smallint , i int , b bool , f float , l bigint , dbl double precision , dec decimal , dat date , tmp timestamptz ) ", ECPGt_EOIT, ECPGt_EORT);
#line 33 "rnull.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 31: QUERY: create table test ( id int , c char ( 10 ) , s smallint , i int , b bool , f float , l bigint , dbl double precision , dec decimal , dat date , tmp timestamptz ) on connection regress1
+[NO_PID]: ECPGexecute line 31: QUERY: create table test ( id int , c char ( 10 ) , s smallint , i int , b bool , f float , l bigint , dbl double precision , dec decimal , dat date , tmp timestamptz ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 31 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGtrans line 34 action = commit connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 36: QUERY: insert into test ( id , c , s , i , b , f , l , dbl ) values( 1 , 'abc ' , 17 , -74874 , 't' , 3.710000038147 , 487444 , 404.404 ) on connection regress1
+[NO_PID]: ECPGexecute line 36: QUERY: insert into test ( id , c , s , i , b , f , l , dbl ) values ( 1 , 'abc ' , 17 , -74874 , 't' , 3.710000038147 , 487444 , 404.404 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 36 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGtrans line 39 action = commit connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 52: QUERY: insert into test ( id , c , s , i , b , f , l , dbl , dec , dat , tmp ) values( 2 , null , null , null , 't' , null , null , null , null , null , null ) on connection regress1
+[NO_PID]: ECPGexecute line 52: QUERY: insert into test ( id , c , s , i , b , f , l , dbl , dec , dat , tmp ) values ( 2 , null , null , null , 't' , null , null , null , null , null , null ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 52 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
#line 18 "test_informix.pgc"
- { ECPGconnect(__LINE__, 1, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 1, "regress1" , NULL, NULL , NULL, 0);
#line 20 "test_informix.pgc"
if (sqlca.sqlcode < 0) dosqlprint ( );}
/* this however should be ok */
- { ECPGdo(__LINE__, 1, 1, NULL, "select i from test where j = ( select j from test order by i limit 1 ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 1, 1, NULL, "select i from test where j = ( select j from test order by i limit 1 ) ", ECPGt_EOIT, ECPGt_EORT);
#line 43 "test_informix.pgc"
if (sqlca.sqlcode < 0) dosqlprint ( );}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 23 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 27: QUERY: insert into test ( i , j ) values( 7 , 0 ) on connection regress1
+[NO_PID]: ECPGexecute line 27: QUERY: insert into test ( i , j ) values ( 7 , 0 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 27 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGtrans line 28 action = commit connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 31: QUERY: insert into test ( i , j ) values( 7 , 12 ) on connection regress1
+[NO_PID]: ECPGexecute line 31: QUERY: insert into test ( i , j ) values ( 7 , 12 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 31: Error: ERROR: duplicate key violates unique constraint "test_pkey"
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: -239, state: 23505
[NO_PID]: ECPGtrans line 33 action = rollback connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35: QUERY: insert into test ( i , j ) values( 14 , 1 ) on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: insert into test ( i , j ) values ( 14 , 1 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 35 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: -284, state: 21000
[NO_PID]: ECPGtrans line 40 action = rollback connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 43: QUERY: select i from test where j = ( select j from test order by i limit 1 ) on connection regress1
+[NO_PID]: ECPGexecute line 43: QUERY: select i from test where j = ( select j from test order by i limit 1 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 43: Correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: raising sqlcode 100 in line 54, 'No data found in line 54.'.
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 72: QUERY: delete from test where i = 21.0 on connection regress1
+[NO_PID]: ECPGexecute line 72: QUERY: delete from test where i = 21.0 on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 72 Ok: DELETE 0
[NO_PID]: sqlca: code: 0, state: 00000
ECPGdebug(1, stderr);
strcpy(dbname, "regress1");
- { ECPGconnect(__LINE__, 1, dbname , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 1, dbname , NULL, NULL , NULL, 0);
#line 63 "test_informix2.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 68 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 71: QUERY: insert into history ( customerid , timestamp , action_taken , narrative ) values( 1 , '2003-05-07 13:28:34 CEST' , 'test' , 'test' ) on connection regress1
+[NO_PID]: ECPGexecute line 71: QUERY: insert into history ( customerid , timestamp , action_taken , narrative ) values ( 1 , '2003-05-07 13:28:34 CEST' , 'test' , 'test' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 71 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_data line 81: RESULT: Wed 07 May 13:28:34 2003 offset: -1 array: Yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 95: QUERY: insert into history ( customerid , timestamp , action_taken , narrative ) values( 2 , timestamp '2003-05-08 15:53:39' , 'test' , 'test' ) on connection regress1
+[NO_PID]: ECPGexecute line 95: QUERY: insert into history ( customerid , timestamp , action_taken , narrative ) values ( 2 , timestamp '2003-05-08 15:53:39' , 'test' , 'test' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 95 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
ECPGdebug(1, stderr);
strcpy(id, "first");
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , id, 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , id, 0); }
#line 24 "test2.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , "second", 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , "second", 0); }
#line 25 "test2.pgc"
ECPGdebug(1, stderr);
strcpy(id, "first");
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , id, 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , id, 0); }
#line 23 "test3.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , "second", 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , "second", 0); }
#line 24 "test3.pgc"
#line 31 "test3.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , "second", 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , "second", 0); }
#line 33 "test3.pgc"
/* will close "second" */
#line 35 "test3.pgc"
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , "second", 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , "second", 0); }
#line 37 "test3.pgc"
{ ECPGdisconnect(__LINE__, "ALL");}
{
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , "main", 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , "main", 0); }
#line 13 "test4.pgc"
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , "main", 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , "main", 0); }
#line 22 "test5.pgc"
{ ECPGdo(__LINE__, 0, 1, NULL, "alter user connectuser encrypted password 'connectpw'", ECPGt_EOIT, ECPGt_EORT);}
strcpy(db, "connectdb");
strcpy(id, "main");
- { ECPGconnect(__LINE__, 0, db , NULL,NULL , id, 0); }
+ { ECPGconnect(__LINE__, 0, db , NULL, NULL , id, 0); }
#line 28 "test5.pgc"
{ ECPGdisconnect(__LINE__, id);}
#line 29 "test5.pgc"
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , "main", 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , "main", 0); }
#line 31 "test5.pgc"
{ ECPGdisconnect(__LINE__, "main");}
#line 32 "test5.pgc"
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , "main", 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , "main", 0); }
#line 34 "test5.pgc"
{ ECPGdisconnect(__LINE__, "main");}
#line 35 "test5.pgc"
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , "main", 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , "main", 0); }
#line 37 "test5.pgc"
{ ECPGdisconnect(__LINE__, "main");}
/* connect twice */
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , "main", 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , "main", 0); }
#line 62 "test5.pgc"
- { ECPGconnect(__LINE__, 0, "connectdb" , NULL,NULL , "main", 0); }
+ { ECPGconnect(__LINE__, 0, "connectdb" , NULL, NULL , "main", 0); }
#line 63 "test5.pgc"
{ ECPGdisconnect(__LINE__, "main");}
/* exec sql whenever sqlerror do sqlprint ( ) ; */
#line 27 "dt_test.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 28 "dt_test.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
#line 28 "dt_test.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table date_test ( d date , ts timestamp ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table date_test ( d date , ts timestamp ) ", ECPGt_EOIT, ECPGt_EORT);
#line 29 "dt_test.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 29: QUERY: create table date_test ( d date , ts timestamp ) on connection regress1
+[NO_PID]: ECPGexecute line 29: QUERY: create table date_test ( d date , ts timestamp ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 29 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 30 Ok: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35: QUERY: insert into date_test ( d , ts ) values( date '1966-01-17' , timestamp '2000-07-12 17:34:29' ) on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: insert into date_test ( d , ts ) values ( date '1966-01-17' , timestamp '2000-07-12 17:34:29' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 35 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
#line 30 "num_test.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 32 "num_test.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
{
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 17 "comment.pgc"
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 34 "define.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
ECPGdebug (1, stderr);
empl.idnum = 1;
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 43 "type.pgc"
if (sqlca.sqlcode)
ECPGdebug(1, stderr);
strcpy(msg, "connect");
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 43 "variable.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
strcpy(msg, "create");
- { ECPGdo(__LINE__, 0, 1, NULL, "create table family ( name char ( 8 ) , born integer , age smallint , married date , children integer ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table family ( name char ( 8 ) , born integer , age smallint , married date , children integer ) ", ECPGt_EOIT, ECPGt_EORT);
#line 49 "variable.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 46 Ok: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 49: QUERY: create table family ( name char ( 8 ) , born integer , age smallint , married date , children integer ) on connection regress1
+[NO_PID]: ECPGexecute line 49: QUERY: create table family ( name char ( 8 ) , born integer , age smallint , married date , children integer ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 49 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 31 "whenever.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 27 "array.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
ECPGdebug (1, stderr);
empl.idnum = 1;
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 28 "binary.pgc"
if (sqlca.sqlcode)
exit (sqlca.sqlcode);
}
- { ECPGdo(__LINE__, 0, 1, NULL, "create table empl ( idnum integer , name char ( 20 ) , accs smallint , byte bytea ) ", ECPGt_EOIT, ECPGt_EORT);}
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table empl ( idnum integer , name char ( 20 ) , accs smallint , byte bytea ) ", ECPGt_EOIT, ECPGt_EORT);}
#line 36 "binary.pgc"
if (sqlca.sqlcode)
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35: QUERY: create table empl ( idnum integer , name char ( 20 ) , accs smallint , byte bytea ) on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: create table empl ( idnum integer , name char ( 20 ) , accs smallint , byte bytea ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 35 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
ECPGdebug(1,stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 15 "code100.pgc"
if (sqlca.sqlcode) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( \"index\" numeric ( 3 ) primary key , \"payload\" int4 not null ) ", ECPGt_EOIT, ECPGt_EORT);}
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( \"index\" numeric ( 3 ) primary key , \"payload\" int4 not null ) ", ECPGt_EOIT, ECPGt_EORT);}
#line 20 "code100.pgc"
if (sqlca.sqlcode) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 18: QUERY: create table test ( "index" numeric ( 3 ) primary key , "payload" int4 not null ) on connection regress1
+[NO_PID]: ECPGexecute line 18: QUERY: create table test ( "index" numeric ( 3 ) primary key , "payload" int4 not null ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 18 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGtrans line 22 action = commit connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 0 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 0 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 1 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 1 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 2 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 2 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 3 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 3 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 4 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 4 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 5 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 5 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 6 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 6 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 7 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 7 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 8 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 8 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values( 0 , 9 ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test ( payload , index ) values ( 0 , 9 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGtrans line 31 action = commit connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 34: QUERY: update test set payload = payload + 1 where index = - 1 on connection regress1
+[NO_PID]: ECPGexecute line 34: QUERY: update test set payload = payload + 1 where index = - 1 on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 34 Ok: UPDATE 0
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: raising sqlcode 100 in line 34, 'No data found in line 34.'.
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 38: QUERY: delete from test where index = - 1 on connection regress1
+[NO_PID]: ECPGexecute line 38: QUERY: delete from test where index = - 1 on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 38 Ok: DELETE 0
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: raising sqlcode 100 in line 38, 'No data found in line 38.'.
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 41: QUERY: insert into test ( select * from test where index = - 1 ) on connection regress1
+[NO_PID]: ECPGexecute line 41: QUERY: insert into test ( select * from test where index = - 1 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 41 Ok: INSERT 0 0
[NO_PID]: sqlca: code: 0, state: 00000
ECPGdebug (1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 19 "copystdout.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 20 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 21: QUERY: insert into foo values( 5 , 'abc' ) on connection regress1
+[NO_PID]: ECPGexecute line 21: QUERY: insert into foo values ( 5 , 'abc' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 21 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 22: QUERY: insert into foo values( 6 , 'def' ) on connection regress1
+[NO_PID]: ECPGexecute line 22: QUERY: insert into foo values ( 6 , 'def' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 22 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 23: QUERY: insert into foo values( 7 , 'ghi' ) on connection regress1
+[NO_PID]: ECPGexecute line 23: QUERY: insert into foo values ( 7 , 'ghi' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 23 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
/* exec sql whenever sqlerror do sqlprint ( ) ; */
#line 16 "define.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 17 "define.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
#line 17 "define.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( a int , b text ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( a int , b text ) ", ECPGt_EOIT, ECPGt_EORT);
#line 19 "define.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
- { ECPGdo(__LINE__, 0, 1, NULL, "select 1 , 29 :: text || '-' || 'abcdef' ", ECPGt_EOIT,
+ { ECPGdo(__LINE__, 0, 1, NULL, "select 1 , 29 :: text || '-' || 'abcdef' ", ECPGt_EOIT,
ECPGt_int,&(i),(long)1,(long)1,sizeof(int),
ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L,
ECPGt_char,(s),(long)200,(long)1,(200)*sizeof(char),
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 19: QUERY: create table test ( a int , b text ) on connection regress1
+[NO_PID]: ECPGexecute line 19: QUERY: create table test ( a int , b text ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 19 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 20: QUERY: insert into test values( 29 , 'abcdef' ) on connection regress1
+[NO_PID]: ECPGexecute line 20: QUERY: insert into test values ( 29 , 'abcdef' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 20 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 23: QUERY: insert into test values( null , 'defined' ) on connection regress1
+[NO_PID]: ECPGexecute line 23: QUERY: insert into test values ( null , 'defined' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 23 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 31: QUERY: insert into test values( null , 'someothervar not defined' ) on connection regress1
+[NO_PID]: ECPGexecute line 31: QUERY: insert into test values ( null , 'someothervar not defined' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 31 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 36: QUERY: select 1 , 29 :: text || '-' || 'abcdef' on connection regress1
+[NO_PID]: ECPGexecute line 36: QUERY: select 1 , 29 :: text || '-' || 'abcdef' on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 36: Correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_data line 36: RESULT: 29-abcdef offset: -1 array: Yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 42: QUERY: insert into test values( 29 , 'no string' ) on connection regress1
+[NO_PID]: ECPGexecute line 42: QUERY: insert into test values ( 29 , 'no string' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 42 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
#line 25 "desc.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 27 "desc.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
#line 27 "desc.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test1 ( a int , b text ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test1 ( a int , b text ) ", ECPGt_EOIT, ECPGt_EORT);
#line 29 "desc.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 29: QUERY: create table test1 ( a int , b text ) on connection regress1
+[NO_PID]: ECPGexecute line 29: QUERY: create table test1 ( a int , b text ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 29 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
/* exec sql whenever sqlerror do sqlprint ( ) ; */
#line 32 "dynalloc.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 33 "dynalloc.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
#line 35 "dynalloc.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( a serial , b numeric ( 12 , 3 ) , c varchar , d varchar ( 3 ) , e char ( 4 ) , f timestamptz , g boolean , h box , i inet ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( a serial , b numeric ( 12 , 3 ) , c varchar , d varchar ( 3 ) , e char ( 4 ) , f timestamptz , g boolean , h box , i inet ) ", ECPGt_EOIT, ECPGt_EORT);
#line 37 "dynalloc.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
if (sqlca.sqlcode < 0) sqlprint ( );
#line 41 "dynalloc.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "select a , b , c , d , e , f , g , h , i from test order by a", ECPGt_EOIT,
+ { ECPGdo(__LINE__, 0, 1, NULL, "select a , b , c , d , e , f , g , h , i from test order by a ", ECPGt_EOIT,
ECPGt_descriptor, "mydesc", 0L, 0L, 0L,
ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
#line 42 "dynalloc.pgc"
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 35 Ok: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 37: QUERY: create table test ( a serial , b numeric ( 12 , 3 ) , c varchar , d varchar ( 3 ) , e char ( 4 ) , f timestamptz , g boolean , h box , i inet ) on connection regress1
+[NO_PID]: ECPGexecute line 37: QUERY: create table test ( a serial , b numeric ( 12 , 3 ) , c varchar , d varchar ( 3 ) , e char ( 4 ) , f timestamptz , g boolean , h box , i inet ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 37 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 38: QUERY: insert into test ( b , c , d , e , f , g , h , i ) values( 23.456 , 'varchar' , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , true , '(1,2,3,4)' , '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128' ) on connection regress1
+[NO_PID]: ECPGexecute line 38: QUERY: insert into test ( b , c , d , e , f , g , h , i ) values ( 23.456 , 'varchar' , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , true , '(1,2,3,4)' , '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 38 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: QUERY: insert into test ( b , c , d , e , f , g , h , i ) values( 2.446456 , null , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , false , null , null ) on connection regress1
+[NO_PID]: ECPGexecute line 39: QUERY: insert into test ( b , c , d , e , f , g , h , i ) values ( 2.446456 , null , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , false , null , null ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 39 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 42: QUERY: select a , b , c , d , e , f , g , h , i from test order by a on connection regress1
+[NO_PID]: ECPGexecute line 42: QUERY: select a , b , c , d , e , f , g , h , i from test order by a on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 42: Correctly got 2 tuples with 9 fields
[NO_PID]: sqlca: code: 0, state: 00000
/* exec sql whenever sqlerror do sqlprint ( ) ; */
#line 19 "dynalloc2.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 20 "dynalloc2.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
#line 22 "dynalloc2.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( a int , b text ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( a int , b text ) ", ECPGt_EOIT, ECPGt_EORT);
#line 24 "dynalloc2.pgc"
if (sqlca.sqlcode < 0) sqlprint ( );}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 22 Ok: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 24: QUERY: create table test ( a int , b text ) on connection regress1
+[NO_PID]: ECPGexecute line 24: QUERY: create table test ( a int , b text ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 24 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 25: QUERY: insert into test values( 1 , 'one' ) on connection regress1
+[NO_PID]: ECPGexecute line 25: QUERY: insert into test values ( 1 , 'one' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 25 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: insert into test values( 2 , 'two' ) on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: insert into test values ( 2 , 'two' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 27: QUERY: insert into test values( null , 'three' ) on connection regress1
+[NO_PID]: ECPGexecute line 27: QUERY: insert into test values ( null , 'three' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 27 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 28: QUERY: insert into test values( 4 , 'four' ) on connection regress1
+[NO_PID]: ECPGexecute line 28: QUERY: insert into test values ( 4 , 'four' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 28 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 29: QUERY: insert into test values( 5 , null ) on connection regress1
+[NO_PID]: ECPGexecute line 29: QUERY: insert into test values ( 5 , null ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 29 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 30: QUERY: insert into test values( null , null ) on connection regress1
+[NO_PID]: ECPGexecute line 30: QUERY: insert into test values ( null , null ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 30 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
#line 45 "dyntest.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0);
#line 47 "dyntest.pgc"
if (sqlca.sqlcode < 0) error ( );}
#line 49 "dyntest.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table dyntest ( name char ( 14 ) , d float8 , i int , bignumber int8 , b boolean , comment text , day date ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table dyntest ( name char ( 14 ) , d float8 , i int , bignumber int8 , b boolean , comment text , day date ) ", ECPGt_EOIT, ECPGt_EORT);
#line 53 "dyntest.pgc"
if (sqlca.sqlcode < 0) error ( );}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 49 Ok: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 51: QUERY: create table dyntest ( name char ( 14 ) , d float8 , i int , bignumber int8 , b boolean , comment text , day date ) on connection regress1
+[NO_PID]: ECPGexecute line 51: QUERY: create table dyntest ( name char ( 14 ) , d float8 , i int , bignumber int8 , b boolean , comment text , day date ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 51 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 54: QUERY: insert into dyntest values( 'first entry' , 14.7 , 14 , 123045607890 , true , 'The world''s most advanced open source database.' , '1987-07-14' ) on connection regress1
+[NO_PID]: ECPGexecute line 54: QUERY: insert into dyntest values ( 'first entry' , 14.7 , 14 , 123045607890 , true , 'The world''s most advanced open source database.' , '1987-07-14' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 54 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 55: QUERY: insert into dyntest values( 'second entry' , 1407.87 , 1407 , 987065403210 , false , 'The elephant never forgets.' , '1999-11-5' ) on connection regress1
+[NO_PID]: ECPGexecute line 55: QUERY: insert into dyntest values ( 'second entry' , 1407.87 , 1407 , 987065403210 , false , 'The elephant never forgets.' , '1999-11-5' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 55 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , "main", 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , "main", 0);
#line 24 "execute.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 14 "fetch.pgc"
#line 17 "fetch.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table My_Table ( Item1 int , Item2 text ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table My_Table ( Item1 int , Item2 text ) ", ECPGt_EOIT, ECPGt_EORT);
#line 19 "fetch.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 19: QUERY: create table My_Table ( Item1 int , Item2 text ) on connection regress1
+[NO_PID]: ECPGexecute line 19: QUERY: create table My_Table ( Item1 int , Item2 text ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 19 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
int main(int argc, char* argv[]) {
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 10 "func.pgc"
#line 14 "func.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table My_Table ( Item1 int , Item2 text ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table My_Table ( Item1 int , Item2 text ) ", ECPGt_EOIT, ECPGt_EORT);
#line 16 "func.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
#line 16 "func.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create function My_Table_Check () returns trigger as $test$\
+ { ECPGdo(__LINE__, 0, 1, NULL, "create function My_Table_Check () returns trigger as $test$\
BEGIN\
RAISE WARNING 'Notice: TG_NAME=%, TG WHEN=%', TG_NAME, TG_WHEN;\
RETURN NEW;\
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGsetcommit line 12 action = on connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 16: QUERY: create table My_Table ( Item1 int , Item2 text ) on connection regress1
+[NO_PID]: ECPGexecute line 16: QUERY: create table My_Table ( Item1 int , Item2 text ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 16 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 18: QUERY: create function My_Table_Check () returns trigger as $test$ BEGIN RAISE WARNING 'Notice: TG_NAME=%, TG WHEN=%', TG_NAME, TG_WHEN; RETURN NEW; END; $test$ language plpgsql on connection regress1
+[NO_PID]: ECPGexecute line 18: QUERY: create function My_Table_Check () returns trigger as $test$ BEGIN RAISE WARNING 'Notice: TG_NAME=%, TG WHEN=%', TG_NAME, TG_WHEN; RETURN NEW; END; $test$ language plpgsql on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 18 Ok: CREATE FUNCTION
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: CREATE TRIGGER
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32: QUERY: insert into My_Table values( 1234 , 'Some random text' ) on connection regress1
+[NO_PID]: ECPGexecute line 32: QUERY: insert into My_Table values ( 1234 , 'Some random text' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: Notice: TG_NAME=my_table_check_trigger, TG WHEN=BEFORE[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: raising sqlcode 0
[NO_PID]: ECPGexecute line 32 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 01000
sql error Notice: TG_NAME=my_table_check_trigger, TG WHEN=BEFORE
-[NO_PID]: ECPGexecute line 33: QUERY: insert into My_Table values( 5678 , 'The Quick Brown' ) on connection regress1
+[NO_PID]: ECPGexecute line 33: QUERY: insert into My_Table values ( 5678 , 'The Quick Brown' ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: Notice: TG_NAME=my_table_check_trigger, TG WHEN=BEFORE[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: raising sqlcode 0
ECPGdebug(1,stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 16 "indicators.pgc"
{ ECPGsetcommit(__LINE__, "off", NULL);}
#line 17 "indicators.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( \"id\" int primary key , \"str\" text not null , val int null ) ", ECPGt_EOIT, ECPGt_EORT);}
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test ( \"id\" int primary key , \"str\" text not null , val int null ) ", ECPGt_EOIT, ECPGt_EORT);}
#line 22 "indicators.pgc"
{ ECPGtrans(__LINE__, NULL, "commit");}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGsetcommit line 17 action = off connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 19: QUERY: create table test ( "id" int primary key , "str" text not null , val int null ) on connection regress1
+[NO_PID]: ECPGexecute line 19: QUERY: create table test ( "id" int primary key , "str" text not null , val int null ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 19 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGtrans line 23 action = commit connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 25: QUERY: insert into test ( id , str , val ) values( 1 , 'Hello' , 0 ) on connection regress1
+[NO_PID]: ECPGexecute line 25: QUERY: insert into test ( id , str , val ) values ( 1 , 'Hello' , 0 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 25 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 28: QUERY: insert into test ( id , str , val ) values( 2 , 'Hi there' , null ) on connection regress1
+[NO_PID]: ECPGexecute line 28: QUERY: insert into test ( id , str , val ) values ( 2 , 'Hi there' , null ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 28 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 30: QUERY: insert into test ( id , str , val ) values( 3 , 'Good evening' , 5 ) on connection regress1
+[NO_PID]: ECPGexecute line 30: QUERY: insert into test ( id , str , val ) values ( 3 , 'Good evening' , 5 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 30 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_data line 37: RESULT: 5 offset: -1 array: Yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 42: QUERY: update test set val = null where id = 1 on connection regress1
+[NO_PID]: ECPGexecute line 42: QUERY: update test set val = null where id = 1 on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 42 Ok: UPDATE 1
[NO_PID]: sqlca: code: 0, state: 00000
--- /dev/null
+/* Processed by ecpg (regression mode) */
+/* These include files are added by the preprocessor */
+#include <ecpgtype.h>
+#include <ecpglib.h>
+#include <ecpgerrno.h>
+#include <sqlca.h>
+/* End of automatic include section */
+#define ECPGdebug(X,Y) ECPGdebug((X)+100,(Y))
+
+#line 1 "parser.pgc"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* test parser addition that merges two tokens into one */
+
+#line 1 "regression.h"
+
+
+
+
+
+
+#line 6 "parser.pgc"
+
+
+int main(int argc, char* argv[]) {
+ /* exec sql begin declare section */
+
+
+#line 10 "parser.pgc"
+ int item [ 3 ] , ind [ 3 ] , i ;
+/* exec sql end declare section */
+#line 11 "parser.pgc"
+
+
+ ECPGdebug(1, stderr);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
+#line 14 "parser.pgc"
+
+
+ { ECPGsetcommit(__LINE__, "on", NULL);}
+#line 16 "parser.pgc"
+
+ /* exec sql whenever sql_warning sqlprint ; */
+#line 17 "parser.pgc"
+
+ /* exec sql whenever sqlerror sqlprint ; */
+#line 18 "parser.pgc"
+
+
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table T ( Item1 int , Item2 int ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 20 "parser.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 20 "parser.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 20 "parser.pgc"
+
+
+ { ECPGdo(__LINE__, 0, 1, NULL, "insert into T values ( 1 , null ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 22 "parser.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 22 "parser.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 22 "parser.pgc"
+
+ { ECPGdo(__LINE__, 0, 1, NULL, "insert into T values ( 1 , 1 ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 23 "parser.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 23 "parser.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 23 "parser.pgc"
+
+ { ECPGdo(__LINE__, 0, 1, NULL, "insert into T values ( 1 , 2 ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 24 "parser.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 24 "parser.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 24 "parser.pgc"
+
+
+ { ECPGdo(__LINE__, 0, 1, NULL, "select Item2 from T order by Item2 nulls last", ECPGt_EOIT,
+ ECPGt_int,(item),(long)1,(long)3,sizeof(int),
+ ECPGt_int,(ind),(long)1,(long)3,sizeof(int), ECPGt_EORT);
+#line 26 "parser.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 26 "parser.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 26 "parser.pgc"
+
+
+ for (i=0; i<3; i++)
+ printf("item[%d] = %d\n", i, ind[i] ? -1 : item[i]);
+
+ { ECPGdo(__LINE__, 0, 1, NULL, "drop table T ", ECPGt_EOIT, ECPGt_EORT);
+#line 31 "parser.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 31 "parser.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 31 "parser.pgc"
+
+
+ { ECPGdisconnect(__LINE__, "ALL");
+#line 33 "parser.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 33 "parser.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 33 "parser.pgc"
+
+
+ return 0;
+}
--- /dev/null
+[NO_PID]: ECPGdebug: set to 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGsetcommit line 16 action = on connection = regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 20: QUERY: create table T ( Item1 int , Item2 int ) on connection regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 20 Ok: CREATE TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: QUERY: insert into T values ( 1 , null ) on connection regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: QUERY: insert into T values ( 1 , 1 ) on connection regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: QUERY: insert into T values ( 1 , 2 ) on connection regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: QUERY: select Item2 from T order by Item2 nulls last on connection regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: Correctly got 3 tuples with 1 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 26: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 26: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 26: RESULT: offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 31: QUERY: drop table T on connection regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 31 Ok: DROP TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: sqlca: code: 0, state: 00000
--- /dev/null
+item[0] = 1
+item[1] = 2
+item[2] = -1
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 13 "quote.pgc"
#line 17 "quote.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table \"My_Table\" ( Item1 int , Item2 text ) ", ECPGt_EOIT, ECPGt_EORT);
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table \"My_Table\" ( Item1 int , Item2 text ) ", ECPGt_EOIT, ECPGt_EORT);
#line 19 "quote.pgc"
if (sqlca.sqlwarn[0] == 'W') sqlprint();
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGsetcommit line 15 action = on connection = regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 19: QUERY: create table "My_Table" ( Item1 int , Item2 text ) on connection regress1
+[NO_PID]: ECPGexecute line 19: QUERY: create table "My_Table" ( Item1 int , Item2 text ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 19 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 13 "show.pgc"
ECPGdebug(1, stderr);
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 13 "update.pgc"
#line 26 "update.pgc"
;
- { ECPGdo(__LINE__, 0, 1, NULL, "select a , b from test order by a", ECPGt_EOIT,
+ { ECPGdo(__LINE__, 0, 1, NULL, "select a , b from test order by a ", ECPGt_EOIT,
ECPGt_int,(i1),(long)1,(long)3,sizeof(int),
ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L,
ECPGt_int,(i2),(long)1,(long)3,sizeof(int),
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 18 Ok: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 20: QUERY: insert into test ( a , b ) values( 1 , 1 ) on connection regress1
+[NO_PID]: ECPGexecute line 20: QUERY: insert into test ( a , b ) values ( 1 , 1 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 20 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 21: QUERY: insert into test ( a , b ) values( 2 , 2 ) on connection regress1
+[NO_PID]: ECPGexecute line 21: QUERY: insert into test ( a , b ) values ( 2 , 2 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 21 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 22: QUERY: insert into test ( a , b ) values( 3 , 3 ) on connection regress1
+[NO_PID]: ECPGexecute line 22: QUERY: insert into test ( a , b ) values ( 3 , 3 ) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 22 Ok: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 24 Ok: UPDATE 3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 25: QUERY: update test set ( a , b )=( 5 , 5 ) where a = 4 on connection regress1
+[NO_PID]: ECPGexecute line 25: QUERY: update test set ( a , b )= ( 5 , 5 ) where a = 4 on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 25 Ok: UPDATE 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 26 Ok: UPDATE 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 28: QUERY: select a , b from test order by a on connection regress1
+[NO_PID]: ECPGexecute line 28: QUERY: select a , b from test order by a on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGexecute line 28: Correctly got 3 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
/* setup test_thread table */
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 41 "thread.pgc"
{ ECPGdo(__LINE__, 0, 1, NULL, "drop table test_thread ", ECPGt_EOIT, ECPGt_EORT);}
{ ECPGtrans(__LINE__, NULL, "commit");}
#line 43 "thread.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test_thread ( tstamp timestamp not null default cast( timeofday () as timestamp ) , thread TEXT not null , iteration integer not null , primary key( thread , iteration ) ) ", ECPGt_EOIT, ECPGt_EORT);}
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test_thread ( tstamp timestamp not null default cast( timeofday () as timestamp ) , thread TEXT not null , iteration integer not null , primary key( thread , iteration ) ) ", ECPGt_EOIT, ECPGt_EORT);}
#line 48 "thread.pgc"
{ ECPGtrans(__LINE__, NULL, "commit");}
free(threads);
/* and check results */
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 72 "thread.pgc"
{ ECPGdo(__LINE__, 0, 1, NULL, "select count (*) from test_thread ", ECPGt_EOIT,
/* exec sql whenever sqlerror sqlprint ; */
#line 94 "thread.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , l_connection, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , l_connection, 0);
#line 95 "thread.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
/* setup test_thread table */
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 42 "thread_implicit.pgc"
{ ECPGdo(__LINE__, 0, 1, NULL, "drop table test_thread ", ECPGt_EOIT, ECPGt_EORT);}
{ ECPGtrans(__LINE__, NULL, "commit");}
#line 44 "thread_implicit.pgc"
- { ECPGdo(__LINE__, 0, 1, NULL, "create table test_thread ( tstamp timestamp not null default cast( timeofday () as timestamp ) , thread TEXT not null , iteration integer not null , primary key( thread , iteration ) ) ", ECPGt_EOIT, ECPGt_EORT);}
+ { ECPGdo(__LINE__, 0, 1, NULL, "create table test_thread ( tstamp timestamp not null default cast( timeofday () as timestamp ) , thread TEXT not null , iteration integer not null , primary key( thread , iteration ) ) ", ECPGt_EOIT, ECPGt_EORT);}
#line 49 "thread_implicit.pgc"
{ ECPGtrans(__LINE__, NULL, "commit");}
free(threads);
/* and check results */
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , NULL, 0); }
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
#line 73 "thread_implicit.pgc"
{ ECPGdo(__LINE__, 0, 1, NULL, "select count (*) from test_thread ", ECPGt_EOIT,
/* exec sql whenever sqlerror sqlprint ; */
#line 95 "thread_implicit.pgc"
- { ECPGconnect(__LINE__, 0, "regress1" , NULL,NULL , l_connection, 0);
+ { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , l_connection, 0);
#line 96 "thread_implicit.pgc"
if (sqlca.sqlcode < 0) sqlprint();}
fetch fetch.c \
func func.c \
indicators indicators.c \
+ parser parser.c \
quote quote.c \
show show.c \
update update.c
--- /dev/null
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* test parser addition that merges two tokens into one */
+EXEC SQL INCLUDE ../regression;
+
+int main(int argc, char* argv[]) {
+ EXEC SQL BEGIN DECLARE SECTION;
+ int item[3], ind[3], i;
+ EXEC SQL END DECLARE SECTION;
+
+ ECPGdebug(1, stderr);
+ EXEC SQL CONNECT TO REGRESSDB1;
+
+ EXEC SQL SET AUTOCOMMIT TO ON;
+ EXEC SQL WHENEVER SQLWARNING SQLPRINT;
+ EXEC SQL WHENEVER SQLERROR SQLPRINT;
+
+ EXEC SQL CREATE TABLE T ( Item1 int, Item2 int );
+
+ EXEC SQL INSERT INTO T VALUES ( 1, null );
+ EXEC SQL INSERT INTO T VALUES ( 1, 1 );
+ EXEC SQL INSERT INTO T VALUES ( 1, 2 );
+
+ EXEC SQL SELECT Item2 INTO :item:ind FROM T ORDER BY Item2 NULLS LAST;
+
+ for (i=0; i<3; i++)
+ printf("item[%d] = %d\n", i, ind[i] ? -1 : item[i]);
+
+ EXEC SQL DROP TABLE T;
+
+ EXEC SQL DISCONNECT ALL;
+
+ return 0;
+}
projects / postgresql / commitdiff