1 files changed, 276 insertions, 219 deletions

diff --git a/src/interfaces/odbc/qresult.c b/src/interfaces/odbc/qresult.c
index 2f17c64334..4f532291c1 100644
--- a/src/interfaces/odbc/qresult.c
+++ b/src/interfaces/odbc/qresult.c
@@ -1,20 +1,20 @@
 
-/* Module:          qresult.c
+/* Module:			qresult.c
  *
- * Description:     This module contains functions related to 
- *                  managing result information (i.e, fetching rows from the backend,
- *                  managing the tuple cache, etc.) and retrieving it.
- *                  Depending on the situation, a QResultClass will hold either data
- *                  from the backend or a manually built result (see "qresult.h" to
- *                  see which functions/macros are for manual or backend results.
- *                  For manually built results, the QResultClass simply points to 
- *                  TupleList and ColumnInfo structures, which actually hold the data.
+ * Description:		This module contains functions related to
+ *					managing result information (i.e, fetching rows from the backend,
+ *					managing the tuple cache, etc.) and retrieving it.
+ *					Depending on the situation, a QResultClass will hold either data
+ *					from the backend or a manually built result (see "qresult.h" to
+ *					see which functions/macros are for manual or backend results.
+ *					For manually built results, the QResultClass simply points to
+ *					TupleList and ColumnInfo structures, which actually hold the data.
  *
- * Classes:         QResultClass (Functions prefix: "QR_")
+ * Classes:			QResultClass (Functions prefix: "QR_")
  *
- * API functions:   none
+ * API functions:	none
  *
- * Comments:        See "notice.txt" for copyright and license information.
+ * Comments:		See "notice.txt" for copyright and license information.
  *
  */
 
@@ -32,23 +32,23 @@
 
 extern GLOBAL_VALUES globals;
 
-/*  Used for building a Manual Result only */
+/*	Used for building a Manual Result only */
 /*	All info functions call this function to create the manual result set. */
-void 
+void
 QR_set_num_fields(QResultClass *self, int new_num_fields)
 {
 	mylog("in QR_set_num_fields\n");
 
-    CI_set_num_fields(self->fields, new_num_fields);
-    if(self->manual_tuples) 
-        TL_Destructor(self->manual_tuples);
+	CI_set_num_fields(self->fields, new_num_fields);
+	if (self->manual_tuples)
+		TL_Destructor(self->manual_tuples);
 
-    self->manual_tuples = TL_Constructor(new_num_fields);
+	self->manual_tuples = TL_Constructor(new_num_fields);
 
 	mylog("exit QR_set_num_fields\n");
 }
 
-void 
+void
 QR_set_position(QResultClass *self, int pos)
 {
 	self->tupleField = self->backend_tuples + ((self->base + pos) * self->num_fields);
@@ -60,7 +60,7 @@ QR_set_cache_size(QResultClass *self, int cache_size)
 	self->cache_size = cache_size;
 }
 
-void 
+void
 QR_set_rowset_size(QResultClass *self, int rowset_size)
 {
 	self->rowset_size = rowset_size;
@@ -73,27 +73,29 @@ QR_inc_base(QResultClass *self, int base_inc)
 }
 
 /************************************/
-/* CLASS QResult                    */
+/* CLASS QResult					*/
 /************************************/
 
 QResultClass *
 QR_Constructor(void)
 {
-QResultClass *rv;
+	QResultClass *rv;
 
 	mylog("in QR_Constructor\n");
 	rv = (QResultClass *) malloc(sizeof(QResultClass));
 
-	if (rv != NULL) {
+	if (rv != NULL)
+	{
 		rv->status = PGRES_EMPTY_QUERY;
 
 		/* construct the column info */
-		if ( ! (rv->fields = CI_Constructor())) {
+		if (!(rv->fields = CI_Constructor()))
+		{
 			free(rv);
 			return NULL;
 		}
-		rv->manual_tuples = NULL;	
-		rv->backend_tuples = NULL;	
+		rv->manual_tuples = NULL;
+		rv->backend_tuples = NULL;
 		rv->message = NULL;
 		rv->command = NULL;
 		rv->notice = NULL;
@@ -126,26 +128,26 @@ QR_Destructor(QResultClass *self)
 	if (self->manual_tuples)
 		TL_Destructor(self->manual_tuples);
 
-	/*	If conn is defined, then we may have used "backend_tuples", */
-	/*	so in case we need to, free it up.  Also, close the cursor. */
+	/* If conn is defined, then we may have used "backend_tuples", */
+	/* so in case we need to, free it up.  Also, close the cursor. */
 	if (self->conn && self->conn->sock && CC_is_in_trans(self->conn))
 		QR_close(self);			/* close the cursor if there is one */
 
-	QR_free_memory(self);	/* safe to call anyway */
+	QR_free_memory(self);		/* safe to call anyway */
 
-	/*	Should have been freed in the close() but just in case... */
+	/* Should have been freed in the close() but just in case... */
 	if (self->cursor)
 		free(self->cursor);
 
-	/*	Free up column info */
+	/* Free up column info */
 	if (self->fields)
 		CI_Destructor(self->fields);
 
-	/*	Free command info (this is from strdup()) */
+	/* Free command info (this is from strdup()) */
 	if (self->command)
 		free(self->command);
 
-	/*	Free notice info (this is from strdup()) */
+	/* Free notice info (this is from strdup()) */
 	if (self->notice)
 		free(self->notice);
 
@@ -164,7 +166,7 @@ QR_set_command(QResultClass *self, char *msg)
 	self->command = msg ? strdup(msg) : NULL;
 }
 
-void 
+void
 QR_set_notice(QResultClass *self, char *msg)
 {
 	if (self->notice)
@@ -173,27 +175,32 @@ QR_set_notice(QResultClass *self, char *msg)
 	self->notice = msg ? strdup(msg) : NULL;
 }
 
-void 
+void
 QR_free_memory(QResultClass *self)
 {
-register int lf, row;
-register TupleField *tuple = self->backend_tuples;
-int fcount = self->fcount;
-int num_fields = self->num_fields;
+	register int lf,
+				row;
+	register TupleField *tuple = self->backend_tuples;
+	int			fcount = self->fcount;
+	int			num_fields = self->num_fields;
 
 	mylog("QResult: free memory in, fcount=%d\n", fcount);
 
-	if ( self->backend_tuples) {
+	if (self->backend_tuples)
+	{
 
-		for (row = 0; row < fcount; row++) {
+		for (row = 0; row < fcount; row++)
+		{
 			mylog("row = %d, num_fields = %d\n", row, num_fields);
-			for (lf=0; lf < num_fields; lf++) {
-				if (tuple[lf].value != NULL) {
+			for (lf = 0; lf < num_fields; lf++)
+			{
+				if (tuple[lf].value != NULL)
+				{
 					mylog("free [lf=%d] %u\n", lf, tuple[lf].value);
 					free(tuple[lf].value);
 				}
 			}
-			tuple += num_fields;  /* next row */
+			tuple += num_fields;/* next row */
 		}
 
 		free(self->backend_tuples);
@@ -209,37 +216,42 @@ int num_fields = self->num_fields;
 char
 QR_fetch_tuples(QResultClass *self, ConnectionClass *conn, char *cursor)
 {
-int tuple_size;
-
-	/*	If called from send_query the first time (conn != NULL),  */
-	/*	then set the inTuples state, */
-	/*	and read the tuples.  If conn is NULL, */
-	/*	it implies that we are being called from next_tuple(), */
-	/*	like to get more rows so don't call next_tuple again! */
-	if (conn != NULL) {
+	int			tuple_size;
+
+	/* If called from send_query the first time (conn != NULL),  */
+	/* then set the inTuples state, */
+	/* and read the tuples.  If conn is NULL, */
+	/* it implies that we are being called from next_tuple(), */
+	/* like to get more rows so don't call next_tuple again! */
+	if (conn != NULL)
+	{
 		self->conn = conn;
 
-		mylog("QR_fetch_tuples: cursor = '%s', self->cursor=%u\n",  (cursor==NULL)?"":cursor, self->cursor);
+		mylog("QR_fetch_tuples: cursor = '%s', self->cursor=%u\n", (cursor == NULL) ? "" : cursor, self->cursor);
 
 		if (self->cursor)
 			free(self->cursor);
 
-		if ( globals.use_declarefetch) {
-			if (! cursor || cursor[0] == '\0') {
+		if (globals.use_declarefetch)
+		{
+			if (!cursor || cursor[0] == '\0')
+			{
 				self->status = PGRES_INTERNAL_ERROR;
 				QR_set_message(self, "Internal Error -- no cursor for fetch");
 				return FALSE;
 			}
 			self->cursor = strdup(cursor);
 		}
- 
-		/*	Read the field attributes. */
-		/*	$$$$ Should do some error control HERE! $$$$ */
-		if ( CI_read_fields(self->fields, self->conn)) {
+
+		/* Read the field attributes. */
+		/* $$$$ Should do some error control HERE! $$$$ */
+		if (CI_read_fields(self->fields, self->conn))
+		{
 			self->status = PGRES_FIELDS_OK;
 			self->num_fields = CI_get_num_fields(self->fields);
 		}
-		else {
+		else
+		{
 			self->status = PGRES_BAD_RESPONSE;
 			QR_set_message(self, "Error reading field information");
 			return FALSE;
@@ -247,7 +259,7 @@ int tuple_size;
 
 		mylog("QR_fetch_tuples: past CI_read_fields: num_fields = %d\n", self->num_fields);
 
-		if (globals.use_declarefetch) 
+		if (globals.use_declarefetch)
 			tuple_size = self->cache_size;
 		else
 			tuple_size = TUPLE_MALLOC_INC;
@@ -255,8 +267,9 @@ int tuple_size;
 		/* allocate memory for the tuple cache */
 		mylog("MALLOC: tuple_size = %d, size = %d\n", tuple_size, self->num_fields * sizeof(TupleField) * tuple_size);
 		self->backend_tuples = (TupleField *) malloc(self->num_fields * sizeof(TupleField) * tuple_size);
-		if ( ! self->backend_tuples) {
-			self->status = PGRES_FATAL_ERROR; 
+		if (!self->backend_tuples)
+		{
+			self->status = PGRES_FATAL_ERROR;
 			QR_set_message(self, "Could not get memory for tuple cache.");
 			return FALSE;
 		}
@@ -264,19 +277,21 @@ int tuple_size;
 		self->inTuples = TRUE;
 
 
-		/*  Force a read to occur in next_tuple */
-		self->fcount = tuple_size+1;
-		self->fetch_count = tuple_size+1;
+		/* Force a read to occur in next_tuple */
+		self->fcount = tuple_size + 1;
+		self->fetch_count = tuple_size + 1;
 		self->base = 0;
 
 		return QR_next_tuple(self);
 	}
-	else {
+	else
+	{
 
-		/*	Always have to read the field attributes. */
-		/*	But we dont have to reallocate memory for them! */
+		/* Always have to read the field attributes. */
+		/* But we dont have to reallocate memory for them! */
 
-		if ( ! CI_read_fields(NULL, self->conn)) {
+		if (!CI_read_fields(NULL, self->conn))
+		{
 			self->status = PGRES_BAD_RESPONSE;
 			QR_set_message(self, "Error reading field information");
 			return FALSE;
@@ -290,10 +305,11 @@ int tuple_size;
 int
 QR_close(QResultClass *self)
 {
-QResultClass *res;
+	QResultClass *res;
 
-	if (globals.use_declarefetch && self->conn && self->cursor) {
-		char buf[64];
+	if (globals.use_declarefetch && self->conn && self->cursor)
+	{
+		char		buf[64];
 
 		sprintf(buf, "close %s", self->cursor);
 		mylog("QResult: closing cursor: '%s'\n", buf);
@@ -306,22 +322,25 @@ QResultClass *res;
 		free(self->cursor);
 		self->cursor = NULL;
 
-		if (res == NULL) {
+		if (res == NULL)
+		{
 			self->status = PGRES_FATAL_ERROR;
 			QR_set_message(self, "Error closing cursor.");
 			return FALSE;
 		}
 		QR_Destructor(res);
 
-		/*	End the transaction if there are no cursors left on this conn */
-		if (CC_cursor_count(self->conn) == 0) {
+		/* End the transaction if there are no cursors left on this conn */
+		if (CC_cursor_count(self->conn) == 0)
+		{
 			mylog("QResult: END transaction on conn=%u\n", self->conn);
 
 			res = CC_send_query(self->conn, "END", NULL);
 
 			CC_set_no_trans(self->conn);
 
-			if (res == NULL) {
+			if (res == NULL)
+			{
 				self->status = PGRES_FATAL_ERROR;
 				QR_set_message(self, "Error ending transaction.");
 				return FALSE;
@@ -338,54 +357,65 @@ QResultClass *res;
 int
 QR_next_tuple(QResultClass *self)
 {
-int id;
-QResultClass *res;
-SocketClass *sock;
+	int			id;
+	QResultClass *res;
+	SocketClass *sock;
+
 /* Speed up access */
-int fetch_count = self->fetch_count;
-int fcount = self->fcount;
-int fetch_size, offset= 0;
-int end_tuple = self->rowset_size + self->base;
-char corrected = FALSE;
-TupleField *the_tuples = self->backend_tuples;
-static char msgbuffer[MAX_MESSAGE_LEN+1];
-char cmdbuffer[MAX_MESSAGE_LEN+1];	/* QR_set_command() dups this string so dont need static */
-char fetch[128];
-QueryInfo qi;
-
-	if (fetch_count < fcount) {	/* return a row from cache */
+	int			fetch_count = self->fetch_count;
+	int			fcount = self->fcount;
+	int			fetch_size,
+				offset = 0;
+	int			end_tuple = self->rowset_size + self->base;
+	char		corrected = FALSE;
+	TupleField *the_tuples = self->backend_tuples;
+	static char msgbuffer[MAX_MESSAGE_LEN + 1];
+	char		cmdbuffer[MAX_MESSAGE_LEN + 1]; /* QR_set_command() dups
+												 * this string so dont
+												 * need static */
+	char		fetch[128];
+	QueryInfo	qi;
+
+	if (fetch_count < fcount)
+	{							/* return a row from cache */
 		mylog("next_tuple: fetch_count < fcount: returning tuple %d, fcount = %d\n", fetch_count, fcount);
-		self->tupleField = the_tuples + (fetch_count * self->num_fields); /* next row */
+		self->tupleField = the_tuples + (fetch_count * self->num_fields);		/* next row */
 		self->fetch_count++;
 		return TRUE;
 	}
-	else if (self->fcount < self->cache_size) {   /* last row from cache */
-		  /*	We are done because we didn't even get CACHE_SIZE tuples */
-		  mylog("next_tuple: fcount < CACHE_SIZE: fcount = %d, fetch_count = %d\n", fcount, fetch_count);
-		  self->tupleField = NULL;
-		  self->status = PGRES_END_TUPLES;
-		  return -1;	/* end of tuples */
+	else if (self->fcount < self->cache_size)
+	{							/* last row from cache */
+		/* We are done because we didn't even get CACHE_SIZE tuples */
+		mylog("next_tuple: fcount < CACHE_SIZE: fcount = %d, fetch_count = %d\n", fcount, fetch_count);
+		self->tupleField = NULL;
+		self->status = PGRES_END_TUPLES;
+		return -1;				/* end of tuples */
 	}
-	else {	
-		/*	See if we need to fetch another group of rows.
-			We may be being called from send_query(), and
-			if so, don't send another fetch, just fall through
-			and read the tuples.
-		*/
+	else
+	{
+
+		/*
+		 * See if we need to fetch another group of rows. We may be being
+		 * called from send_query(), and if so, don't send another fetch,
+		 * just fall through and read the tuples.
+		 */
 		self->tupleField = NULL;
 
-		if ( ! self->inTuples) {
+		if (!self->inTuples)
+		{
 
-			if ( ! globals.use_declarefetch) {
+			if (!globals.use_declarefetch)
+			{
 				mylog("next_tuple: ALL_ROWS: done, fcount = %d, fetch_count = %d\n", fcount, fetch_count);
 				self->tupleField = NULL;
 				self->status = PGRES_END_TUPLES;
-				return -1;	/* end of tuples */
+				return -1;		/* end of tuples */
 			}
 
-			if (self->base == fcount) {		/* not a correction */
+			if (self->base == fcount)
+			{					/* not a correction */
 
-				/*	Determine the optimum cache size.  */
+				/* Determine the optimum cache size.  */
 				if (globals.fetch_max % self->rowset_size == 0)
 					fetch_size = globals.fetch_max;
 				else if (self->rowset_size < globals.fetch_max)
@@ -394,9 +424,10 @@ QueryInfo qi;
 					fetch_size = self->rowset_size;
 
 				self->cache_size = fetch_size;
-				self->fetch_count = 1;		
-			} 
-			else {	/* need to correct */
+				self->fetch_count = 1;
+			}
+			else
+			{					/* need to correct */
 
 				corrected = TRUE;
 
@@ -411,8 +442,9 @@ QueryInfo qi;
 
 
 			self->backend_tuples = (TupleField *) realloc(self->backend_tuples, self->num_fields * sizeof(TupleField) * self->cache_size);
-			if ( ! self->backend_tuples) {
-				self->status = PGRES_FATAL_ERROR; 
+			if (!self->backend_tuples)
+			{
+				self->status = PGRES_FATAL_ERROR;
 				QR_set_message(self, "Out of memory while reading tuples.");
 				return FALSE;
 			}
@@ -420,29 +452,34 @@ QueryInfo qi;
 
 			mylog("next_tuple: sending actual fetch (%d) query '%s'\n", fetch_size, fetch);
 
-			/*	don't read ahead for the next tuple (self) ! */
+			/* don't read ahead for the next tuple (self) ! */
 			qi.row_size = self->cache_size;
 			qi.result_in = self;
 			qi.cursor = NULL;
 			res = CC_send_query(self->conn, fetch, &qi);
-			if (res == NULL) {
+			if (res == NULL)
+			{
 				self->status = PGRES_FATAL_ERROR;
 				QR_set_message(self, "Error fetching next group.");
 				return FALSE;
 			}
 			self->inTuples = TRUE;
 		}
-		else {
+		else
+		{
 			mylog("next_tuple: inTuples = true, falling through: fcount = %d, fetch_count = %d\n", self->fcount, self->fetch_count);
-			/*	This is a pre-fetch (fetching rows right after query
-				but before any real SQLFetch() calls.  This is done
-				so the field attributes are available.
-			*/
+
+			/*
+			 * This is a pre-fetch (fetching rows right after query but
+			 * before any real SQLFetch() calls.  This is done so the
+			 * field attributes are available.
+			 */
 			self->fetch_count = 0;
 		}
 	}
 
-	if ( ! corrected) {
+	if (!corrected)
+	{
 		self->base = 0;
 		self->fcount = 0;
 	}
@@ -451,88 +488,98 @@ QueryInfo qi;
 	sock = CC_get_socket(self->conn);
 	self->tupleField = NULL;
 
-	for ( ; ;) {
+	for (;;)
+	{
 
 		id = SOCK_get_char(sock);
 
-		switch (id) {
-		case 'T': /* Tuples within tuples cannot be handled */
-			self->status = PGRES_BAD_RESPONSE;
-			QR_set_message(self, "Tuples within tuples cannot be handled");
-			return FALSE;
-		case 'B': /* Tuples in binary format */
-		case 'D': /* Tuples in ASCII format  */
-
-			if ( ! globals.use_declarefetch && self->fcount > 0 && ! (self->fcount % TUPLE_MALLOC_INC)) {
-				size_t old_size = self->fcount * self->num_fields * sizeof(TupleField);
-				mylog("REALLOC: old_size = %d\n", old_size);
+		switch (id)
+		{
+			case 'T':			/* Tuples within tuples cannot be handled */
+				self->status = PGRES_BAD_RESPONSE;
+				QR_set_message(self, "Tuples within tuples cannot be handled");
+				return FALSE;
+			case 'B':			/* Tuples in binary format */
+			case 'D':			/* Tuples in ASCII format  */
+
+				if (!globals.use_declarefetch && self->fcount > 0 && !(self->fcount % TUPLE_MALLOC_INC))
+				{
+					size_t		old_size = self->fcount * self->num_fields * sizeof(TupleField);
+
+					mylog("REALLOC: old_size = %d\n", old_size);
+
+					self->backend_tuples = (TupleField *) realloc(self->backend_tuples, old_size + (self->num_fields * sizeof(TupleField) * TUPLE_MALLOC_INC));
+					if (!self->backend_tuples)
+					{
+						self->status = PGRES_FATAL_ERROR;
+						QR_set_message(self, "Out of memory while reading tuples.");
+						return FALSE;
+					}
+				}
 
-				self->backend_tuples = (TupleField *) realloc(self->backend_tuples, old_size + (self->num_fields * sizeof(TupleField) * TUPLE_MALLOC_INC));
-				if ( ! self->backend_tuples) {
-					self->status = PGRES_FATAL_ERROR; 
-					QR_set_message(self, "Out of memory while reading tuples.");
+				if (!QR_read_tuple(self, (char) (id == 0)))
+				{
+					self->status = PGRES_BAD_RESPONSE;
+					QR_set_message(self, "Error reading the tuple");
 					return FALSE;
 				}
-			}
 
-			if ( ! QR_read_tuple(self, (char) (id == 0))) {
-				self->status = PGRES_BAD_RESPONSE;
-				QR_set_message(self, "Error reading the tuple");
-				return FALSE;
-			}
-			
-			self->fcount++;
-			break;	/* continue reading */
+				self->fcount++;
+				break;			/* continue reading */
 
 
-		case 'C': /* End of tuple list */
-			SOCK_get_string(sock, cmdbuffer, MAX_MESSAGE_LEN);
-			QR_set_command(self, cmdbuffer);
+			case 'C':			/* End of tuple list */
+				SOCK_get_string(sock, cmdbuffer, MAX_MESSAGE_LEN);
+				QR_set_command(self, cmdbuffer);
 
-			mylog("end of tuple list -- setting inUse to false: this = %u\n", self);
+				mylog("end of tuple list -- setting inUse to false: this = %u\n", self);
 
-			self->inTuples = FALSE;
-			if (self->fcount > 0) {
+				self->inTuples = FALSE;
+				if (self->fcount > 0)
+				{
 
-				qlog("    [ fetched %d rows ]\n", self->fcount);
-				mylog("_next_tuple: 'C' fetch_max && fcount = %d\n", self->fcount);
+					qlog("    [ fetched %d rows ]\n", self->fcount);
+					mylog("_next_tuple: 'C' fetch_max && fcount = %d\n", self->fcount);
 
-				/*  set to first row */
-				self->tupleField = self->backend_tuples + (offset * self->num_fields);
-				return TRUE;
-			} 
-			else { /*	We are surely done here (we read 0 tuples) */
-				qlog("    [ fetched 0 rows ]\n");
-				mylog("_next_tuple: 'C': DONE (fcount == 0)\n");
-				return -1;	/* end of tuples */
-			}
+					/* set to first row */
+					self->tupleField = self->backend_tuples + (offset * self->num_fields);
+					return TRUE;
+				}
+				else
+				{				/* We are surely done here (we read 0
+								 * tuples) */
+					qlog("    [ fetched 0 rows ]\n");
+					mylog("_next_tuple: 'C': DONE (fcount == 0)\n");
+					return -1;	/* end of tuples */
+				}
 
-		case 'E': /* Error */
-			SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
-			QR_set_message(self, msgbuffer);
-			self->status = PGRES_FATAL_ERROR;
+			case 'E':			/* Error */
+				SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
+				QR_set_message(self, msgbuffer);
+				self->status = PGRES_FATAL_ERROR;
 
-			if ( ! strncmp(msgbuffer, "FATAL", 5))
-				CC_set_no_trans(self->conn);
+				if (!strncmp(msgbuffer, "FATAL", 5))
+					CC_set_no_trans(self->conn);
 
-			qlog("ERROR from backend in next_tuple: '%s'\n", msgbuffer);
+				qlog("ERROR from backend in next_tuple: '%s'\n", msgbuffer);
 
-			return FALSE;
+				return FALSE;
 
-		case 'N': /* Notice */
-			SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
-			QR_set_message(self, msgbuffer);
-			self->status = PGRES_NONFATAL_ERROR;
-			qlog("NOTICE from backend in next_tuple: '%s'\n", msgbuffer);
-			continue;
-
-		default: /* this should only happen if the backend dumped core */
-			mylog("QR_next_tuple: Unexpected result from backend: id = '%c' (%d)\n", id, id);
-			qlog("QR_next_tuple: Unexpected result from backend: id = '%c' (%d)\n", id, id);
-			QR_set_message(self, "Unexpected result from backend. It probably crashed");
-			self->status = PGRES_FATAL_ERROR;
-			CC_set_no_trans(self->conn);
-			return FALSE;
+			case 'N':			/* Notice */
+				SOCK_get_string(sock, msgbuffer, ERROR_MSG_LENGTH);
+				QR_set_message(self, msgbuffer);
+				self->status = PGRES_NONFATAL_ERROR;
+				qlog("NOTICE from backend in next_tuple: '%s'\n", msgbuffer);
+				continue;
+
+			default:			/* this should only happen if the backend
+								 * dumped core */
+				mylog("QR_next_tuple: Unexpected result from backend: id = '%c' (%d)\n", id, id);
+				qlog("QR_next_tuple: Unexpected result from backend: id = '%c' (%d)\n", id, id);
+				QR_set_message(self, "Unexpected result from backend. It probably crashed");
+				self->status = PGRES_FATAL_ERROR;
+				CC_set_no_trans(self->conn);
+				return FALSE;
 		}
 	}
 	return TRUE;
@@ -541,17 +588,18 @@ QueryInfo qi;
 char
 QR_read_tuple(QResultClass *self, char binary)
 {
-Int2 field_lf;
-TupleField *this_tuplefield;
-char bmp, bitmap[MAX_FIELDS];        /* Max. len of the bitmap */
-Int2 bitmaplen;                       /* len of the bitmap in bytes */
-Int2 bitmap_pos;
-Int2 bitcnt;
-Int4 len;
-char *buffer;
-int num_fields = self->num_fields;	/* speed up access */
-SocketClass *sock = CC_get_socket(self->conn);
-ColumnInfoClass *flds;
+	Int2		field_lf;
+	TupleField *this_tuplefield;
+	char		bmp,
+				bitmap[MAX_FIELDS];		/* Max. len of the bitmap */
+	Int2		bitmaplen;		/* len of the bitmap in bytes */
+	Int2		bitmap_pos;
+	Int2		bitcnt;
+	Int4		len;
+	char	   *buffer;
+	int			num_fields = self->num_fields;	/* speed up access */
+	SocketClass *sock = CC_get_socket(self->conn);
+	ColumnInfoClass *flds;
 
 
 	/* set the current row to read the fields into */
@@ -562,31 +610,36 @@ ColumnInfoClass *flds;
 		bitmaplen++;
 
 	/*
-		At first the server sends a bitmap that indicates which
-		database fields are null
-	*/
+	 * At first the server sends a bitmap that indicates which database
+	 * fields are null
+	 */
 	SOCK_get_n_char(sock, bitmap, bitmaplen);
 
 	bitmap_pos = 0;
 	bitcnt = 0;
 	bmp = bitmap[bitmap_pos];
 
-	for(field_lf = 0; field_lf < num_fields; field_lf++) {
+	for (field_lf = 0; field_lf < num_fields; field_lf++)
+	{
 		/* Check if the current field is NULL */
-		if(!(bmp & 0200)) {
+		if (!(bmp & 0200))
+		{
 			/* YES, it is NULL ! */
 			this_tuplefield[field_lf].len = 0;
 			this_tuplefield[field_lf].value = 0;
-		} else {
+		}
+		else
+		{
+
 			/*
-			NO, the field is not null. so get at first the
-			length of the field (four bytes)
-			*/
+			 * NO, the field is not null. so get at first the length of
+			 * the field (four bytes)
+			 */
 			len = SOCK_get_int(sock, VARHDRSZ);
 			if (!binary)
 				len -= VARHDRSZ;
 
-			buffer = (char *)malloc(len+1);
+			buffer = (char *) malloc(len + 1);
 			SOCK_get_n_char(sock, buffer, len);
 			buffer[len] = '\0';
 
@@ -595,27 +648,31 @@ ColumnInfoClass *flds;
 			this_tuplefield[field_lf].len = len;
 			this_tuplefield[field_lf].value = buffer;
 
-			/*	This can be used to set the longest length of the column for any
-				row in the tuple cache.  It would not be accurate for varchar and
-				text fields to use this since a tuple cache is only 100 rows.
-				Bpchar can be handled since the strlen of all rows is fixed,
-				assuming there are not 100 nulls in a row!
-			*/
+			/*
+			 * This can be used to set the longest length of the column
+			 * for any row in the tuple cache.	It would not be accurate
+			 * for varchar and text fields to use this since a tuple cache
+			 * is only 100 rows. Bpchar can be handled since the strlen of
+			 * all rows is fixed, assuming there are not 100 nulls in a
+			 * row!
+			 */
 
 			flds = self->fields;
 			if (flds->display_size[field_lf] < len)
 				flds->display_size[field_lf] = len;
 		}
+
 		/*
-		Now adjust for the next bit to be scanned in the
-		next loop.
-		*/
+		 * Now adjust for the next bit to be scanned in the next loop.
+		 */
 		bitcnt++;
-		if (BYTELEN == bitcnt) {
+		if (BYTELEN == bitcnt)
+		{
 			bitmap_pos++;
 			bmp = bitmap[bitmap_pos];
 			bitcnt = 0;
-		} else
+		}
+		else
 			bmp <<= 1;
 	}
 	self->currTuple++;