--- /dev/null
+/* dynamic SQL support routines
+ *
+ * Copyright (c) 2000, Christof Petig <christof.petig@wtal.de>
+ *
+ * $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/dynamic.c,v 1.1 2000/02/16 16:18:12 meskes Exp $
+ */
+
+/* I borrowed the include files from ecpglib.c, maybe we don't need all of them */
+
+#if 0
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <string.h>
+#include <ctype.h>
+#include <locale.h>
+
+#include <libpq-fe.h>
+#include <libpq/pqcomm.h>
+#include <ecpgtype.h>
+#include <ecpglib.h>
+#include <sqlca.h>
+#endif
+#include <sql3types.h>
+
+static struct descriptor
+{ char *name;
+ PGresult *result;
+ struct descriptor *next;
+} *all_descriptors=NULL;
+
+PGconn *ECPG_internal_get_connection(char *name);
+
+unsigned int ECPGDynamicType(Oid type)
+{ switch(type)
+ { case 16: return SQL3_BOOLEAN; /* bool */
+ case 21: return SQL3_SMALLINT; /* int2 */
+ case 23: return SQL3_INTEGER; /* int4 */
+ case 25: return SQL3_CHARACTER; /* text */
+ case 700: return SQL3_REAL; /* float4 */
+ case 701: return SQL3_DOUBLE_PRECISION; /* float8 */
+ case 1042: return SQL3_CHARACTER; /* bpchar */
+ case 1043: return SQL3_CHARACTER_VARYING; /* varchar */
+ case 1082: return SQL3_DATE_TIME_TIMESTAMP; /* date */
+ case 1083: return SQL3_DATE_TIME_TIMESTAMP; /* time */
+ case 1184: return SQL3_DATE_TIME_TIMESTAMP; /* datetime */
+ case 1296: return SQL3_DATE_TIME_TIMESTAMP; /* timestamp */
+ case 1700: return SQL3_NUMERIC; /* numeric */
+ default:
+ return -type;
+ }
+}
+
+unsigned int ECPGDynamicType_DDT(Oid type)
+{ switch(type)
+ {
+ case 1082: return SQL3_DDT_DATE; /* date */
+ case 1083: return SQL3_DDT_TIME; /* time */
+ case 1184: return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE; /* datetime */
+ case 1296: return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE; /* timestamp */
+ default:
+ return SQL3_DDT_ILLEGAL;
+ }
+}
+
+// like ECPGexecute
+static bool execute_descriptor(int lineno,const char *query
+ ,struct connection *con,PGresult **resultptr)
+{
+ bool status = false;
+ PGresult *results;
+ PGnotify *notify;
+
+ /* Now the request is built. */
+
+ if (con->committed && !con->autocommit)
+ {
+ if ((results = PQexec(con->connection, "begin transaction")) == NULL)
+ {
+ register_error(ECPG_TRANS, "Error in transaction processing line %d.", lineno);
+ return false;
+ }
+ PQclear(results);
+ con->committed = false;
+ }
+
+ ECPGlog("execute_descriptor line %d: QUERY: %s on connection %s\n", lineno, query, con->name);
+ results = PQexec(con->connection, query);
+
+ if (results == NULL)
+ {
+ ECPGlog("ECPGexecute line %d: error: %s", lineno,
+ PQerrorMessage(con->connection));
+ register_error(ECPG_PGSQL, "Postgres error: %s line %d.",
+ PQerrorMessage(con->connection), lineno);
+ }
+ else
+ { *resultptr=results;
+ switch (PQresultStatus(results))
+ { int ntuples;
+ case PGRES_TUPLES_OK:
+ status = true;
+ sqlca.sqlerrd[2] = ntuples = PQntuples(results);
+ if (ntuples < 1)
+ {
+ ECPGlog("execute_descriptor line %d: Incorrect number of matches: %d\n",
+ lineno, ntuples);
+ register_error(ECPG_NOT_FOUND, "No data found line %d.", lineno);
+ status = false;
+ break;
+ }
+ break;
+#if 1 /* strictly these are not needed (yet) */
+ case PGRES_EMPTY_QUERY:
+ /* do nothing */
+ register_error(ECPG_EMPTY, "Empty query line %d.", lineno);
+ break;
+ case PGRES_COMMAND_OK:
+ status = true;
+ sqlca.sqlerrd[1] = atol(PQoidStatus(results));
+ sqlca.sqlerrd[2] = atol(PQcmdTuples(results));
+ ECPGlog("ECPGexecute line %d Ok: %s\n", lineno, PQcmdStatus(results));
+ break;
+ case PGRES_COPY_OUT:
+ ECPGlog("ECPGexecute line %d: Got PGRES_COPY_OUT ... tossing.\n", lineno);
+ PQendcopy(con->connection);
+ break;
+ case PGRES_COPY_IN:
+ ECPGlog("ECPGexecute line %d: Got PGRES_COPY_IN ... tossing.\n", lineno);
+ PQendcopy(con->connection);
+ break;
+#else
+ case PGRES_EMPTY_QUERY:
+ case PGRES_COMMAND_OK:
+ case PGRES_COPY_OUT:
+ case PGRES_COPY_IN:
+ break;
+#endif
+ case PGRES_NONFATAL_ERROR:
+ case PGRES_FATAL_ERROR:
+ case PGRES_BAD_RESPONSE:
+ ECPGlog("ECPGexecute line %d: Error: %s",
+ lineno, PQerrorMessage(con->connection));
+ register_error(ECPG_PGSQL, "Postgres error: %s line %d.",
+ PQerrorMessage(con->connection), lineno);
+ status = false;
+ break;
+ default:
+ ECPGlog("ECPGexecute line %d: Got something else, postgres error.\n",
+ lineno);
+ register_error(ECPG_PGSQL, "Postgres error: %s line %d.",
+ PQerrorMessage(con->connection), lineno);
+ status = false;
+ break;
+ }
+ }
+
+ /* check for asynchronous returns */
+ notify = PQnotifies(con->connection);
+ if (notify)
+ {
+ ECPGlog("ECPGexecute line %d: ASYNC NOTIFY of '%s' from backend pid '%d' received\n",
+ lineno, notify->relname, notify->be_pid);
+ free(notify);
+ }
+ return status;
+}
+
+/* like ECPGdo */
+static bool do_descriptor2(int lineno,const char *connection_name,
+ PGresult **resultptr, const char *query)
+{
+ struct connection *con = get_connection(connection_name);
+ bool status=true;
+ char *locale = setlocale(LC_NUMERIC, NULL);
+
+ /* Make sure we do NOT honor the locale for numeric input/output */
+ /* since the database wants teh standard decimal point */
+ setlocale(LC_NUMERIC, "C");
+
+ if (!ecpg_init(con, connection_name, lineno))
+ { setlocale(LC_NUMERIC, locale);
+ return(false);
+ }
+
+ /* are we connected? */
+ if (con == NULL || con->connection == NULL)
+ {
+ ECPGlog("ECPGdo: not connected to %s\n", con->name);
+ register_error(ECPG_NOT_CONN, "Not connected in line %d.", lineno);
+ setlocale(LC_NUMERIC, locale);
+ return false;
+ }
+
+ status = execute_descriptor(lineno,query,con,resultptr);
+
+ /* and reset locale value so our application is not affected */
+ setlocale(LC_NUMERIC, locale);
+ return (status);
+}
+
+bool ECPGdo_descriptor(int line,const char *connection,
+ const char *descriptor,const char *query)
+{
+ struct descriptor *i;
+ for (i=all_descriptors;i!=NULL;i=i->next)
+ { if (!strcmp(descriptor,i->name))
+ {
+ bool status;
+
+ /* free previous result */
+ if (i->result) PQclear(i->result);
+ i->result=NULL;
+
+ status=do_descriptor2(line,connection,&i->result,query);
+
+ if (!i->result) PQmakeEmptyPGresult(NULL, 0);
+ return (status);
+ }
+ }
+ ECPGraise(line,ECPG_UNKNOWN_DESCRIPTOR);
+ return false;
+}
+
+PGresult *ECPGresultByDescriptor(int line,const char *name)
+{
+ struct descriptor *i;
+ for (i=all_descriptors;i!=NULL;i=i->next)
+ { if (!strcmp(name,i->name)) return i->result;
+ }
+ ECPGraise(line,ECPG_UNKNOWN_DESCRIPTOR);
+ return 0;
+}
+
+
+bool ECPGdeallocate_desc(int line,const char *name)
+{
+ struct descriptor *i;
+ struct descriptor **lastptr=&all_descriptors;
+ for (i=all_descriptors;i;lastptr=&i->next,i=i->next)
+ { if (!strcmp(name,i->name))
+ { *lastptr=i->next;
+ free(i->name);
+ PQclear(i->result);
+ free(i);
+ return true;
+ }
+ }
+ ECPGraise(line,ECPG_UNKNOWN_DESCRIPTOR);
+ return false;
+}
+
+bool ECPGallocate_desc(int line,const char *name)
+{
+ struct descriptor *new=(struct descriptor *)malloc(sizeof(struct descriptor));
+
+ new->next=all_descriptors;
+ new->name=malloc(strlen(name)+1);
+ new->result=PQmakeEmptyPGresult(NULL, 0);
+ strcpy(new->name,name);
+ all_descriptors=new;
+ return true;
+}
+
+void ECPGraise(int line,int code)
+{ sqlca.sqlcode=code;
+ switch (code)
+ { case ECPG_NOT_FOUND:
+ snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
+ "No data found line %d.",line);
+ break;
+ case ECPG_MISSING_INDICATOR:
+ snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
+ "NULL value without indicator, line %d.",line);
+ break;
+ case ECPG_UNKNOWN_DESCRIPTOR:
+ snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
+ "descriptor not found, line %d.",line);
+ break;
+ case ECPG_INVALID_DESCRIPTOR_INDEX:
+ snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
+ "descriptor index out of range, line %d.",line);
+ break;
+ default:
+ snprintf(sqlca.sqlerrm.sqlerrmc,sizeof(sqlca.sqlerrm.sqlerrmc),
+ "SQL error #%d, line %d.",code,line);
+ break;
+ }
+}
int struct_level = 0;
char errortext[128];
static char *connection = NULL;
+static char *descriptor_name = NULL;
+static char *descriptor_index= NULL;
static int QueryIsRule = 0, ForUpdateNotAllowed = 0, FoundInto = 0;
static int FoundSort = 0;
static int initializer = 0;
struct ECPGtype ecpg_query = {ECPGt_char_variable, 0L, {NULL}};
+/* variable lookup */
+
+static struct variable * find_variable(char * name);
+static void whenever_action(int mode);
+
/*
* Handle parsing errors and warnings
*/
free(cmd);
}
+/*
+ * assignment handling function (descriptor)
+ */
+
+static struct assignment *assignments;
+
+static void push_assignment(char *var,char *value)
+{
+ struct assignment *new=(struct assignment *)mm_alloc(sizeof(struct assignment));
+
+ new->next=assignments;
+ new->variable=mm_alloc(strlen(var)+1);
+ strcpy(new->variable,var);
+ new->value=mm_alloc(strlen(value)+1);
+ strcpy(new->value,value);
+ assignments=new;
+}
+
+static void drop_assignments(void)
+{ while (assignments)
+ { struct assignment *old_head=assignments;
+ assignments=old_head->next;
+ free(old_head->variable);
+ free(old_head->value);
+ free(old_head);
+ }
+}
+
+/* XXX: these should be more accurate (consider ECPGdump_a_* ) */
+static void ECPGnumeric_lvalue(FILE *f,char *name)
+{ const struct variable *v=find_variable(name);
+ switch(v->type->typ)
+ { case ECPGt_short:
+ case ECPGt_int:
+ case ECPGt_long:
+ case ECPGt_unsigned_short:
+ case ECPGt_unsigned_int:
+ case ECPGt_unsigned_long:
+ fputs(name,yyout);
+ break;
+ default:
+ snprintf(errortext,sizeof errortext,"variable %s: numeric type needed"
+ ,name);
+ mmerror(ET_ERROR,errortext);
+ break;
+ }
+}
+
+static void ECPGstring_buffer(FILE *f,char *name)
+{ const struct variable *v=find_variable(name);
+ switch(v->type->typ)
+ { case ECPGt_varchar:
+ fprintf(yyout,"%s.arr",name);
+ break;
+
+ case ECPGt_char:
+ case ECPGt_unsigned_char:
+ fputs(name,yyout);
+ break;
+
+ default:
+ snprintf(errortext,sizeof errortext,"variable %s: character type needed"
+ ,name);
+ mmerror(ET_ERROR,errortext);
+ break;
+ }
+}
+
+static void ECPGstring_length(FILE *f,char *name)
+{ const struct variable *v=find_variable(name);
+ switch(v->type->typ)
+ { case ECPGt_varchar:
+ case ECPGt_char:
+ case ECPGt_unsigned_char:
+ if (!v->type->size)
+ { snprintf(errortext,sizeof errortext,"zero length char variable %s for assignment",
+ v->name);
+ mmerror(ET_ERROR,errortext);
+ }
+ fprintf(yyout,"%ld",v->type->size);
+ break;
+ default:
+ snprintf(errortext,sizeof errortext,"variable %s: character type needed"
+ ,name);
+ mmerror(ET_ERROR,errortext);
+ break;
+ }
+}
+
+static void ECPGdata_assignment(char *variable,char *index_plus_1)
+{ const struct variable *v=find_variable(variable);
+ fprintf(yyout,"\t\t\tif (!PQgetisnull(ECPGresult,0,(%s)-1))\n",index_plus_1);
+ switch(v->type->typ)
+ { case ECPGt_short:
+ case ECPGt_int: /* use the same conversion as ecpglib does */
+ case ECPGt_long:
+ fprintf(yyout,"\t\t\t\t%s=strtol(PQgetvalue(ECPGresult,0,(%s)-1),NULL,10);\n"
+ ,variable,index_plus_1);
+ break;
+ case ECPGt_unsigned_short:
+ case ECPGt_unsigned_int:
+ case ECPGt_unsigned_long:
+ fprintf(yyout,"\t\t\t\t%s=strtoul(PQgetvalue(ECPGresult,0,(%s)-1),NULL,10);\n"
+ ,variable,index_plus_1);
+ break;
+ case ECPGt_float:
+ case ECPGt_double:
+ fprintf(yyout,"\t\t\t\t%s=strtod(PQgetvalue(ECPGresult,0,(%s)-1),NULL);\n"
+ ,variable,index_plus_1);
+ break;
+
+ case ECPGt_bool:
+ fprintf(yyout,"\t\t\t\t%s=PQgetvalue(ECPGresult,0,(%s)-1)[0]=='t';\n"
+ ,variable,index_plus_1);
+ break;
+
+ case ECPGt_varchar:
+ fprintf(yyout,"\t\t\t{\tstrncpy(%s.arr,PQgetvalue(ECPGresult,0,(%s)-1),%ld);\n"
+ ,variable,index_plus_1,v->type->size);
+ fprintf(yyout,"\t\t\t\t%s.len=strlen(PQgetvalue(ECPGresult,0,(%s)-1)\n"
+ ,variable,index_plus_1);
+ fprintf(yyout,"\t\t\t\tif (%s.len>%ld) { %s.len=%ld; sqlca.sqlwarn[0]=sqlca.sqlwarn[1]='W'; }\n"
+ ,variable,v->type->size,variable,v->type->size);
+ fputs("\t\t\t}\n",yyout);
+ break;
+
+ case ECPGt_char:
+ case ECPGt_unsigned_char:
+ if (!v->type->size)
+ { snprintf(errortext,sizeof errortext,"zero length char variable %s for DATA assignment",
+ v->name);
+ mmerror(ET_ERROR,errortext);
+ }
+ fprintf(yyout,"\t\t\t{\tstrncpy(%s,PQgetvalue(ECPGresult,0,(%s)-1),%ld);\n"
+ ,variable,index_plus_1,v->type->size);
+ fprintf(yyout,"\t\t\t\tif (strlen(PQgetvalue(ECPGresult,0,(%s)-1))>=%ld)\n"
+ "\t\t\t\t{ %s[%ld]=0; sqlca.sqlwarn[0]=sqlca.sqlwarn[1]='W'; }\n"
+ ,index_plus_1,v->type->size,variable,v->type->size-1);
+ fputs("\t\t\t}\n",yyout);
+ break;
+
+ default:
+ snprintf(errortext,sizeof errortext,"unknown variable type %d for DATA assignment"
+ ,v->type->typ);
+ mmerror(ET_ERROR,errortext);
+ break;
+ }
+}
+
+static void
+output_get_descr_header(char *desc_name)
+{ struct assignment *results;
+ fprintf(yyout,"{\tPGresult *ECPGresult=ECPGresultByDescriptor(%d, \"%s\");\n"
+ ,yylineno,desc_name);
+ fputs("\tif (ECPGresult)\n\t{",yyout);
+ for (results=assignments;results!=NULL;results=results->next)
+ { if (!strcasecmp(results->value,"count"))
+ { fputs("\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fputs("=PQnfields(ECPGresult);\n",yyout);
+ }
+ else
+ { snprintf(errortext,sizeof errortext,"unknown descriptor header item '%s'",results->value);
+ mmerror(ET_WARN,errortext);
+ }
+ }
+ drop_assignments();
+ fputs("}",yyout);
+
+ whenever_action(2|1);
+}
+
+static void
+output_get_descr(char *desc_name)
+{ struct assignment *results;
+ int flags=0;
+ const int DATA_SEEN=1;
+ const int INDICATOR_SEEN=2;
+
+ fprintf(yyout,"{\tPGresult *ECPGresult=ECPGresultByDescriptor(%d, \"%s\");\n"
+ ,yylineno,desc_name);
+ fputs("\tif (ECPGresult)\n\t{",yyout);
+ fprintf(yyout,"\tif (PQntuples(ECPGresult)<1) ECPGraise(%d,ECPG_NOT_FOUND);\n",yylineno);
+ fprintf(yyout,"\t\telse if (%s<1 || %s>PQnfields(ECPGresult))\n"
+ "\t\t\tECPGraise(%d,ECPG_INVALID_DESCRIPTOR_INDEX);\n"
+ ,descriptor_index,descriptor_index,yylineno);
+ fputs("\t\telse\n\t\t{\n",yyout);
+ for (results=assignments;results!=NULL;results=results->next)
+ { if (!strcasecmp(results->value,"type"))
+ { fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=ECPGDynamicType(PQftype(ECPGresult,(%s)-1));\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"datetime_interval_code"))
+ { fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=ECPGDynamicType_DDT(PQftype(ECPGresult,(%s)-1));\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"length"))
+ { fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=PQfmod(ECPGresult,(%s)-1)-VARHDRSZ;\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"octet_length"))
+ { fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=PQfsize(ECPGresult,(%s)-1);\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"returned_length")
+ || !strcasecmp(results->value,"returned_octet_length"))
+ { fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=PQgetlength(ECPGresult,0,(%s)-1);\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"precision"))
+ { fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=PQfmod(ECPGresult,(%s)-1)>>16;\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"scale"))
+ { fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=(PQfmod(ECPGresult,(%s)-1)-VARHDRSZ)&0xffff;\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"nullable"))
+ { mmerror(ET_WARN,"nullable is always 1");
+ fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=1;\n");
+ }
+ else if (!strcasecmp(results->value,"key_member"))
+ { mmerror(ET_WARN,"key_member is always 0");
+ fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=0;\n");
+ }
+ else if (!strcasecmp(results->value,"name"))
+ { fputs("\t\t\tstrncpy(",yyout);
+ ECPGstring_buffer(yyout,results->variable);
+ fprintf(yyout,",PQfname(ECPGresult,(%s)-1),",descriptor_index);
+ ECPGstring_length(yyout,results->variable);
+ fputs(");\n",yyout);
+ }
+ else if (!strcasecmp(results->value,"indicator"))
+ { flags|=INDICATOR_SEEN;
+ fputs("\t\t\t",yyout);
+ ECPGnumeric_lvalue(yyout,results->variable);
+ fprintf(yyout,"=-PQgetisnull(ECPGresult,0,(%s)-1);\n",descriptor_index);
+ }
+ else if (!strcasecmp(results->value,"data"))
+ { flags|=DATA_SEEN;
+ ECPGdata_assignment(results->variable,descriptor_index);
+ }
+ else
+ { snprintf(errortext,sizeof errortext,"unknown descriptor header item '%s'",results->value);
+ mmerror(ET_WARN,errortext);
+ }
+ }
+ if (flags==DATA_SEEN) /* no indicator */
+ { fprintf(yyout,"\t\t\tif (PQgetisnull(ECPGresult,0,(%s)-1))\n"
+ "\t\t\t\tECPGraise(%d,ECPG_MISSING_INDICATOR);\n"
+ ,descriptor_index,yylineno);
+ }
+ drop_assignments();
+ fputs("\t\t}\n\t}\n",yyout);
+
+ whenever_action(2|1);
+}
+
/*
* store the whenever action here
*/
return(p);
}
-static struct variable * find_variable(char * name);
-
static struct variable *
find_struct_member(char *name, char *str, struct ECPGstruct_member *members)
{
}
}
+/*
+ * descriptor name lookup
+ */
+
+static struct descriptor *descriptors;
+
+static void add_descriptor(char *name,char *connection)
+{
+ struct descriptor *new=(struct descriptor *)mm_alloc(sizeof(struct descriptor));
+
+ new->next=descriptors;
+ new->name=mm_alloc(strlen(name)+1);
+ strcpy(new->name,name);
+ if (connection)
+ { new->connection=mm_alloc(strlen(connection)+1);
+ strcpy(new->connection,connection);
+ }
+ else new->connection=connection;
+ descriptors=new;
+}
+
+static void drop_descriptor(char *name,char *connection)
+{ struct descriptor *i;
+ struct descriptor **lastptr=&descriptors;
+ for (i=descriptors;i;lastptr=&i->next,i=i->next)
+ { if (!strcmp(name,i->name))
+ { if ((!connection && !i->connection)
+ || (connection && i->connection
+ && !strcmp(connection,i->connection)))
+ { *lastptr=i->next;
+ if (i->connection) free(i->connection);
+ free(i->name);
+ free(i);
+ return;
+ }
+ }
+ }
+ snprintf(errortext,sizeof errortext,"unknown descriptor %s",name);
+ mmerror(ET_WARN,errortext);
+}
+
+static struct descriptor *lookup_descriptor(char *name,char *connection)
+{ struct descriptor *i;
+ for (i=descriptors;i;i=i->next)
+ { if (!strcmp(name,i->name))
+ { if ((!connection && !i->connection)
+ || (connection && i->connection
+ && !strcmp(connection,i->connection)))
+ { return i;
+ }
+ }
+ }
+ snprintf(errortext,sizeof errortext,"unknown descriptor %s",name);
+ mmerror(ET_WARN,errortext);
+ return NULL;
+}
+
+/*
+ * string concatenation
+ */
+
static char *
cat2_str(char *str1, char *str2)
{
free(connection);
}
+static void
+output_statement_desc(char * stmt, int mode)
+{
+ int i, j=strlen(stmt);
+
+ fprintf(yyout, "{ ECPGdo_descriptor(__LINE__, %s, \"%s\", \"",
+ connection ? connection : "NULL", descriptor_name);
+
+ /* do this char by char as we have to filter '\"' */
+ for (i = 0;i < j; i++) {
+ if (stmt[i] != '\"')
+ fputc(stmt[i], yyout);
+ else
+ fputs("\\\"", yyout);
+ }
+
+ fputs("\");", yyout);
+
+ mode |= 2;
+ whenever_action(mode);
+ free(stmt);
+ if (connection != NULL)
+ free(connection);
+ free(descriptor_name);
+}
+
static struct typedefs *
get_typedef(char *name)
{
}
/* special embedded SQL token */
-%token SQL_AT SQL_AUTOCOMMIT SQL_BOOL SQL_BREAK
+%token SQL_ALLOCATE SQL_AT SQL_AUTOCOMMIT SQL_BOOL SQL_BREAK
%token SQL_CALL SQL_CONNECT SQL_CONNECTION SQL_CONTINUE
-%token SQL_DEALLOCATE SQL_DISCONNECT SQL_ENUM
-%token SQL_FOUND SQL_FREE SQL_GO SQL_GOTO
+%token SQL_DEALLOCATE SQL_DESCRIPTOR SQL_DISCONNECT SQL_ENUM
+%token SQL_FOUND SQL_FREE SQL_GET SQL_GO SQL_GOTO
%token SQL_IDENTIFIED SQL_INDICATOR SQL_INT SQL_LONG
%token SQL_OFF SQL_OPEN SQL_PREPARE SQL_RELEASE SQL_REFERENCE
-%token SQL_SECTION SQL_SHORT SQL_SIGNED SQL_SQLERROR SQL_SQLPRINT
+%token SQL_SECTION SQL_SHORT SQL_SIGNED SQL_SQL
+%token SQL_SQLERROR SQL_SQLPRINT
%token SQL_SQLWARNING SQL_START SQL_STOP SQL_STRUCT SQL_UNSIGNED
-%token SQL_VAR SQL_WHENEVER
+%token SQL_VALUE SQL_VAR SQL_WHENEVER
/* C token */
%token S_ANYTHING S_AUTO S_CONST S_EXTERN
%type <str> ECPGFree ECPGDeclare ECPGVar opt_at enum_definition
%type <str> struct_type s_struct declaration declarations variable_declarations
%type <str> s_struct s_union union_type ECPGSetAutocommit on_off
+%type <str> ECPGAllocateDescr ECPGDeallocateDescr
+%type <str> ECPGGetDescriptor ECPGGetDescriptorHeader
+%type <str> FetchDescriptorStmt
%type <type_enum> simple_type signed_type unsigned_type varchar_type
| ExtendStmt { output_statement($1, 0); }
| ExplainStmt { output_statement($1, 0); }
| FetchStmt { output_statement($1, 1); }
+ | FetchDescriptorStmt { output_statement_desc($1, 1); }
| GrantStmt { output_statement($1, 0); }
| IndexStmt { output_statement($1, 0); }
| ListenStmt { output_statement($1, 0); }
| VariableShowStmt { output_statement($1, 0); }
| VariableResetStmt { output_statement($1, 0); }
| ConstraintsSetStmt { output_statement($1, 0); }
+ | ECPGAllocateDescr { fprintf(yyout,"ECPGallocate_desc(__LINE__, \"%s\");",$1);
+ whenever_action(0);
+ free($1);
+ }
| ECPGConnect {
if (connection)
mmerror(ET_ERROR, "no at option for connect statement.\n");
whenever_action(2);
free($1);
}
+ | ECPGDeallocateDescr { fprintf(yyout,"ECPGdeallocate_desc(__LINE__, \"%s\");",$1);
+ whenever_action(0);
+ free($1);
+ }
| ECPGDeclare {
output_simple_statement($1);
}
whenever_action(2);
free($1);
}
+ | ECPGGetDescriptor {
+ lookup_descriptor($1,connection);
+ output_get_descr($1);
+ }
+ | ECPGGetDescriptorHeader {
+ lookup_descriptor($1,connection);
+ output_get_descr_header($1);
+ }
| ECPGOpen {
struct cursor *ptr;
$$ = cat2_str(make3_str(make_str("\""), $2, make_str("\",")), $4);
}
+/*
+ * dynamic SQL: descriptor based access
+ * written by Christof Petig <christof.petig@wtal.de>
+ */
+
+/*
+ * deallocate a descriptor
+ */
+ECPGDeallocateDescr: SQL_DEALLOCATE SQL_DESCRIPTOR ident
+{ drop_descriptor($3,connection);
+ $$ = $3;
+}
+
+/*
+ * allocate a descriptor
+ */
+ECPGAllocateDescr: SQL_ALLOCATE SQL_DESCRIPTOR ident
+{ add_descriptor($3,connection);
+ $$ = $3;
+}
+
+/*
+ * read from descriptor
+ */
+
+ECPGGetDescHeaderItem: cvariable '=' ident {
+ push_assignment($1,$3);
+}
+
+ECPGGetDescItem: cvariable '=' ident {
+ push_assignment($1,$3);
+}
+ | cvariable '=' TYPE_P {
+ push_assignment($1,"type");
+}
+ | cvariable '=' PRECISION {
+ push_assignment($1,"precision");
+}
+ | cvariable '=' SQL_INDICATOR {
+ push_assignment($1,"indicator");
+}
+
+ECPGGetDescHeaderItems: ECPGGetDescHeaderItem
+ | ECPGGetDescHeaderItems ',' ECPGGetDescHeaderItem;
+
+ECPGGetDescItems: ECPGGetDescItem
+ | ECPGGetDescItems ',' ECPGGetDescItem;
+
+ECPGGetDescriptorHeader: SQL_GET SQL_DESCRIPTOR ident ECPGGetDescHeaderItems
+{ $$ = $3; }
+
+ECPGGetDescriptor: SQL_GET SQL_DESCRIPTOR ident SQL_VALUE cvariable ECPGGetDescItems
+{ $$ = $3; descriptor_index=$5; }
+ | SQL_GET SQL_DESCRIPTOR ident SQL_VALUE Iconst ECPGGetDescItems
+{ $$ = $3; descriptor_index=$5; }
+
+/*
+ * fetch [ in | from ] <portalname> into sql descriptor <name>
+ */
+
+FetchDescriptorStmt: FETCH from_in name INTO SQL_SQL SQL_DESCRIPTOR ident
+ {
+ $$ = cat_str(3, make_str("fetch"), $2, $3);
+ descriptor_name=$7;
+ }
+ | FETCH name INTO SQL_SQL SQL_DESCRIPTOR ident
+ {
+ $$ = cat2_str(make_str("fetch"), $2);
+ descriptor_name=$6;
+ }
+ ;
+
/*
* for compatibility with ORACLE we will also allow the keyword RELEASE
* after a transaction statement to disconnect from the database.
projects / postgresql / commitdiff