Tu Jan 17 18:53:03 CET 2006

- Data transferred binary is now put into the variables verbatim.

Tu Jan 24 10:59:21 CET 2006

- Synced parser and keyword list.

- Added another test case.

- Set ecpg library version to 5.2.

- Set ecpg version to 4.2.1.

{"header",HEADER_P},

{"hold",HOLD},

{"hour",HOUR_P},

{"if",IF_P},

{"ilike",ILIKE},

{"immediate",IMMEDIATE},

{"immutable",IMMUTABLE},

{"out",OUT_P},

{"outer",OUTER_P},

{"overlaps",OVERLAPS},

{"owned",OWNED},

{"owner",OWNER},

{"partial",PARTIAL},

{"password",PASSWORD},

{"quote",QUOTE},

{"read",READ},

{"real",REAL},

{"reassign",REASSIGN},

{"recheck",RECHECK},

{"references",REFERENCES},

{"reindex",REINDEX},

HANDLER HAVING HEADER_P HOLD HOUR_P

ILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IN_P INCLUDING INCREMENT

IF_PILIKE IMMEDIATE IMMUTABLE IMPLICIT_P IN_P INCLUDING INCREMENT

INDEX INHERIT INHERITS INITIALLY INNER_P INOUT INPUT_P

INSENSITIVE INSERT INSTEAD INT_P INTEGER INTERSECT

INTERVAL INTO INVOKER IS ISNULL ISOLATION

NOT NOTHING NOTIFY NOTNULL NOWAIT NULL_P NULLIF NUMERIC

OBJECT_P OF OFF OFFSET OIDS OLD ON ONLY OPERATOR OPTION OR ORDER

OUT_P OUTER_P OVERLAPS OVERLAY OWNER

OUT_P OUTER_P OVERLAPS OVERLAYOWNEDOWNER

PARTIAL PASSWORD PLACING POSITION

PRECISION PRESERVE PREPARE PREPARED PRIMARY

PRIOR PRIVILEGES PROCEDURAL PROCEDURE

QUOTE

READ REAL RECHECK REFERENCES REINDEX RELATIVE_P RELEASE RENAME

READ REALREASSIGNRECHECK REFERENCES REINDEX RELATIVE_P RELEASE RENAME

REPEATABLE REPLACE RESET RESTART RESTRICT RETURNS REVOKE RIGHT

ROLE ROLLBACK ROW ROWS RULE

|DropCastStmt{ output_statement($1,0, connection); }

|DropGroupStmt{ output_statement($1,0, connection); }

|DropOpClassStmt{ output_statement($1,0, connection); }

|DropOwnedStmt{ output_statement($1,0, connection); }

|DropPLangStmt{ output_statement($1,0, connection); }

|DropRoleStmt{ output_statement($1,0, connection); }

|DropRuleStmt{ output_statement($1,0, connection); }

|LockStmt{ output_statement($1,0, connection); }

|NotifyStmt{ output_statement($1,0, connection); }

|ReassignOwnedStmt{ output_statement($1,0, connection); }

|ReindexStmt{ output_statement($1,0, connection); }

|RemoveAggrStmt{ output_statement($1,0, connection); }

|RemoveOperStmt{ output_statement($1,0, connection); }

OptRoleList:

PASSWORDSconst{$$ = cat2_str(make_str("password"),$2); }

|PASSWORDNULL_P{$$ = make_str("password null"); }

|ENCRYPTEDPASSWORDSconst{$$ = cat2_str(make_str("encrypted password"),$3); }

|UNENCRYPTEDPASSWORDSconst{$$ = cat2_str(make_str("unencrypted password"),$3); }

|SUPERUSER_P{$$ = make_str("superuser"); }

DropOwnedStmt:

{

$$ = cat_str(3, make_str("drop owned by"),$4,$5);

}

;

ReassignOwnedStmt:

{

$$ = cat_str(4, make_str("reassign owned by"),$4, make_str("to"),$6);

}

;

DropStmt:DROPdrop_typeany_name_listopt_drop_behavior

DropStmt:DROPdrop_typeIF_PEXISTSany_name_listopt_drop_behavior

{$$ = cat_str(5, make_str("drop"),$2, make_str("if exists"),$5,$6); }

{$$ = cat_str(4, make_str("drop"),$2,$3,$4); }

;

DropdbStmt:DROPDATABASEdatabase_name

{$$ = cat2_str(make_str("drop database"),$3); }

{$$ = cat2_str(make_str("drop database if exists"),$5); }

;

{$$ = cat2_str($1, make_str("is not unknown")); }

|a_exprISDISTINCTFROMa_expr %precIS

{$$ = cat_str(3,$1, make_str("is distinct from"),$5); }

|a_exprISNOTDISTINCTFROMa_expr %precIS

{$$ = cat_str(3,$1, make_str("is not distinct from"),$6); }

|a_exprISOF'('type_list')' %precIS

{$$ = cat_str(4,$1, make_str("is of ("),$5, make_str(")")); }

|a_exprISNOTOF'('type_list')' %precIS

{$$ = cat2_str($1,$2); }

|b_exprISDISTINCTFROMb_expr %precIS

{$$ = cat_str(3,$1, make_str("is distinct from"),$5); }

|b_exprISNOTDISTINCTFROMb_expr %precIS

{$$ = cat_str(3,$1, make_str("is not distinct from"),$6); }

|b_exprISOF'('b_expr')' %precIS

{$$ = cat_str(4,$1, make_str("is of ("),$5, make_str(")")); }

|b_exprISNOTOF'('b_expr')' %precIS

|HEADER_P{$$ = make_str("header"); }

|HOLD{$$ = make_str("hold"); }

|IF_P{$$ = make_str("if"); }

|IMMEDIATE{$$ = make_str("immediate"); }

|IMMUTABLE{$$ = make_str("immutable"); }

|IMPLICIT_P{$$ = make_str("implicit"); }

|OIDS{$$ = make_str("oids"); }

|OPERATOR{$$ = make_str("operator"); }

|OPTION{$$ = make_str("option"); }

|OWNED{$$ = make_str("owned"); }

|OWNER{$$ = make_str("owner"); }

|PARTIAL{$$ = make_str("partial"); }

|PASSWORD{$$ = make_str("password"); }

|PROCEDURE{$$ = make_str("procedure"); }

|QUOTE{$$ = make_str("quote"); }

|READ{$$ = make_str("read"); }

|REASSIGN{$$ = make_str("reassign"); }

|RECHECK{$$ = make_str("recheck"); }

|REINDEX{$$ = make_str("reindex"); }

|RELATIVE_P{$$ = make_str("relative"); }

subdir = src/interfaces/ecpg/test

top_builddir = ../../../..

TESTS = test1 test2 test3 test4 test5 perftest dyntest dyntest2 test_notice\

test_code100 test_init testdynalloc num_test dt_test test_informix\

test_desc

test_informix2test_desc

ifeq ($(enable_thread_safety), yes)

TESTS += test_thread test_thread_implicit

test_informix: test_informix.o

$(CC)$(CFLAGS)$(LDFLAGS) -L../compatlib -L../ecpglib -L ../pgtypeslib -L../../libpq$^$(LIBS) -lpgtypes -lecpg -lecpg_compat -lpq$(PTHREAD_LIBS) -o$@

test_informix2: test_informix2.o

$(CC)$(CFLAGS)$(LDFLAGS) -L../compatlib -L../ecpglib -L ../pgtypeslib -L../../libpq$^$(LIBS) -lpgtypes -lecpg -lecpg_compat -lpq$(PTHREAD_LIBS) -o$@

%.c:%.pgc

$(ECPG) -o$@ -I$(srcdir)$<

test_informix.c: test_informix.pgc

$(ECPG) -o$@ -C INFORMIX -r no_indicator$<

test_informix2.c: test_informix2.pgc

$(ECPG) -o$@ -C INFORMIX$<

clean:

rm -f$(TESTS)$(TESTS:%=%.o)$(TESTS:%=%.c) log

#include <stdio.h>

#include <stdlib.h>

#include "sqltypes.h"

EXEC SQL include sqlca.h;

/* Check SQLCODE, and produce a "standard error" if it's wrong! */

static void sql_check(char *fn, char *caller, int ignore)

{

char errorstring[255];

if (SQLCODE == ignore)

return;

else

{

if (SQLCODE != 0)

{

sprintf(errorstring, "**SQL error %ld doing '%s' in function '%s'. [%s]",

SQLCODE, caller, fn, sqlca.sqlerrm.sqlerrmc);

fprintf(stderr, "%s", errorstring);

printf("%s\n", errorstring);

/* attempt a ROLLBACK */

EXEC SQL rollback;

if (SQLCODE == 0)

{

sprintf(errorstring, "Rollback successful.\n");

} else {

sprintf(errorstring, "Rollback failed with code %ld.\n", SQLCODE);

}

fprintf(stderr, "%s", errorstring);

printf("%s\n", errorstring);

exit(1);

}

}

}

int main(void)

{

EXEC SQL BEGIN DECLARE SECTION;

int c;

timestamp d;

timestamp maxd;

char dbname[30];

EXEC SQL END DECLARE SECTION;

EXEC SQL whenever sqlerror sqlprint;

strcpy(dbname, "mm");

EXEC SQL connect to :dbname;

sql_check("main", "connect", 0);

EXEC SQL create table history (customerid integer, timestamp timestamp without time zone, action_taken char(5), narrative varchar(100));

sql_check("main", "create", 0);

EXEC SQL insert into history

(customerid, timestamp, action_taken, narrative)

values(1, now(), 'test', 'test');

sql_check("main", "insert", 0);

EXEC SQL select max(timestamp)

into :maxd

from history;

sql_check("main", "select max", 100);

if (risnull(CDTIMETYPE, (char *) &maxd))

{

printf("Nothing on the history table\n\n");

exit(0);

}

EXEC SQL select customerid, timestamp

into :c, :d

from history

where timestamp = :maxd

limit 1;

sql_check("main", "select", 0);

printf("Read in customer %d\n", c);

/* Adding 1 to d adds 1 second. So:

60 1 minute

3600 1 hour

86400 1 day */

d=d+86400;

c++;

EXEC SQL insert into history

(customerid, timestamp, action_taken, narrative)

values(:c, :d, 'test', 'test');

sql_check("main", "update", 0);

EXEC SQL commit;

EXEC SQL drop table history;

sql_check("main", "drop", 0);

EXEC SQL commit;

EXEC SQL disconnect;

sql_check("main", "disconnect", 0);

printf("All OK!\n");

exit(0);

/*

Table "public.history"

Column | Type | Modifiers

--------------+-----------------------------+-----------

customerid | integer | not null

timestamp | timestamp without time zone | not null

action_taken | character(5) | not null

narrative | character varying(100) |

*/

}