- Finished major rewrite to use new protocol version

- Really prepare statements
- Added more regression tests
- Added auto-prepare mode
- Use '$n' for positional variables, '?' is still possible via ecpg option
- Cleaned up the sources a little bit

src/interfaces/ecpg/test/Makefile

@@ -1,4 +1,4 @@
-# $PostgreSQL: pgsql/src/interfaces/ecpg/test/Makefile,v 1.71 2007/06/15 08:23:52 meskes Exp $
+# $PostgreSQL: pgsql/src/interfaces/ecpg/test/Makefile,v 1.72 2007/08/14 10:01:53 meskes Exp $
 
 subdir = src/interfaces/ecpg/test
 top_builddir = ../../../..
@@ -6,7 +6,7 @@ include $(top_builddir)/src/Makefile.global
 
 # port number for temp-installation test postmaster
 # this is also defined in test/connect/Makefile
-TEMP_PORT = 5$(DEF_PGPORT)
+TEMP_PORT = 4$(DEF_PGPORT)
 
 # where to find psql for testing an existing installation
 PSQLDIR = $(bindir)

src/interfaces/ecpg/test/compat_informix/dec_test.pgc

@@ -236,5 +236,4 @@ check_errno(void)
 			printf("(libc: (%s)) ", strerror(errno));
 			break;
 	}
-
 }

src/interfaces/ecpg/test/compat_informix/rnull.pgc

@@ -12,7 +12,7 @@ test_null(int type, char *ptr)
 
 int main(void)
 {
-	$char c[] = "abc       ";
+	$char c[] = "abc";
 	$short s = 17;
 	$int i = -74874;
 	$bool b = 1;

src/interfaces/ecpg/test/compat_informix/test_informix.pgc

@@ -69,7 +69,7 @@ int main(void)
 	deccvint(7, &j);
 	deccvint(14, &m);
 	decadd(&j, &m, &n);
-	$delete from test where i=:n;
+	$delete from test where i= :n::decimal;
 	printf("DELETE: %ld\n", sqlca.sqlcode);
 
 	$select 1 from test where i=14;

src/interfaces/ecpg/test/compat_informix/test_informix2.pgc

@@ -89,7 +89,7 @@ int main(void)
 
 	intvl = PGTYPESinterval_from_asc("1 day 2 hours 24 minutes 65 seconds", NULL);
 	PGTYPEStimestamp_add_interval(&d, intvl, &e);
-
+	free(intvl);
 	c++;
 
 	EXEC SQL insert into history

src/interfaces/ecpg/test/connect/Makefile

@@ -5,7 +5,7 @@ include $(top_srcdir)/$(subdir)/../Makefile.regress
 
 # port number for temp-installation test postmaster
 # this is also defined in ../Makefile
-TEMP_PORT = 5$(DEF_PGPORT)
+TEMP_PORT = 4$(DEF_PGPORT)
 
 test1.pgc: test1.pgc.in
 	sed -e 's,@TEMP_PORT@,$(TEMP_PORT),g' \

src/interfaces/ecpg/test/ecpg_schedule

@@ -13,6 +13,8 @@ test: pgtypeslib/dt_test
 test: pgtypeslib/dt_test2
 test: pgtypeslib/num_test
 test: pgtypeslib/num_test2
+test: preproc/array_of_struct
+test: preproc/autoprep
 test: preproc/comment
 test: preproc/define
 test: preproc/init
@@ -32,6 +34,7 @@ test: sql/execute
 test: sql/fetch
 test: sql/func
 test: sql/indicators
+test: sql/oldexec
 test: sql/quote
 test: sql/show
 test: sql/insupd

src/interfaces/ecpg/test/ecpg_schedule_tcp

@@ -13,6 +13,8 @@ test: pgtypeslib/dt_test
 test: pgtypeslib/dt_test2
 test: pgtypeslib/num_test
 test: pgtypeslib/num_test2
+test: preproc/array_of_struct
+test: preproc/autoprep
 test: preproc/comment
 test: preproc/define
 test: preproc/init
@@ -32,6 +34,7 @@ test: sql/execute
 test: sql/fetch
 test: sql/func
 test: sql/indicators
+test: sql/oldexec
 test: sql/quote
 test: sql/show
 test: sql/insupd

src/interfaces/ecpg/test/expected/compat_informix-dec_test.c

@@ -257,5 +257,4 @@ check_errno(void)
 			printf("(libc: (%s)) ", strerror(errno));
 			break;
 	}
-
 }

src/interfaces/ecpg/test/expected/compat_informix-rnull.c

@@ -35,7 +35,7 @@ int main(void)
 {
 	
 #line 15 "rnull.pgc"
- char  c []   = "abc       " ;
+ char  c []   = "abc" ;
 
 #line 15 "rnull.pgc"
 
@@ -106,7 +106,7 @@ 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, 0, 0, "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 (  );}
@@ -119,8 +119,8 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 34 "rnull.pgc"
 
 
-	{ ECPGdo(__LINE__, 1, 0, NULL, "insert into test ( id  , c  , s  , i  , b  , f  , l  , dbl  ) values ( 1 ,  ? ,  ? ,  ? ,  ? ,  ? ,  ? ,  ? ) ", 
-	ECPGt_char,(c),(long)sizeof("abc       "),(long)1,(sizeof("abc       "))*sizeof(char), 
+	{ ECPGdo(__LINE__, 1, 0, NULL, 0, 0, "insert into test ( id  , c  , s  , i  , b  , f  , l  , dbl  ) values ( 1 ,  $1  ,  $2  ,  $3  ,  $4  ,  $5  ,  $6  ,  $7  ) ", 
+	ECPGt_char,(c),(long)sizeof("abc"),(long)1,(sizeof("abc"))*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_short,&(s),(long)1,(long)1,sizeof(short), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
@@ -157,8 +157,8 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 	rsetnull(CDATETYPE, (char *) &dat);
 	rsetnull(CDTIMETYPE, (char *) &tmp);
 
-	{ ECPGdo(__LINE__, 1, 0, NULL, "insert into test ( id  , c  , s  , i  , b  , f  , l  , dbl  , dec  , dat  , tmp  ) values ( 2 ,  ? ,  ? ,  ? ,  ? ,  ? ,  ? ,  ? ,  ? ,  ? ,  ? ) ", 
-	ECPGt_char,(c),(long)sizeof("abc       "),(long)1,(sizeof("abc       "))*sizeof(char), 
+	{ ECPGdo(__LINE__, 1, 0, NULL, 0, 0, "insert into test ( id  , c  , s  , i  , b  , f  , l  , dbl  , dec  , dat  , tmp  ) values ( 2 ,  $1  ,  $2  ,  $3  ,  $4  ,  $5  ,  $6  ,  $7  ,  $8  ,  $9  ,  $10  ) ", 
+	ECPGt_char,(c),(long)sizeof("abc"),(long)1,(sizeof("abc"))*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_short,&(s),(long)1,(long)1,sizeof(short), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
@@ -192,8 +192,8 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 
 	printf("first select\n");
 
-	{ ECPGdo(__LINE__, 1, 0, NULL, "select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 1  ", ECPGt_EOIT, 
-	ECPGt_char,(c),(long)sizeof("abc       "),(long)1,(sizeof("abc       "))*sizeof(char), 
+	{ ECPGdo(__LINE__, 1, 0, NULL, 0, 0, "select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 1  ", ECPGt_EOIT, 
+	ECPGt_char,(c),(long)sizeof("abc"),(long)1,(sizeof("abc"))*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_short,&(s),(long)1,(long)1,sizeof(short), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
@@ -232,8 +232,8 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 
 	printf("second select\n");
 
-	{ ECPGdo(__LINE__, 1, 0, NULL, "select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 2  ", ECPGt_EOIT, 
-	ECPGt_char,(c),(long)sizeof("abc       "),(long)1,(sizeof("abc       "))*sizeof(char), 
+	{ ECPGdo(__LINE__, 1, 0, NULL, 0, 0, "select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 2  ", ECPGt_EOIT, 
+	ECPGt_char,(c),(long)sizeof("abc"),(long)1,(sizeof("abc"))*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_short,&(s),(long)1,(long)1,sizeof(short), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
@@ -270,7 +270,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 	test_null(CDATETYPE, (char *) &dat);
 	test_null(CDTIMETYPE, (char *) &tmp);
 
-	{ ECPGdo(__LINE__, 1, 0, NULL, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 0, NULL, 0, 0, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
 #line 91 "rnull.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}

src/interfaces/ecpg/test/expected/compat_informix-rnull.stderr

@@ -2,25 +2,67 @@
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 31: using PQexec
 [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 ,  $1  ,  $2  ,  $3  ,  $4  ,  $5  ,  $6  ,  $7  )  with 7 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: parameter 1 = abc
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: parameter 2 = 17
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: parameter 3 = -74874
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: parameter 4 = t
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: parameter 5 = 3.710000038147
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: parameter 6 = 487444
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: parameter 7 = 404.404
 [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 ,  $1  ,  $2  ,  $3  ,  $4  ,  $5  ,  $6  ,  $7  ,  $8  ,  $9  ,  $10  )  with 10 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 1 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 2 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 3 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 4 = t
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 5 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 6 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 7 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 8 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 9 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 10 = null
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 52 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 55 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 59: QUERY: select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 1   on connection regress1
+[NO_PID]: ECPGexecute line 59: QUERY: select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 1   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 59: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 59: Correctly got 1 tuples with 10 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -44,7 +86,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 59: RESULT:  offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 76: QUERY: select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 2   on connection regress1
+[NO_PID]: ECPGexecute line 76: QUERY: select  c , s , i , b , f , l , dbl , dec , dat , tmp  from test where id = 2   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 76: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 76: Correctly got 1 tuples with 10 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -68,7 +112,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 76: RESULT:  offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 91: QUERY: drop table test  on connection regress1
+[NO_PID]: ECPGexecute line 91: QUERY: drop table test  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 91: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 91 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/compat_informix-test_informix.c

@@ -58,7 +58,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 	if (sqlca.sqlcode != 0) exit(1);
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "create  table test ( i int   primary key   , j int   )    ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "create  table test ( i int   primary key   , j int   )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 23 "test_informix.pgc"
 
 if (sqlca.sqlcode < 0) dosqlprint (  );}
@@ -67,7 +67,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 	/* this INSERT works */
 	rsetnull(CDECIMALTYPE, (char *)&j);
-	{ ECPGdo(__LINE__, 1, 1, NULL, "insert into test ( i  , j  ) values ( 7 ,  ? ) ", 
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "insert into test ( i  , j  ) values ( 7 ,  $1  ) ", 
 	ECPGt_decimal,&(j),(long)1,(long)1,sizeof(decimal), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 27 "test_informix.pgc"
@@ -83,7 +83,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 
 	/* this INSERT should fail because i is a unique column */
-	{ ECPGdo(__LINE__, 1, 1, NULL, "insert into test ( i  , j  ) values ( 7 , 12 ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "insert into test ( i  , j  ) values ( 7 , 12 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 31 "test_informix.pgc"
 
 if (sqlca.sqlcode < 0) dosqlprint (  );}
@@ -97,7 +97,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 #line 33 "test_informix.pgc"
 
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "insert into test ( i  , j  ) values (  ? , 1 ) ", 
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "insert into test ( i  , j  ) values (  $1  , 1 ) ", 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 35 "test_informix.pgc"
@@ -113,7 +113,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 
 	/* this will fail (more than one row in subquery) */
-	{ ECPGdo(__LINE__, 1, 1, NULL, "select  i  from test where j = ( select  j  from test    )  ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "select  i  from test where j = ( select  j  from test    )  ", ECPGt_EOIT, ECPGt_EORT);
 #line 39 "test_informix.pgc"
 
 if (sqlca.sqlcode < 0) dosqlprint (  );}
@@ -127,7 +127,7 @@ 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, 0, 0, "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 (  );}
@@ -142,7 +142,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 
 	 ECPG_informix_set_var( 0, &( i ), __LINE__);\
-  /* declare c  cursor  for select  *  from test where i <=  ?   */
+  /* declare c  cursor  for select  *  from test where i <=  $1    */
 #line 47 "test_informix.pgc"
 
 	openit();
@@ -151,7 +151,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 	while (1)
 	{
-		{ ECPGdo(__LINE__, 1, 1, NULL, "fetch forward from c", ECPGt_EOIT, 
+		{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "fetch forward from c", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_decimal,&(j),(long)1,(long)1,sizeof(decimal), 
@@ -178,7 +178,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 	deccvint(7, &j);
 	deccvint(14, &m);
 	decadd(&j, &m, &n);
-	{ ECPGdo(__LINE__, 1, 1, NULL, "delete from test  where i =  ? ", 
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "delete from test  where i =  $1  :: decimal   ", 
 	ECPGt_decimal,&(n),(long)1,(long)1,sizeof(decimal), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 72 "test_informix.pgc"
@@ -188,7 +188,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 	printf("DELETE: %ld\n", sqlca.sqlcode);
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "select  1  from test where i = 14  ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "select  1  from test where i = 14  ", ECPGt_EOIT, ECPGt_EORT);
 #line 75 "test_informix.pgc"
 
 if (sqlca.sqlcode < 0) dosqlprint (  );}
@@ -196,7 +196,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 	printf("Exists: %ld\n", sqlca.sqlcode);
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "select  1  from test where i = 147  ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "select  1  from test where i = 147  ", ECPGt_EOIT, ECPGt_EORT);
 #line 78 "test_informix.pgc"
 
 if (sqlca.sqlcode < 0) dosqlprint (  );}
@@ -210,7 +210,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 if (sqlca.sqlcode < 0) dosqlprint (  );}
 #line 81 "test_informix.pgc"
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
 #line 82 "test_informix.pgc"
 
 if (sqlca.sqlcode < 0) dosqlprint (  );}
@@ -235,7 +235,7 @@ if (sqlca.sqlcode < 0) dosqlprint (  );}
 
 static void openit(void)
 {
-	{ ECPGdo(__LINE__, 1, 1, NULL, "declare c  cursor  for select  *  from test where i <=  ?  ", 
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "declare c  cursor  for select  *  from test where i <=  $1   ", 
 	ECPGt_int,&(*( int  *)(ECPG_informix_get_var( 0))),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 92 "test_informix.pgc"

src/interfaces/ecpg/test/expected/compat_informix-test_informix.stderr

@@ -2,47 +2,69 @@
 [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 23: QUERY: create  table test ( i int   primary key   , j int   )     on connection regress1
+[NO_PID]: ECPGexecute line 23: QUERY: create  table test ( i int   primary key   , j int   )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 27: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 27: parameter 1 = 0
 [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 )  with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 31: Error: ERROR:  duplicate key value violates unique constraint "test_pkey"
+[NO_PID]: ECPGexecute line 31: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 31: Error: ERROR:  duplicate key value violates unique constraint "test_pkey"
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 23505 (sqlcode: -239) in line 31, ''duplicate key value violates unique constraint "test_pkey"' in line 31.'.
 [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 (  $1  , 1 )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: parameter 1 = 14
 [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]: ECPGtrans line 36 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: QUERY: select  i  from test where j = ( select  j  from test    )   on connection regress1
+[NO_PID]: ECPGexecute line 39: QUERY: select  i  from test where j = ( select  j  from test    )   with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: Error: ERROR:  more than one row returned by a subquery used as an expression
+[NO_PID]: ECPGexecute line 39: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 39: Error: ERROR:  more than one row returned by a subquery used as an expression
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 21000 (sqlcode: -284) in line 39, ''more than one row returned by a subquery used as an expression' in line 39.'.
 [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  )   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 43: using PQexec
 [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]: ECPGexecute line 92: QUERY: declare c  cursor  for select  *  from test where i <=  14   on connection regress1
+[NO_PID]: ECPGexecute line 92: QUERY: declare c  cursor  for select  *  from test where i <=  $1    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 92: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 92: parameter 1 = 14
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 92 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 54: QUERY: fetch forward from c on connection regress1
+[NO_PID]: ECPGexecute line 54: QUERY: fetch forward from c with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 54: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 54: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -50,7 +72,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 54: RESULT: 0 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 54: QUERY: fetch forward from c on connection regress1
+[NO_PID]: ECPGexecute line 54: QUERY: fetch forward from c with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 54: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 54: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -58,23 +82,33 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 54: RESULT: 1 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 54: QUERY: fetch forward from c on connection regress1
+[NO_PID]: ECPGexecute line 54: QUERY: fetch forward from c with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 54: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 54: Correctly got 0 tuples with 2 fields
 [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 =  $1  :: decimal    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 72: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 72: parameter 1 = 21.0
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 72 Ok: DELETE 0
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlcode 100 in line 72, 'No data found in line 72.'.
 [NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 75: QUERY: select  1  from test where i = 14   on connection regress1
+[NO_PID]: ECPGexecute line 75: QUERY: select  1  from test where i = 14   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 75: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 75: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 78: QUERY: select  1  from test where i = 147   on connection regress1
+[NO_PID]: ECPGexecute line 78: QUERY: select  1  from test where i = 147   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 78: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 78: Correctly got 0 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -82,7 +116,9 @@
 [NO_PID]: sqlca: code: 100, state: 02000
 [NO_PID]: ECPGtrans line 81 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 82: QUERY: drop table test  on connection regress1
+[NO_PID]: ECPGexecute line 82: QUERY: drop table test  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 82: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 82 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/compat_informix-test_informix2.c

@@ -180,14 +180,14 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	sql_check("main", "connect", 0);
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "set DateStyle to 'DMY'", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "set DateStyle to 'DMY'", ECPGt_EOIT, ECPGt_EORT);
 #line 66 "test_informix2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 66 "test_informix2.pgc"
 
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "create  table history ( customerid integer   , timestamp timestamp without time zone   , action_taken char  ( 5 )    , narrative varchar ( 100 )    )    ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "create  table history ( customerid integer   , timestamp timestamp without time zone   , action_taken char  ( 5 )    , narrative varchar ( 100 )    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 68 "test_informix2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -195,7 +195,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	sql_check("main", "create", 0);
 	
-	{ ECPGdo(__LINE__, 1, 1, NULL, "insert into history ( customerid  , timestamp  , action_taken  , narrative  ) values ( 1 , '2003-05-07 13:28:34 CEST' , 'test' , 'test' ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "insert into history ( customerid  , timestamp  , action_taken  , narrative  ) values ( 1 , '2003-05-07 13:28:34 CEST' , 'test' , 'test' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 73 "test_informix2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -203,7 +203,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	sql_check("main", "insert", 0);
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "select  max ( timestamp )  from history   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "select  max ( timestamp )  from history   ", ECPGt_EOIT, 
 	ECPGt_timestamp,&(maxd),(long)1,(long)1,sizeof(timestamp), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 78 "test_informix2.pgc"
@@ -213,7 +213,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	sql_check("main", "select max", 100);
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "select  customerid , timestamp  from history where timestamp =  ?    limit 1 ", 
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "select  customerid , timestamp  from history where timestamp =  $1     limit 1 ", 
 	ECPGt_timestamp,&(maxd),(long)1,(long)1,sizeof(timestamp), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
 	ECPGt_int,&(c),(long)1,(long)1,sizeof(int), 
@@ -231,10 +231,10 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	intvl = PGTYPESinterval_from_asc("1 day 2 hours 24 minutes 65 seconds", NULL);
 	PGTYPEStimestamp_add_interval(&d, intvl, &e);
-
+	free(intvl);
 	c++;
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "insert into history ( customerid  , timestamp  , action_taken  , narrative  ) values (  ? ,  ? , 'test' , 'test' ) ", 
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "insert into history ( customerid  , timestamp  , action_taken  , narrative  ) values (  $1  ,  $2  , 'test' , 'test' ) ", 
 	ECPGt_int,&(c),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_timestamp,&(e),(long)1,(long)1,sizeof(timestamp), 
@@ -253,7 +253,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 100 "test_informix2.pgc"
 
 
-	{ ECPGdo(__LINE__, 1, 1, NULL, "drop table history ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 1, 1, NULL, 0, 0, "drop table history ", ECPGt_EOIT, ECPGt_EORT);
 #line 102 "test_informix2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}

src/interfaces/ecpg/test/expected/compat_informix-test_informix2.stderr

@@ -2,25 +2,37 @@
 [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 66: QUERY: set DateStyle to 'DMY' on connection regress1
+[NO_PID]: ECPGexecute line 66: QUERY: set DateStyle to 'DMY' with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 66: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 66 Ok: SET
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 68: QUERY: create  table history ( customerid integer   , timestamp timestamp without time zone   , action_taken char  ( 5 )    , narrative varchar ( 100 )    )     on connection regress1
+[NO_PID]: ECPGexecute line 68: QUERY: create  table history ( customerid integer   , timestamp timestamp without time zone   , action_taken char  ( 5 )    , narrative varchar ( 100 )    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 68: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
 [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]: ECPGexecute line 76: QUERY: select  max ( timestamp )  from history    on connection regress1
+[NO_PID]: ECPGexecute line 76: QUERY: select  max ( timestamp )  from history    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 76: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 76: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 76: RESULT: Wed 07 May 13:28:34 2003 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 81: QUERY: select  customerid , timestamp  from history where timestamp =  timestamp '2003-05-07 13:28:34'    limit 1  on connection regress1
+[NO_PID]: ECPGexecute line 81: QUERY: select  customerid , timestamp  from history where timestamp =  $1     limit 1  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 81: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 81: parameter 1 = 2003-05-07 13:28:34
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 81: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -28,13 +40,21 @@
 [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 (  $1  ,  $2  , 'test' , 'test' )  with 2 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 95: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 95: parameter 1 = 2
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 95: parameter 2 = 2003-05-08 15:53:39
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 95 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 100 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 102: QUERY: drop table history  on connection regress1
+[NO_PID]: ECPGexecute line 102: QUERY: drop table history  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 102: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 102 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/connect-test1.stderr

@@ -2,7 +2,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT> 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 23: QUERY: alter user connectuser  encrypted password 'connectpw' on connection main
+[NO_PID]: ECPGexecute line 23: QUERY: alter user connectuser  encrypted password 'connectpw' with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 23 Ok: ALTER ROLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/connect-test2.c

@@ -56,17 +56,17 @@ main(void)
 
 
 	/* this selects from "second" which was opened last */
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  current_database ()     ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  current_database ()     ", ECPGt_EOIT, 
 	ECPGt_char,(res),(long)200,(long)1,(200)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 28 "test2.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, "first", "select  current_database ()     ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, "first", 0, 0, "select  current_database ()     ", ECPGt_EOIT, 
 	ECPGt_char,(res),(long)200,(long)1,(200)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 29 "test2.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, "second", "select  current_database ()     ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, "second", 0, 0, "select  current_database ()     ", ECPGt_EOIT, 
 	ECPGt_char,(res),(long)200,(long)1,(200)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 30 "test2.pgc"
@@ -75,7 +75,7 @@ main(void)
 	{ ECPGsetconn(__LINE__, "first");}
 #line 32 "test2.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  current_database ()     ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  current_database ()     ", ECPGt_EOIT, 
 	ECPGt_char,(res),(long)200,(long)1,(200)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 33 "test2.pgc"
@@ -85,7 +85,7 @@ main(void)
 	{ ECPGdisconnect(__LINE__, "CURRENT");}
 #line 36 "test2.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  current_database ()     ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  current_database ()     ", ECPGt_EOIT, 
 	ECPGt_char,(res),(long)200,(long)1,(200)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 37 "test2.pgc"

src/interfaces/ecpg/test/expected/connect-test2.stderr

@@ -4,25 +4,33 @@
 [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 28: QUERY: select  current_database ()      on connection second
+[NO_PID]: ECPGexecute line 28: QUERY: select  current_database ()      with 0 parameter on connection second 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 28: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 28: RESULT: regress1 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 29: QUERY: select  current_database ()      on connection first
+[NO_PID]: ECPGexecute line 29: QUERY: select  current_database ()      with 0 parameter on connection first 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 29: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 29: RESULT: connectdb offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 30: QUERY: select  current_database ()      on connection second
+[NO_PID]: ECPGexecute line 30: QUERY: select  current_database ()      with 0 parameter on connection second 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 30: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 30: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 30: RESULT: regress1 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 33: QUERY: select  current_database ()      on connection first
+[NO_PID]: ECPGexecute line 33: QUERY: select  current_database ()      with 0 parameter on connection first 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 33: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 33: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -30,7 +38,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ecpg_finish: Connection first closed.
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 37: QUERY: select  current_database ()      on connection second
+[NO_PID]: ECPGexecute line 37: QUERY: select  current_database ()      with 0 parameter on connection second 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 37: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/connect-test3.c

@@ -55,7 +55,7 @@ main(void)
 
 
 	/* this selects from "second" which was opened last */
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  current_database ()     ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  current_database ()     ", ECPGt_EOIT, 
 	ECPGt_char,(res),(long)200,(long)1,(200)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 27 "test3.pgc"
@@ -65,7 +65,7 @@ main(void)
 	{ ECPGdisconnect(__LINE__, "CURRENT");}
 #line 30 "test3.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  current_database ()     ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  current_database ()     ", ECPGt_EOIT, 
 	ECPGt_char,(res),(long)200,(long)1,(200)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 31 "test3.pgc"

src/interfaces/ecpg/test/expected/connect-test3.stderr

@@ -4,7 +4,9 @@
 [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 27: QUERY: select  current_database ()      on connection second
+[NO_PID]: ECPGexecute line 27: QUERY: select  current_database ()      with 0 parameter on connection second 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 27: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 27: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -12,7 +14,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ecpg_finish: Connection second closed.
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 31: QUERY: select  current_database ()      on connection first
+[NO_PID]: ECPGexecute line 31: QUERY: select  current_database ()      with 0 parameter on connection first 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 31: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 31: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/connect-test5.c

@@ -40,7 +40,7 @@ main(void)
 	{ 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);}
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "alter user connectuser  encrypted password 'connectpw'", ECPGt_EOIT, ECPGt_EORT);}
 #line 23 "test5.pgc"
 
 	{ ECPGdisconnect(__LINE__, "CURRENT");}

src/interfaces/ecpg/test/expected/connect-test5.stderr

@@ -2,7 +2,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT> 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 23: QUERY: alter user connectuser  encrypted password 'connectpw' on connection main
+[NO_PID]: ECPGexecute line 23: QUERY: alter user connectuser  encrypted password 'connectpw' with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 23 Ok: ALTER ROLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/pgtypeslib-dt_test.c

@@ -66,13 +66,13 @@ main(void)
 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, 0, 0, "create  table date_test ( d date    , ts timestamp    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 29 "dt_test.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 29 "dt_test.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "set datestyle to iso", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set datestyle to iso", ECPGt_EOIT, ECPGt_EORT);
 #line 30 "dt_test.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -82,7 +82,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 	date1 = PGTYPESdate_from_asc(d1, NULL); 
 	ts1 = PGTYPEStimestamp_from_asc(t1, NULL); 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into date_test ( d  , ts  ) values (  ? ,  ? ) ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into date_test ( d  , ts  ) values (  $1  ,  $2  ) ", 
 	ECPGt_date,&(date1),(long)1,(long)1,sizeof(date), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_timestamp,&(ts1),(long)1,(long)1,sizeof(timestamp), 
@@ -93,7 +93,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 35 "dt_test.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from date_test where d =  ?  ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from date_test where d =  $1   ", 
 	ECPGt_date,&(date1),(long)1,(long)1,sizeof(date), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
 	ECPGt_date,&(date1),(long)1,(long)1,sizeof(date), 

src/interfaces/ecpg/test/expected/pgtypeslib-dt_test.stderr

@@ -2,19 +2,33 @@
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 29 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 30: QUERY: set datestyle to iso on connection regress1
+[NO_PID]: ECPGexecute line 30: QUERY: set datestyle to iso with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 30: using PQexec
 [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 (  $1  ,  $2  )  with 2 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: parameter 1 = 1966-01-17
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: parameter 2 = 2000-07-12 17:34:29
 [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]: ECPGexecute line 37: QUERY: select  *  from date_test where d =  date '1966-01-17'   on connection regress1
+[NO_PID]: ECPGexecute line 37: QUERY: select  *  from date_test where d =  $1    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: parameter 1 = 1966-01-17
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 37: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/pgtypeslib-num_test.c

@@ -68,7 +68,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 34 "num_test.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "create  table test ( text char  ( 5 )    , num numeric ( 14 , 7 )   )    ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table test ( text char  ( 5 )    , num numeric ( 14 , 7 )   )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 35 "num_test.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -98,7 +98,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 
 	des = PGTYPESnumeric_new();
 	PGTYPESnumeric_copy(res, des);
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( text  , num  ) values ( 'test' ,  ? ) ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test ( text  , num  ) values ( 'test' ,  $1  ) ", 
 	ECPGt_numeric,&(des),(long)1,(long)0,sizeof(numeric), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 60 "num_test.pgc"
@@ -111,7 +111,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 	PGTYPESnumeric_mul(value1, value2, res);
 	PGTYPESnumeric_free(value2);
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  num  from test where text = 'test'  ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  num  from test where text = 'test'  ", ECPGt_EOIT, 
 	ECPGt_numeric,&(des),(long)1,(long)0,sizeof(numeric), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 66 "num_test.pgc"

src/interfaces/ecpg/test/expected/pgtypeslib-num_test.stderr

@@ -4,15 +4,23 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGsetcommit line 34 action = off connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35: QUERY: create  table test ( text char  ( 5 )    , num numeric ( 14 , 7 )   )     on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: create  table test ( text char  ( 5 )    , num numeric ( 14 , 7 )   )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 35 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 60: QUERY: insert into test ( text  , num  ) values ( 'test' ,  2369.7 )  on connection regress1
+[NO_PID]: ECPGexecute line 60: QUERY: insert into test ( text  , num  ) values ( 'test' ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 60: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 60: parameter 1 = 2369.7
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 60 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 66: QUERY: select  num  from test where text = 'test'   on connection regress1
+[NO_PID]: ECPGexecute line 66: QUERY: select  num  from test where text = 'test'   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 66: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 66: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/preproc-array_of_struct.c

@@ -0,0 +1,265 @@
+/* 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 "array_of_struct.pgc"
+#include <stdio.h>
+
+
+#line 1 "regression.h"
+
+
+
+
+
+
+#line 3 "array_of_struct.pgc"
+
+
+/* exec sql whenever sqlerror  sqlprint ; */
+#line 5 "array_of_struct.pgc"
+
+/* exec sql whenever sql_warning  sqlprint ; */
+#line 6 "array_of_struct.pgc"
+
+/* exec sql whenever not found  sqlprint ; */
+#line 7 "array_of_struct.pgc"
+
+
+typedef  struct { 
+#line 12 "array_of_struct.pgc"
+   struct varchar_name_12  { int len; char arr[ 50 ]; }  name    ;
+ 
+#line 13 "array_of_struct.pgc"
+ int  phone    ;
+ }   customer ;
+#line 14 "array_of_struct.pgc"
+
+
+typedef  struct ind { 
+#line 19 "array_of_struct.pgc"
+ short  name_ind    ;
+ 
+#line 20 "array_of_struct.pgc"
+ short  phone_ind    ;
+ }   cust_ind ;
+#line 21 "array_of_struct.pgc"
+
+
+int main( int argc, char * argv[] )
+{
+    /* exec sql begin declare section */
+        
+        
+       
+      
+         
+             
+       typedef struct { 
+#line 30 "array_of_struct.pgc"
+   struct varchar_name_30  { int len; char arr[ 50 ]; }  name    ;
+ 
+#line 31 "array_of_struct.pgc"
+ int  phone    ;
+ }  customer2 ;
+
+#line 32 "array_of_struct.pgc"
+
+        
+       
+      
+         
+             
+       
+       
+      
+         
+             
+       
+       
+    
+#line 26 "array_of_struct.pgc"
+ customer  custs1 [ 10 ]    ;
+ 
+#line 27 "array_of_struct.pgc"
+ cust_ind  inds [ 10 ]    ;
+  
+#line 33 "array_of_struct.pgc"
+ customer2  custs2 [ 10 ]    ;
+ 
+#line 38 "array_of_struct.pgc"
+ struct customer3 { 
+#line 36 "array_of_struct.pgc"
+   struct varchar_name_36  { int len; char arr[ 50 ]; }  name    ;
+ 
+#line 37 "array_of_struct.pgc"
+ int  phone    ;
+ }  custs3 [ 10 ]    ;
+ 
+#line 43 "array_of_struct.pgc"
+ struct customer4 { 
+#line 41 "array_of_struct.pgc"
+   struct varchar_name_41  { int len; char arr[ 50 ]; }  name    ;
+ 
+#line 42 "array_of_struct.pgc"
+ int  phone    ;
+ }  custs4    ;
+ 
+#line 44 "array_of_struct.pgc"
+ int  r    ;
+/* exec sql end declare section */
+#line 45 "array_of_struct.pgc"
+
+
+    ECPGdebug(1, stderr);
+	  
+    { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); 
+#line 49 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 49 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 49 "array_of_struct.pgc"
+
+
+    { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table customers ( c varchar ( 50 )    , p int   )    ", ECPGt_EOIT, ECPGt_EORT);
+#line 51 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 51 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 51 "array_of_struct.pgc"
+
+    { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into customers values ( 'John Doe' , '12345' ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 52 "array_of_struct.pgc"
+
+if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint();
+#line 52 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 52 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 52 "array_of_struct.pgc"
+
+    { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into customers values ( 'Jane Doe' , '67890' ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 53 "array_of_struct.pgc"
+
+if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint();
+#line 53 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 53 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 53 "array_of_struct.pgc"
+
+
+    { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from customers     limit 2 ", ECPGt_EOIT, 
+	ECPGt_varchar,&(custs1->name),(long)50,(long)10,sizeof( customer ), 
+	ECPGt_short,&(inds->name_ind),(long)1,(long)10,sizeof( struct ind ), 
+	ECPGt_int,&(custs1->phone),(long)1,(long)10,sizeof( customer ), 
+	ECPGt_short,&(inds->phone_ind),(long)1,(long)10,sizeof( struct ind ), ECPGt_EORT);
+#line 55 "array_of_struct.pgc"
+
+if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint();
+#line 55 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 55 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 55 "array_of_struct.pgc"
+
+    printf("custs1:\n");
+    for (r = 0; r < 2; r++)
+    {
+	    printf( "name  - %s\n", custs1[r].name.arr );
+	    printf( "phone - %d\n", custs1[r].phone );
+    }
+
+    { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from customers     limit 2 ", ECPGt_EOIT, 
+	ECPGt_varchar,&(custs2->name),(long)50,(long)10,sizeof( customer2 ), 
+	ECPGt_short,&(inds->name_ind),(long)1,(long)10,sizeof( struct ind ), 
+	ECPGt_int,&(custs2->phone),(long)1,(long)10,sizeof( customer2 ), 
+	ECPGt_short,&(inds->phone_ind),(long)1,(long)10,sizeof( struct ind ), ECPGt_EORT);
+#line 63 "array_of_struct.pgc"
+
+if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint();
+#line 63 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 63 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 63 "array_of_struct.pgc"
+
+    printf("\ncusts2:\n");
+    for (r = 0; r < 2; r++)
+    {
+	    printf( "name  - %s\n", custs2[r].name.arr );
+	    printf( "phone - %d\n", custs2[r].phone );
+    }
+
+    { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from customers     limit 2 ", ECPGt_EOIT, 
+	ECPGt_varchar,&(custs3->name),(long)50,(long)10,sizeof( struct customer3 ), 
+	ECPGt_short,&(inds->name_ind),(long)1,(long)10,sizeof( struct ind ), 
+	ECPGt_int,&(custs3->phone),(long)1,(long)10,sizeof( struct customer3 ), 
+	ECPGt_short,&(inds->phone_ind),(long)1,(long)10,sizeof( struct ind ), ECPGt_EORT);
+#line 71 "array_of_struct.pgc"
+
+if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint();
+#line 71 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 71 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 71 "array_of_struct.pgc"
+
+    printf("\ncusts3:\n");
+    for (r = 0; r < 2; r++)
+    {
+	    printf( "name  - %s\n", custs3[r].name.arr );
+	    printf( "phone - %d\n", custs3[r].phone );
+    }
+
+    { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from customers     limit 1 ", ECPGt_EOIT, 
+	ECPGt_varchar,&(custs4.name),(long)50,(long)1,sizeof(struct varchar_name_41), 
+	ECPGt_short,&(inds[0].name_ind),(long)1,(long)1,sizeof(short), 
+	ECPGt_int,&(custs4.phone),(long)1,(long)1,sizeof(int), 
+	ECPGt_short,&(inds[0].phone_ind),(long)1,(long)1,sizeof(short), ECPGt_EORT);
+#line 79 "array_of_struct.pgc"
+
+if (sqlca.sqlcode == ECPG_NOT_FOUND) sqlprint();
+#line 79 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 79 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 79 "array_of_struct.pgc"
+
+    printf("\ncusts4:\n");
+    printf( "name  - %s\n", custs4.name.arr );
+    printf( "phone - %d\n", custs4.phone );
+
+    { ECPGdisconnect(__LINE__, "ALL");
+#line 84 "array_of_struct.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 84 "array_of_struct.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 84 "array_of_struct.pgc"
+
+
+    return( 0 );
+}

src/interfaces/ecpg/test/expected/preproc-array_of_struct.stderr

@@ -0,0 +1,76 @@
+[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]: ECPGexecute line 51: QUERY: create  table customers ( c varchar ( 50 )    , p int   )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 51: using PQexec
+[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 52: QUERY: insert into customers values ( 'John Doe' , '12345' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: QUERY: insert into customers values ( 'Jane Doe' , '67890' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 55: QUERY: select  *  from customers     limit 2  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 55: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 55: Correctly got 2 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 55: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 55: RESULT: Jane Doe offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 55: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 55: RESULT: 67890 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 63: QUERY: select  *  from customers     limit 2  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 63: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 63: Correctly got 2 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 63: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 63: RESULT: Jane Doe offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 63: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 63: RESULT: 67890 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: QUERY: select  *  from customers     limit 2  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: Correctly got 2 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 71: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 71: RESULT: Jane Doe offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 71: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 71: RESULT: 67890 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 79: QUERY: select  *  from customers     limit 1  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 79: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 79: Correctly got 1 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 79: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 79: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/preproc-array_of_struct.stdout

@@ -0,0 +1,21 @@
+custs1:
+name  - John Doe
+phone - 12345
+name  - Jane Doe
+phone - 67890
+
+custs2:
+name  - John Doe
+phone - 12345
+name  - Jane Doe
+phone - 67890
+
+custs3:
+name  - John Doe
+phone - 12345
+name  - Jane Doe
+phone - 67890
+
+custs4:
+name  - John Doe
+phone - 12345

src/interfaces/ecpg/test/expected/preproc-autoprep.c

@@ -0,0 +1,183 @@
+/* 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 "autoprep.pgc"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* test automatic prepare for all statements */
+
+#line 1 "regression.h"
+
+
+
+
+
+
+#line 6 "autoprep.pgc"
+
+
+int main(int argc, char* argv[]) {
+  /* exec sql begin declare section */
+  	     
+  
+#line 10 "autoprep.pgc"
+ int  item [ 4 ]    ,  ind [ 4 ]    ,  i   = 1 ;
+/* exec sql end declare section */
+#line 11 "autoprep.pgc"
+
+
+  ECPGdebug(1, stderr);
+  { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
+#line 14 "autoprep.pgc"
+
+
+  /* exec sql whenever sql_warning  sqlprint ; */
+#line 16 "autoprep.pgc"
+
+  /* exec sql whenever sqlerror  sqlprint ; */
+#line 17 "autoprep.pgc"
+
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "create  table T ( Item1 int   , Item2 int   )    ", ECPGt_EOIT, ECPGt_EORT);
+#line 19 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 19 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 19 "autoprep.pgc"
+
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "insert into T values ( 1 , null ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 21 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 21 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 21 "autoprep.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "insert into T values ( 1 ,  $1  ) ", 
+	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+#line 22 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 22 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 22 "autoprep.pgc"
+
+  i++;
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "insert into T values ( 1 ,  $1  ) ", 
+	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+#line 24 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 24 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 24 "autoprep.pgc"
+
+  { ECPGprepare(__LINE__, NULL, 0, "i", " insert into T values ( 1 , 2 )  ");
+#line 25 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 25 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 25 "autoprep.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 1, "i", ECPGt_EOIT, ECPGt_EORT);
+#line 26 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 26 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 26 "autoprep.pgc"
+
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "select  Item2  from T    order by Item2  nulls last", ECPGt_EOIT, 
+	ECPGt_int,(item),(long)1,(long)4,sizeof(int), 
+	ECPGt_int,(ind),(long)1,(long)4,sizeof(int), ECPGt_EORT);
+#line 28 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 28 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 28 "autoprep.pgc"
+
+
+  for (i=0; i<4; i++)
+  	printf("item[%d] = %d\n", i, ind[i] ? -1 : item[i]);
+
+  /* declare C  cursor  for select  Item1  from T    */
+#line 33 "autoprep.pgc"
+
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "declare C  cursor  for select  Item1  from T   ", ECPGt_EOIT, ECPGt_EORT);
+#line 35 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 35 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 35 "autoprep.pgc"
+
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "fetch 1 in C", ECPGt_EOIT, 
+	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
+#line 37 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 37 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 37 "autoprep.pgc"
+
+  printf("i = %d\n", i);
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "close C", ECPGt_EOIT, ECPGt_EORT);
+#line 40 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 40 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 40 "autoprep.pgc"
+
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 3, "drop table T ", ECPGt_EOIT, ECPGt_EORT);
+#line 42 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 42 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 42 "autoprep.pgc"
+
+
+  { ECPGdisconnect(__LINE__, "ALL");
+#line 44 "autoprep.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 44 "autoprep.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 44 "autoprep.pgc"
+
+
+  return 0;
+}

src/interfaces/ecpg/test/expected/preproc-autoprep.stderr

@@ -0,0 +1,116 @@
+[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]: ECPGauto_prepare line 19: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 19: NAME: ecpg1 QUERY: create  table T ( Item1 int   , Item2 int   )    
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 19: QUERY: create  table T ( Item1 int   , Item2 int   )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 19: using PQexecPrepared for create  table T ( Item1 int   , Item2 int   )    
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 19 Ok: CREATE TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGauto_prepare line 21: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 21: NAME: ecpg2 QUERY: insert into T values ( 1 , null ) 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 21: QUERY: insert into T values ( 1 , null )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 21: using PQexecPrepared for insert into T values ( 1 , null ) 
+[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]: ECPGauto_prepare line 22: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 22: NAME: ecpg3 QUERY: insert into T values ( 1 ,  $1  ) 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: QUERY: insert into T values ( 1 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: using PQexecPrepared for insert into T values ( 1 ,  $1  ) 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: parameter 1 = 1
+[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]: ECPGauto_prepare line 24: stmt found in cache, entry 6248
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: QUERY: insert into T values ( 1 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: using PQexecPrepared for insert into T values ( 1 ,  $1  ) 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: parameter 1 = 2
+[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]: ECPGprepare line 25: NAME: i QUERY:  insert into T values ( 1 , 2 )  
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: QUERY:  insert into T values ( 1 , 2 )   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecPrepared for  insert into T values ( 1 , 2 )  
+[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]: ECPGauto_prepare line 28: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 28: NAME: ecpg4 QUERY: select  Item2  from T    order by Item2  nulls last
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: QUERY: select  Item2  from T    order by Item2  nulls last with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: using PQexecPrepared for select  Item2  from T    order by Item2  nulls last
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: Correctly got 4 tuples with 1 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 28: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 28: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 28: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 28: RESULT:  offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGauto_prepare line 35: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 35: NAME: ecpg5 QUERY: declare C  cursor  for select  Item1  from T   
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: QUERY: declare C  cursor  for select  Item1  from T    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexecPrepared for declare C  cursor  for select  Item1  from T   
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35 Ok: DECLARE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGauto_prepare line 37: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 37: NAME: ecpg6 QUERY: fetch 1 in C
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: QUERY: fetch 1 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: using PQexecPrepared for fetch 1 in C
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: Correctly got 1 tuples with 1 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 37: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGauto_prepare line 40: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 40: NAME: ecpg7 QUERY: close C
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: QUERY: close C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: using PQexecPrepared for close C
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40 Ok: CLOSE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGauto_prepare line 42: stmt not in cache; inserting
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 42: NAME: ecpg8 QUERY: drop table T 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: QUERY: drop table T  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: using PQexecPrepared for drop table T 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42 Ok: DROP TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/preproc-autoprep.stdout

@@ -0,0 +1,5 @@
+item[0] = 1
+item[1] = 2
+item[2] = 2
+item[3] = -1
+i = 1

src/interfaces/ecpg/test/expected/preproc-define.c

@@ -78,7 +78,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 34 "define.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )    ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 36 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -91,13 +91,13 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 37 "define.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into Test ( name  , amount  , letter  ) values ( 'false' , 1 , 'f' ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into Test ( name  , amount  , letter  ) values ( 'false' , 1 , 'f' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 39 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 39 "define.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( name  , amount  , letter  ) values ( 'true' , 2 , 't' ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test ( name  , amount  , letter  ) values ( 'true' , 2 , 't' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 40 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -110,7 +110,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 41 "define.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from test   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from test   ", ECPGt_EOIT, 
 	ECPGt_char,(name),(long)8,(long)6,(8)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_int,(amount),(long)1,(long)6,sizeof(int), 
@@ -142,7 +142,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 		printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, n, i, a, i, l);
 	}
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
 #line 56 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}

src/interfaces/ecpg/test/expected/preproc-define.stderr

@@ -2,23 +2,31 @@
 [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 36: QUERY: create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )     on connection regress1
+[NO_PID]: ECPGexecute line 36: QUERY: create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 36 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 37 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: QUERY: insert into Test ( name  , amount  , letter  ) values ( 'false' , 1 , 'f' )  on connection regress1
+[NO_PID]: ECPGexecute line 39: QUERY: insert into Test ( name  , amount  , letter  ) values ( 'false' , 1 , 'f' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: using PQexec
 [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 40: QUERY: insert into test ( name  , amount  , letter  ) values ( 'true' , 2 , 't' )  on connection regress1
+[NO_PID]: ECPGexecute line 40: QUERY: insert into test ( name  , amount  , letter  ) values ( 'true' , 2 , 't' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 40 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 41 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 43: QUERY: select  *  from test    on connection regress1
+[NO_PID]: ECPGexecute line 43: QUERY: select  *  from test    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 43: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 43: Correctly got 2 tuples with 3 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -34,7 +42,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 43: RESULT: t offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 56: QUERY: drop table test  on connection regress1
+[NO_PID]: ECPGexecute line 56: QUERY: drop table test  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 56: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 56 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/preproc-init.c

@@ -207,7 +207,7 @@ int main(void)
 	/* exec sql whenever sqlerror  do fa (  ) ; */
 #line 87 "init.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
 #line 88 "init.pgc"
 
 if (sqlca.sqlcode < 0) fa (  );}
@@ -216,7 +216,7 @@ if (sqlca.sqlcode < 0) fa (  );}
 	/* exec sql whenever sqlerror  do fb ( 20 ) ; */
 #line 89 "init.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
 #line 90 "init.pgc"
 
 if (sqlca.sqlcode < 0) fb ( 20 );}
@@ -225,7 +225,7 @@ if (sqlca.sqlcode < 0) fb ( 20 );}
 	/* exec sql whenever sqlerror  do fc ( \"50\" ) ; */
 #line 91 "init.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
 #line 92 "init.pgc"
 
 if (sqlca.sqlcode < 0) fc ( "50" );}
@@ -234,7 +234,7 @@ if (sqlca.sqlcode < 0) fc ( "50" );}
 	/* exec sql whenever sqlerror  do fd ( \"50\" , 1 ) ; */
 #line 93 "init.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
 #line 94 "init.pgc"
 
 if (sqlca.sqlcode < 0) fd ( "50" , 1 );}
@@ -243,7 +243,7 @@ if (sqlca.sqlcode < 0) fd ( "50" , 1 );}
 	/* exec sql whenever sqlerror  do fe ( ENUM0 ) ; */
 #line 95 "init.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
 #line 96 "init.pgc"
 
 if (sqlca.sqlcode < 0) fe ( ENUM0 );}
@@ -252,7 +252,7 @@ if (sqlca.sqlcode < 0) fe ( ENUM0 );}
 	/* exec sql whenever sqlerror  do sqlnotice ( NULL , 0 ) ; */
 #line 97 "init.pgc"
  
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  now ()     ", ECPGt_EOIT, ECPGt_EORT);
 #line 98 "init.pgc"
 
 if (sqlca.sqlcode < 0) sqlnotice ( NULL , 0 );}

src/interfaces/ecpg/test/expected/preproc-type.c

@@ -120,7 +120,7 @@ main (void)
       exit (sqlca.sqlcode);
     }
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create  table empl ( idnum integer   , name char  ( 20 )    , accs smallint   , string1 char  ( 10 )    , string2 char  ( 10 )    , string3 char  ( 10 )    )    ", ECPGt_EOIT, ECPGt_EORT);}
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table empl ( idnum integer   , name char  ( 20 )    , accs smallint   , string1 char  ( 10 )    , string2 char  ( 10 )    , string3 char  ( 10 )    )    ", ECPGt_EOIT, ECPGt_EORT);}
 #line 51 "type.pgc"
 
   if (sqlca.sqlcode)
@@ -129,7 +129,7 @@ main (void)
       exit (sqlca.sqlcode);
     }
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into empl values ( 1 , 'user name' , 320 , 'first str' , 'second str' , 'third str' ) ", ECPGt_EOIT, ECPGt_EORT);}
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into empl values ( 1 , 'user name' , 320 , 'first str' , 'second str' , 'third str' ) ", ECPGt_EOIT, ECPGt_EORT);}
 #line 58 "type.pgc"
 
   if (sqlca.sqlcode)
@@ -138,7 +138,7 @@ main (void)
       exit (sqlca.sqlcode);
     }
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "select  idnum , name , accs , string1 , string2 , string3  from empl where idnum =  ?  ", 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  idnum , name , accs , string1 , string2 , string3  from empl where idnum =  $1   ", 
 	ECPGt_long,&(empl.idnum),(long)1,(long)1,sizeof(long), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
 	ECPGt_long,&(empl.idnum),(long)1,(long)1,sizeof(long), 

src/interfaces/ecpg/test/expected/preproc-type.stderr

@@ -2,15 +2,23 @@
 [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 50: QUERY: create  table empl ( idnum integer   , name char  ( 20 )    , accs smallint   , string1 char  ( 10 )    , string2 char  ( 10 )    , string3 char  ( 10 )    )     on connection regress1
+[NO_PID]: ECPGexecute line 50: QUERY: create  table empl ( idnum integer   , name char  ( 20 )    , accs smallint   , string1 char  ( 10 )    , string2 char  ( 10 )    , string3 char  ( 10 )    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 50: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 50 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 58: QUERY: insert into empl values ( 1 , 'user name' , 320 , 'first str' , 'second str' , 'third str' )  on connection regress1
+[NO_PID]: ECPGexecute line 58: QUERY: insert into empl values ( 1 , 'user name' , 320 , 'first str' , 'second str' , 'third str' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 58: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 58 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 65: QUERY: select  idnum , name , accs , string1 , string2 , string3  from empl where idnum =  1   on connection regress1
+[NO_PID]: ECPGexecute line 65: QUERY: select  idnum , name , accs , string1 , string2 , string3  from empl where idnum =  $1    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 65: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 65: parameter 1 = 1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 65: Correctly got 1 tuples with 6 fields
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/preproc-variable.c

@@ -75,7 +75,7 @@ main (void)
 #line 27 "variable.pgc"
  struct personal_struct { 
 #line 25 "variable.pgc"
-   struct varchar_name  { int len; char arr[ BUFFERSIZ ]; }  name    ;
+   struct varchar_name_25  { int len; char arr[ BUFFERSIZ ]; }  name    ;
  
 #line 26 "variable.pgc"
  struct birthinfo  birth    ;
@@ -128,7 +128,7 @@ if (sqlca.sqlcode < 0) exit (1);}
 
 
 	strcpy(msg, "set");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "set datestyle to iso", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set datestyle to iso", ECPGt_EOIT, ECPGt_EORT);
 #line 46 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
@@ -136,7 +136,7 @@ if (sqlca.sqlcode < 0) exit (1);}
 
 
 	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, 0, 0, "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) exit (1);}
@@ -144,31 +144,31 @@ if (sqlca.sqlcode < 0) exit (1);}
 
 
 	strcpy(msg, "insert");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into family ( name  , married  , children  ) values ( 'Mum' , '19870714' , 3 ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into family ( name  , married  , children  ) values ( 'Mum' , '19870714' , 3 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 52 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
 #line 52 "variable.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into family ( name  , born  , married  , children  ) values ( 'Dad' , '19610721' , '19870714' , 3 ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into family ( name  , born  , married  , children  ) values ( 'Dad' , '19610721' , '19870714' , 3 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 53 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
 #line 53 "variable.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into family ( name  , age  ) values ( 'Child 1' , 16 ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into family ( name  , age  ) values ( 'Child 1' , 16 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 54 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
 #line 54 "variable.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into family ( name  , age  ) values ( 'Child 2' , 14 ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into family ( name  , age  ) values ( 'Child 2' , 14 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 55 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
 #line 55 "variable.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into family ( name  , age  ) values ( 'Child 3' , 9 ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into family ( name  , age  ) values ( 'Child 3' , 9 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 56 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
@@ -184,7 +184,7 @@ if (sqlca.sqlcode < 0) exit (1);}
 
 
 	strcpy(msg, "open");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "declare cur  cursor  for select  name , born , age , married , children  from family   ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare cur  cursor  for select  name , born , age , married , children  from family   ", ECPGt_EOIT, ECPGt_EORT);
 #line 62 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
@@ -200,8 +200,8 @@ if (sqlca.sqlcode < 0) exit (1);}
 	memset(i, 0, sizeof(ind_personal));
 	while (1) {
 		strcpy(msg, "fetch");
-		{ ECPGdo(__LINE__, 0, 1, NULL, "fetch cur", ECPGt_EOIT, 
-	ECPGt_varchar,&(p->name),(long)BUFFERSIZ,(long)1,sizeof(struct varchar_name), 
+		{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch cur", ECPGt_EOIT, 
+	ECPGt_varchar,&(p->name),(long)BUFFERSIZ,(long)1,sizeof(struct varchar_name_25), 
 	ECPGt_int,&(i->ind_name),(long)1,(long)1,sizeof(int), 
 	ECPGt_long,&(p->birth.born),(long)1,(long)1,sizeof(long), 
 	ECPGt_long,&(i->ind_birth.born),(long)1,(long)1,sizeof(long), 
@@ -235,7 +235,7 @@ if (sqlca.sqlcode < 0) exit (1);}
 	}
 
 	strcpy(msg, "close");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "close cur", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close cur", ECPGt_EOIT, ECPGt_EORT);
 #line 88 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}
@@ -243,7 +243,7 @@ if (sqlca.sqlcode < 0) exit (1);}
 
 
 	strcpy(msg, "drop");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "drop table family ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table family ", ECPGt_EOIT, ECPGt_EORT);
 #line 91 "variable.pgc"
 
 if (sqlca.sqlcode < 0) exit (1);}

src/interfaces/ecpg/test/expected/preproc-variable.stderr

@@ -2,41 +2,59 @@
 [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 46: QUERY: set datestyle to iso on connection regress1
+[NO_PID]: ECPGexecute line 46: QUERY: set datestyle to iso with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: using PQexec
 [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   )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 49: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 49 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 52: QUERY: insert into family ( name  , married  , children  ) values ( 'Mum' , '19870714' , 3 )  on connection regress1
+[NO_PID]: ECPGexecute line 52: QUERY: insert into family ( name  , married  , children  ) values ( 'Mum' , '19870714' , 3 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 52 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 53: QUERY: insert into family ( name  , born  , married  , children  ) values ( 'Dad' , '19610721' , '19870714' , 3 )  on connection regress1
+[NO_PID]: ECPGexecute line 53: QUERY: insert into family ( name  , born  , married  , children  ) values ( 'Dad' , '19610721' , '19870714' , 3 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 53 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 54: QUERY: insert into family ( name  , age  ) values ( 'Child 1' , 16 )  on connection regress1
+[NO_PID]: ECPGexecute line 54: QUERY: insert into family ( name  , age  ) values ( 'Child 1' , 16 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 54: using PQexec
 [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 family ( name  , age  ) values ( 'Child 2' , 14 )  on connection regress1
+[NO_PID]: ECPGexecute line 55: QUERY: insert into family ( name  , age  ) values ( 'Child 2' , 14 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 55: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 55 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 56: QUERY: insert into family ( name  , age  ) values ( 'Child 3' , 9 )  on connection regress1
+[NO_PID]: ECPGexecute line 56: QUERY: insert into family ( name  , age  ) values ( 'Child 3' , 9 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 56: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 56 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 59 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 62: QUERY: declare cur  cursor  for select  name , born , age , married , children  from family    on connection regress1
+[NO_PID]: ECPGexecute line 62: QUERY: declare cur  cursor  for select  name , born , age , married , children  from family    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 62: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 62 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 71: QUERY: fetch cur on connection regress1
+[NO_PID]: ECPGexecute line 71: QUERY: fetch cur with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 71: Correctly got 1 tuples with 5 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -52,7 +70,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 71: RESULT: 3 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 71: QUERY: fetch cur on connection regress1
+[NO_PID]: ECPGexecute line 71: QUERY: fetch cur with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 71: Correctly got 1 tuples with 5 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -68,7 +88,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 71: RESULT: 3 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 71: QUERY: fetch cur on connection regress1
+[NO_PID]: ECPGexecute line 71: QUERY: fetch cur with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 71: Correctly got 1 tuples with 5 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -84,7 +106,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 71: RESULT:  offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 71: QUERY: fetch cur on connection regress1
+[NO_PID]: ECPGexecute line 71: QUERY: fetch cur with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 71: Correctly got 1 tuples with 5 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -100,7 +124,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 71: RESULT:  offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 71: QUERY: fetch cur on connection regress1
+[NO_PID]: ECPGexecute line 71: QUERY: fetch cur with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 71: Correctly got 1 tuples with 5 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -116,17 +142,23 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 71: RESULT:  offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 71: QUERY: fetch cur on connection regress1
+[NO_PID]: ECPGexecute line 71: QUERY: fetch cur with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 71: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 71: Correctly got 0 tuples with 5 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlcode 100 in line 71, 'No data found in line 71.'.
 [NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 88: QUERY: close cur on connection regress1
+[NO_PID]: ECPGexecute line 88: QUERY: close cur with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 88: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 88 Ok: CLOSE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 91: QUERY: drop table family  on connection regress1
+[NO_PID]: ECPGexecute line 91: QUERY: drop table family  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 91: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 91 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/preproc-whenever.c

@@ -65,13 +65,13 @@ int main(void)
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 31 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "create  table test ( i int   , c char  ( 10 )    )    ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table test ( i int   , c char  ( 10 )    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 32 "whenever.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 32 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( 1 , 'abcdefghij' ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( 1 , 'abcdefghij' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 33 "whenever.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -81,7 +81,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 	/* exec sql whenever sql_warning  do warn (  ) ; */
 #line 35 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from test   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from test   ", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(c),(long)6,(long)1,(6)*sizeof(char), 
@@ -104,7 +104,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 37 "whenever.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from nonexistant   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from nonexistant   ", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 39 "whenever.pgc"
@@ -128,7 +128,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 	/* exec sql whenever sqlerror  do print ( \"select\" ) ; */
 #line 42 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from nonexistant   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from nonexistant   ", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 43 "whenever.pgc"
@@ -152,7 +152,7 @@ if (sqlca.sqlcode < 0) print ( "select" );}
 	/* exec sql whenever sqlerror  call print2 (  ) ; */
 #line 46 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from nonexistant   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from nonexistant   ", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 47 "whenever.pgc"
@@ -176,7 +176,7 @@ if (sqlca.sqlcode < 0) print2 (  );}
 	/* exec sql whenever sqlerror  continue ; */
 #line 50 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from nonexistant   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from nonexistant   ", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 51 "whenever.pgc"
@@ -194,7 +194,7 @@ if (sqlca.sqlwarn[0] == 'W') warn (  );}
 	/* exec sql whenever sqlerror  goto  error ; */
 #line 54 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from nonexistant   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from nonexistant   ", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 55 "whenever.pgc"
@@ -221,7 +221,7 @@ if (sqlca.sqlcode < 0) goto error;}
 	/* exec sql whenever sqlerror  stop ; */
 #line 61 "whenever.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from nonexistant   ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from nonexistant   ", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 62 "whenever.pgc"

src/interfaces/ecpg/test/expected/preproc-whenever.stderr

@@ -2,15 +2,21 @@
 [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 32: QUERY: create  table test ( i int   , c char  ( 10 )    )     on connection regress1
+[NO_PID]: ECPGexecute line 32: QUERY: create  table test ( i int   , c char  ( 10 )    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 32 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 33: QUERY: insert into test values ( 1 , 'abcdefghij' )  on connection regress1
+[NO_PID]: ECPGexecute line 33: QUERY: insert into test values ( 1 , 'abcdefghij' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 33: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 33 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 36: QUERY: select  *  from test    on connection regress1
+[NO_PID]: ECPGexecute line 36: QUERY: select  *  from test    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: using PQexec
 [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
@@ -21,18 +27,22 @@
 Warning: At least one column was truncated
 [NO_PID]: ECPGtrans line 37 action = rollback connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: QUERY: select  *  from nonexistant    on connection regress1
+[NO_PID]: ECPGexecute line 39: QUERY: select  *  from nonexistant    with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: Error: ERROR:  relation "nonexistant" does not exist
+[NO_PID]: ECPGexecute line 39: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 39: Error: ERROR:  relation "nonexistant" does not exist
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 39, ''relation "nonexistant" does not exist' in line 39.'.
 [NO_PID]: sqlca: code: -400, state: 42P01
 sql error 'relation "nonexistant" does not exist' in line 39.
 [NO_PID]: ECPGtrans line 40 action = rollback connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 43: QUERY: select  *  from nonexistant    on connection regress1
+[NO_PID]: ECPGexecute line 43: QUERY: select  *  from nonexistant    with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 43: Error: ERROR:  relation "nonexistant" does not exist
+[NO_PID]: ECPGexecute line 43: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 43: Error: ERROR:  relation "nonexistant" does not exist
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 43, ''relation "nonexistant" does not exist' in line 43.'.
 [NO_PID]: sqlca: code: -400, state: 42P01
@@ -40,9 +50,11 @@ Error in statement 'select':
 sql error 'relation "nonexistant" does not exist' in line 43.
 [NO_PID]: ECPGtrans line 44 action = rollback connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 47: QUERY: select  *  from nonexistant    on connection regress1
+[NO_PID]: ECPGexecute line 47: QUERY: select  *  from nonexistant    with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 47: Error: ERROR:  relation "nonexistant" does not exist
+[NO_PID]: ECPGexecute line 47: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 47: Error: ERROR:  relation "nonexistant" does not exist
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 47, ''relation "nonexistant" does not exist' in line 47.'.
 [NO_PID]: sqlca: code: -400, state: 42P01
@@ -50,25 +62,31 @@ Found another error
 sql error 'relation "nonexistant" does not exist' in line 47.
 [NO_PID]: ECPGtrans line 48 action = rollback connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 51: QUERY: select  *  from nonexistant    on connection regress1
+[NO_PID]: ECPGexecute line 51: QUERY: select  *  from nonexistant    with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 51: Error: ERROR:  relation "nonexistant" does not exist
+[NO_PID]: ECPGexecute line 51: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 51: Error: ERROR:  relation "nonexistant" does not exist
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 51, ''relation "nonexistant" does not exist' in line 51.'.
 [NO_PID]: sqlca: code: -400, state: 42P01
 [NO_PID]: ECPGtrans line 52 action = rollback connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 55: QUERY: select  *  from nonexistant    on connection regress1
+[NO_PID]: ECPGexecute line 55: QUERY: select  *  from nonexistant    with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 55: Error: ERROR:  relation "nonexistant" does not exist
+[NO_PID]: ECPGexecute line 55: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 55: Error: ERROR:  relation "nonexistant" does not exist
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 55, ''relation "nonexistant" does not exist' in line 55.'.
 [NO_PID]: sqlca: code: -400, state: 42P01
 [NO_PID]: ECPGtrans line 59 action = rollback connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 62: QUERY: select  *  from nonexistant    on connection regress1
+[NO_PID]: ECPGexecute line 62: QUERY: select  *  from nonexistant    with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 62: Error: ERROR:  relation "nonexistant" does not exist
+[NO_PID]: ECPGexecute line 62: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGcheck_PQresult line 62: Error: ERROR:  relation "nonexistant" does not exist
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 62, ''relation "nonexistant" does not exist' in line 62.'.
 [NO_PID]: sqlca: code: -400, state: 42P01

src/interfaces/ecpg/test/expected/sql-array.c

@@ -156,21 +156,21 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 31 "array.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "create  table test ( f float    , i int   , a int [ 10 ]   , text char  ( 10 )    )    ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table test ( f float    , i int   , a int [ 10 ]   , text char  ( 10 )    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 33 "array.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 33 "array.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( f  , i  , a  , text  ) values ( 404.90 , 3 , '{0,1,2,3,4,5,6,7,8,9}' , 'abcdefghij' ) ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test ( f  , i  , a  , text  ) values ( 404.90 , 3 , '{0,1,2,3,4,5,6,7,8,9}' , 'abcdefghij' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 35 "array.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 35 "array.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( f  , i  , a  , text  ) values ( 140787.0 , 2 ,  ? ,  ? ) ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test ( f  , i  , a  , text  ) values ( 140787.0 , 2 ,  $1  ,  $2  ) ", 
 	ECPGt_int,(a),(long)1,(long)10,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(text),(long)25,(long)1,(25)*sizeof(char), 
@@ -180,8 +180,8 @@ if (sqlca.sqlcode < 0) sqlprint();}
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 37 "array.pgc"
 
-	
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( f  , i  , a  , text  ) values ( 14.07 ,  ? ,  ? ,  ? ) ", 
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test ( f  , i  , a  , text  ) values ( 14.07 ,  $1  ,  $2  ,  $3  ) ", 
 	ECPGt_int,&(did),(long)1,(long)0,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_int,(a),(long)1,(long)10,sizeof(int), 
@@ -208,7 +208,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 43 "array.pgc"
  
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  f , text  from test where i = 1  ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  f , text  from test where i = 1  ", ECPGt_EOIT, 
 	ECPGt_double,&(f),(long)1,(long)1,sizeof(double), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(text),(long)25,(long)1,(25)*sizeof(char), 
@@ -222,7 +222,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 	printf("Found f=%f text=%10.10s\n", f, text);
 
 	f=140787;
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  a , text  from test where f =  ?  ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  a , text  from test where f =  $1   ", 
 	ECPGt_double,&(f),(long)1,(long)1,sizeof(double), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
 	ECPGt_int,(a),(long)1,(long)10,sizeof(int), 
@@ -240,7 +240,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	printf("Found text=%10.10s\n", t);
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  a  from test where f =  ?  ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  a  from test where f =  $1   ", 
 	ECPGt_double,&(f),(long)1,(long)1,sizeof(double), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
 	ECPGt_char,(text),(long)25,(long)1,(25)*sizeof(char), 
@@ -253,7 +253,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	printf("Found text=%s\n", text);
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
 #line 70 "array.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}

src/interfaces/ecpg/test/expected/sql-array.stderr

@@ -6,19 +6,37 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 31 action = begin transaction  connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 33: QUERY: create  table test ( f float    , i int   , a int [ 10 ]   , text char  ( 10 )    )     on connection regress1
+[NO_PID]: ECPGexecute line 33: QUERY: create  table test ( f float    , i int   , a int [ 10 ]   , text char  ( 10 )    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 33: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 33 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35: QUERY: insert into test ( f  , i  , a  , text  ) values ( 404.90 , 3 , '{0,1,2,3,4,5,6,7,8,9}' , 'abcdefghij' )  on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: insert into test ( f  , i  , a  , text  ) values ( 404.90 , 3 , '{0,1,2,3,4,5,6,7,8,9}' , 'abcdefghij' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
 [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]: ECPGexecute line 37: QUERY: insert into test ( f  , i  , a  , text  ) values ( 140787.0 , 2 ,  array [9,8,7,6,5,4,3,2,1,0] ,  'klmnopqrst' )  on connection regress1
+[NO_PID]: ECPGexecute line 37: QUERY: insert into test ( f  , i  , a  , text  ) values ( 140787.0 , 2 ,  $1  ,  $2  )  with 2 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: parameter 1 = {9,8,7,6,5,4,3,2,1,0}
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: parameter 2 = klmnopqrst
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 37 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: QUERY: insert into test ( f  , i  , a  , text  ) values ( 14.07 ,  1 ,  array [9,8,7,6,5,4,3,2,1,0] ,  '0123456789' )  on connection regress1
+[NO_PID]: ECPGexecute line 39: QUERY: insert into test ( f  , i  , a  , text  ) values ( 14.07 ,  $1  ,  $2  ,  $3  )  with 3 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: parameter 1 = 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: parameter 2 = {9,8,7,6,5,4,3,2,1,0}
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: parameter 3 = 0123456789
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 39 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -26,7 +44,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 43 action = begin transaction  connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 45: QUERY: select  f , text  from test where i = 1   on connection regress1
+[NO_PID]: ECPGexecute line 45: QUERY: select  f , text  from test where i = 1   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 45: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 45: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -34,7 +54,11 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 45: RESULT: 0123456789 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 53: QUERY: select  a , text  from test where f =  140787   on connection regress1
+[NO_PID]: ECPGexecute line 53: QUERY: select  a , text  from test where f =  $1    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: parameter 1 = 140787
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 53: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -44,13 +68,19 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 53: RESULT: klmnopqrst offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 63: QUERY: select  a  from test where f =  140787   on connection regress1
+[NO_PID]: ECPGexecute line 63: QUERY: select  a  from test where f =  $1    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 63: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 63: parameter 1 = 140787
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 63: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 63: RESULT: {9,8,7,6,5,4,3,2,1,0} offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 70: QUERY: drop table test  on connection regress1
+[NO_PID]: ECPGexecute line 70: QUERY: drop table test  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 70: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 70 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-binary.c

@@ -75,7 +75,7 @@ main (void)
       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, 0, 0, "create  table empl ( idnum integer   , name char  ( 20 )    , accs smallint   , byte bytea    )    ", ECPGt_EOIT, ECPGt_EORT);}
 #line 36 "binary.pgc"
 
   if (sqlca.sqlcode)
@@ -84,7 +84,7 @@ main (void)
       exit (sqlca.sqlcode);
     }
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into empl values ( 1 , 'first user' , 320 ,  ? ) ", 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into empl values ( 1 , 'first user' , 320 ,  $1  ) ", 
 	ECPGt_char,&(data),(long)0,(long)1,(1)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
 #line 43 "binary.pgc"
@@ -95,15 +95,15 @@ main (void)
       exit (sqlca.sqlcode);
     }
 
-  /* declare C  cursor  for select  name , accs , byte  from empl where idnum =  ?   */
+  /* declare C  cursor  for select  name , accs , byte  from empl where idnum =  $1    */
 #line 50 "binary.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "declare C  cursor  for select  name , accs , byte  from empl where idnum =  ?  ", 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare C  cursor  for select  name , accs , byte  from empl where idnum =  $1   ", 
 	ECPGt_long,&(empl.idnum),(long)1,(long)1,sizeof(long), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
 #line 51 "binary.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "fetch C", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch C", ECPGt_EOIT, 
 	ECPGt_char,(empl.name),(long)21,(long)1,(21)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_short,&(empl.accs),(long)1,(long)1,sizeof(short), 
@@ -122,15 +122,15 @@ main (void)
 
   memset(empl.name, 0, 21L);
   memset(empl.byte, '#', 20L);
-  /* declare B  binary cursor  for select  name , accs , byte  from empl where idnum =  ?   */
+  /* declare B  binary cursor  for select  name , accs , byte  from empl where idnum =  $1    */
 #line 63 "binary.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "declare B  binary cursor  for select  name , accs , byte  from empl where idnum =  ?  ", 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare B  binary cursor  for select  name , accs , byte  from empl where idnum =  $1   ", 
 	ECPGt_long,&(empl.idnum),(long)1,(long)1,sizeof(long), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
 #line 64 "binary.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "fetch B", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch B", ECPGt_EOIT, 
 	ECPGt_char,(empl.name),(long)21,(long)1,(21)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_short,&(empl.accs),(long)1,(long)1,sizeof(short), 
@@ -145,7 +145,7 @@ main (void)
       exit (sqlca.sqlcode);
     }
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "close B", ECPGt_EOIT, ECPGt_EORT);}
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close B", ECPGt_EOIT, ECPGt_EORT);}
 #line 72 "binary.pgc"
 
 

src/interfaces/ecpg/test/expected/sql-binary.stderr

@@ -2,19 +2,31 @@
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 35 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 43: QUERY: insert into empl values ( 1 , 'first user' , 320 ,  E'\\001\\155\\000\\212' )  on connection regress1
+[NO_PID]: ECPGexecute line 43: QUERY: insert into empl values ( 1 , 'first user' , 320 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 43: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 43: parameter 1 = \001\155\000\212
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 43 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 51: QUERY: declare C  cursor  for select  name , accs , byte  from empl where idnum =  1   on connection regress1
+[NO_PID]: ECPGexecute line 51: QUERY: declare C  cursor  for select  name , accs , byte  from empl where idnum =  $1    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 51: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 51: parameter 1 = 1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 51 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 52: QUERY: fetch C on connection regress1
+[NO_PID]: ECPGexecute line 52: QUERY: fetch C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 52: Correctly got 1 tuples with 3 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -24,11 +36,17 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 52: RESULT: \001m\000\212 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 64: QUERY: declare B  binary cursor  for select  name , accs , byte  from empl where idnum =  1   on connection regress1
+[NO_PID]: ECPGexecute line 64: QUERY: declare B  binary cursor  for select  name , accs , byte  from empl where idnum =  $1    with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 64: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 64: parameter 1 = 1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 64 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 65: QUERY: fetch B on connection regress1
+[NO_PID]: ECPGexecute line 65: QUERY: fetch B with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 65: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 65: Correctly got 1 tuples with 3 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -38,7 +56,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 65: RESULT: BINARY offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 72: QUERY: close B on connection regress1
+[NO_PID]: ECPGexecute line 72: QUERY: close B with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 72: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 72 Ok: CLOSE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-code100.c

@@ -111,7 +111,7 @@ int main(int argc, char **argv)
 
    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, 0, 0, "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);
@@ -121,7 +121,7 @@ int main(int argc, char **argv)
    if (sqlca.sqlcode) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);
    
    for (index=0;index<10;++index)
-   {  { ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( payload  , index  ) values ( 0 ,  ? ) ", 
+   {  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test ( payload  , index  ) values ( 0 ,  $1  ) ", 
 	ECPGt_int,&(index),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);}
 #line 28 "code100.pgc"
@@ -133,22 +133,22 @@ int main(int argc, char **argv)
 
    if (sqlca.sqlcode) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);
    
-   { ECPGdo(__LINE__, 0, 1, NULL, "update test set payload  = payload + 1  where index = - 1 ", ECPGt_EOIT, ECPGt_EORT);}
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "update test set payload  = payload + 1  where index = - 1 ", ECPGt_EOIT, ECPGt_EORT);}
 #line 35 "code100.pgc"
 
    if (sqlca.sqlcode!=100) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);
    
-   { ECPGdo(__LINE__, 0, 1, NULL, "delete from test  where index = - 1 ", ECPGt_EOIT, ECPGt_EORT);}
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "delete from test  where index = - 1 ", ECPGt_EOIT, ECPGt_EORT);}
 #line 38 "code100.pgc"
 
    if (sqlca.sqlcode!=100) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( select  *  from test where index = - 1   ) ", ECPGt_EOIT, ECPGt_EORT);}
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test ( select  *  from test where index = - 1   ) ", ECPGt_EOIT, ECPGt_EORT);}
 #line 41 "code100.pgc"
 
    if (sqlca.sqlcode!=100) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "drop table test ", ECPGt_EOIT, ECPGt_EORT);}
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table test ", ECPGt_EOIT, ECPGt_EORT);}
 #line 44 "code100.pgc"
 
    if (sqlca.sqlcode) printf("%ld:%s\n",sqlca.sqlcode,sqlca.sqlerrm.sqlerrmc);

src/interfaces/ecpg/test/expected/sql-code100.stderr

@@ -2,73 +2,123 @@
 [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 )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 18: using PQexec
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 0
 [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  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 1
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 2
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 3
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 4
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 5
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 6
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 7
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 8
 [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 ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: parameter 1 = 9
 [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  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 34: using PQexec
 [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  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 38: using PQexec
 [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   )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 41 Ok: INSERT 0 0
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlcode 100 in line 41, 'No data found in line 41.'.
 [NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 44: QUERY: drop table test  on connection regress1
+[NO_PID]: ECPGexecute line 44: QUERY: drop table test  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 44: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 44 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-copystdout.c

@@ -113,25 +113,25 @@ main ()
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 19 "copystdout.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create  table foo ( a int   , b varchar    )    ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table foo ( a int   , b varchar    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 20 "copystdout.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 20 "copystdout.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into foo values ( 5 , 'abc' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into foo values ( 5 , 'abc' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 21 "copystdout.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 21 "copystdout.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into foo values ( 6 , 'def' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into foo values ( 6 , 'def' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 22 "copystdout.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 22 "copystdout.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into foo values ( 7 , 'ghi' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into foo values ( 7 , 'ghi' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 23 "copystdout.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -142,7 +142,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
   /* EXEC SQL COPY foo TO:fname WITH DELIMITER ','; */
   /* printf ("copy to /tmp/foo : sqlca.sqlcode = %ld", sqlca.sqlcode); */
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "copy  foo  to stdout  with  delimiter  ','", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "copy  foo  to stdout  with  delimiter  ','", ECPGt_EOIT, ECPGt_EORT);
 #line 29 "copystdout.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}

src/interfaces/ecpg/test/expected/sql-copystdout.stderr

@@ -2,23 +2,33 @@
 [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 20: QUERY: create  table foo ( a int   , b varchar    )     on connection regress1
+[NO_PID]: ECPGexecute line 20: QUERY: create  table foo ( a int   , b varchar    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 20: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 21: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [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 29: QUERY: copy  foo  to stdout  with  delimiter  ',' on connection regress1
+[NO_PID]: ECPGexecute line 29: QUERY: copy  foo  to stdout  with  delimiter  ',' with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 29: Got PGRES_COPY_OUT
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-define.c

@@ -120,13 +120,13 @@ 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, 0, 0, "create  table test ( a int   , b text    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 19 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 19 "define.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( 29 , 'abcdef' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( 29 , 'abcdef' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 20 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -134,7 +134,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 
 
    
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( null , 'defined' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( null , 'defined' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 23 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -147,7 +147,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
    
            
    
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( null , 'someothervar not defined' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( null , 'someothervar not defined' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 31 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -157,7 +157,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 
    
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "select  1 , 29 :: text   || '-' || 'abcdef'     ", ECPGt_EOIT, 
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "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), 
@@ -172,7 +172,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 
    
    
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( 29 , 'no string' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( 29 , 'no string' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 42 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -188,7 +188,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
    
         
    
-   { ECPGdo(__LINE__, 0, 1, NULL, "set TIMEZONE to 'UTC'", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set TIMEZONE to 'UTC'", ECPGt_EOIT, ECPGt_EORT);
 #line 53 "define.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}

src/interfaces/ecpg/test/expected/sql-define.stderr

@@ -2,23 +2,33 @@
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 19: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 20: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 31: using PQexec
 [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'      with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: using PQexec
 [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
@@ -26,11 +36,15 @@
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 42 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 53: QUERY: set TIMEZONE to 'UTC' on connection regress1
+[NO_PID]: ECPGexecute line 53: QUERY: set TIMEZONE to 'UTC' with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 53 Ok: SET
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-desc.c

@@ -37,13 +37,13 @@ main(void)
 	  
 	
 #line 8 "desc.pgc"
- char * stmt1   = "INSERT INTO test1 VALUES (?, ?)" ;
+ char * stmt1   = "INSERT INTO test1 VALUES ($1, $2)" ;
  
 #line 9 "desc.pgc"
- char * stmt2   = "SELECT * from test1 where a = ? and b = ?" ;
+ char * stmt2   = "SELECT * from test1 where a = $1 and b = $2" ;
  
 #line 10 "desc.pgc"
- char * stmt3   = "SELECT * from test1 where a = ?" ;
+ char * stmt3   = "SELECT * from test1 where :var = a" ;
  
 #line 12 "desc.pgc"
  int  val1   = 1 ;
@@ -103,260 +103,271 @@ 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, 0, 0, "create  table test1 ( a int   , b text    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 29 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 29 "desc.pgc"
 
-	{ ECPGprepare(__LINE__, "foo1" , stmt1);
+	{ ECPGprepare(__LINE__, NULL, 0, "foo1", stmt1);
 #line 30 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 30 "desc.pgc"
 
-	{ ECPGprepare(__LINE__, "foo2" , stmt2);
+	{ ECPGprepare(__LINE__, NULL, 0, "Foo-1", stmt1);
 #line 31 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 31 "desc.pgc"
 
-	{ ECPGprepare(__LINE__, "foo3" , stmt3);
+	{ ECPGprepare(__LINE__, NULL, 0, "foo2", stmt2);
 #line 32 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 32 "desc.pgc"
 
+	{ ECPGprepare(__LINE__, NULL, 0, "foo3", stmt3);
+#line 33 "desc.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(ECPGprepared_statement("foo1")),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 33 "desc.pgc"
+
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 1, "foo1", 
 	ECPGt_descriptor, "indesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
-#line 34 "desc.pgc"
+#line 35 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 34 "desc.pgc"
+#line 35 "desc.pgc"
 
 
 	{ ECPGset_desc(__LINE__, "indesc", 1,ECPGd_data,
 	ECPGt_const,"2",(long)1,(long)1,strlen("2"), ECPGd_EODT);
 
-#line 36 "desc.pgc"
+#line 37 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 36 "desc.pgc"
+#line 37 "desc.pgc"
 
 	{ ECPGset_desc(__LINE__, "indesc", 2,ECPGd_data,
 	ECPGt_char,(val2),(long)4,(long)1,(4)*sizeof(char), ECPGd_indicator,
 	ECPGt_int,&(val2null),(long)1,(long)1,sizeof(int), ECPGd_EODT);
 
-#line 37 "desc.pgc"
+#line 38 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 37 "desc.pgc"
+#line 38 "desc.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(ECPGprepared_statement("foo1")),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 1, "foo1", 
 	ECPGt_descriptor, "indesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
-#line 39 "desc.pgc"
+#line 40 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 39 "desc.pgc"
+#line 40 "desc.pgc"
 
 
 	{ ECPGset_desc(__LINE__, "indesc", 1,ECPGd_data,
 	ECPGt_const,"3",(long)1,(long)1,strlen("3"), ECPGd_EODT);
 
-#line 41 "desc.pgc"
+#line 42 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 41 "desc.pgc"
+#line 42 "desc.pgc"
 
 	{ ECPGset_desc(__LINE__, "indesc", 2,ECPGd_data,
 	ECPGt_const,"this is a long test",(long)19,(long)1,strlen("this is a long test"), ECPGd_indicator,
 	ECPGt_int,&(val1),(long)1,(long)1,sizeof(int), ECPGd_EODT);
 
-#line 42 "desc.pgc"
+#line 43 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 42 "desc.pgc"
+#line 43 "desc.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(ECPGprepared_statement("foo1")),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 1, "Foo-1", 
 	ECPGt_descriptor, "indesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
-#line 44 "desc.pgc"
+#line 45 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 44 "desc.pgc"
+#line 45 "desc.pgc"
+
+
+	{ ECPGdeallocate(__LINE__, 0, "Foo-1");
+#line 47 "desc.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 47 "desc.pgc"
 
 
 	{ ECPGset_desc(__LINE__, "indesc", 1,ECPGd_data,
 	ECPGt_int,&(val1),(long)1,(long)1,sizeof(int), ECPGd_EODT);
 
-#line 46 "desc.pgc"
+#line 49 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 46 "desc.pgc"
+#line 49 "desc.pgc"
 
 	{ ECPGset_desc(__LINE__, "indesc", 2,ECPGd_data,
 	ECPGt_char,(val2),(long)4,(long)1,(4)*sizeof(char), ECPGd_indicator,
 	ECPGt_int,&(val2i),(long)1,(long)1,sizeof(int), ECPGd_EODT);
 
-#line 47 "desc.pgc"
+#line 50 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 47 "desc.pgc"
+#line 50 "desc.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(ECPGprepared_statement("foo2")),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 1, "foo2", 
 	ECPGt_descriptor, "indesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
 	ECPGt_descriptor, "outdesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
-#line 49 "desc.pgc"
+#line 52 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 49 "desc.pgc"
+#line 52 "desc.pgc"
 
 
 	{ ECPGget_desc(__LINE__, "outdesc", 1,ECPGd_data,
 	ECPGt_char,(val2output),(long)sizeof("AAA"),(long)1,(sizeof("AAA"))*sizeof(char), ECPGd_EODT);
 
-#line 51 "desc.pgc"
+#line 54 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 51 "desc.pgc"
+#line 54 "desc.pgc"
 
 	printf("output = %s\n", val2output);
 
-	/* declare c1  cursor  for ? */
-#line 54 "desc.pgc"
+	/* declare c1  cursor  for $1 */
+#line 57 "desc.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "declare c1  cursor  for ?", 
-	ECPGt_char_variable,(ECPGprepared_statement("foo2")),(long)1,(long)1,(1)*sizeof(char), 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare c1  cursor  for $1", 
+	ECPGt_char_variable,(ECPGprepared_statement("foo2", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_descriptor, "indesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
-#line 55 "desc.pgc"
+#line 58 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 55 "desc.pgc"
+#line 58 "desc.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "fetch next from c1", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch next from c1", ECPGt_EOIT, 
 	ECPGt_int,&(val1output),(long)1,(long)1,sizeof(int), 
 	ECPGt_int,&(ind1),(long)1,(long)1,sizeof(int), 
 	ECPGt_char,(val2output),(long)sizeof("AAA"),(long)1,(sizeof("AAA"))*sizeof(char), 
 	ECPGt_int,&(ind2),(long)1,(long)1,sizeof(int), ECPGt_EORT);
-#line 57 "desc.pgc"
+#line 60 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 57 "desc.pgc"
+#line 60 "desc.pgc"
 
 	printf("val1=%d (ind1: %d) val2=%s (ind2: %d)\n",
 		val1output, ind1, val2output, ind2);
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "close c1", ECPGt_EOIT, ECPGt_EORT);
-#line 61 "desc.pgc"
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close c1", ECPGt_EOIT, ECPGt_EORT);
+#line 64 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 61 "desc.pgc"
+#line 64 "desc.pgc"
 
 
 	{ ECPGset_desc_header(__LINE__, "indesc", (int)(1));
 
-#line 63 "desc.pgc"
+#line 66 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 63 "desc.pgc"
+#line 66 "desc.pgc"
 
 	{ ECPGset_desc(__LINE__, "indesc", 1,ECPGd_data,
 	ECPGt_const,"2",(long)1,(long)1,strlen("2"), ECPGd_EODT);
 
-#line 64 "desc.pgc"
+#line 67 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 64 "desc.pgc"
+#line 67 "desc.pgc"
 
 
-	/* declare c2  cursor  for ? */
-#line 66 "desc.pgc"
+	/* declare c2  cursor  for $1 */
+#line 69 "desc.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "declare c2  cursor  for ?", 
-	ECPGt_char_variable,(ECPGprepared_statement("foo3")),(long)1,(long)1,(1)*sizeof(char), 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare c2  cursor  for $1", 
+	ECPGt_char_variable,(ECPGprepared_statement("foo3", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_descriptor, "indesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
-#line 67 "desc.pgc"
+#line 70 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 67 "desc.pgc"
+#line 70 "desc.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "fetch next from c2", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch next from c2", ECPGt_EOIT, 
 	ECPGt_int,&(val1output),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(val2output),(long)sizeof("AAA"),(long)1,(sizeof("AAA"))*sizeof(char), 
 	ECPGt_int,&(val2i),(long)1,(long)1,sizeof(int), ECPGt_EORT);
-#line 69 "desc.pgc"
+#line 72 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 69 "desc.pgc"
+#line 72 "desc.pgc"
 
 	printf("val1=%d val2=%s\n", val1output, val2i ? "null" : val2output);
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "close c2", ECPGt_EOIT, ECPGt_EORT);
-#line 72 "desc.pgc"
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close c2", ECPGt_EOIT, ECPGt_EORT);
+#line 75 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 72 "desc.pgc"
+#line 75 "desc.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  *  from test1 where a = 3  ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from test1 where a = 3  ", ECPGt_EOIT, 
 	ECPGt_int,&(val1output),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(val2output),(long)sizeof("AAA"),(long)1,(sizeof("AAA"))*sizeof(char), 
 	ECPGt_int,&(val2i),(long)1,(long)1,sizeof(int), ECPGt_EORT);
-#line 74 "desc.pgc"
+#line 77 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 74 "desc.pgc"
+#line 77 "desc.pgc"
 
 	printf("val1=%d val2=%c%c%c%c warn=%c truncate=%d\n", val1output, val2output[0], val2output[1], val2output[2], val2output[3], sqlca.sqlwarn[0], val2i);
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "drop table test1 ", ECPGt_EOIT, ECPGt_EORT);
-#line 77 "desc.pgc"
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table test1 ", ECPGt_EOIT, ECPGt_EORT);
+#line 80 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 77 "desc.pgc"
+#line 80 "desc.pgc"
+
+	{ ECPGdeallocate_all(__LINE__, 0);
+#line 81 "desc.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 81 "desc.pgc"
 
 	{ ECPGdisconnect(__LINE__, "CURRENT");
-#line 78 "desc.pgc"
+#line 82 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 78 "desc.pgc"
+#line 82 "desc.pgc"
 
 
 	ECPGdeallocate_desc(__LINE__, "indesc");
-#line 80 "desc.pgc"
+#line 84 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();
-#line 80 "desc.pgc"
+#line 84 "desc.pgc"
 
 	ECPGdeallocate_desc(__LINE__, "outdesc");
-#line 81 "desc.pgc"
+#line 85 "desc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();
-#line 81 "desc.pgc"
+#line 85 "desc.pgc"
 
 
 	return 0;

src/interfaces/ecpg/test/expected/sql-desc.stderr

@@ -2,81 +2,139 @@
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 29 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 30: QUERY: INSERT INTO test1 VALUES (?, ?)
+[NO_PID]: ECPGprepare line 30: NAME: foo1 QUERY: INSERT INTO test1 VALUES ($1, $2)
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 31: QUERY: SELECT * from test1 where a = ? and b = ?
+[NO_PID]: ECPGprepare line 31: NAME: Foo-1 QUERY: INSERT INTO test1 VALUES ($1, $2)
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 32: QUERY: SELECT * from test1 where a = ?
+[NO_PID]: ECPGprepare line 32: NAME: foo2 QUERY: SELECT * from test1 where a = $1 and b = $2
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 34: QUERY: INSERT INTO test1 VALUES ('1', 'one') on connection regress1
+[NO_PID]: ECPGprepare line 33: NAME: foo3 QUERY: SELECT * from test1 where $1 = a
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 34 Ok: INSERT 0 1
+[NO_PID]: ECPGexecute line 35: QUERY: INSERT INTO test1 VALUES ($1, $2) with 2 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: QUERY: INSERT INTO test1 VALUES ('2', null) on connection regress1
+[NO_PID]: ECPGexecute line 35: using PQexecPrepared for INSERT INTO test1 VALUES ($1, $2)
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39 Ok: INSERT 0 1
+[NO_PID]: ECPGexecute line 35: parameter 1 = 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 44: QUERY: INSERT INTO test1 VALUES ('3', 'this is a long test') on connection regress1
+[NO_PID]: ECPGexecute line 35: parameter 2 = one
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 44 Ok: INSERT 0 1
+[NO_PID]: ECPGexecute line 35 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 49: QUERY: SELECT * from test1 where a = '1' and b = 'one' on connection regress1
+[NO_PID]: ECPGexecute line 40: QUERY: INSERT INTO test1 VALUES ($1, $2) with 2 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 49: Correctly got 1 tuples with 2 fields
+[NO_PID]: ECPGexecute line 40: using PQexecPrepared for INSERT INTO test1 VALUES ($1, $2)
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: parameter 1 = 2
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: parameter 2 = null
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 45: QUERY: INSERT INTO test1 VALUES ($1, $2) with 2 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 45: using PQexecPrepared for INSERT INTO test1 VALUES ($1, $2)
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 45: parameter 1 = 3
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 45: parameter 2 = this is a long test
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 45 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGdeallocate line 47: NAME: Foo-1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: QUERY: SELECT * from test1 where a = $1 and b = $2 with 2 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: using PQexecPrepared for SELECT * from test1 where a = $1 and b = $2
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 1 = 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: parameter 2 = one
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute putting result (1 tuples) into descriptor 'outdesc'
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_desc: reading items for tuple 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 51: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ECPGget_data line 54: RESULT: 1 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 55: QUERY: declare c1  cursor  for SELECT * from test1 where a = '1' and b = 'one' on connection regress1
+[NO_PID]: ECPGexecute line 58: QUERY: declare c1  cursor  for SELECT * from test1 where a = $1 and b = $2 with 2 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 55 Ok: DECLARE CURSOR
+[NO_PID]: ECPGexecute line 58: using PQexecParams 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 57: QUERY: fetch next from c1 on connection regress1
+[NO_PID]: ECPGexecute line 58: parameter 1 = 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 57: Correctly got 1 tuples with 2 fields
+[NO_PID]: ECPGexecute line 58: parameter 2 = one
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 57: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 58 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 57: RESULT: one offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 60: QUERY: fetch next from c1 with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 61: QUERY: close c1 on connection regress1
+[NO_PID]: ECPGexecute line 60: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 61 Ok: CLOSE CURSOR
+[NO_PID]: ECPGexecute line 60: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 67: QUERY: declare c2  cursor  for SELECT * from test1 where a = '2' on connection regress1
+[NO_PID]: ECPGget_data line 60: RESULT: 1 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 67 Ok: DECLARE CURSOR
+[NO_PID]: ECPGget_data line 60: RESULT: one offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 69: QUERY: fetch next from c2 on connection regress1
+[NO_PID]: ECPGexecute line 64: QUERY: close c1 with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 69: Correctly got 1 tuples with 2 fields
+[NO_PID]: ECPGexecute line 64: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 69: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 64 Ok: CLOSE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 69: RESULT:  offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 70: QUERY: declare c2  cursor  for SELECT * from test1 where $1 = a with 1 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 72: QUERY: close c2 on connection regress1
+[NO_PID]: ECPGexecute line 70: using PQexecParams 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 72 Ok: CLOSE CURSOR
+[NO_PID]: ECPGexecute line 70: parameter 1 = 2
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 74: QUERY: select  *  from test1 where a = 3   on connection regress1
+[NO_PID]: ECPGexecute line 70 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 74: Correctly got 1 tuples with 2 fields
+[NO_PID]: ECPGexecute line 72: QUERY: fetch next from c2 with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 74: RESULT: 3 offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 72: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 74: RESULT: this is a long test offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 72: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 77: QUERY: drop table test1  on connection regress1
+[NO_PID]: ECPGget_data line 72: RESULT: 2 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 77 Ok: DROP TABLE
+[NO_PID]: ECPGget_data line 72: RESULT:  offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 75: QUERY: close c2 with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 75: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 75 Ok: CLOSE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 77: QUERY: select  *  from test1 where a = 3   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 77: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 77: Correctly got 1 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 77: RESULT: 3 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 77: RESULT: this is a long test offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 80: QUERY: drop table test1  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 80: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 80 Ok: DROP TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGdeallocate line 81: NAME: foo3
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGdeallocate line 81: NAME: foo2
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGdeallocate line 81: NAME: foo1
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ecpg_finish: Connection regress1 closed.
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-dynalloc.c

@@ -178,26 +178,26 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 33 "dynalloc.pgc"
 
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "set datestyle to mdy", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set datestyle to mdy", ECPGt_EOIT, ECPGt_EORT);
 #line 35 "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, 0, 0, "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 (  );}
 #line 37 "dynalloc.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "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' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "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' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 38 "dynalloc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 38 "dynalloc.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "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 ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "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 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 39 "dynalloc.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -210,7 +210,7 @@ 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, 0, 0, "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"

src/interfaces/ecpg/test/expected/sql-dynalloc.stderr

@@ -2,23 +2,33 @@
 [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: set datestyle to mdy on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: set datestyle to mdy with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 38: using PQexec
 [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 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: using PQexec
 [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   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: using PQexec
 [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

src/interfaces/ecpg/test/expected/sql-dynalloc2.c

@@ -132,50 +132,50 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 20 "dynalloc2.pgc"
 
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "set datestyle to postgres", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set datestyle to postgres", ECPGt_EOIT, ECPGt_EORT);
 #line 22 "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, 0, 0, "create  table test ( a int   , b text    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 24 "dynalloc2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 24 "dynalloc2.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( 1 , 'one' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( 1 , 'one' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 25 "dynalloc2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 25 "dynalloc2.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( 2 , 'two' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( 2 , 'two' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 26 "dynalloc2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 26 "dynalloc2.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( null , 'three' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( null , 'three' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 27 "dynalloc2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 27 "dynalloc2.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( 4 , 'four' ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( 4 , 'four' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 28 "dynalloc2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 28 "dynalloc2.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( 5 , null ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( 5 , null ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 29 "dynalloc2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
 #line 29 "dynalloc2.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "insert into test values ( null , null ) ", ECPGt_EOIT, ECPGt_EORT);
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test values ( null , null ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 30 "dynalloc2.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint (  );}
@@ -188,7 +188,7 @@ if (sqlca.sqlcode < 0) sqlprint (  );}
 if (sqlca.sqlcode < 0) sqlprint (  );
 #line 32 "dynalloc2.pgc"
 
-   { ECPGdo(__LINE__, 0, 1, NULL, "select  *  from test   ", ECPGt_EOIT, 
+   { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  *  from test   ", ECPGt_EOIT, 
 	ECPGt_descriptor, "mydesc", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 33 "dynalloc2.pgc"

src/interfaces/ecpg/test/expected/sql-dynalloc2.stderr

@@ -2,39 +2,57 @@
 [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 22: QUERY: set datestyle to postgres on connection regress1
+[NO_PID]: ECPGexecute line 22: QUERY: set datestyle to postgres with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: using PQexec
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 25: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 27: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: using PQexec
 [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 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: using PQexec
 [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 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 30: using PQexec
 [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]: ECPGexecute line 33: QUERY: select  *  from test    on connection regress1
+[NO_PID]: ECPGexecute line 33: QUERY: select  *  from test    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 33: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 33: Correctly got 6 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-dyntest.c

@@ -226,44 +226,44 @@ if (sqlca.sqlcode < 0) error (  );}
 #line 47 "dyntest.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "set datestyle to german", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set datestyle to german", ECPGt_EOIT, ECPGt_EORT);
 #line 49 "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, 0, 0, "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 (  );}
 #line 53 "dyntest.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into dyntest values ( 'first entry' , 14.7 , 14 , 123045607890 , true , 'The world''s most advanced open source database.' , '1987-07-14' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into dyntest values ( 'first entry' , 14.7 , 14 , 123045607890 , true , 'The world''s most advanced open source database.' , '1987-07-14' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 54 "dyntest.pgc"
 
 if (sqlca.sqlcode < 0) error (  );}
 #line 54 "dyntest.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into dyntest values ( 'second entry' , 1407.87 , 1407 , 987065403210 , false , 'The elephant never forgets.' , '1999-11-5' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into dyntest values ( 'second entry' , 1407.87 , 1407 , 987065403210 , false , 'The elephant never forgets.' , '1999-11-5' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 55 "dyntest.pgc"
 
 if (sqlca.sqlcode < 0) error (  );}
 #line 55 "dyntest.pgc"
 
 
-  { ECPGprepare(__LINE__, "MYQUERY" , QUERY);
+  { ECPGprepare(__LINE__, NULL, 0, "myquery", QUERY);
 #line 57 "dyntest.pgc"
 
 if (sqlca.sqlcode < 0) error (  );}
 #line 57 "dyntest.pgc"
 
-  /* declare MYCURS  cursor  for ? */
+  /* declare MYCURS  cursor  for $1 */
 #line 58 "dyntest.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "declare MYCURS  cursor  for ?", 
-	ECPGt_char_variable,(ECPGprepared_statement("MYQUERY")),(long)1,(long)1,(1)*sizeof(char), 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare MYCURS  cursor  for $1", 
+	ECPGt_char_variable,(ECPGprepared_statement("myquery", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 60 "dyntest.pgc"
 
@@ -273,7 +273,7 @@ if (sqlca.sqlcode < 0) error (  );}
 
   while (1)
     {
-      { ECPGdo(__LINE__, 0, 1, NULL, "fetch in MYCURS", ECPGt_EOIT, 
+      { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch in MYCURS", ECPGt_EOIT, 
 	ECPGt_descriptor, "MYDESC", 0L, 0L, 0L, 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 64 "dyntest.pgc"
@@ -472,7 +472,7 @@ if (sqlca.sqlcode < 0) error (  );}
 	}
     }
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "close MYCURS", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close MYCURS", ECPGt_EOIT, ECPGt_EORT);
 #line 197 "dyntest.pgc"
 
 if (sqlca.sqlcode < 0) error (  );}

src/interfaces/ecpg/test/expected/sql-dyntest.stderr

@@ -2,29 +2,41 @@
 [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 49: QUERY: set datestyle to german on connection regress1
+[NO_PID]: ECPGexecute line 49: QUERY: set datestyle to german with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 49: using PQexec
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 51: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 54: using PQexec
 [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' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 55: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 55 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 57: QUERY: select * from dyntest
+[NO_PID]: ECPGprepare line 57: NAME: myquery QUERY: select * from dyntest
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 60: QUERY: declare MYCURS  cursor  for select * from dyntest on connection regress1
+[NO_PID]: ECPGexecute line 60: QUERY: declare MYCURS  cursor  for select * from dyntest with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 60: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 60 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 64: QUERY: fetch in MYCURS on connection regress1
+[NO_PID]: ECPGexecute line 64: QUERY: fetch in MYCURS with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 64: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 64: Correctly got 1 tuples with 7 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -192,7 +204,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 179: RESULT: 14.07.1987 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 64: QUERY: fetch in MYCURS on connection regress1
+[NO_PID]: ECPGexecute line 64: QUERY: fetch in MYCURS with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 64: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 64: Correctly got 1 tuples with 7 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -360,13 +374,17 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 179: RESULT: 05.11.1999 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 64: QUERY: fetch in MYCURS on connection regress1
+[NO_PID]: ECPGexecute line 64: QUERY: fetch in MYCURS with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 64: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 64: Correctly got 0 tuples with 7 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlcode 100 in line 64, 'No data found in line 64.'.
 [NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 197: QUERY: close MYCURS on connection regress1
+[NO_PID]: ECPGexecute line 197: QUERY: close MYCURS with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 197: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 197 Ok: CLOSE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-execute.c

@@ -65,7 +65,7 @@ main(void)
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 24 "execute.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )    ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 25 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -79,9 +79,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 
 	sprintf(command, "insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f')");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(command),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 2, command, ECPGt_EOIT, ECPGt_EORT);
 #line 29 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -89,9 +87,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 
 	sprintf(command, "insert into test (name, amount, letter) values ('db: ''r1''', 2, 't')");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(command),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 2, command, ECPGt_EOIT, ECPGt_EORT);
 #line 32 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -99,9 +95,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 
 	sprintf(command, "insert into test (name, amount, letter) select name, amount+10, letter from test");
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(command),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 2, command, ECPGt_EOIT, ECPGt_EORT);
 #line 35 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
@@ -110,16 +104,14 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	printf("Inserted %ld tuples via execute immediate\n", sqlca.sqlerrd[2]);
 
-	sprintf(command, "insert into test (name, amount, letter) select name, amount+?, letter from test");
-	{ ECPGprepare(__LINE__, "I" , command);
+	sprintf(command, "insert into test (name, amount, letter) select name, amount+$1, letter from test");
+	{ ECPGprepare(__LINE__, NULL, 0, "i", command);
 #line 40 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 40 "execute.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "?", 
-	ECPGt_char_variable,(ECPGprepared_statement("I")),(long)1,(long)1,(1)*sizeof(char), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 1, "i", 
 	ECPGt_int,&(increment),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 41 "execute.pgc"
@@ -139,25 +131,25 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
 	sprintf (command, "select * from test");
 
-	{ ECPGprepare(__LINE__, "F" , command);
+	{ ECPGprepare(__LINE__, NULL, 0, "f", command);
 #line 49 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 49 "execute.pgc"
 
-	/* declare CUR  cursor  for ? */
+	/* declare CUR  cursor  for $1 */
 #line 50 "execute.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "declare CUR  cursor  for ?", 
-	ECPGt_char_variable,(ECPGprepared_statement("F")),(long)1,(long)1,(1)*sizeof(char), 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare CUR  cursor  for $1", 
+	ECPGt_char_variable,(ECPGprepared_statement("f", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
 #line 52 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 52 "execute.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "fetch 8 in CUR", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch 8 in CUR", ECPGt_EOIT, 
 	ECPGt_char,(name),(long)8,(long)8,(8)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_int,(amount),(long)1,(long)8,sizeof(int), 
@@ -189,46 +181,52 @@ if (sqlca.sqlcode < 0) sqlprint();}
 		printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, n, i, a, i, l);
 	}
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "close CUR", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close CUR", ECPGt_EOIT, ECPGt_EORT);
 #line 66 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 66 "execute.pgc"
 
-
-	sprintf (command, "select * from test where amount = ?");
-
-	{ ECPGprepare(__LINE__, "F" , command);
-#line 70 "execute.pgc"
+	{ ECPGdeallocate(__LINE__, 0, "f");
+#line 67 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 70 "execute.pgc"
+#line 67 "execute.pgc"
 
-	/* declare CUR2  cursor  for ? */
+
+	sprintf (command, "select * from test where amount = $1");
+
+	{ ECPGprepare(__LINE__, NULL, 0, "f", command);
 #line 71 "execute.pgc"
 
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 71 "execute.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "declare CUR2  cursor  for ?", 
-	ECPGt_char_variable,(ECPGprepared_statement("F")),(long)1,(long)1,(1)*sizeof(char), 
+	/* declare CUR2  cursor  for $1 */
+#line 72 "execute.pgc"
+
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare CUR2  cursor  for $1", 
+	ECPGt_char_variable,(ECPGprepared_statement("f", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_const,"1",(long)1,(long)1,strlen("1"), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
-#line 73 "execute.pgc"
+#line 74 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 73 "execute.pgc"
+#line 74 "execute.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "fetch in CUR2", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch in CUR2", ECPGt_EOIT, 
 	ECPGt_char,(name),(long)8,(long)8,(8)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_int,(amount),(long)1,(long)8,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(letter),(long)1,(long)8,(1)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
-#line 74 "execute.pgc"
+#line 75 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 74 "execute.pgc"
+#line 75 "execute.pgc"
 
 
 	for (i=0, j=sqlca.sqlerrd[2]; i<j; i++)
@@ -237,42 +235,42 @@ if (sqlca.sqlcode < 0) sqlprint();}
 		    
 		   
 		
-#line 79 "execute.pgc"
+#line 80 "execute.pgc"
  char  n [ 8 ]    ,  l   = letter [ i ] [ 0 ] ;
  
-#line 80 "execute.pgc"
+#line 81 "execute.pgc"
  int  a   = amount [ i ] ;
 /* exec sql end declare section */
-#line 81 "execute.pgc"
+#line 82 "execute.pgc"
 
 
 		strncpy(n, name[i], 8);
 		printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, n, i, a, i, l);
 	}
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "close CUR2", ECPGt_EOIT, ECPGt_EORT);
-#line 87 "execute.pgc"
-
-if (sqlca.sqlcode < 0) sqlprint();}
-#line 87 "execute.pgc"
-
-	{ ECPGdo(__LINE__, 0, 1, NULL, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close CUR2", ECPGt_EOIT, ECPGt_EORT);
 #line 88 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 88 "execute.pgc"
 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
+#line 89 "execute.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 89 "execute.pgc"
+
 	{ ECPGtrans(__LINE__, NULL, "commit");
-#line 89 "execute.pgc"
+#line 90 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 89 "execute.pgc"
+#line 90 "execute.pgc"
 
 	{ ECPGdisconnect(__LINE__, "CURRENT");
-#line 90 "execute.pgc"
+#line 91 "execute.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 90 "execute.pgc"
+#line 91 "execute.pgc"
 
 
 	return (0);

src/interfaces/ecpg/test/expected/sql-execute.stderr

@@ -2,39 +2,55 @@
 [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 25: QUERY: create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )     on connection main
+[NO_PID]: ECPGexecute line 25: QUERY: create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )     with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 25: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 25 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 26 action = commit connection = main
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 29: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f') on connection main
+[NO_PID]: ECPGexecute line 29: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f') with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: using PQexec
 [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 32: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 2, 't') on connection main
+[NO_PID]: ECPGexecute line 32: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 2, 't') with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 32 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35: QUERY: insert into test (name, amount, letter) select name, amount+10, letter from test on connection main
+[NO_PID]: ECPGexecute line 35: QUERY: insert into test (name, amount, letter) select name, amount+10, letter from test with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 35 Ok: INSERT 0 2
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 40: QUERY: insert into test (name, amount, letter) select name, amount+?, letter from test
+[NO_PID]: ECPGprepare line 40: NAME: i QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 41: QUERY: insert into test (name, amount, letter) select name, amount+100, letter from test on connection main
+[NO_PID]: ECPGexecute line 41: QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test with 1 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: using PQexecPrepared for insert into test (name, amount, letter) select name, amount+$1, letter from test
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: parameter 1 = 100
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 41 Ok: INSERT 0 4
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGtrans line 45 action = commit connection = main
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 49: QUERY: select * from test
+[NO_PID]: ECPGprepare line 49: NAME: f QUERY: select * from test
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 52: QUERY: declare CUR  cursor  for select * from test on connection main
+[NO_PID]: ECPGexecute line 52: QUERY: declare CUR  cursor  for select * from test with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 52 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 53: QUERY: fetch 8 in CUR on connection main
+[NO_PID]: ECPGexecute line 53: QUERY: fetch 8 in CUR with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 53: Correctly got 8 tuples with 3 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -86,35 +102,49 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 53: RESULT: t offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 66: QUERY: close CUR on connection main
+[NO_PID]: ECPGexecute line 66: QUERY: close CUR with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 66: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 66 Ok: CLOSE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 70: QUERY: select * from test where amount = ?
+[NO_PID]: ECPGdeallocate line 67: NAME: f
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 73: QUERY: declare CUR2  cursor  for select * from test where amount = 1 on connection main
+[NO_PID]: ECPGprepare line 71: NAME: f QUERY: select * from test where amount = $1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 73 Ok: DECLARE CURSOR
+[NO_PID]: ECPGexecute line 74: QUERY: declare CUR2  cursor  for select * from test where amount = $1 with 1 parameter on connection main 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 74: QUERY: fetch in CUR2 on connection main
+[NO_PID]: ECPGexecute line 74: using PQexecParams 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 74: Correctly got 1 tuples with 3 fields
+[NO_PID]: ECPGexecute line 74: parameter 1 = 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 74: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 74 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 74: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 75: QUERY: fetch in CUR2 with 0 parameter on connection main 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 74: RESULT: f offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 75: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 87: QUERY: close CUR2 on connection main
+[NO_PID]: ECPGexecute line 75: Correctly got 1 tuples with 3 fields
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 87 Ok: CLOSE CURSOR
+[NO_PID]: ECPGget_data line 75: RESULT: db: 'r1' offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 88: QUERY: drop table test  on connection main
+[NO_PID]: ECPGget_data line 75: RESULT: 1 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 88 Ok: DROP TABLE
+[NO_PID]: ECPGget_data line 75: RESULT: f offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 89 action = commit connection = main
+[NO_PID]: ECPGexecute line 88: QUERY: close CUR2 with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 88: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 88 Ok: CLOSE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 89: QUERY: drop table test  with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 89: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 89 Ok: DROP TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGtrans line 90 action = commit connection = main
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ecpg_finish: Connection main closed.
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-fetch.c

@@ -26,13 +26,13 @@
 int main(int argc, char* argv[]) {
   /* exec sql begin declare section */
      
-        
+      
   
 #line 9 "fetch.pgc"
  char  str [ 25 ]    ;
  
 #line 10 "fetch.pgc"
- int  i    ,  how_many   = 1 ;
+ int  i    ;
 /* exec sql end declare section */
 #line 11 "fetch.pgc"
 
@@ -49,7 +49,7 @@ int main(int argc, char* argv[]) {
 #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, 0, 0, "create  table My_Table ( Item1 int   , Item2 text    )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 19 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -59,7 +59,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 19 "fetch.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into My_Table values ( 1 , 'text1' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into My_Table values ( 1 , 'text1' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 21 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -68,7 +68,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 21 "fetch.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into My_Table values ( 2 , 'text2' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into My_Table values ( 2 , 'text2' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 22 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -77,7 +77,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 22 "fetch.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into My_Table values ( 3 , 'text3' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into My_Table values ( 3 , 'text3' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 23 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -86,7 +86,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 23 "fetch.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into My_Table values ( 4 , 'text4' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into My_Table values ( 4 , 'text4' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 24 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -100,7 +100,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 26 "fetch.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "declare C  cursor  for select  *  from My_Table   ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare C  cursor  for select  *  from My_Table   ", ECPGt_EOIT, ECPGt_EORT);
 #line 28 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -114,7 +114,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 30 "fetch.pgc"
 
   while (1) {
-  	{ ECPGdo(__LINE__, 0, 1, NULL, "fetch 1 in C", ECPGt_EOIT, 
+  	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch 1 in C", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(str),(long)25,(long)1,(25)*sizeof(char), 
@@ -136,7 +136,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
   /* exec sql whenever not found  continue ; */
 #line 36 "fetch.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "move backward 2 in C", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "move backward 2 in C", ECPGt_EOIT, ECPGt_EORT);
 #line 37 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -146,9 +146,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 37 "fetch.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "fetch  ? in C", 
-	ECPGt_int,&(how_many),(long)1,(long)1,sizeof(int), 
-	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch 1 in C", ECPGt_EOIT, 
 	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_char,(str),(long)25,(long)1,(25)*sizeof(char), 
@@ -163,7 +161,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
   printf("%d: %s\n", i, str);
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "close C", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "close C", ECPGt_EOIT, ECPGt_EORT);
 #line 42 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -173,7 +171,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 42 "fetch.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "drop table My_Table ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table My_Table ", ECPGt_EOIT, ECPGt_EORT);
 #line 44 "fetch.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();

src/interfaces/ecpg/test/expected/sql-fetch.stderr

@@ -2,31 +2,45 @@
 [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    )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 19: using PQexec
 [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 21: QUERY: insert into My_Table values ( 1 , 'text1' )  on connection regress1
+[NO_PID]: ECPGexecute line 21: QUERY: insert into My_Table values ( 1 , 'text1' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 21: using PQexec
 [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 My_Table values ( 2 , 'text2' )  on connection regress1
+[NO_PID]: ECPGexecute line 22: QUERY: insert into My_Table values ( 2 , 'text2' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: using PQexec
 [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 My_Table values ( 3 , 'text3' )  on connection regress1
+[NO_PID]: ECPGexecute line 23: QUERY: insert into My_Table values ( 3 , 'text3' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [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 My_Table values ( 4 , 'text4' )  on connection regress1
+[NO_PID]: ECPGexecute line 24: QUERY: insert into My_Table values ( 4 , 'text4' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: using PQexec
 [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 28: QUERY: declare C  cursor  for select  *  from My_Table    on connection regress1
+[NO_PID]: ECPGexecute line 28: QUERY: declare C  cursor  for select  *  from My_Table    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 28 Ok: DECLARE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C on connection regress1
+[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 32: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -34,7 +48,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 32: RESULT: text1 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C on connection regress1
+[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 32: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -42,7 +58,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 32: RESULT: text2 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C on connection regress1
+[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 32: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -50,7 +68,9 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 32: RESULT: text3 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C on connection regress1
+[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 32: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -58,17 +78,23 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 32: RESULT: text4 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C on connection regress1
+[NO_PID]: ECPGexecute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 32: Correctly got 0 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlcode 100 in line 32, 'No data found in line 32.'.
 [NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGexecute line 37: QUERY: move backward 2 in C on connection regress1
+[NO_PID]: ECPGexecute line 37: QUERY: move backward 2 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 37 Ok: MOVE 2
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 39: QUERY: fetch  1 in C on connection regress1
+[NO_PID]: ECPGexecute line 39: QUERY: fetch 1 in C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 39: Correctly got 1 tuples with 2 fields
 [NO_PID]: sqlca: code: 0, state: 00000
@@ -76,11 +102,15 @@
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 39: RESULT: text4 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 42: QUERY: close C on connection regress1
+[NO_PID]: ECPGexecute line 42: QUERY: close C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 42 Ok: CLOSE CURSOR
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 44: QUERY: drop table My_Table  on connection regress1
+[NO_PID]: ECPGexecute line 44: QUERY: drop table My_Table  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 44: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 44 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-func.c

@@ -24,57 +24,62 @@
 
 
 int main(int argc, char* argv[]) {
+  
+#line 8 "func.pgc"
+ char  text [ 25 ]    ;
+
+#line 8 "func.pgc"
+
 
   ECPGdebug(1, stderr);
   { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
-#line 10 "func.pgc"
+#line 11 "func.pgc"
 
 
   { ECPGsetcommit(__LINE__, "on", NULL);}
-#line 12 "func.pgc"
-
-  /* exec sql whenever sql_warning  sqlprint ; */
 #line 13 "func.pgc"
 
-  /* exec sql whenever sqlerror  sqlprint ; */
+  /* exec sql whenever sql_warning  sqlprint ; */
 #line 14 "func.pgc"
 
+  /* exec sql whenever sqlerror  sqlprint ; */
+#line 15 "func.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create  table My_Table ( Item1 int   , Item2 text    )    ", ECPGt_EOIT, ECPGt_EORT);
-#line 16 "func.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table My_Table ( Item1 int   , Item2 text    )    ", ECPGt_EOIT, ECPGt_EORT);
+#line 17 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 16 "func.pgc"
+#line 17 "func.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 16 "func.pgc"
+#line 17 "func.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table Log ( name text    , w text    )    ", ECPGt_EOIT, ECPGt_EORT);
+#line 18 "func.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 18 "func.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 18 "func.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create  function My_Table_Check () returns trigger   as $test$\
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  function My_Table_Check () returns trigger   as $test$\
     BEGIN\
-	RAISE WARNING 'Notice: TG_NAME=%, TG WHEN=%', TG_NAME, TG_WHEN;\
+	INSERT INTO Log VALUES(TG_NAME, TG_WHEN);\
 	RETURN NEW;\
     END; $test$ language plpgsql", ECPGt_EOIT, ECPGt_EORT);
-#line 24 "func.pgc"
+#line 26 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 24 "func.pgc"
+#line 26 "func.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 24 "func.pgc"
+#line 26 "func.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create trigger My_Table_Check_Trigger before insert on My_Table for each row execute procedure My_Table_Check (  )", ECPGt_EOIT, ECPGt_EORT);
-#line 30 "func.pgc"
-
-if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 30 "func.pgc"
-
-if (sqlca.sqlcode < 0) sqlprint();}
-#line 30 "func.pgc"
-
-
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into My_Table values ( 1234 , 'Some random text' ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create trigger My_Table_Check_Trigger before insert on My_Table for each row execute procedure My_Table_Check (  )", ECPGt_EOIT, ECPGt_EORT);
 #line 32 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -83,17 +88,17 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 32 "func.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into My_Table values ( 5678 , 'The Quick Brown' ) ", ECPGt_EOIT, ECPGt_EORT);
-#line 33 "func.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into My_Table values ( 1234 , 'Some random text' ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 34 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 33 "func.pgc"
+#line 34 "func.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 33 "func.pgc"
+#line 34 "func.pgc"
 
-
-  { ECPGdo(__LINE__, 0, 1, NULL, "drop trigger My_Table_Check_Trigger on My_Table ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into My_Table values ( 5678 , 'The Quick Brown' ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 35 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -102,7 +107,9 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 35 "func.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "drop function My_Table_Check () ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  name  from Log     limit 1 ", ECPGt_EOIT, 
+	ECPGt_char,(text),(long)25,(long)1,(25)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 36 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -111,24 +118,53 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 36 "func.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "drop table My_Table ", ECPGt_EOIT, ECPGt_EORT);
-#line 37 "func.pgc"
+  printf("Trigger %s fired.\n", text);
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop trigger My_Table_Check_Trigger on My_Table ", ECPGt_EOIT, ECPGt_EORT);
+#line 39 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 37 "func.pgc"
+#line 39 "func.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 37 "func.pgc"
+#line 39 "func.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop function My_Table_Check () ", ECPGt_EOIT, ECPGt_EORT);
+#line 40 "func.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 40 "func.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 40 "func.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table Log ", ECPGt_EOIT, ECPGt_EORT);
+#line 41 "func.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 41 "func.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 41 "func.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table My_Table ", ECPGt_EOIT, ECPGt_EORT);
+#line 42 "func.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 42 "func.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 42 "func.pgc"
 
 
   { ECPGdisconnect(__LINE__, "ALL");
-#line 39 "func.pgc"
+#line 44 "func.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 39 "func.pgc"
+#line 44 "func.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 39 "func.pgc"
+#line 44 "func.pgc"
 
 
   return 0;

src/interfaces/ecpg/test/expected/sql-func.stderr

@@ -2,47 +2,75 @@
 [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 12 action = on connection = regress1
+[NO_PID]: ECPGsetcommit line 13 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 17: QUERY: create  table My_Table ( Item1 int   , Item2 text    )     with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 16 Ok: CREATE TABLE
+[NO_PID]: ECPGexecute line 17: using PQexec
 [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 17 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 18 Ok: CREATE FUNCTION
+[NO_PID]: ECPGexecute line 18: QUERY: create  table Log ( name text    , w text    )     with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: create trigger My_Table_Check_Trigger before insert on My_Table for each row execute procedure My_Table_Check (  ) on connection regress1
+[NO_PID]: ECPGexecute line 18: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26 Ok: CREATE TRIGGER
+[NO_PID]: ECPGexecute line 18 Ok: CREATE TABLE
 [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 20: QUERY: create  function My_Table_Check () returns trigger   as $test$    BEGIN	INSERT INTO Log VALUES(TG_NAME, TG_WHEN);	RETURN NEW;    END; $test$ language plpgsql with 0 parameter 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]: sqlca: code: 0, state: 01000
-[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 20: using PQexec
 [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]: sqlca: code: 0, state: 01000
-[NO_PID]: ECPGexecute line 33 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 35: QUERY: drop trigger My_Table_Check_Trigger on My_Table  on connection regress1
+[NO_PID]: ECPGexecute line 20 Ok: CREATE FUNCTION
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35 Ok: DROP TRIGGER
+[NO_PID]: ECPGexecute line 28: QUERY: create trigger My_Table_Check_Trigger before insert on My_Table for each row execute procedure My_Table_Check (  ) with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 36: QUERY: drop function My_Table_Check ()  on connection regress1
+[NO_PID]: ECPGexecute line 28: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 36 Ok: DROP FUNCTION
+[NO_PID]: ECPGexecute line 28 Ok: CREATE TRIGGER
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 37: QUERY: drop table My_Table  on connection regress1
+[NO_PID]: ECPGexecute line 34: QUERY: insert into My_Table values ( 1234 , 'Some random text' )  with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 37 Ok: DROP TABLE
+[NO_PID]: ECPGexecute line 34: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 34 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: QUERY: insert into My_Table values ( 5678 , 'The Quick Brown' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
+[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]: ECPGexecute line 36: QUERY: select  name  from Log     limit 1  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 36: Correctly got 1 tuples with 1 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 36: RESULT: my_table_check_trigger offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: QUERY: drop trigger My_Table_Check_Trigger on My_Table  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 39 Ok: DROP TRIGGER
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: QUERY: drop function My_Table_Check ()  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40 Ok: DROP FUNCTION
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: QUERY: drop table Log  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41 Ok: DROP TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: QUERY: drop table My_Table  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ecpg_finish: Connection regress1 closed.
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-func.stdout

@@ -0,0 +1 @@
+Trigger my_table_check_trigger fired.

src/interfaces/ecpg/test/expected/sql-indicators.c

@@ -117,25 +117,25 @@ int main(int argc, char **argv)
 #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, 0, 0, "create  table indicator_test ( \"id\" int   primary key   , \"str\" text    not null , val int   null )    ", ECPGt_EOIT, ECPGt_EORT);}
 #line 22 "indicators.pgc"
 
 	{ ECPGtrans(__LINE__, NULL, "commit");}
 #line 23 "indicators.pgc"
 
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( id  , str  , val  ) values ( 1 , 'Hello' , 0 ) ", ECPGt_EOIT, ECPGt_EORT);}
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into indicator_test ( id  , str  , val  ) values ( 1 , 'Hello' , 0 ) ", ECPGt_EOIT, ECPGt_EORT);}
 #line 25 "indicators.pgc"
 
 
 	/* use indicator in insert */
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( id  , str  , val  ) values ( 2 , 'Hi there' ,  ? ) ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into indicator_test ( id  , str  , val  ) values ( 2 , 'Hi there' ,  $1  ) ", 
 	ECPGt_int,&(intvar),(long)1,(long)1,sizeof(int), 
 	ECPGt_int,&(nullind),(long)1,(long)1,sizeof(int), ECPGt_EOIT, ECPGt_EORT);}
 #line 28 "indicators.pgc"
 
 	nullind = 0;
-	{ ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( id  , str  , val  ) values ( 3 , 'Good evening' ,  ? ) ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into indicator_test ( id  , str  , val  ) values ( 3 , 'Good evening' ,  $1  ) ", 
 	ECPGt_int,&(intvar),(long)1,(long)1,sizeof(int), 
 	ECPGt_int,&(nullind),(long)1,(long)1,sizeof(int), ECPGt_EOIT, ECPGt_EORT);}
 #line 30 "indicators.pgc"
@@ -145,18 +145,18 @@ int main(int argc, char **argv)
 
 
 	/* use indicators to get information about selects */
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  val  from test where id = 1  ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  val  from indicator_test where id = 1  ", ECPGt_EOIT, 
 	ECPGt_int,&(intvar),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 34 "indicators.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  val  from test where id = 2  ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  val  from indicator_test where id = 2  ", ECPGt_EOIT, 
 	ECPGt_int,&(intvar),(long)1,(long)1,sizeof(int), 
 	ECPGt_int,&(nullind),(long)1,(long)1,sizeof(int), ECPGt_EORT);}
 #line 35 "indicators.pgc"
 
 	printf("intvar: %d, nullind: %d\n", intvar, nullind);
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  val  from test where id = 3  ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  val  from indicator_test where id = 3  ", ECPGt_EOIT, 
 	ECPGt_int,&(intvar),(long)1,(long)1,sizeof(int), 
 	ECPGt_int,&(nullind),(long)1,(long)1,sizeof(int), ECPGt_EORT);}
 #line 37 "indicators.pgc"
@@ -165,19 +165,19 @@ int main(int argc, char **argv)
 
 	/* use indicators for update */
 	intvar = 5; nullind = -1;
-	{ ECPGdo(__LINE__, 0, 1, NULL, "update test set val  =  ?  where id = 1 ", 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "update indicator_test set val  =  $1   where id = 1 ", 
 	ECPGt_int,&(intvar),(long)1,(long)1,sizeof(int), 
 	ECPGt_int,&(nullind),(long)1,(long)1,sizeof(int), ECPGt_EOIT, ECPGt_EORT);}
 #line 42 "indicators.pgc"
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "select  val  from test where id = 1  ", ECPGt_EOIT, 
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  val  from indicator_test where id = 1  ", ECPGt_EOIT, 
 	ECPGt_int,&(intvar),(long)1,(long)1,sizeof(int), 
 	ECPGt_int,&(nullind),(long)1,(long)1,sizeof(int), ECPGt_EORT);}
 #line 43 "indicators.pgc"
 
 	printf("intvar: %d, nullind: %d\n", intvar, nullind);
 
-	{ ECPGdo(__LINE__, 0, 1, NULL, "drop table test ", ECPGt_EOIT, ECPGt_EORT);}
+	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table indicator_test ", ECPGt_EOIT, ECPGt_EORT);}
 #line 46 "indicators.pgc"
 
 	{ ECPGtrans(__LINE__, NULL, "commit");}

src/interfaces/ecpg/test/expected/sql-indicators.stderr

@@ -4,55 +4,81 @@
 [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 indicator_test ( "id" int   primary key   , "str" text    not null , val int   null )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 19: using PQexec
 [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 indicator_test ( id  , str  , val  ) values ( 1 , 'Hello' , 0 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 25: using PQexec
 [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 indicator_test ( id  , str  , val  ) values ( 2 , 'Hi there' ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: parameter 1 = null
 [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 indicator_test ( id  , str  , val  ) values ( 3 , 'Good evening' ,  $1  )  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 30: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 30: parameter 1 = 5
 [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]: ECPGtrans line 31 action = commit connection = regress1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 34: QUERY: select  val  from test where id = 1   on connection regress1
+[NO_PID]: ECPGexecute line 34: QUERY: select  val  from indicator_test where id = 1   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 34: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 34: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 34: RESULT: 0 offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 35: QUERY: select  val  from test where id = 2   on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: select  val  from indicator_test where id = 2   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 35: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 35: RESULT:  offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 37: QUERY: select  val  from test where id = 3   on connection regress1
+[NO_PID]: ECPGexecute line 37: QUERY: select  val  from indicator_test where id = 3   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 37: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 37: Correctly got 1 tuples with 1 fields
 [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 indicator_test set val  =  $1   where id = 1  with 1 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 42: parameter 1 = null
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 42 Ok: UPDATE 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 43: QUERY: select  val  from test where id = 1   on connection regress1
+[NO_PID]: ECPGexecute line 43: QUERY: select  val  from indicator_test where id = 1   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 43: using PQexec
 [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]: ECPGget_data line 43: RESULT:  offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 46: QUERY: drop table test  on connection regress1
+[NO_PID]: ECPGexecute line 46: QUERY: drop table indicator_test  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 46 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-insupd.c

@@ -45,7 +45,7 @@ int main(int argc, char* argv[]) {
 #line 16 "insupd.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create  table test ( a int   , b int   )    ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table insupd_test ( a int   , b int   )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 18 "insupd.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -55,7 +55,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 18 "insupd.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( a  , b  ) values ( 1 , 1 ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into insupd_test ( a  , b  ) values ( 1 , 1 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 20 "insupd.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -64,7 +64,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 20 "insupd.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( a  , b  ) values ( 2 , 2 ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into insupd_test ( a  , b  ) values ( 2 , 2 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 21 "insupd.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -73,7 +73,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 21 "insupd.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into test ( a  , b  ) values ( 3 , 3 ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into insupd_test ( a  , b  ) values ( 3 , 3 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 22 "insupd.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -83,7 +83,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 22 "insupd.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "update test set a  = a + 1   ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "update insupd_test set a  = a + 1   ", ECPGt_EOIT, ECPGt_EORT);
 #line 24 "insupd.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -92,7 +92,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 24 "insupd.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "update test set ( a  , b  )= ( 5 , 5 )  where a = 4 ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "update insupd_test set ( a  , b  )= ( 5 , 5 )  where a = 4 ", ECPGt_EOIT, ECPGt_EORT);
 #line 25 "insupd.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -101,7 +101,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 25 "insupd.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "update test set a  = 4  where a = 3 ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "update insupd_test set a  = 4  where a = 3 ", ECPGt_EOIT, ECPGt_EORT);
 #line 26 "insupd.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -111,7 +111,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 26 "insupd.pgc"
 ;
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "select  a , b  from test    order by a  ", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  a , b  from insupd_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), 

src/interfaces/ecpg/test/expected/sql-insupd.stderr

@@ -2,35 +2,51 @@
 [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 ( a int   , b int   )     on connection regress1
+[NO_PID]: ECPGexecute line 18: QUERY: create  table insupd_test ( a int   , b int   )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 18: using PQexec
 [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 insupd_test ( a  , b  ) values ( 1 , 1 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 20: using PQexec
 [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 insupd_test ( a  , b  ) values ( 2 , 2 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 21: using PQexec
 [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 insupd_test ( a  , b  ) values ( 3 , 3 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: using PQexec
 [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 24: QUERY: update test set a  = a + 1    on connection regress1
+[NO_PID]: ECPGexecute line 24: QUERY: update insupd_test set a  = a + 1    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: using PQexec
 [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 insupd_test set ( a  , b  )= ( 5 , 5 )  where a = 4  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 25: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 25 Ok: UPDATE 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: update test set a  = 4  where a = 3  on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: update insupd_test set a  = 4  where a = 3  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexec
 [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 insupd_test    order by a   with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 28: using PQexec
 [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

src/interfaces/ecpg/test/expected/sql-oldexec.c

@@ -0,0 +1,271 @@
+/* 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 "oldexec.pgc"
+#include <stdlib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+#line 1 "regression.h"
+
+
+
+
+
+
+#line 6 "oldexec.pgc"
+
+
+/* exec sql whenever sqlerror  sqlprint ; */
+#line 8 "oldexec.pgc"
+
+
+int
+main(void)
+{
+/* exec sql begin declare section */
+	 
+	 
+	 
+	 
+	 
+
+#line 14 "oldexec.pgc"
+ int  amount [ 8 ]    ;
+ 
+#line 15 "oldexec.pgc"
+ int  increment   = 100 ;
+ 
+#line 16 "oldexec.pgc"
+ char  name [ 8 ] [ 8 ]    ;
+ 
+#line 17 "oldexec.pgc"
+ char  letter [ 8 ] [ 1 ]    ;
+ 
+#line 18 "oldexec.pgc"
+ char  command [ 128 ]    ;
+/* exec sql end declare section */
+#line 19 "oldexec.pgc"
+
+	int i,j;
+
+	ECPGdebug(1, stderr);
+
+	{ ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , "main", 0); 
+#line 24 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 24 "oldexec.pgc"
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )    ", ECPGt_EOIT, ECPGt_EORT);
+#line 25 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 25 "oldexec.pgc"
+
+	{ ECPGtrans(__LINE__, NULL, "commit");
+#line 26 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 26 "oldexec.pgc"
+
+
+	sprintf(command, "insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f')");
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 2, command, ECPGt_EOIT, ECPGt_EORT);
+#line 29 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 29 "oldexec.pgc"
+
+
+	sprintf(command, "insert into test (name, amount, letter) values ('db: ''r1''', 2, 't')");
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 2, command, ECPGt_EOIT, ECPGt_EORT);
+#line 32 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 32 "oldexec.pgc"
+
+
+	sprintf(command, "insert into test (name, amount, letter) select name, amount+10, letter from test");
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 2, command, ECPGt_EOIT, ECPGt_EORT);
+#line 35 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 35 "oldexec.pgc"
+
+
+	printf("Inserted %ld tuples via execute immediate\n", sqlca.sqlerrd[2]);
+
+	sprintf(command, "insert into test (name, amount, letter) select name, amount+$1, letter from test");
+	{ ECPGprepare(__LINE__, NULL, 1, "i", command);
+#line 40 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 40 "oldexec.pgc"
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 1, "i", 
+	ECPGt_int,&(increment),(long)1,(long)1,sizeof(int), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+#line 41 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 41 "oldexec.pgc"
+
+
+	printf("Inserted %ld tuples via prepared execute\n", sqlca.sqlerrd[2]);
+
+	{ ECPGtrans(__LINE__, NULL, "commit");
+#line 45 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 45 "oldexec.pgc"
+
+
+	sprintf (command, "select * from test");
+
+	{ ECPGprepare(__LINE__, NULL, 1, "f", command);
+#line 49 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 49 "oldexec.pgc"
+
+	/* declare CUR  cursor  for $1 */
+#line 50 "oldexec.pgc"
+
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "declare CUR  cursor  for $1", 
+	ECPGt_char_variable,(ECPGprepared_statement("f", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+#line 52 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 52 "oldexec.pgc"
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "fetch 8 in CUR", ECPGt_EOIT, 
+	ECPGt_char,(name),(long)8,(long)8,(8)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	ECPGt_int,(amount),(long)1,(long)8,sizeof(int), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	ECPGt_char,(letter),(long)1,(long)8,(1)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
+#line 53 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 53 "oldexec.pgc"
+
+
+	for (i=0, j=sqlca.sqlerrd[2]; i<j; i++)
+	{
+		/* exec sql begin declare section */
+		    
+		   
+		
+#line 58 "oldexec.pgc"
+ char  n [ 8 ]    ,  l   = letter [ i ] [ 0 ] ;
+ 
+#line 59 "oldexec.pgc"
+ int  a   = amount [ i ] ;
+/* exec sql end declare section */
+#line 60 "oldexec.pgc"
+
+
+		strncpy(n, name[i], 8);
+		printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, n, i, a, i, l);
+	}
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "close CUR", ECPGt_EOIT, ECPGt_EORT);
+#line 66 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 66 "oldexec.pgc"
+
+
+	sprintf (command, "select * from test where ? = amount");
+
+	{ ECPGprepare(__LINE__, NULL, 1, "f", command);
+#line 70 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 70 "oldexec.pgc"
+
+	/* declare CUR3  cursor  for $1 */
+#line 71 "oldexec.pgc"
+
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "declare CUR3  cursor  for $1", 
+	ECPGt_char_variable,(ECPGprepared_statement("f", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	ECPGt_const,"1",(long)1,(long)1,strlen("1"), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
+#line 73 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 73 "oldexec.pgc"
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "fetch in CUR3", ECPGt_EOIT, 
+	ECPGt_char,(name),(long)8,(long)8,(8)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	ECPGt_int,(amount),(long)1,(long)8,sizeof(int), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	ECPGt_char,(letter),(long)1,(long)8,(1)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
+#line 74 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 74 "oldexec.pgc"
+
+
+	for (i=0, j=sqlca.sqlerrd[2]; i<j; i++)
+	{
+		/* exec sql begin declare section */
+		    
+		   
+		
+#line 79 "oldexec.pgc"
+ char  n [ 8 ]    ,  l   = letter [ i ] [ 0 ] ;
+ 
+#line 80 "oldexec.pgc"
+ int  a   = amount [ i ] ;
+/* exec sql end declare section */
+#line 81 "oldexec.pgc"
+
+
+		strncpy(n, name[i], 8);
+		printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, n, i, a, i, l);
+	}
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "close CUR3", ECPGt_EOIT, ECPGt_EORT);
+#line 87 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 87 "oldexec.pgc"
+
+	{ ECPGdo(__LINE__, 0, 1, NULL, 1, 0, "drop table test ", ECPGt_EOIT, ECPGt_EORT);
+#line 88 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 88 "oldexec.pgc"
+
+	{ ECPGtrans(__LINE__, NULL, "commit");
+#line 89 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 89 "oldexec.pgc"
+
+	{ ECPGdisconnect(__LINE__, "CURRENT");
+#line 90 "oldexec.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 90 "oldexec.pgc"
+
+
+	return (0);
+}

src/interfaces/ecpg/test/expected/sql-oldexec.stderr

@@ -0,0 +1,150 @@
+[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]: ECPGexecute line 25: QUERY: create  table test ( name char  ( 8 )    , amount int   , letter char  ( 1 )    )     with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 25: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 25 Ok: CREATE TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGtrans line 26 action = commit connection = main
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f') with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 29: using PQexec
+[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 32: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 2, 't') with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 32 Ok: INSERT 0 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: QUERY: insert into test (name, amount, letter) select name, amount+10, letter from test with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 35 Ok: INSERT 0 2
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 40: NAME: i QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test with 1 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: using PQexecPrepared for insert into test (name, amount, letter) select name, amount+$1, letter from test
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41: parameter 1 = 100
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 41 Ok: INSERT 0 4
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGtrans line 45 action = commit connection = main
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 49: NAME: f QUERY: select * from test
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: QUERY: declare CUR  cursor  for select * from test with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 52 Ok: DECLARE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: QUERY: fetch 8 in CUR with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 53: Correctly got 8 tuples with 3 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 11 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 12 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 101 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 102 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 111 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: 112 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 66: QUERY: close CUR with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 66: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 66 Ok: CLOSE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGdeallocate line 70: NAME: f
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGprepare line 70: NAME: f QUERY: select * from test where $1 = amount
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 73: QUERY: declare CUR3  cursor  for select * from test where $1 = amount with 1 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 73: using PQexecParams 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 73: parameter 1 = 1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 73 Ok: DECLARE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 74: QUERY: fetch in CUR3 with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 74: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 74: Correctly got 1 tuples with 3 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 74: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 74: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 74: RESULT: f offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 87: QUERY: close CUR3 with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 87: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 87 Ok: CLOSE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 88: QUERY: drop table test  with 0 parameter on connection main 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 88: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 88 Ok: DROP TABLE
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGtrans line 89 action = commit connection = main
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-oldexec.stdout

@@ -0,0 +1,11 @@
+Inserted 2 tuples via execute immediate
+Inserted 4 tuples via prepared execute
+name[0]=db: 'r1'	amount[0]=1	letter[0]=f
+name[1]=db: 'r1'	amount[1]=2	letter[1]=t
+name[2]=db: 'r1'	amount[2]=11	letter[2]=f
+name[3]=db: 'r1'	amount[3]=12	letter[3]=t
+name[4]=db: 'r1'	amount[4]=101	letter[4]=f
+name[5]=db: 'r1'	amount[5]=102	letter[5]=t
+name[6]=db: 'r1'	amount[6]=111	letter[6]=f
+name[7]=db: 'r1'	amount[7]=112	letter[7]=t
+name[0]=db: 'r1'	amount[0]=1	letter[0]=f

src/interfaces/ecpg/test/expected/sql-parser.c

@@ -49,7 +49,7 @@ int main(int argc, char* argv[]) {
 #line 18 "parser.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create  table T ( Item1 int   , Item2 int   )    ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table T ( Item1 int   , Item2 int   )    ", ECPGt_EOIT, ECPGt_EORT);
 #line 20 "parser.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -59,7 +59,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 #line 20 "parser.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into T values ( 1 , null ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into T values ( 1 , null ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 22 "parser.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -68,7 +68,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 22 "parser.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into T values ( 1 , 1 ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into T values ( 1 , 1 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 23 "parser.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -77,7 +77,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 23 "parser.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into T values ( 1 , 2 ) ", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into T values ( 1 , 2 ) ", ECPGt_EOIT, ECPGt_EORT);
 #line 24 "parser.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -87,7 +87,7 @@ 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, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "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"
@@ -102,7 +102,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
   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);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table T ", ECPGt_EOIT, ECPGt_EORT);
 #line 31 "parser.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();

src/interfaces/ecpg/test/expected/sql-parser.stderr

@@ -4,23 +4,33 @@
 [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]: ECPGexecute line 20: QUERY: create  table T ( Item1 int   , Item2 int   )     with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 20: using PQexec
 [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]: ECPGexecute line 22: QUERY: insert into T values ( 1 , null )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: using PQexec
 [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]: ECPGexecute line 23: QUERY: insert into T values ( 1 , 1 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [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]: ECPGexecute line 24: QUERY: insert into T values ( 1 , 2 )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 24: using PQexec
 [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]: ECPGexecute line 26: QUERY: select  Item2  from T    order by Item2  nulls last with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexec
 [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
@@ -30,7 +40,9 @@
 [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]: ECPGexecute line 31: QUERY: drop table T  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 31: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 31 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-quote.c

@@ -26,131 +26,182 @@
 int main(int argc, char* argv[]) {
   /* exec sql begin declare section */
      
+     
   
 #line 9 "quote.pgc"
  char  var [ 25 ]    ;
-/* exec sql end declare section */
+ 
 #line 10 "quote.pgc"
+ int  i    ;
+/* exec sql end declare section */
+#line 11 "quote.pgc"
 
 
   ECPGdebug(1, stderr);
   { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
-#line 13 "quote.pgc"
+#line 14 "quote.pgc"
 
 
   { ECPGsetcommit(__LINE__, "on", NULL);}
-#line 15 "quote.pgc"
-
-  /* exec sql whenever sql_warning  sqlprint ; */
 #line 16 "quote.pgc"
 
-  /* exec sql whenever sqlerror  sqlprint ; */
+  /* exec sql whenever sql_warning  sqlprint ; */
 #line 17 "quote.pgc"
 
+  /* exec sql whenever sqlerror  sqlprint ; */
+#line 18 "quote.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "create  table \"My_Table\" ( Item1 int   , Item2 text    )    ", ECPGt_EOIT, ECPGt_EORT);
-#line 19 "quote.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "create  table \"My_Table\" ( Item1 int   , Item2 text    )    ", ECPGt_EOIT, ECPGt_EORT);
+#line 20 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 19 "quote.pgc"
+#line 20 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 19 "quote.pgc"
+#line 20 "quote.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "show standard_conforming_strings", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "show standard_conforming_strings", ECPGt_EOIT, 
 	ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
-#line 21 "quote.pgc"
+#line 22 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 21 "quote.pgc"
+#line 22 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 21 "quote.pgc"
+#line 22 "quote.pgc"
 
   printf("Standard conforming strings: %s\n", var);
 
   /* this is a\\b actually */
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into \"My_Table\" values ( 1 , 'a\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
-#line 25 "quote.pgc"
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into \"My_Table\" values ( 1 , 'a\\\\\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 26 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 25 "quote.pgc"
+#line 26 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 25 "quote.pgc"
+#line 26 "quote.pgc"
 
-  /* this is a\b */
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into \"My_Table\" values ( 1 , 'a\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
-#line 27 "quote.pgc"
+  /* this is a\\b */
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into \"My_Table\" values ( 1 , E'a\\\\\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 28 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 27 "quote.pgc"
+#line 28 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 27 "quote.pgc"
+#line 28 "quote.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "set standard_conforming_strings to on", ECPGt_EOIT, ECPGt_EORT);
-#line 29 "quote.pgc"
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set standard_conforming_strings to on", ECPGt_EOIT, ECPGt_EORT);
+#line 30 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 29 "quote.pgc"
+#line 30 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 29 "quote.pgc"
+#line 30 "quote.pgc"
 
 
-  /* this is a\\b actually */
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into \"My_Table\" values ( 1 , 'a\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
-#line 32 "quote.pgc"
+  /* this is a\\\\b actually */
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into \"My_Table\" values ( 2 , 'a\\\\\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 33 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 32 "quote.pgc"
+#line 33 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 32 "quote.pgc"
+#line 33 "quote.pgc"
 
-  /* this is a\b */
-  { ECPGdo(__LINE__, 0, 1, NULL, "insert into \"My_Table\" values ( 1 , 'a\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
-#line 34 "quote.pgc"
+  /* this is a\\b */
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into \"My_Table\" values ( 2 , E'a\\\\\\\\b' ) ", ECPGt_EOIT, ECPGt_EORT);
+#line 35 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 34 "quote.pgc"
+#line 35 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 34 "quote.pgc"
+#line 35 "quote.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "select  *  from \"My_Table\"   ", ECPGt_EOIT, ECPGt_EORT);
-#line 36 "quote.pgc"
+  { ECPGtrans(__LINE__, NULL, "begin transaction ");
+#line 37 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 36 "quote.pgc"
+#line 37 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 36 "quote.pgc"
+#line 37 "quote.pgc"
 
-
-  { ECPGdo(__LINE__, 0, 1, NULL, "drop table \"My_Table\" ", ECPGt_EOIT, ECPGt_EORT);
+  /* declare C  cursor  for select  *  from \"My_Table\"    */
 #line 38 "quote.pgc"
 
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "declare C  cursor  for select  *  from \"My_Table\"   ", ECPGt_EOIT, ECPGt_EORT);
+#line 40 "quote.pgc"
+
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 38 "quote.pgc"
+#line 40 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 38 "quote.pgc"
+#line 40 "quote.pgc"
+
+
+  /* exec sql whenever not found  break ; */
+#line 42 "quote.pgc"
+
+
+  while (true)
+  {
+  	{ ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "fetch C", ECPGt_EOIT, 
+	ECPGt_int,&(i),(long)1,(long)1,sizeof(int), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
+	ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char), 
+	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
+#line 46 "quote.pgc"
+
+if (sqlca.sqlcode == ECPG_NOT_FOUND) break;
+#line 46 "quote.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 46 "quote.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 46 "quote.pgc"
+
+	printf("value: %d %s\n", i, var);
+  }
+
+  { ECPGtrans(__LINE__, NULL, "rollback");
+#line 50 "quote.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 50 "quote.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 50 "quote.pgc"
+
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table \"My_Table\" ", ECPGt_EOIT, ECPGt_EORT);
+#line 51 "quote.pgc"
+
+if (sqlca.sqlwarn[0] == 'W') sqlprint();
+#line 51 "quote.pgc"
+
+if (sqlca.sqlcode < 0) sqlprint();}
+#line 51 "quote.pgc"
 
 
   { ECPGdisconnect(__LINE__, "ALL");
-#line 40 "quote.pgc"
+#line 53 "quote.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
-#line 40 "quote.pgc"
+#line 53 "quote.pgc"
 
 if (sqlca.sqlcode < 0) sqlprint();}
-#line 40 "quote.pgc"
+#line 53 "quote.pgc"
 
 
   return 0;

src/interfaces/ecpg/test/expected/sql-quote.stderr

@@ -2,56 +2,120 @@
 [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 15 action = on connection = regress1
+[NO_PID]: ECPGsetcommit line 16 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 20: QUERY: create  table "My_Table" ( Item1 int   , Item2 text    )     with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 19 Ok: CREATE TABLE
+[NO_PID]: ECPGexecute line 20: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 21: QUERY: show standard_conforming_strings on connection regress1
+[NO_PID]: ECPGexecute line 20 Ok: CREATE TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 21: Correctly got 1 tuples with 1 fields
+[NO_PID]: ECPGexecute line 22: QUERY: show standard_conforming_strings with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_data line 21: RESULT: off offset: -1 array: Yes
+[NO_PID]: ECPGexecute line 22: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 25: QUERY: insert into "My_Table" values ( 1 , 'a\\b' )  on connection regress1
+[NO_PID]: ECPGexecute line 22: Correctly got 1 tuples with 1 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 22: RESULT: off offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: QUERY: insert into "My_Table" values ( 1 , 'a\\\\b' )  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGnoticeReceiver nonstandard use of \\ in a string literal
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: nonstandard use of \\ in a string literal[NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: raising sqlcode 0
 [NO_PID]: sqlca: code: 0, state: 22P06
-[NO_PID]: ECPGexecute line 25 Ok: INSERT 0 1
+[NO_PID]: ECPGexecute line 26: using PQexec
+[NO_PID]: sqlca: code: 0, state: 22P06
+[NO_PID]: ECPGexecute line 26 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 22P06
 sql error nonstandard use of \\ in a string literal
-[NO_PID]: ECPGexecute line 27: QUERY: insert into "My_Table" values ( 1 , 'a\\b' )  on connection regress1
+[NO_PID]: ECPGexecute line 28: QUERY: insert into "My_Table" values ( 1 , E'a\\\\b' )  with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: nonstandard use of \\ in a string literal[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 0
-[NO_PID]: sqlca: code: 0, state: 22P06
-[NO_PID]: ECPGexecute line 27 Ok: INSERT 0 1
-[NO_PID]: sqlca: code: 0, state: 22P06
-sql error nonstandard use of \\ in a string literal
-[NO_PID]: ECPGexecute line 29: QUERY: set standard_conforming_strings to on on connection regress1
+[NO_PID]: ECPGexecute line 28: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 29 Ok: SET
+[NO_PID]: ECPGexecute line 28 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32: QUERY: insert into "My_Table" values ( 1 , 'a\\b' )  on connection regress1
+[NO_PID]: ECPGexecute line 30: QUERY: set standard_conforming_strings to on with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 32 Ok: INSERT 0 1
+[NO_PID]: ECPGexecute line 30: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 34: QUERY: insert into "My_Table" values ( 1 , 'a\\b' )  on connection regress1
+[NO_PID]: ECPGexecute line 30 Ok: SET
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 34 Ok: INSERT 0 1
+[NO_PID]: ECPGexecute line 33: QUERY: insert into "My_Table" values ( 2 , 'a\\\\b' )  with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 36: QUERY: select  *  from "My_Table"    on connection regress1
+[NO_PID]: ECPGexecute line 33: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 36: Correctly got 4 tuples with 2 fields
+[NO_PID]: ECPGexecute line 33 Ok: INSERT 0 1
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -202 in line 36, 'Too few arguments in line 36.'.
-[NO_PID]: sqlca: code: -202, state: 07002
-sql error Too few arguments in line 36.
-[NO_PID]: ECPGexecute line 38: QUERY: drop table "My_Table"  on connection regress1
+[NO_PID]: ECPGexecute line 35: QUERY: insert into "My_Table" values ( 2 , E'a\\\\b' )  with 0 parameter on connection regress1 
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 38 Ok: DROP TABLE
+[NO_PID]: ECPGexecute line 35: using PQexec
+[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]: ECPGtrans line 37 action = begin transaction  connection = regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: QUERY: declare C  cursor  for select  *  from "My_Table"    with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 40 Ok: DECLARE CURSOR
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: QUERY: fetch C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: a\\b offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: QUERY: fetch C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: a\\b offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: QUERY: fetch C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: a\\\\b offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: QUERY: fetch C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGget_data line 46: RESULT: a\\b offset: -1 array: Yes
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: QUERY: fetch C with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 46: Correctly got 0 tuples with 2 fields
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: raising sqlcode 100 in line 46, 'No data found in line 46.'.
+[NO_PID]: sqlca: code: 100, state: 02000
+[NO_PID]: ECPGtrans line 50 action = rollback connection = regress1
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 51: QUERY: drop table "My_Table"  with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 51: using PQexec
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 51 Ok: DROP TABLE
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ecpg_finish: Connection regress1 closed.
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/sql-quote.stdout

@@ -1 +1,5 @@
 Standard conforming strings: off
+value: 1 a\\b
+value: 1 a\\b
+value: 2 a\\\\b
+value: 2 a\\b

src/interfaces/ecpg/test/expected/sql-show.c

@@ -45,7 +45,7 @@ int main(int argc, char* argv[]) {
 #line 16 "show.pgc"
 
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "set search_path to 'public'", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set search_path to 'public'", ECPGt_EOIT, ECPGt_EORT);
 #line 18 "show.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -54,7 +54,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 18 "show.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "show search_path", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "show search_path", ECPGt_EOIT, 
 	ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 19 "show.pgc"
@@ -67,7 +67,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
   printf("Var: Search path: %s\n", var);
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "set standard_conforming_strings to off", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set standard_conforming_strings to off", ECPGt_EOIT, ECPGt_EORT);
 #line 22 "show.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -76,7 +76,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 22 "show.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "show standard_conforming_strings", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "show standard_conforming_strings", ECPGt_EOIT, 
 	ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 23 "show.pgc"
@@ -89,7 +89,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
   printf("Var: Standard conforming strings: %s\n", var);
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "set time zone PST8PDT", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set time zone PST8PDT", ECPGt_EOIT, ECPGt_EORT);
 #line 26 "show.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -98,7 +98,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 26 "show.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "show time zone", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "show time zone", ECPGt_EOIT, 
 	ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 27 "show.pgc"
@@ -111,7 +111,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
 
   printf("Time Zone: %s\n", var);
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "set transaction isolation level read committed", ECPGt_EOIT, ECPGt_EORT);
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "set transaction isolation level read committed", ECPGt_EOIT, ECPGt_EORT);
 #line 30 "show.pgc"
 
 if (sqlca.sqlwarn[0] == 'W') sqlprint();
@@ -120,7 +120,7 @@ if (sqlca.sqlwarn[0] == 'W') sqlprint();
 if (sqlca.sqlcode < 0) sqlprint();}
 #line 30 "show.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "show transaction isolation level", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "show transaction isolation level", ECPGt_EOIT, 
 	ECPGt_char,(var),(long)25,(long)1,(25)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
 #line 31 "show.pgc"

src/interfaces/ecpg/test/expected/sql-show.stderr

@@ -2,41 +2,57 @@
 [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: set search_path to 'public' on connection regress1
+[NO_PID]: ECPGexecute line 18: QUERY: set search_path to 'public' with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 18: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 18 Ok: SET
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 19: QUERY: show search_path on connection regress1
+[NO_PID]: ECPGexecute line 19: QUERY: show search_path with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 19: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 19: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 19: RESULT: public offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 22: QUERY: set standard_conforming_strings to off on connection regress1
+[NO_PID]: ECPGexecute line 22: QUERY: set standard_conforming_strings to off with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 22: using PQexec
 [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 23: QUERY: show standard_conforming_strings on connection regress1
+[NO_PID]: ECPGexecute line 23: QUERY: show standard_conforming_strings with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 23: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 23: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 23: RESULT: off offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 26: QUERY: set time zone PST8PDT on connection regress1
+[NO_PID]: ECPGexecute line 26: QUERY: set time zone PST8PDT with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 26: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 26 Ok: SET
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 27: QUERY: show time zone on connection regress1
+[NO_PID]: ECPGexecute line 27: QUERY: show time zone with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 27: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 27: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGget_data line 27: RESULT: PST8PDT offset: -1 array: Yes
 [NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGexecute line 30: QUERY: set transaction isolation level read committed on connection regress1
+[NO_PID]: ECPGexecute line 30: QUERY: set transaction isolation level read committed with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 30: using PQexec
 [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 31: QUERY: show transaction isolation level on connection regress1
+[NO_PID]: ECPGexecute line 31: QUERY: show transaction isolation level with 0 parameter on connection regress1 
+[NO_PID]: sqlca: code: 0, state: 00000
+[NO_PID]: ECPGexecute line 31: using PQexec
 [NO_PID]: sqlca: code: 0, state: 00000
 [NO_PID]: ECPGexecute line 31: Correctly got 1 tuples with 1 fields
 [NO_PID]: sqlca: code: 0, state: 00000

src/interfaces/ecpg/test/expected/thread-thread.c

@@ -70,13 +70,13 @@ int main(int argc, char *argv[])
   { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
 #line 46 "thread.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "drop table test_thread ", ECPGt_EOIT, ECPGt_EORT);}
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table test_thread ", ECPGt_EOIT, ECPGt_EORT);}
 #line 47 "thread.pgc"
  /* DROP might fail */
   { ECPGtrans(__LINE__, NULL, "commit");}
 #line 48 "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, 0, 0, "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 53 "thread.pgc"
 
   { ECPGtrans(__LINE__, NULL, "commit");}
@@ -117,7 +117,7 @@ int main(int argc, char *argv[])
   { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
 #line 85 "thread.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "select  count (*)  from test_thread   ", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  count (*)  from test_thread   ", ECPGt_EOIT, 
 	ECPGt_int,&(l_rows),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 86 "thread.pgc"
@@ -182,7 +182,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
   /* insert into test_thread table */
   for( l_i = 1; l_i <= iterations; l_i++ )
     {
-      { ECPGdo(__LINE__, 0, 1, l_connection, "insert into test_thread ( thread  , iteration  ) values (  ? ,  ? ) ", 
+      { ECPGdo(__LINE__, 0, 1, l_connection, 0, 0, "insert into test_thread ( thread  , iteration  ) values (  $1  ,  $2  ) ", 
 	ECPGt_char,(l_connection),(long)128,(long)1,(128)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_int,&(l_i),(long)1,(long)1,sizeof(int), 

src/interfaces/ecpg/test/expected/thread-thread.stdout

@@ -1 +1 @@
-No threading enabled.
+Success.

src/interfaces/ecpg/test/expected/thread-thread_implicit.c

@@ -71,13 +71,13 @@ int main(int argc, char *argv[])
   { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
 #line 47 "thread_implicit.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "drop table test_thread ", ECPGt_EOIT, ECPGt_EORT);}
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "drop table test_thread ", ECPGt_EOIT, ECPGt_EORT);}
 #line 48 "thread_implicit.pgc"
  /* DROP might fail */
   { ECPGtrans(__LINE__, NULL, "commit");}
 #line 49 "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, 0, 0, "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 54 "thread_implicit.pgc"
 
   { ECPGtrans(__LINE__, NULL, "commit");}
@@ -118,7 +118,7 @@ int main(int argc, char *argv[])
   { ECPGconnect(__LINE__, 0, "regress1" , NULL, NULL , NULL, 0); }
 #line 86 "thread_implicit.pgc"
 
-  { ECPGdo(__LINE__, 0, 1, NULL, "select  count (*)  from test_thread   ", ECPGt_EOIT, 
+  { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "select  count (*)  from test_thread   ", ECPGt_EOIT, 
 	ECPGt_int,&(l_rows),(long)1,(long)1,sizeof(int), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);}
 #line 87 "thread_implicit.pgc"
@@ -183,7 +183,7 @@ if (sqlca.sqlcode < 0) sqlprint();}
   /* insert into test_thread table */
   for( l_i = 1; l_i <= iterations; l_i++ )
     {
-      { ECPGdo(__LINE__, 0, 1, NULL, "insert into test_thread ( thread  , iteration  ) values (  ? ,  ? ) ", 
+      { ECPGdo(__LINE__, 0, 1, NULL, 0, 0, "insert into test_thread ( thread  , iteration  ) values (  $1  ,  $2  ) ", 
 	ECPGt_char,(l_connection),(long)128,(long)1,(128)*sizeof(char), 
 	ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, 
 	ECPGt_int,&(l_i),(long)1,(long)1,sizeof(int), 

src/interfaces/ecpg/test/expected/thread-thread_implicit.stdout

@@ -1 +1 @@
-No threading enabled.
+Success.

src/interfaces/ecpg/test/preproc/Makefile

@@ -4,7 +4,9 @@ include $(top_builddir)/src/Makefile.global
 include $(top_srcdir)/$(subdir)/../Makefile.regress
 
 
-TESTS = comment comment.c \
+TESTS = array_of_struct array_of_struct.c \
+	autoprep autoprep.c \
+	comment comment.c \
 	define define.c \
 	init init.c \
 	type type.c \
@@ -13,3 +15,9 @@ TESTS = comment comment.c \
 
 all: $(TESTS)
 
+array_of_struct.c:	array_of_struct.pgc ../regression.h
+	$(ECPG) -c -o $@ -I$(srcdir) $<
+
+autoprep.c:     autoprep.pgc ../regression.h
+	$(ECPG) -r prepare -o $@ -I$(srcdir) $<
+

src/interfaces/ecpg/test/preproc/array_of_struct.pgc

@@ -0,0 +1,87 @@
+#include <stdio.h>
+
+exec sql include ../regression;
+
+EXEC SQL WHENEVER sqlerror sqlprint;
+EXEC SQL WHENEVER sqlwarning sqlprint;
+EXEC SQL WHENEVER not found sqlprint;
+
+EXEC SQL TYPE customer IS
+    struct
+    {
+        varchar name[50];
+        int     phone;
+    };
+
+EXEC SQL TYPE cust_ind IS
+    struct ind
+    {
+        short   name_ind;
+        short   phone_ind;
+    };
+
+int main( int argc, char * argv[] )
+{
+    EXEC SQL begin declare section;
+      customer  custs1[10];
+      cust_ind  inds[10];
+      typedef struct
+      {
+        varchar name[50];
+        int     phone;
+      } customer2;
+      customer2  custs2[10];
+      struct customer3
+      {
+        varchar name[50];
+        int     phone;
+      } custs3[10];
+      struct customer4
+      {
+        varchar name[50];
+        int     phone;
+      } custs4;
+      int r;
+    EXEC SQL end declare section;
+
+    ECPGdebug(1, stderr);
+	  
+    EXEC SQL connect to REGRESSDB1;
+
+    EXEC SQL create table customers (c varchar(50), p int);
+    EXEC SQL insert into customers values ('John Doe', '12345');
+    EXEC SQL insert into customers values ('Jane Doe', '67890');
+
+    EXEC SQL select * INTO :custs1:inds from customers limit 2;
+    printf("custs1:\n");
+    for (r = 0; r < 2; r++)
+    {
+	    printf( "name  - %s\n", custs1[r].name.arr );
+	    printf( "phone - %d\n", custs1[r].phone );
+    }
+
+    EXEC SQL select * INTO :custs2:inds from customers limit 2;
+    printf("\ncusts2:\n");
+    for (r = 0; r < 2; r++)
+    {
+	    printf( "name  - %s\n", custs2[r].name.arr );
+	    printf( "phone - %d\n", custs2[r].phone );
+    }
+
+    EXEC SQL select * INTO :custs3:inds from customers limit 2;
+    printf("\ncusts3:\n");
+    for (r = 0; r < 2; r++)
+    {
+	    printf( "name  - %s\n", custs3[r].name.arr );
+	    printf( "phone - %d\n", custs3[r].phone );
+    }
+
+    EXEC SQL select * INTO :custs4:inds[0] from customers limit 1;
+    printf("\ncusts4:\n");
+    printf( "name  - %s\n", custs4.name.arr );
+    printf( "phone - %d\n", custs4.phone );
+
+    EXEC SQL disconnect all;
+
+    return( 0 );
+}

src/interfaces/ecpg/test/preproc/autoprep.pgc

@@ -0,0 +1,47 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* test automatic prepare for all statements */
+EXEC SQL INCLUDE ../regression;
+
+int main(int argc, char* argv[]) {
+  EXEC SQL BEGIN DECLARE SECTION;
+  	int item[4], ind[4], i = 1;
+  EXEC SQL END DECLARE SECTION;
+
+  ECPGdebug(1, stderr);
+  EXEC SQL CONNECT TO REGRESSDB1;
+
+  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, :i );
+  i++;
+  EXEC SQL INSERT INTO T VALUES ( 1, :i );
+  EXEC SQL PREPARE I AS INSERT INTO T VALUES ( 1, 2 );
+  EXEC SQL EXECUTE I;
+
+  EXEC SQL SELECT Item2 INTO :item:ind FROM T ORDER BY Item2 NULLS LAST;
+
+  for (i=0; i<4; i++)
+  	printf("item[%d] = %d\n", i, ind[i] ? -1 : item[i]);
+
+  EXEC SQL DECLARE C CURSOR FOR SELECT Item1 FROM T;
+
+  EXEC SQL OPEN C;
+
+  EXEC SQL FETCH 1 IN C INTO :i;
+  printf("i = %d\n", i);
+
+  EXEC SQL CLOSE C;
+
+  EXEC SQL DROP TABLE T;
+
+  EXEC SQL DISCONNECT ALL;
+
+  return 0;
+}

src/interfaces/ecpg/test/sql/Makefile

@@ -16,6 +16,7 @@ TESTS = array array.c \
         fetch fetch.c \
         func func.c \
         indicators indicators.c \
+	oldexec oldexec.c \
         parser parser.c \
         quote quote.c \
         show show.c \
@@ -23,7 +24,6 @@ TESTS = array array.c \
 
 all: $(TESTS)
 
-# bits needs the -c option for the "EXEC SQL TYPE" construct
-bits.c: bits.pgc ../regression.h
-	$(ECPG) -c -o $@ -I$(srcdir) $<
+oldexec.c:	oldexec.pgc ../regression.h
+	$(ECPG) -r questionmarks -o $@ -I$(srcdir) $<
 

src/interfaces/ecpg/test/sql/array.pgc

@@ -35,7 +35,7 @@ EXEC SQL END DECLARE SECTION;
 	EXEC SQL INSERT INTO test(f,i,a,text) VALUES(404.90,3,'{0,1,2,3,4,5,6,7,8,9}','abcdefghij');
 
 	EXEC SQL INSERT INTO test(f,i,a,text) VALUES(140787.0,2,:a,:text);
-	
+
 	EXEC SQL INSERT INTO test(f,i,a,text) VALUES(14.07,:did,:a,:t);
 
 	EXEC SQL COMMIT;

src/interfaces/ecpg/test/sql/desc.pgc

@@ -5,9 +5,9 @@ int
 main(void)
 {
 	EXEC SQL BEGIN DECLARE SECTION;
-	char *stmt1 = "INSERT INTO test1 VALUES (?, ?)";
-	char *stmt2 = "SELECT * from test1 where a = ? and b = ?";
-	char *stmt3 = "SELECT * from test1 where a = ?";
+	char *stmt1 = "INSERT INTO test1 VALUES ($1, $2)";
+	char *stmt2 = "SELECT * from test1 where a = $1 and b = $2";
+	char *stmt3 = "SELECT * from test1 where :var = a";
 
 	int val1 = 1;
 	char val2[4] = "one", val2output[] = "AAA";
@@ -28,6 +28,7 @@ main(void)
 
 	EXEC SQL CREATE TABLE test1 (a int, b text);
 	EXEC SQL PREPARE foo1 FROM :stmt1;
+	EXEC SQL PREPARE "Foo-1" FROM :stmt1;
 	EXEC SQL PREPARE foo2 FROM :stmt2;
 	EXEC SQL PREPARE foo3 FROM :stmt3;
 
@@ -41,7 +42,9 @@ main(void)
 	EXEC SQL SET DESCRIPTOR indesc VALUE 1 DATA = 3;
 	EXEC SQL SET DESCRIPTOR indesc VALUE 2 INDICATOR = :val1, DATA = 'this is a long test';
 
-	EXEC SQL EXECUTE foo1 USING DESCRIPTOR indesc;
+	EXEC SQL EXECUTE "Foo-1" USING DESCRIPTOR indesc;
+
+	EXEC SQL DEALLOCATE "Foo-1";
 
 	EXEC SQL SET DESCRIPTOR indesc VALUE 1 DATA = :val1;
 	EXEC SQL SET DESCRIPTOR indesc VALUE 2 INDICATOR = :val2i, DATA = :val2;
@@ -75,6 +78,7 @@ main(void)
 	printf("val1=%d val2=%c%c%c%c warn=%c truncate=%d\n", val1output, val2output[0], val2output[1], val2output[2], val2output[3], sqlca.sqlwarn[0], val2i);
 
 	EXEC SQL DROP TABLE test1;
+	EXEC SQL DEALLOCATE ALL;
 	EXEC SQL DISCONNECT;
 
 	EXEC SQL DEALLOCATE DESCRIPTOR indesc;

src/interfaces/ecpg/test/sql/dyntest.pgc

@@ -54,7 +54,7 @@ main (int argc, char **argv)
   exec sql insert into dyntest values ('first entry', 14.7, 14, 123045607890, true, 'The world''''s most advanced open source database.', '1987-07-14');
   exec sql insert into dyntest values ('second entry', 1407.87, 1407, 987065403210, false, 'The elephant never forgets.', '1999-11-5');
 
-  exec sql prepare MYQUERY from:QUERY;
+  exec sql prepare MYQUERY from :QUERY;
   exec sql declare MYCURS cursor for MYQUERY;
 
   exec sql open MYCURS;

src/interfaces/ecpg/test/sql/execute.pgc

@@ -36,7 +36,7 @@ exec sql end declare section;
 
 	printf("Inserted %ld tuples via execute immediate\n", sqlca.sqlerrd[2]);
 
-	sprintf(command, "insert into test (name, amount, letter) select name, amount+?, letter from test");
+	sprintf(command, "insert into test (name, amount, letter) select name, amount+$1, letter from test");
 	exec sql prepare I from :command;
 	exec sql execute I using :increment;
 
@@ -46,8 +46,8 @@ exec sql end declare section;
 
 	sprintf (command, "select * from test");
 
-	exec sql prepare F from :command;
-	exec sql declare CUR cursor for F;
+	exec sql prepare f from :command;
+	exec sql declare CUR cursor for f;
 
 	exec sql open CUR;
 	exec sql fetch 8 in CUR into :name, :amount, :letter;
@@ -64,11 +64,12 @@ exec sql end declare section;
 	}
 
 	exec sql close CUR;
+	exec sql deallocate f;
 
-	sprintf (command, "select * from test where amount = ?");
+	sprintf (command, "select * from test where amount = $1");
 
-	exec sql prepare F from :command;
-	exec sql declare CUR2 cursor for F;
+	exec sql prepare f from :command;
+	exec sql declare CUR2 cursor for f;
 
 	exec sql open CUR2 using 1;
 	exec sql fetch in CUR2 into :name, :amount, :letter;

src/interfaces/ecpg/test/sql/fetch.pgc

@@ -7,7 +7,7 @@ EXEC SQL INCLUDE ../regression;
 int main(int argc, char* argv[]) {
   EXEC SQL BEGIN DECLARE SECTION;
     char str[25];
-    int i, how_many = 1;
+    int i; 
   EXEC SQL END DECLARE SECTION;
 
   ECPGdebug(1, stderr);
@@ -36,7 +36,7 @@ int main(int argc, char* argv[]) {
   EXEC SQL WHENEVER NOT FOUND CONTINUE;
   EXEC SQL MOVE BACKWARD 2 IN C;
 
-  EXEC SQL FETCH :how_many IN C INTO :i, :str;
+  EXEC SQL FETCH 1 IN C INTO :i, :str;
   printf("%d: %s\n", i, str);
 
   EXEC SQL CLOSE C;

src/interfaces/ecpg/test/sql/func.pgc

@@ -5,6 +5,7 @@
 EXEC SQL INCLUDE ../regression;
 
 int main(int argc, char* argv[]) {
+  EXEC SQL char text[25];
 
   ECPGdebug(1, stderr);
   EXEC SQL CONNECT TO REGRESSDB1;
@@ -14,11 +15,12 @@ int main(int argc, char* argv[]) {
   EXEC SQL WHENEVER SQLERROR SQLPRINT;
 
   EXEC SQL CREATE TABLE My_Table ( Item1 int, Item2 text );
+  EXEC SQL CREATE TABLE Log (name text, w text);
 
   EXEC SQL CREATE FUNCTION My_Table_Check() RETURNS trigger
     AS $test$
     BEGIN
-	RAISE WARNING 'Notice: TG_NAME=%, TG WHEN=%', TG_NAME, TG_WHEN;
+	INSERT INTO Log VALUES(TG_NAME, TG_WHEN);
 	RETURN NEW;
     END; $test$
     LANGUAGE plpgsql;
@@ -31,9 +33,12 @@ int main(int argc, char* argv[]) {
 
   EXEC SQL INSERT INTO My_Table VALUES (1234, 'Some random text');
   EXEC SQL INSERT INTO My_Table VALUES (5678, 'The Quick Brown');
+  EXEC SQL SELECT name INTO :text FROM Log LIMIT 1;
+  printf("Trigger %s fired.\n", text);
 
   EXEC SQL DROP TRIGGER My_Table_Check_Trigger ON My_Table;
   EXEC SQL DROP FUNCTION My_Table_Check();
+  EXEC SQL DROP TABLE Log;
   EXEC SQL DROP TABLE My_Table;
 
   EXEC SQL DISCONNECT ALL;

src/interfaces/ecpg/test/sql/indicators.pgc

@@ -16,34 +16,34 @@ int main(int argc, char **argv)
 	exec sql connect to REGRESSDB1;
 	exec sql set autocommit to off;
 
-	exec sql create table test (
+	exec sql create table indicator_test (
 	     "id" int primary key,
 	     "str" text NOT NULL,
 	      val int null);
 	exec sql commit work;
 
-	exec sql insert into test (id, str, val) values ( 1, 'Hello', 0);
+	exec sql insert into indicator_test (id, str, val) values ( 1, 'Hello', 0);
 
 	/* use indicator in insert */
-	exec sql insert into test (id, str, val) values ( 2, 'Hi there', :intvar :nullind);
+	exec sql insert into indicator_test (id, str, val) values ( 2, 'Hi there', :intvar :nullind);
 	nullind = 0;
-	exec sql insert into test (id, str, val) values ( 3, 'Good evening', :intvar :nullind);
+	exec sql insert into indicator_test (id, str, val) values ( 3, 'Good evening', :intvar :nullind);
 	exec sql commit work;
 
 	/* use indicators to get information about selects */
-	exec sql select val into :intvar from test where id = 1;
-	exec sql select val into :intvar :nullind from test where id = 2;
+	exec sql select val into :intvar from indicator_test where id = 1;
+	exec sql select val into :intvar :nullind from indicator_test where id = 2;
 	printf("intvar: %d, nullind: %d\n", intvar, nullind);
-	exec sql select val into :intvar :nullind from test where id = 3;
+	exec sql select val into :intvar :nullind from indicator_test where id = 3;
 	printf("intvar: %d, nullind: %d\n", intvar, nullind);
 
 	/* use indicators for update */
 	intvar = 5; nullind = -1;
-	exec sql update test set val = :intvar :nullind where id = 1;
-	exec sql select val into :intvar :nullind from test where id = 1;
+	exec sql update indicator_test set val = :intvar :nullind where id = 1;
+	exec sql select val into :intvar :nullind from indicator_test where id = 1;
 	printf("intvar: %d, nullind: %d\n", intvar, nullind);
 
-	exec sql drop table test;
+	exec sql drop table indicator_test;
 	exec sql commit work;
 
 	exec sql disconnect;

src/interfaces/ecpg/test/sql/insupd.pgc

@@ -15,17 +15,17 @@ int main(int argc, char* argv[]) {
   EXEC SQL WHENEVER SQLWARNING SQLPRINT;
   EXEC SQL WHENEVER SQLERROR SQLPRINT;
 
-  EXEC SQL CREATE TABLE test(a int, b int);
+  EXEC SQL CREATE TABLE insupd_test(a int, b int);
 
-  EXEC SQL INSERT INTO test (a,b) values (1, 1);
-  EXEC SQL INSERT INTO test (a,b) values (2, 2);
-  EXEC SQL INSERT INTO test (a,b) values (3, 3);
+  EXEC SQL INSERT INTO insupd_test (a,b) values (1, 1);
+  EXEC SQL INSERT INTO insupd_test (a,b) values (2, 2);
+  EXEC SQL INSERT INTO insupd_test (a,b) values (3, 3);
 
-  EXEC SQL UPDATE test set a=a+1;
-  EXEC SQL UPDATE test set (a,b)=(5,5) where a = 4;
-  EXEC SQL UPDATE test set a=4 where a=3;;
+  EXEC SQL UPDATE insupd_test set a=a+1;
+  EXEC SQL UPDATE insupd_test set (a,b)=(5,5) where a = 4;
+  EXEC SQL UPDATE insupd_test set a=4 where a=3;;
 
-  EXEC SQL SELECT a,b into :i1,:i2 from test order by a;
+  EXEC SQL SELECT a,b into :i1,:i2 from insupd_test order by a;
 
   printf("test\na b\n%d %d\n%d %d\n%d %d\n", i1[0], i2[0], i1[1], i2[1], i1[2], i2[2]);
 

src/interfaces/ecpg/test/sql/oldexec.pgc

@@ -0,0 +1,93 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+exec sql include ../regression;
+
+exec sql whenever sqlerror sqlprint;
+
+int
+main(void)
+{
+exec sql begin declare section;
+	int amount[8];
+	int increment=100;
+	char name[8][8];
+	char letter[8][1];
+	char command[128];
+exec sql end declare section;
+	int i,j;
+
+	ECPGdebug(1, stderr);
+
+	exec sql connect to REGRESSDB1 as main;
+	exec sql create table test (name char(8), amount int, letter char(1));
+	exec sql commit;
+
+	sprintf(command, "insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f')");
+	exec sql execute immediate :command;
+
+	sprintf(command, "insert into test (name, amount, letter) values ('db: ''r1''', 2, 't')");
+	exec sql execute immediate :command;
+
+	sprintf(command, "insert into test (name, amount, letter) select name, amount+10, letter from test");
+	exec sql execute immediate :command;
+
+	printf("Inserted %ld tuples via execute immediate\n", sqlca.sqlerrd[2]);
+
+	sprintf(command, "insert into test (name, amount, letter) select name, amount+$1, letter from test");
+	exec sql prepare I from :command;
+	exec sql execute I using :increment;
+
+	printf("Inserted %ld tuples via prepared execute\n", sqlca.sqlerrd[2]);
+
+	exec sql commit;
+
+	sprintf (command, "select * from test");
+
+	exec sql prepare F from :command;
+	exec sql declare CUR cursor for F;
+
+	exec sql open CUR;
+	exec sql fetch 8 in CUR into :name, :amount, :letter;
+
+	for (i=0, j=sqlca.sqlerrd[2]; i<j; i++)
+	{
+		exec sql begin declare section;
+		char n[8], l = letter[i][0];
+		int a = amount[i];
+		exec sql end declare section;
+
+		strncpy(n, name[i], 8);
+		printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, n, i, a, i, l);
+	}
+
+	exec sql close CUR;
+
+	sprintf (command, "select * from test where ? = amount");
+
+	exec sql prepare F from :command;
+	exec sql declare CUR3 cursor for F;
+
+	exec sql open CUR3 using 1;
+	exec sql fetch in CUR3 into :name, :amount, :letter;
+
+	for (i=0, j=sqlca.sqlerrd[2]; i<j; i++)
+	{
+		exec sql begin declare section;
+		char n[8], l = letter[i][0];
+		int a = amount[i];
+		exec sql end declare section;
+
+		strncpy(n, name[i], 8);
+		printf("name[%d]=%8.8s\tamount[%d]=%d\tletter[%d]=%c\n", i, n, i, a, i, l);
+	}
+
+	exec sql close CUR3;
+	exec sql drop table test;
+	exec sql commit;
+	exec sql disconnect;
+
+	return (0);
+}

src/interfaces/ecpg/test/sql/quote.pgc

@@ -7,6 +7,7 @@ EXEC SQL INCLUDE ../regression;
 int main(int argc, char* argv[]) {
   EXEC SQL BEGIN DECLARE SECTION;
     char var[25];
+    int i;
   EXEC SQL END DECLARE SECTION;
 
   ECPGdebug(1, stderr);
@@ -23,18 +24,30 @@ int main(int argc, char* argv[]) {
 
   /* this is a\\b actually */
   EXEC SQL INSERT INTO "My_Table" VALUES ( 1, 'a\\\\b' );
-  /* this is a\b */
+  /* this is a\\b */
   EXEC SQL INSERT INTO "My_Table" VALUES ( 1, E'a\\\\b' );
 
   EXEC SQL SET standard_conforming_strings TO on;
 
-  /* this is a\\b actually */
-  EXEC SQL INSERT INTO "My_Table" VALUES ( 1, 'a\\\\b' );
-  /* this is a\b */
-  EXEC SQL INSERT INTO "My_Table" VALUES ( 1, E'a\\\\b' );
+  /* this is a\\\\b actually */
+  EXEC SQL INSERT INTO "My_Table" VALUES ( 2, 'a\\\\b' );
+  /* this is a\\b */
+  EXEC SQL INSERT INTO "My_Table" VALUES ( 2, E'a\\\\b' );
 
-  EXEC SQL SELECT * FROM "My_Table";
+  EXEC SQL BEGIN;
+  EXEC SQL DECLARE C CURSOR FOR SELECT * FROM "My_Table";
 
+  EXEC SQL OPEN C;
+
+  EXEC SQL WHENEVER NOT FOUND DO BREAK;
+
+  while (true)
+  {
+  	EXEC SQL FETCH C INTO :i, :var;
+	printf("value: %d %s\n", i, var);
+  }
+
+  EXEC SQL ROLLBACK;
   EXEC SQL DROP TABLE "My_Table";
 
   EXEC SQL DISCONNECT ALL;