diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/execute.c pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/execute.c *** pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/execute.c 2009-06-13 18:25:05.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/execute.c 2009-08-03 16:36:23.000000000 +0200 *************** *** 25,30 **** --- 25,31 ---- #include "ecpgerrno.h" #include "extern.h" #include "sqlca.h" + #include "sqlda.h" #include "sql3types.h" #include "pgtypes_numeric.h" #include "pgtypes_date.h" *************** ecpg_store_input(const int lineno, const *** 1031,1036 **** --- 1032,1038 ---- break; case ECPGt_descriptor: + case ECPGt_sqlda: break; default: *************** ecpg_execute(struct statement * stmt) *** 1170,1175 **** --- 1172,1233 ---- if (desc->count == desc_counter) desc_counter = 0; } + else if (var->type == ECPGt_sqlda) + { + pg_sqlda_t **_sqlda = (pg_sqlda_t **)var->pointer; + pg_sqlda_t *sqlda = *_sqlda; + struct variable desc_inlist; + int i; + + if (sqlda == NULL) + return false; + + desc_counter++; + for (i = 0; i < sqlda->sqld; i++) + { + if (i + 1 == desc_counter) + { + desc_inlist.type = ecpg_sqlda_type(sqlda->sqlvar[i].sqltype); + desc_inlist.value = sqlda->sqlvar[i].sqldata; + desc_inlist.pointer = &(sqlda->sqlvar[i].sqldata); + switch (desc_inlist.type) + { + case ECPGt_char: + case ECPGt_varchar: + desc_inlist.varcharsize = strlen(sqlda->sqlvar[i].sqldata); + break; + default: + desc_inlist.varcharsize = 0; + break; + } + desc_inlist.arrsize = 1; + desc_inlist.offset = 0; + if (sqlda->sqlvar[i].sqlind) + { + desc_inlist.ind_type = ECPGt_short; + /* ECPG expects indicator value < 0 */ + if (*(sqlda->sqlvar[i].sqlind)) + *(sqlda->sqlvar[i].sqlind) = -1; + desc_inlist.ind_value = sqlda->sqlvar[i].sqlind; + desc_inlist.ind_pointer = &(sqlda->sqlvar[i].sqlind); + desc_inlist.ind_varcharsize = desc_inlist.ind_arrsize = 1; + desc_inlist.ind_offset = 0; + } + else + { + desc_inlist.ind_type = ECPGt_NO_INDICATOR; + desc_inlist.ind_value = desc_inlist.ind_pointer = NULL; + desc_inlist.ind_varcharsize = desc_inlist.ind_arrsize = desc_inlist.ind_offset = 0; + } + if (!ecpg_store_input(stmt->lineno, stmt->force_indicator, &desc_inlist, &tobeinserted, false)) + return false; + + break; + } + } + if (sqlda->sqld == desc_counter) + desc_counter = 0; + } else { if (!ecpg_store_input(stmt->lineno, stmt->force_indicator, var, &tobeinserted, false)) *************** ecpg_execute(struct statement * stmt) *** 1351,1356 **** --- 1409,1435 ---- } var = var->next; } + else if (var != NULL && var->type == ECPGt_sqlda) + { + pg_sqlda_t **_sqlda = (pg_sqlda_t **)var->pointer; + pg_sqlda_t *sqlda = *_sqlda; + + if (!sqlda) + { + sqlda = ecpg_build_sqlda_for_PGresult(stmt->lineno, results); + if (!sqlda) + status = false; + else + *_sqlda = sqlda; + } + else if (!ecpg_compare_sqlda_with_PGresult(sqlda, results)) + status = false; + + if (status == true) + ecpg_set_sqlda_from_PGresult(stmt->lineno, _sqlda, results); + + var = var->next; + } else for (act_field = 0; act_field < nfields && status; act_field++) { diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/extern.h pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/extern.h *** pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/extern.h 2009-05-25 12:08:48.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/extern.h 2009-08-03 15:25:02.000000000 +0200 *************** *** 6,11 **** --- 6,12 ---- #include "postgres_fe.h" #include "libpq-fe.h" #include "sqlca.h" + #include "sqlda.h" #include "ecpg_config.h" #ifndef CHAR_BIT #include *************** bool ecpg_init(const struct connection *** 129,134 **** --- 130,137 ---- char *ecpg_strdup(const char *, int); const char *ecpg_type_name(enum ECPGttype); int ecpg_dynamic_type(Oid); + int ecpg_sqlda_type(int); + int ecpg_to_sqlda_type(Oid); void ecpg_free_auto_mem(void); void ecpg_clear_auto_mem(void); *************** void ecpg_log(const char *format,...); *** 149,154 **** --- 152,161 ---- bool ecpg_auto_prepare(int, const char *, const int, char **, const char *); void ecpg_init_sqlca(struct sqlca_t * sqlca); + pg_sqlda_t *ecpg_build_sqlda_for_PGresult(int, PGresult *); + bool ecpg_compare_sqlda_with_PGresult(pg_sqlda_t *sqlda, const PGresult *results); + void ecpg_set_sqlda_from_PGresult(int, pg_sqlda_t **, const PGresult *); + /* SQLSTATE values generated or processed by ecpglib (intentionally * not exported -- users should refer to the codes directly) */ diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/Makefile pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/Makefile *** pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/Makefile 2009-07-13 11:16:41.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/Makefile 2009-08-03 15:25:02.000000000 +0200 *************** override CFLAGS += $(PTHREAD_CFLAGS) *** 24,30 **** # Need to recompile any libpgport object files LIBS := $(filter-out -lpgport, $(LIBS)) ! OBJS= execute.o typename.o descriptor.o data.o error.o prepare.o memory.o \ connect.o misc.o path.o pgstrcasecmp.o \ $(filter snprintf.o strlcpy.o, $(LIBOBJS)) --- 24,30 ---- # Need to recompile any libpgport object files LIBS := $(filter-out -lpgport, $(LIBS)) ! OBJS= execute.o typename.o descriptor.o sqlda.o data.o error.o prepare.o memory.o \ connect.o misc.o path.o pgstrcasecmp.o \ $(filter snprintf.o strlcpy.o, $(LIBOBJS)) diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/sqlda.c pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/sqlda.c *** pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/sqlda.c 1970-01-01 01:00:00.000000000 +0100 --- pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/sqlda.c 2009-08-03 16:34:12.000000000 +0200 *************** *** 0 **** --- 1,272 ---- + /* + * Crude SQLDA support routines + * Only supports fetching 1 record at a time + * + * The allocated memory area pointed by an sqlda pointer + * contains both the metadata and the data, so freeing up + * is a simple free(sqlda) as expected by the ESQL/C examples. + * + * (C) 2009 Cybertec GmbH + * Zoltán Böszörményi + * Hans-Jürgen Schönig + * Placed under the same license as PostgreSQL. + */ + + #define POSTGRES_ECPG_INTERNAL + #include "postgres_fe.h" + #include "pg_type.h" + + #include + #include + + #include "ecpg-pthread-win32.h" + #include "decimal.h" + #include "ecpgtype.h" + #include "ecpglib.h" + #include "ecpgerrno.h" + #include "extern.h" + #include "sqlca.h" + #include "sqlda.h" + #include "sqltypes.h" + + /* + * Build pg_sqlda_t (metadata only) from PGresult + */ + pg_sqlda_t * + ecpg_build_sqlda_for_PGresult(int line, PGresult *res) + { + pg_sqlda_t *sqlda; + pg_sqlvar_t*sqlvar; + char *fname; + long size; + int i; + + size = sizeof(pg_sqlda_t) + PQnfields(res) * sizeof(pg_sqlvar_t); + for (i = 0; i < PQnfields(res); i++) + size += strlen(PQfname(res, i)) + 1; + /* round allocated size up to the next multiple of 8 */ + if (size % 8) + size += 8 - (size % 8); + + sqlda = (pg_sqlda_t *)ecpg_alloc(size, line); + if (!sqlda) + { + ecpg_raise(line, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL); + return NULL; + } + memset(sqlda, 0, size); + sqlvar = (pg_sqlvar_t *)(sqlda + 1); + fname = (char *)(sqlvar + PQnfields(res)); + + sqlda->sqld = PQnfields(res); + sqlda->desc_occ = size; /* cheat here, keep the full allocated size */ + sqlda->sqlvar = sqlvar; + + for (i = 0; i < sqlda->sqld; i++) + { + sqlda->sqlvar[i].sqltype = ecpg_to_sqlda_type(PQftype(res, i)); + strcpy(fname, PQfname(res, i)); + sqlda->sqlvar[i].sqlname = fname; + fname += strlen(sqlda->sqlvar[i].sqlname) + 1; + sqlda->sqlvar[i].sqlformat = (char *)(long)PQfformat(res, i); + sqlda->sqlvar[i].sqlxid = PQftype(res, i); + sqlda->sqlvar[i].sqltypelen = PQfsize(res, i); + } + + return sqlda; + } + + /* + * Check whether the supplied sqlda and PGresult + * both has the same metadata + */ + bool + ecpg_compare_sqlda_with_PGresult(pg_sqlda_t *sqlda, const PGresult *res) + { + int i; + + if (sqlda->sqld != PQnfields(res)) + return false; + + for (i = 0; i < sqlda->sqld; i++) + { + if (sqlda->sqlvar[i].sqltype != ecpg_dynamic_type(PQftype(res, i))) + return false; + if (strcmp(sqlda->sqlvar[i].sqlname, PQfname(res, i))) + return false; + if (sqlda->sqlvar[i].sqlformat != (char *)(long)PQfformat(res, i)) + return false; + if (sqlda->sqlvar[i].sqlxid != PQftype(res, i)) + return false; + if (sqlda->sqlvar[i].sqltypelen != PQfsize(res, i)) + return false; + } + + return true; + } + + static long + ecpg_sqlda_size_round_align(long size, int alignment, int round) + { + if (size % alignment) + size += alignment - (size % alignment); + size += round; + return size; + } + + static long + ecpg_sqlda_size_align(long size, int alignment) + { + if (size % alignment) + size += alignment - (size % alignment); + return size; + } + + /* + * Sets values from PGresult. + * Reallocates the memory area pointed by *_sqlda if needed + */ + void + ecpg_set_sqlda_from_PGresult(int lineno, pg_sqlda_t **_sqlda, const PGresult *res) + { + pg_sqlda_t *sqlda = (*_sqlda); + int i; + long size; + static int2 value_is_null = 1; + static int2 value_is_not_null = 0; + + /* Compute new structure size for allocation */ + size = sizeof(pg_sqlda_t) + sqlda->sqld * sizeof(pg_sqlvar_t); + for (i = 0; i < PQnfields(res); i++) + size += strlen(PQfname(res, i)) + 1; + + for (i = 0; i < sqlda->sqld; i++) + { + switch (sqlda->sqlvar[i].sqltype) + { + case SQLSMINT: + size = ecpg_sqlda_size_round_align(size, sizeof(short), sizeof(short)); + break; + case SQLINT: + case SQLSERIAL: + size = ecpg_sqlda_size_round_align(size, sizeof(int), sizeof(int)); + break; + case SQLFLOAT: + size = ecpg_sqlda_size_round_align(size, sizeof(double), sizeof(double)); + break; + case SQLSMFLOAT: + size = ecpg_sqlda_size_round_align(size, sizeof(float), sizeof(float)); + break; + case SQLDECIMAL: + size = ecpg_sqlda_size_round_align(size, sizeof(int), sizeof(decimal)); + break; + case SQLINT8: + case SQLSERIAL8: + size = ecpg_sqlda_size_round_align(size, sizeof(int64_t), sizeof(int64_t)); + break; + + /* + * These types will be passed as character strings + * until we know what to do with them. + */ + case SQLCHAR: + case SQLTEXT: + case SQLVCHAR: + case SQLNCHAR: + case SQLNVCHAR: + case SQLMONEY: + case SQLDATE: + case SQLDTIME: + case SQLINTERVAL: + default: + break; + } + } + + if (sqlda->desc_occ < size) + { + sqlda = realloc(sqlda, size); + *_sqlda = sqlda; + sqlda->desc_occ = size; + } + + /* + * Set sqlvar[i]->sqldata pointers and convert values to correct format + */ + size = sizeof(pg_sqlda_t) + sqlda->sqld * sizeof(pg_sqlvar_t); + for (i = 0; i < PQnfields(res); i++) + size += strlen(PQfname(res, i)) + 1; + + for (i = 0; i < sqlda->sqld; i++) + { + switch (sqlda->sqlvar[i].sqltype) + { + case SQLSMINT: + size = ecpg_sqlda_size_align(size, sizeof(short)); + sscanf(PQgetvalue(res, 0, i), "%hd", (short *)((char *)sqlda + size)); + sqlda->sqlvar[i].sqldata = (char *)sqlda + size; + size += sizeof(short); + break; + case SQLINT: + case SQLSERIAL: + size = ecpg_sqlda_size_align(size, sizeof(int)); + sscanf(PQgetvalue(res, 0, i), "%d", (int *)((char *)sqlda + size)); + sqlda->sqlvar[i].sqldata = (char *)sqlda + size; + size += sizeof(int); + break; + case SQLFLOAT: + size = ecpg_sqlda_size_align(size, sizeof(double)); + sscanf(PQgetvalue(res, 0, i), "%lf", (double *)((char *)sqlda + size)); + sqlda->sqlvar[i].sqldata = (char *)sqlda + size; + size += sizeof(double); + break; + case SQLSMFLOAT: + size = ecpg_sqlda_size_align(size, sizeof(float)); + sscanf(PQgetvalue(res, 0, i), "%f", (float *)((char *)sqlda + size)); + sqlda->sqlvar[i].sqldata = (char *)sqlda + size; + size += sizeof(float); + break; + case SQLDECIMAL: + { + size = ecpg_sqlda_size_align(size, sizeof(int)); + sqlda->sqlvar[i].sqldata = (char *)sqlda + size; + + ecpg_get_data(res, 0, i, lineno, + ECPGt_decimal, ECPGt_NO_INDICATOR, + sqlda->sqlvar[i].sqldata, NULL, 0, 0, 0, + ECPG_ARRAY_NONE, ECPG_COMPAT_INFORMIX, false); + + size += sizeof(decimal); + break; + } + case SQLINT8: + case SQLSERIAL8: + size = ecpg_sqlda_size_align(size, sizeof(int64_t)); + sscanf(PQgetvalue(res, 0, i), "%" PRId64, (int64_t *)((char *)sqlda + size)); + sqlda->sqlvar[i].sqldata = (char *)sqlda + size; + size += sizeof(int64_t); + break; + + /* + * These types will be passed as character strings until + * it's known what to do with them. We use sqlvar->sqldata + * in all cases regardless of length, don't care about + * sqlvar->sqlilongdata. + */ + case SQLCHAR: + case SQLTEXT: + case SQLVCHAR: + case SQLNCHAR: + case SQLNVCHAR: + case SQLMONEY: + case SQLDATE: + case SQLDTIME: + case SQLINTERVAL: + default: + sqlda->sqlvar[i].sqldata = PQgetvalue(res, 0, i); + break; + } + + sqlda->sqlvar[i].sqlind = PQgetisnull(res, 0, i) ? &value_is_null : &value_is_not_null; + } + } diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/typename.c pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/typename.c *** pgsql85dev.1dyncursor/src/interfaces/ecpg/ecpglib/typename.c 2007-11-15 22:14:45.000000000 +0100 --- pgsql85dev.2sqlda/src/interfaces/ecpg/ecpglib/typename.c 2009-08-03 16:38:16.000000000 +0200 *************** *** 7,12 **** --- 7,13 ---- #include "ecpgtype.h" #include "ecpglib.h" #include "extern.h" + #include "sqltypes.h" #include "sql3types.h" #include "pg_type.h" *************** ecpg_dynamic_type(Oid type) *** 99,101 **** --- 100,189 ---- return -(int) type; } } + + int + ecpg_sqlda_type(int type) + { + switch (type) + { + case SQLCHAR: + case SQLNCHAR: + return ECPGt_char; + case SQLSMINT: + return ECPGt_short; + case SQLINT: + return ECPGt_int; + case SQLFLOAT: + return ECPGt_double; + case SQLSMFLOAT: + return ECPGt_float; + case SQLDECIMAL: + return ECPGt_decimal; + case SQLSERIAL: + return ECPGt_int; + case SQLDATE: + return ECPGt_date; + #if 0 + case SQLMONEY: + return ???; + case SQLNULL: + return ???; + #endif + case SQLDTIME: + return ECPGt_timestamp; + #if 0 + case SQLBYTES: + return ???; + #endif + case SQLTEXT: + return ECPGt_char; + case SQLVCHAR: + case SQLNVCHAR: + return ECPGt_varchar; + case SQLINTERVAL: + return ECPGt_interval; + case SQLINT8: + case SQLSERIAL8: + return ECPGt_long_long; + default: + return (-type); + } + } + + int + ecpg_to_sqlda_type(Oid type) + { + switch (type) + { + case CHAROID: + case BPCHAROID: + return SQLCHAR; + case INT2OID: + return SQLSMINT; + case INT4OID: + return SQLINT; + case FLOAT8OID: + return SQLFLOAT; + case FLOAT4OID: + return SQLSMFLOAT; + case NUMERICOID: + return SQLDECIMAL; + case DATEOID: + return SQLDATE; + case CASHOID: + return SQLMONEY; + case TIMESTAMPOID: + case TIMESTAMPTZOID: + return SQLDTIME; + case TEXTOID: + return SQLTEXT; + case VARCHAROID: + return SQLVCHAR; + case INTERVALOID: + return SQLINTERVAL; + case INT8OID: + return SQLINT8; + default: + return (-type); + } + } diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/include/ecpgtype.h pgsql85dev.2sqlda/src/interfaces/ecpg/include/ecpgtype.h *** pgsql85dev.1dyncursor/src/interfaces/ecpg/include/ecpgtype.h 2007-08-14 12:01:52.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/include/ecpgtype.h 2009-08-03 15:25:02.000000000 +0200 *************** enum ECPGttype *** 61,67 **** ECPGt_const, /* a constant is needed sometimes */ ECPGt_EOIT, /* End of insert types. */ ECPGt_EORT, /* End of result types. */ ! ECPGt_NO_INDICATOR /* no indicator */ }; /* descriptor items */ --- 61,68 ---- ECPGt_const, /* a constant is needed sometimes */ ECPGt_EOIT, /* End of insert types. */ ECPGt_EORT, /* End of result types. */ ! ECPGt_NO_INDICATOR, /* no indicator */ ! ECPGt_sqlda /* INFORMIX-compatible sqlda_t descriptor */ }; /* descriptor items */ diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/include/sqlda.h pgsql85dev.2sqlda/src/interfaces/ecpg/include/sqlda.h *** pgsql85dev.1dyncursor/src/interfaces/ecpg/include/sqlda.h 2009-06-13 18:25:05.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/include/sqlda.h 2009-08-03 15:25:02.000000000 +0200 *************** *** 1,3 **** --- 1,74 ---- /* * $PostgreSQL: pgsql/src/interfaces/ecpg/include/sqlda.h,v 1.4 2009/06/11 14:49:13 momjian Exp $ */ + + #ifndef POSTGRES_SQLDA_H + #define POSTGRES_SQLDA_H + + /* Define Informix "standard" types */ + #ifndef C_H + typedef int int4; + typedef short int2; + #endif + typedef char int1; + + typedef int mint; + typedef long mlong; + + typedef short MSHORT; + typedef char MCHAR; + + typedef unsigned int uint4; + typedef unsigned short uint2; + typedef unsigned char uint1; + + typedef unsigned int muint; + typedef unsigned long mulong; + + typedef unsigned short MUSHORT; + typedef unsigned char MUCHAR; + + #define MI_INT_SIZE (sizeof(int) * 8) + #define MI_LONG_SIZE (sizeof(long) * 8) + #define MI_PTR_SIZE (sizeof(char *) * 8) + + typedef struct sqlvar_struct + { + int2 sqltype; /* variable type */ + int4 sqllen; /* length in bytes */ + char *sqldata; /* pointer to data */ + int2 *sqlind; /* pointer to indicator */ + char *sqlname; /* variable name */ + char *sqlformat; /* reserved for future use */ + int2 sqlitype; /* ind variable type */ + int2 sqlilen; /* ind length in bytes */ + char *sqlidata; /* ind data pointer */ + int4 sqlxid; /* extended id type */ + char *sqltypename; /* extended type name */ + int2 sqltypelen; /* length of extended type name */ + int2 sqlownerlen; /* length of owner name */ + int2 sqlsourcetype; /* source type for distinct of built-ins */ + char *sqlownername; /* owner name */ + int4 sqlsourceid; /* extended id of source type */ + + /* + * sqlilongdata is new. It supports data that exceeds the 32k + * limit. sqlilen and sqlidata are for backward compatibility + * and they have maximum value of <32K. + */ + char *sqlilongdata; /* for data field beyond 32K */ + int4 sqlflags; /* for internal use only */ + void *sqlreserved; /* reserved for future use */ + } pg_sqlvar_t; + + typedef struct sqlda + { + int2 sqld; + pg_sqlvar_t *sqlvar; + char desc_name[19]; /* descriptor name */ + int2 desc_occ; /* size of sqlda structure */ + struct sqlda *desc_next; /* pointer to next sqlda struct */ + void *reserved; /* reserved for future use */ + } pg_sqlda_t; + + #endif /* POSTGRES_SQLDA_H */ diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/include/sqltypes.h pgsql85dev.2sqlda/src/interfaces/ecpg/include/sqltypes.h *** pgsql85dev.1dyncursor/src/interfaces/ecpg/include/sqltypes.h 2009-06-13 18:25:05.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/include/sqltypes.h 2009-08-03 16:39:30.000000000 +0200 *************** *** 30,33 **** --- 30,55 ---- #define CLVCHARPTRTYPE 124 #define CTYPEMAX 25 + /* + * Values used in sqlda->sqlvar[i]->sqltype + */ + #define SQLCHAR 0 + #define SQLSMINT 1 + #define SQLINT 2 + #define SQLFLOAT 3 + #define SQLSMFLOAT 4 + #define SQLDECIMAL 5 + #define SQLSERIAL 6 + #define SQLDATE 7 + #define SQLMONEY 8 + #define SQLDTIME 10 + #define SQLBYTES 11 + #define SQLTEXT 12 + #define SQLVCHAR 13 + #define SQLINTERVAL 14 + #define SQLNCHAR 15 + #define SQLNVCHAR 16 + #define SQLINT8 17 + #define SQLSERIAL8 18 + #endif /* ndef ECPG_SQLTYPES_H */ diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/descriptor.c pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/descriptor.c *** pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/descriptor.c 2009-01-30 17:28:46.000000000 +0100 --- pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/descriptor.c 2009-08-03 15:25:02.000000000 +0200 *************** descriptor_variable(const char *name, in *** 326,328 **** --- 326,347 ---- strlcpy(descriptor_names[input], name, sizeof(descriptor_names[input])); return (struct variable *) & varspace[input]; } + + struct variable * + sqlda_variable(const char *name) + { + struct variable *p = (struct variable *) mm_alloc(sizeof(struct variable)); + + p->name = mm_strdup(name); + p->type = (struct ECPGtype *) mm_alloc(sizeof(struct ECPGtype)); + p->type->type = ECPGt_sqlda; + p->type->size = NULL; + p->type->struct_sizeof = NULL; + p->type->u.element = NULL; + p->type->lineno = 0; + p->brace_level = 0; + p->next = NULL; + + return p; + } + diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/ecpg.addons pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/ecpg.addons *** pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/ecpg.addons 2009-08-03 15:09:45.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/ecpg.addons 2009-08-03 15:25:02.000000000 +0200 *************** ECPG: FetchStmtFETCHcursor_name block *** 366,414 **** $$ = cat_str(2, make_str("fetch"), cursor_marker); } ECPG: FetchStmtMOVEcursor_name rule ! | FETCH BACKWARD from_in cursor_name ecpg_into { char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4; add_additional_variables($4, false); $$ = cat_str(3, make_str("fetch backward"), $3, cursor_marker); } ! | FETCH FORWARD from_in cursor_name ecpg_into { char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4; add_additional_variables($4, false); $$ = cat_str(3, make_str("fetch forward"), $3, cursor_marker); } ! | FETCH fetch_direction from_in cursor_name ecpg_into { char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4; add_additional_variables($4, false); $$ = cat_str(4, make_str("fetch"), $2, $3, cursor_marker); } ! | FETCH BACKWARD cursor_name ecpg_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat2_str(make_str("fetch backward from"), cursor_marker); } ! | FETCH FORWARD cursor_name ecpg_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat2_str(make_str("fetch forward from"), cursor_marker); } ! | FETCH fetch_direction cursor_name ecpg_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat_str(4, make_str("fetch"), $2, make_str("from"), cursor_marker); } ! | FETCH from_in cursor_name ecpg_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat_str(3, make_str("fetch"), $2, cursor_marker); } ! | FETCH cursor_name ecpg_into { char *cursor_marker = $2[0] == ':' ? make_str("$0") : $2; add_additional_variables($2, false); --- 366,414 ---- $$ = cat_str(2, make_str("fetch"), cursor_marker); } ECPG: FetchStmtMOVEcursor_name rule ! | FETCH BACKWARD from_in cursor_name ecpg_fetch_into { char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4; add_additional_variables($4, false); $$ = cat_str(3, make_str("fetch backward"), $3, cursor_marker); } ! | FETCH FORWARD from_in cursor_name ecpg_fetch_into { char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4; add_additional_variables($4, false); $$ = cat_str(3, make_str("fetch forward"), $3, cursor_marker); } ! | FETCH fetch_direction from_in cursor_name ecpg_fetch_into { char *cursor_marker = $4[0] == ':' ? make_str("$0") : $4; add_additional_variables($4, false); $$ = cat_str(4, make_str("fetch"), $2, $3, cursor_marker); } ! | FETCH BACKWARD cursor_name ecpg_fetch_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat2_str(make_str("fetch backward from"), cursor_marker); } ! | FETCH FORWARD cursor_name ecpg_fetch_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat2_str(make_str("fetch forward from"), cursor_marker); } ! | FETCH fetch_direction cursor_name ecpg_fetch_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat_str(4, make_str("fetch"), $2, make_str("from"), cursor_marker); } ! | FETCH from_in cursor_name ecpg_fetch_into { char *cursor_marker = $3[0] == ':' ? make_str("$0") : $3; add_additional_variables($3, false); $$ = cat_str(3, make_str("fetch"), $2, cursor_marker); } ! | FETCH cursor_name ecpg_fetch_into { char *cursor_marker = $2[0] == ':' ? make_str("$0") : $2; add_additional_variables($2, false); diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/ecpg.trailer pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/ecpg.trailer *** pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/ecpg.trailer 2009-08-03 15:09:45.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/ecpg.trailer 2009-08-03 15:25:02.000000000 +0200 *************** ecpg_using: USING using_list { $$ = EMP *** 972,990 **** using_descriptor: USING opt_sql SQL_DESCRIPTOR quoted_ident_stringvar { ! add_variable_to_head(&argsinsert, descriptor_variable($4,0), &no_indicator); $$ = EMPTY; } ; into_descriptor: INTO opt_sql SQL_DESCRIPTOR quoted_ident_stringvar { ! add_variable_to_head(&argsresult, descriptor_variable($4,1), &no_indicator); $$ = EMPTY; } ; ! opt_sql: /*EMPTY*/ | SQL_SQL; using_list: UsingValue | UsingValue ',' using_list; --- 972,1020 ---- using_descriptor: USING opt_sql SQL_DESCRIPTOR quoted_ident_stringvar { ! if (strlen($2) || !(INFORMIX_MODE)) ! add_variable_to_head(&argsinsert, descriptor_variable($4,0), &no_indicator); ! else ! { ! if ($4[0] == '\"') ! { ! char *pos; ! ! $4[0] = ' '; ! for (pos = $4; *pos; pos++) ! if (*pos == '\"') ! *pos = ' '; ! } ! add_variable_to_head(&argsinsert, sqlda_variable($4), &no_indicator); ! } $$ = EMPTY; } ; into_descriptor: INTO opt_sql SQL_DESCRIPTOR quoted_ident_stringvar { ! if (strlen($2) || !(INFORMIX_MODE)) ! add_variable_to_head(&argsresult, descriptor_variable($4,1), &no_indicator); ! else ! { ! if ($4[0] == '\"') ! { ! char *pos; ! ! $4[0] = ' '; ! for (pos = $4; *pos; pos++) ! if (*pos == '\"') ! *pos = ' '; ! } ! add_variable_to_head(&argsresult, sqlda_variable($4), &no_indicator); ! } $$ = EMPTY; } ; ! opt_sql: /*EMPTY*/ { $$ = EMPTY; } ! | SQL_SQL { $$ = make_str("sql"); } ! ; using_list: UsingValue | UsingValue ',' using_list; *************** ecpg_into: INTO into_list { $$ = EMPTY; *** 2006,2011 **** --- 2036,2056 ---- | into_descriptor { $$ = $1; } ; + ecpg_fetch_into: ecpg_into { $$ = $1; } + | using_descriptor + { + struct variable *var; + + if (!INFORMIX_MODE) + mmerror(PARSE_ERROR, ET_ERROR, "Not in Informix compatibility mode"); + + var = argsinsert->variable; + remove_variable_from_list(&argsinsert, var); + add_variable_to_head(&argsresult, var, &no_indicator); + $$ = $1; + } + ; + %% void base_yyerror(const char *error) diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/ecpg.type pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/ecpg.type *** pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/ecpg.type 2009-08-03 15:09:45.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/ecpg.type 2009-08-03 15:25:02.000000000 +0200 *************** *** 61,66 **** --- 61,67 ---- %type ecpg_ident %type ecpg_interval %type ecpg_into + %type ecpg_fetch_into %type ecpg_param %type ecpg_sconst %type ecpg_using *************** *** 85,90 **** --- 86,92 ---- %type opt_reference %type opt_scale %type opt_server + %type opt_sql %type opt_user %type opt_opt_value %type ora_user diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/extern.h pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/extern.h *** pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/extern.h 2009-08-03 15:09:45.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/extern.h 2009-08-03 15:25:02.000000000 +0200 *************** extern void add_descriptor(char *, char *** 89,94 **** --- 89,95 ---- extern void drop_descriptor(char *, char *); extern struct descriptor *lookup_descriptor(char *, char *); extern struct variable *descriptor_variable(const char *name, int input); + extern struct variable *sqlda_variable(const char *name); extern void add_variable_to_head(struct arguments **, struct variable *, struct variable *); extern void add_variable_to_tail(struct arguments **, struct variable *, struct variable *); extern void remove_variable_from_list(struct arguments ** list, struct variable * var); diff -dcrpN pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/type.c pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/type.c *** pgsql85dev.1dyncursor/src/interfaces/ecpg/preproc/type.c 2009-06-13 18:25:05.000000000 +0200 --- pgsql85dev.2sqlda/src/interfaces/ecpg/preproc/type.c 2009-08-03 15:25:02.000000000 +0200 *************** ECPGdump_a_simple(FILE *o, const char *n *** 325,330 **** --- 325,332 ---- else if (type == ECPGt_descriptor) /* remember that name here already contains quotes (if needed) */ fprintf(o, "\n\tECPGt_descriptor, %s, 0L, 0L, 0L, ", name); + else if (type == ECPGt_sqlda) + fprintf(o, "\n\tECPGt_sqlda, &%s, 0L, 0L, 0L, ", name); else { char *variable = (char *) mm_alloc(strlen(name) + ((prefix == NULL) ? 0 : strlen(prefix)) + 4);