enhanced error fields

diff doc/src/sgml/config.sgml
index 074afee..5cf2fe3
*** a/doc/src/sgml/config.sgml
--- b/doc/src/sgml/config.sgml
*************** CREATE TABLE postgres_log
*** 4180,4185 ****
--- 4180,4193 ----
    query_pos integer,
    location text,
    application_name text,
+   column_name text,
+   table_name text,
+   schema_name text,
+   constraint_name text,
+   constraint_schema text,
+   routine_name text,
+   trigger_name text,
+   trigger_schema text,
    PRIMARY KEY (session_id, session_line_num)
  );
  </programlisting>
diff doc/src/sgml/protocol.sgml
index e725563..739d1fe
*** a/doc/src/sgml/protocol.sgml
--- b/doc/src/sgml/protocol.sgml
*************** message.
*** 4720,4725 ****
--- 4720,4824 ----
  </listitem>
  </varlistentry>

+ <varlistentry>
+ <term>
+ <literal>c</>
+ </term>
+ <listitem>
+ <para>
+         Column name: the name of column related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>t</>
+ </term>
+ <listitem>
+ <para>
+         Table name: the name of table related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>s</>
+ </term>
+ <listitem>
+ <para>
+         Schema name: the name of schema related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>n</>
+ </term>
+ <listitem>
+ <para>
+         Constraint name: the name of constraint related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>m</>
+ </term>
+ <listitem>
+ <para>
+         Constraint schema: the schema of constraint related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>r</>
+ </term>
+ <listitem>
+ <para>
+         Routine name: the name of routine related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>u</>
+ </term>
+ <listitem>
+ <para>
+         Routine schema: the schema of routine related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>g</>
+ </term>
+ <listitem>
+ <para>
+         Trigger name: the name of trigger related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>h</>
+ </term>
+ <listitem>
+ <para>
+         Trigger schema: the schema of trigger related to error
+ </para>
+ </listitem>
+ </varlistentry>
+
  </variablelist>

  <para>
diff src/backend/access/nbtree/nbtinsert.c
index 3ed9b5c..a5e5d12
*** a/src/backend/access/nbtree/nbtinsert.c
--- b/src/backend/access/nbtree/nbtinsert.c
*************** _bt_check_unique(Relation rel, IndexTupl
*** 393,399 ****
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull))));
  					}
  				}
  				else if (all_dead)
--- 393,400 ----
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull)),
! 								 constraint_relation_error(rel)));
  					}
  				}
  				else if (all_dead)
*************** _bt_check_unique(Relation rel, IndexTupl
*** 455,461 ****
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression.")));

  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
--- 456,463 ----
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression."),
! 				 relation_error(rel)));

  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
*************** _bt_findinsertloc(Relation rel,
*** 533,539 ****
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing.")));

  	/*----------
  	 * If we will need to split the page to put the item on this page,
--- 535,542 ----
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing."),
! 				relation_error(rel)));

  	/*----------
  	 * If we will need to split the page to put the item on this page,
diff src/backend/executor/execMain.c
index 440438b..11da994
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
*************** ExecConstraints(ResultRelInfo *resultRel
*** 1522,1528 ****
  						 errmsg("null value in column \"%s\" violates not-null constraint",
  						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64))));
  		}
  	}

--- 1522,1530 ----
  						 errmsg("null value in column \"%s\" violates not-null constraint",
  						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64)),
! 						 relation_column_error(rel, NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
! 						 constraint_error(rel, "not_null_violation")));
  		}
  	}

*************** ExecConstraints(ResultRelInfo *resultRel
*** 1536,1542 ****
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64))));
  	}
  }

--- 1538,1546 ----
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64)),
! 					 relation_error(rel),
! 					 constraint_error(rel, failed)));
  	}
  }

diff src/backend/executor/execUtils.c
index 2bd8b42..d64c747
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
*************** retry:
*** 1304,1317 ****
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing)));
  	}

  	index_endscan(index_scan);
--- 1304,1319 ----
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing),
! 					 constraint_relation_error(index)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing),
! 					 constraint_relation_error(index)));
  	}

  	index_endscan(index_scan);
diff src/backend/utils/adt/ri_triggers.c
index 983f631..49859a8
*** a/src/backend/utils/adt/ri_triggers.c
--- b/src/backend/utils/adt/ri_triggers.c
*************** RI_FKey_check(TriggerData *trigdata)
*** 338,344 ****
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);

--- 338,346 ----
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 							 relation_error(trigdata->tg_relation),
! 					 constraint_error(trigdata->tg_relation, NameStr(riinfo->conname))));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);

*************** RI_Initial_Check(Trigger *trigger, Relat
*** 2466,2472 ****
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));

  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
--- 2468,2477 ----
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("match full does not allow mixing of null and nonnull key values."),
! 					 relation_error(fk_rel),
! 					 constraint_error(fk_rel, NameStr(fake_riinfo.conname))));
!

  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
*************** ri_ReportViolation(const RI_ConstraintIn
*** 3218,3224 ****
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
--- 3223,3231 ----
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel)),
! 				 relation_error(fk_rel),
! 				 constraint_error(fk_rel, NameStr(riinfo->conname))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
*************** ri_ReportViolation(const RI_ConstraintIn
*** 3228,3234 ****
  						RelationGetRelationName(fk_rel)),
  			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
  					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel))));
  }


--- 3235,3243 ----
  						RelationGetRelationName(fk_rel)),
  			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
  					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel)),
! 				 relation_error(pk_rel),
! 				 constraint_error(fk_rel, NameStr(riinfo->conname))));
  }


diff src/backend/utils/cache/relcache.c
index 2e6776e..80561b7
*** a/src/backend/utils/cache/relcache.c
--- b/src/backend/utils/cache/relcache.c
*************** unlink_initfile(const char *initfilename
*** 4624,4626 ****
--- 4624,4674 ----
  			elog(LOG, "could not remove cache file \"%s\": %m", initfilename);
  	}
  }
+
+ /*
+  * Sets column_name, table_name and schema_name in ErrorData related to relation
+  */
+ inline int
+ relation_column_error(Relation rel, const char *colname)
+ {
+ 	if (colname != NULL)
+ 		erritem(PG_DIAG_COLUMN_NAME, colname);
+
+ 	erritem(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+ 	erritem(PG_DIAG_SCHEMA_NAME, get_namespace_name(RelationGetNamespace(rel)));
+
+ 	return 0;
+ }
+
+ /*
+  * Sets column_name, table_name and schema_name in ErrorData related to relation
+  */
+ inline int
+ relation_error(Relation rel)
+ {
+ 	erritem(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+ 	erritem(PG_DIAG_SCHEMA_NAME, get_namespace_name(RelationGetNamespace(rel)));
+
+ 	return 0;
+ }
+
+ /*
+  * Sets constraint_name and constraint_schema in ErrorData
+  */
+ inline int
+ constraint_error(Relation rel, const char *cname)
+ {
+ 	erritem(PG_DIAG_CONSTRAINT_NAME, cname);
+ 	erritem(PG_DIAG_CONSTRAINT_SCHEMA, get_namespace_name(RelationGetNamespace(rel)));
+
+ 	return 0;
+ }
+
+ inline int
+ constraint_relation_error(Relation rel)
+ {
+ 	erritem(PG_DIAG_CONSTRAINT_NAME, RelationGetRelationName(rel));
+ 	erritem(PG_DIAG_CONSTRAINT_SCHEMA, get_namespace_name(RelationGetNamespace(rel)));
+
+ 	return 0;
+ }
diff src/backend/utils/error/elog.c
index a40b343..7fd952f
*** a/src/backend/utils/error/elog.c
--- b/src/backend/utils/error/elog.c
*************** errfinish(int dummy,...)
*** 477,482 ****
--- 477,500 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);

  	errordata_stack_depth--;

*************** internalerrquery(const char *query)
*** 1078,1083 ****
--- 1096,1193 ----
  	return 0;					/* return value does not matter */
  }

+ static inline void
+ set_field(char **ptr, const char *str, bool overwrite)
+ {
+ 	if (*ptr != NULL)
+ 	{
+ 		/*
+ 		 * for some cases like ROUTINE_NAME, ROUTINE_SCHEMA we would
+ 		 * to get the most older value.
+ 		 */
+ 		if (!overwrite)
+ 			return;
+
+ 		pfree(*ptr);
+ 		*ptr = NULL;
+ 	}
+
+ 	if (str != NULL)
+ 		*ptr = MemoryContextStrdup(ErrorContext, str);
+ }
+
+ /*
+  * erritem -- generic setting of ErrorData string fields
+  */
+ int
+ erritem(int field, const char *str)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+
+ 	switch (field)
+ 	{
+ 		case PG_DIAG_MESSAGE_PRIMARY:
+ 			set_field(&edata->message, str, true);
+ 			break;
+
+ 		case PG_DIAG_MESSAGE_DETAIL:
+ 			set_field(&edata->detail, str, true);
+ 			break;
+
+ 		case PG_DIAG_MESSAGE_HINT:
+ 			set_field(&edata->hint, str, true);
+ 			break;
+
+ 		case PG_DIAG_CONTEXT:
+ 			set_field(&edata->context, str, true);
+ 			break;
+
+ 		case PG_DIAG_COLUMN_NAME:
+ 			set_field(&edata->column_name, str, true);
+ 			break;
+
+ 		case PG_DIAG_TABLE_NAME:
+ 			set_field(&edata->table_name, str, true);
+ 			break;
+
+ 		case PG_DIAG_SCHEMA_NAME:
+ 			set_field(&edata->schema_name, str, true);
+ 			break;
+
+ 		case PG_DIAG_CONSTRAINT_NAME:
+ 			set_field(&edata->constraint_name, str, true);
+ 			break;
+
+ 		case PG_DIAG_CONSTRAINT_SCHEMA:
+ 			set_field(&edata->constraint_schema, str, true);
+ 			break;
+
+ 		case PG_DIAG_ROUTINE_NAME:
+ 			set_field(&edata->routine_name, str, false);
+ 			break;
+
+ 		case PG_DIAG_ROUTINE_SCHEMA:
+ 			set_field(&edata->routine_schema, str, false);
+ 			break;
+
+ 		case PG_DIAG_TRIGGER_NAME:
+ 			set_field(&edata->trigger_name, str, false);
+ 			break;
+
+ 		case PG_DIAG_TRIGGER_SCHEMA:
+ 			set_field(&edata->trigger_schema, str, false);
+ 			break;
+
+ 		default:
+ 			elog(ERROR, "unknown ErrorData field id %d", field);
+ 	}
+
+ 	return 0;					/* return value does not matter */
+ }
+
  /*
   * geterrcode --- return the currently set SQLSTATE error code
   *
*************** CopyErrorData(void)
*** 1352,1357 ****
--- 1462,1485 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);

  	return newedata;
  }
*************** FreeErrorData(ErrorData *edata)
*** 1377,1382 ****
--- 1505,1528 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);
  	pfree(edata);
  }

*************** ReThrowError(ErrorData *edata)
*** 1449,1454 ****
--- 1595,1618 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);

  	recursion_depth--;
  	PG_RE_THROW();
*************** write_csvlog(ErrorData *edata)
*** 2259,2264 ****
--- 2423,2455 ----
  	/* application name */
  	if (application_name)
  		appendCSVLiteral(&buf, application_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->column_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->table_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->schema_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->constraint_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->constraint_schema);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->routine_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->routine_schema);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->trigger_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->trigger_schema);

  	appendStringInfoChar(&buf, '\n');

*************** send_message_to_server_log(ErrorData *ed
*** 2377,2382 ****
--- 2568,2636 ----
  				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
  								 edata->filename, edata->lineno);
  			}
+ 			if (edata->column_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("COLUMN NAME:  "));
+ 				append_with_tabs(&buf, edata->column_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TABLE NAME:  "));
+ 				append_with_tabs(&buf, edata->table_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->schema_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("SCHEMA NAME:  "));
+ 				append_with_tabs(&buf, edata->schema_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT NAME:  "));
+ 				append_with_tabs(&buf, edata->constraint_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->constraint_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE NAME:  "));
+ 				append_with_tabs(&buf, edata->routine_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->routine_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER NAME:  "));
+ 				append_with_tabs(&buf, edata->trigger_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->trigger_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
  		}
  	}

*************** send_message_to_frontend(ErrorData *edat
*** 2673,2678 ****
--- 2927,2986 ----
  			err_sendstring(&msgbuf, edata->funcname);
  		}

+ 		if (edata->column_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+ 			err_sendstring(&msgbuf, edata->column_name);
+ 		}
+
+ 		if (edata->table_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+ 			err_sendstring(&msgbuf, edata->table_name);
+ 		}
+
+ 		if (edata->schema_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+ 			err_sendstring(&msgbuf, edata->schema_name);
+ 		}
+
+ 		if (edata->constraint_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+ 			err_sendstring(&msgbuf, edata->constraint_name);
+ 		}
+
+ 		if (edata->constraint_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->constraint_schema);
+ 		}
+
+ 		if (edata->routine_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_NAME);
+ 			err_sendstring(&msgbuf, edata->routine_name);
+ 		}
+
+ 		if (edata->routine_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->routine_schema);
+ 		}
+
+ 		if (edata->trigger_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_NAME);
+ 			err_sendstring(&msgbuf, edata->trigger_name);
+ 		}
+
+ 		if (edata->trigger_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->trigger_schema);
+ 		}
+
  		pq_sendbyte(&msgbuf, '\0');		/* terminator */
  	}
  	else
diff src/include/postgres_ext.h
index b6ebb7a..833c59e
*** a/src/include/postgres_ext.h
--- b/src/include/postgres_ext.h
*************** typedef unsigned int Oid;
*** 55,59 ****
--- 55,68 ----
  #define PG_DIAG_SOURCE_FILE		'F'
  #define PG_DIAG_SOURCE_LINE		'L'
  #define PG_DIAG_SOURCE_FUNCTION 'R'
+ #define PG_DIAG_COLUMN_NAME	'c'
+ #define PG_DIAG_TABLE_NAME	't'
+ #define PG_DIAG_SCHEMA_NAME	's'
+ #define PG_DIAG_CONSTRAINT_NAME		'n'
+ #define PG_DIAG_CONSTRAINT_SCHEMA	'm'
+ #define PG_DIAG_ROUTINE_NAME		'r'
+ #define PG_DIAG_ROUTINE_SCHEMA		'u'
+ #define PG_DIAG_TRIGGER_NAME		'g'
+ #define PG_DIAG_TRIGGER_SCHEMA		'h'

  #endif
diff src/include/utils/elog.h
index 1bbfd2b..3bfead9
*** a/src/include/utils/elog.h
--- b/src/include/utils/elog.h
*************** extern int	geterrcode(void);
*** 190,195 ****
--- 189,196 ----
  extern int	geterrposition(void);
  extern int	getinternalerrposition(void);

+ extern int	erritem(int field, const char *str);
+

  /*----------
   * Old-style error reporting API: to be used in this way:
*************** typedef struct ErrorData
*** 321,326 ****
--- 323,337 ----
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
+ 	char	   *column_name;		/* name of column */
+ 	char	   *table_name;			/* name of table */
+ 	char	   *schema_name;		/* name of schema */
+ 	char	   *constraint_name;		/* name of constraint */
+ 	char	   *constraint_schema;		/* name of schema with constraint */
+ 	char	   *routine_name;		/* name of function that caused error */
+ 	char	   *routine_schema;		/* schema name of function that caused error */
+ 	char	   *trigger_name;		/* name of trigger that caused error */
+ 	char	   *trigger_schema;		/* schema of trigger that caused error */
  	int			cursorpos;		/* cursor index into query string */
  	int			internalpos;	/* cursor index into internalquery */
  	char	   *internalquery;	/* text of internally-generated query */
diff src/include/utils/rel.h
index 4669d8a..82d50e5
*** a/src/include/utils/rel.h
--- b/src/include/utils/rel.h
*************** typedef struct StdRdOptions
*** 394,397 ****
--- 394,404 ----
  extern void RelationIncrementReferenceCount(Relation rel);
  extern void RelationDecrementReferenceCount(Relation rel);

+ extern inline int relation_column_error(Relation rel, const char *colname);
+ extern inline int relation_error(Relation rel);
+ extern inline int constraint_error(Relation rel, const char *ccname);
+ extern inline int constraint_relation_error(Relation rel);
+ extern inline int column_error(const char *cname);
+
+
  #endif   /* REL_H */
diff src/interfaces/libpq/fe-protocol3.c
index 173af2e..6f0a664
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 980,985 ****
--- 980,1013 ----
  								  valf, vall);
  			appendPQExpBufferChar(&workBuf, '\n');
  		}
+
+ 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("COLUMN NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("TABLE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("SCHEMA NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("ROUTINE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("ROUTINE SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER SCHEMA:  %s\n"), val);
  	}

  	/*

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 4e0492b..ddaf900 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -4183,6 +4183,16 @@ CREATE TABLE postgres_log
   query_pos integer,
   location text,
   application_name text,
+  column_name text,
+  table_name text,
+  schema_name text,
+  constraint_name text,
+  constraint_table text,
+  constraint_schema text,
+  routine_name text,
+  trigger_name text,
+  trigger_table text,
+  trigger_schema text,
   PRIMARY KEY (session_id, session_line_num)
 );
 </programlisting>
diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml
index e725563..6f34448 100644
--- a/doc/src/sgml/protocol.sgml
+++ b/doc/src/sgml/protocol.sgml
@@ -4720,6 +4720,127 @@ message.
 </listitem>
 </varlistentry>
 
+<varlistentry>
+<term>
+<literal>c</>
+</term>
+<listitem>
+<para>
+        Column name: the name of column related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>t</>
+</term>
+<listitem>
+<para>
+        Table name: the name of table related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>s</>
+</term>
+<listitem>
+<para>
+        Schema name: the name of schema related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>n</>
+</term>
+<listitem>
+<para>
+        Constraint name: the name of constraint related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>o</>
+</term>
+<listitem>
+<para>
+        Constraint table: the table name of constraint related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>m</>
+</term>
+<listitem>
+<para>
+        Constraint schema: the schema of constraint related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>r</>
+</term>
+<listitem>
+<para>
+        Routine name: the name of routine related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>u</>
+</term>
+<listitem>
+<para>
+        Routine schema: the schema of routine related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>g</>
+</term>
+<listitem>
+<para>
+        Trigger name: the name of trigger related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>i</>
+</term>
+<listitem>
+<para>
+        Trigger table: the table of trigger related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>h</>
+</term>
+<listitem>
+<para>
+        Trigger schema: the schema of trigger related to error
+</para>
+</listitem>
+</varlistentry>
+
 </variablelist>
 
 <para>
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 3ed9b5c..419823c 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -23,6 +23,7 @@
 #include "storage/predicate.h"
 #include "utils/inval.h"
 #include "utils/tqual.h"
+#include "utils/relerror.h"
 
 
 typedef struct
@@ -393,7 +394,8 @@ _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
 										RelationGetRelationName(rel)),
 								 errdetail("Key %s already exists.",
 										   BuildIndexValueDescription(rel,
-														  values, isnull))));
+														  values, isnull)),
+								 errrelation(rel)));
 					}
 				}
 				else if (all_dead)
@@ -455,7 +457,8 @@ _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
 				(errcode(ERRCODE_INTERNAL_ERROR),
 				 errmsg("failed to re-find tuple within index \"%s\"",
 						RelationGetRelationName(rel)),
-		errhint("This may be because of a non-immutable index expression.")));
+		errhint("This may be because of a non-immutable index expression."),
+				 errrelation(rel)));
 
 	if (nbuf != InvalidBuffer)
 		_bt_relbuf(rel, nbuf);
@@ -533,7 +536,8 @@ _bt_findinsertloc(Relation rel,
 				   RelationGetRelationName(rel)),
 		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
 				"Consider a function index of an MD5 hash of the value, "
-				"or use full text indexing.")));
+				"or use full text indexing."),
+				errrelation(rel)));
 
 	/*----------
 	 * If we will need to split the page to put the item on this page,
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index d69809a..91b8665 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -81,6 +81,7 @@
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/relcache.h"
+#include "utils/relerror.h"
 #include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
@@ -3808,6 +3809,10 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
 					ereport(ERROR,
 							(errcode(ERRCODE_NOT_NULL_VIOLATION),
 							 errmsg("column \"%s\" contains null values",
+								NameStr(newTupDesc->attrs[attn]->attname)),
+							 (newrel) ? errrelation_column(newrel,
+								NameStr(newTupDesc->attrs[attn]->attname)) :
+							errrelation_column(oldrel,
 								NameStr(newTupDesc->attrs[attn]->attname))));
 			}
 
@@ -3822,7 +3827,9 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
 							ereport(ERROR,
 									(errcode(ERRCODE_CHECK_VIOLATION),
 									 errmsg("check constraint \"%s\" is violated by some row",
-											con->name)));
+											con->name),
+						 (newrel) ? errrelation(newrel) : errrelation(oldrel),
+						 (newrel) ? errconstraint(newrel, con->name) : errconstraint(oldrel, con->name)));
 						break;
 					case CONSTR_FOREIGN:
 						/* Nothing to do here */
@@ -6632,7 +6639,9 @@ validateCheckConstraint(Relation rel, HeapTuple constrtup)
 			ereport(ERROR,
 					(errcode(ERRCODE_CHECK_VIOLATION),
 					 errmsg("check constraint \"%s\" is violated by some row",
-							NameStr(constrForm->conname))));
+							NameStr(constrForm->conname)),
+					 errrelation(rel),
+					 errconstraint(rel, NameStr(constrForm->conname))));
 
 		ResetExprContext(econtext);
 	}
diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index 30850b2..040adab 100644
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -69,6 +69,7 @@
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/rel.h"
+#include "utils/relerror.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
 
@@ -2233,7 +2234,9 @@ AlterDomainNotNull(List *names, bool notNull)
 								(errcode(ERRCODE_NOT_NULL_VIOLATION),
 								 errmsg("column \"%s\" of table \"%s\" contains null values",
 								NameStr(tupdesc->attrs[attnum - 1]->attname),
-										RelationGetRelationName(testrel))));
+										RelationGetRelationName(testrel)),
+								 errrelation_column(testrel,
+								NameStr(tupdesc->attrs[attnum - 1]->attname))));
 				}
 			}
 			heap_endscan(scan);
@@ -2602,7 +2605,9 @@ validateDomainConstraint(Oid domainoid, char *ccbin)
 							(errcode(ERRCODE_CHECK_VIOLATION),
 							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
 								NameStr(tupdesc->attrs[attnum - 1]->attname),
-									RelationGetRelationName(testrel))));
+									RelationGetRelationName(testrel)),
+							errrelation_column(testrel,
+								NameStr(tupdesc->attrs[attnum - 1]->attname))));
 			}
 
 			ResetExprContext(econtext);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 440438b..8332ecf 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -53,6 +53,7 @@
 #include "utils/acl.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
+#include "utils/relerror.h"
 #include "utils/snapmgr.h"
 #include "utils/tqual.h"
 
@@ -1522,7 +1523,9 @@ ExecConstraints(ResultRelInfo *resultRelInfo,
 						 errmsg("null value in column \"%s\" violates not-null constraint",
 						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
 						 errdetail("Failing row contains %s.",
-								   ExecBuildSlotValueDescription(slot, 64))));
+								   ExecBuildSlotValueDescription(slot, 64)),
+						 errrelation_column(rel,
+							   NameStr(rel->rd_att->attrs[attrChk - 1]->attname))));
 		}
 	}
 
@@ -1536,7 +1539,9 @@ ExecConstraints(ResultRelInfo *resultRelInfo,
 					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
 							RelationGetRelationName(rel), failed),
 					 errdetail("Failing row contains %s.",
-							   ExecBuildSlotValueDescription(slot, 64))));
+							   ExecBuildSlotValueDescription(slot, 64)),
+					 errrelation(rel),
+					 errconstraint(rel, failed)));
 	}
 }
 
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 2bd8b42..7f0d331 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -50,6 +50,7 @@
 #include "parser/parsetree.h"
 #include "storage/lmgr.h"
 #include "utils/memutils.h"
+#include "utils/relerror.h"
 #include "utils/tqual.h"
 
 
@@ -1304,14 +1305,16 @@ retry:
 					 errmsg("could not create exclusion constraint \"%s\"",
 							RelationGetRelationName(index)),
 					 errdetail("Key %s conflicts with key %s.",
-							   error_new, error_existing)));
+							   error_new, error_existing),
+					 errrelation(index)));
 		else
 			ereport(ERROR,
 					(errcode(ERRCODE_EXCLUSION_VIOLATION),
 					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
 							RelationGetRelationName(index)),
 					 errdetail("Key %s conflicts with existing key %s.",
-							   error_new, error_existing)));
+							   error_new, error_existing),
+					 errrelation(index)));
 	}
 
 	index_endscan(index_scan);
diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c
index 983f631..48b02d5 100644
--- a/src/backend/utils/adt/ri_triggers.c
+++ b/src/backend/utils/adt/ri_triggers.c
@@ -49,6 +49,7 @@
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/rel.h"
+#include "utils/relerror.h"
 #include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/tqual.h"
@@ -338,7 +339,9 @@ RI_FKey_check(TriggerData *trigdata)
 							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
 							  RelationGetRelationName(trigdata->tg_relation),
 									NameStr(riinfo->conname)),
-							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
+							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
+							 errrelation(trigdata->tg_relation),
+						   errconstraint(trigdata->tg_relation, NameStr(riinfo->conname))));
 					heap_close(pk_rel, RowShareLock);
 					return PointerGetDatum(NULL);
 
@@ -2466,7 +2469,10 @@ RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
 					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
 							RelationGetRelationName(fk_rel),
 							NameStr(fake_riinfo.conname)),
-					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
+					 errdetail("match full does not allow mixing of null and nonnull key values."),
+					 errrelation(fk_rel),
+					 errconstraint(fk_rel, NameStr(fake_riinfo.conname))));
+
 
 		/*
 		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
@@ -3218,7 +3224,9 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
 						NameStr(riinfo->conname)),
 				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
 						   key_names.data, key_values.data,
-						   RelationGetRelationName(pk_rel))));
+						   RelationGetRelationName(pk_rel)),
+				 errrelation(fk_rel),
+				 errconstraint(fk_rel, NameStr(riinfo->conname))));
 	else
 		ereport(ERROR,
 				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
@@ -3228,7 +3236,9 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
 						RelationGetRelationName(fk_rel)),
 			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
 					  key_names.data, key_values.data,
-					  RelationGetRelationName(fk_rel))));
+					  RelationGetRelationName(fk_rel)),
+				 errrelation(pk_rel),
+				 errconstraint(fk_rel, NameStr(riinfo->conname))));
 }
 
 
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index a40b343..93f39eb 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -75,9 +75,11 @@
 #include "storage/proc.h"
 #include "tcop/tcopprot.h"
 #include "utils/guc.h"
+#include "utils/lsyscache.h"
 #include "utils/memutils.h"
 #include "utils/ps_status.h"
-
+#include "utils/rel.h"
+#include "utils/relerror.h"
 
 #undef _
 #define _(x) err_gettext(x)
@@ -477,6 +479,28 @@ errfinish(int dummy,...)
 		pfree(edata->context);
 	if (edata->internalquery)
 		pfree(edata->internalquery);
+	if (edata->column_name)
+		pfree(edata->column_name);
+	if (edata->table_name)
+		pfree(edata->table_name);
+	if (edata->schema_name)
+		pfree(edata->schema_name);
+	if (edata->constraint_name)
+		pfree(edata->constraint_name);
+	if (edata->constraint_table)
+		pfree(edata->constraint_table);
+	if (edata->constraint_schema)
+		pfree(edata->constraint_schema);
+	if (edata->routine_name)
+		pfree(edata->routine_name);
+	if (edata->routine_schema)
+		pfree(edata->routine_schema);
+	if (edata->trigger_name)
+		pfree(edata->trigger_name);
+	if (edata->trigger_table)
+		pfree(edata->trigger_table);
+	if (edata->trigger_schema)
+		pfree(edata->trigger_schema);
 
 	errordata_stack_depth--;
 
@@ -1079,6 +1103,157 @@ internalerrquery(const char *query)
 }
 
 /*
+ * Sets column_name, table_name and schema_name in ErrorData related to relation
+ */
+int
+errrelation_column(Relation rel, const char *colname)
+{
+	erritem(PG_DIAG_COLUMN_NAME, colname);
+	erritem(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+	erritem(PG_DIAG_SCHEMA_NAME,
+			get_namespace_name(RelationGetNamespace(rel)));
+
+	return 0;
+}
+
+/*
+ * Sets column_name, table_name and schema_name in ErrorData related to relation
+ */
+int
+errrelation(Relation rel)
+{
+	erritem(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+	erritem(PG_DIAG_SCHEMA_NAME,
+			get_namespace_name(RelationGetNamespace(rel)));
+
+	return 0;
+}
+
+/*
+ * Sets constraint_name, constraint_table  and constraint_schema in ErrorData
+ */
+int
+errconstraint(Relation rel, const char *cname)
+{
+	erritem(PG_DIAG_CONSTRAINT_NAME, cname);
+	erritem(PG_DIAG_CONSTRAINT_TABLE, RelationGetRelationName(rel));
+	erritem(PG_DIAG_CONSTRAINT_SCHEMA,
+			get_namespace_name(RelationGetNamespace(rel)));
+
+	return 0;
+}
+
+/*
+ * set ErrorData field - ensure not overwriting for selected fields
+ */
+static void
+set_field(char **ptr, const char *str, bool overwrite)
+{
+	if (*ptr != NULL)
+	{
+		/*
+		 * for some cases like ROUTINE_NAME, ROUTINE_SCHEMA we would
+		 * to get the most older value.
+		 */
+		if (!overwrite)
+			return;
+
+		pfree(*ptr);
+		*ptr = NULL;
+	}
+
+	if (str != NULL)
+		*ptr = MemoryContextStrdup(ErrorContext, str);
+}
+
+/*
+ * erritem -- generic setting of ErrorData string fields
+ */
+int
+erritem(int field, const char *str)
+{
+	ErrorData  *edata = &errordata[errordata_stack_depth];
+
+	/* we don't bother incrementing recursion_depth */
+	CHECK_STACK_DEPTH();
+
+	switch (field)
+	{
+		case PG_DIAG_MESSAGE_PRIMARY:
+			set_field(&edata->message, str, true);
+			break;
+
+		case PG_DIAG_MESSAGE_DETAIL:
+			set_field(&edata->detail, str, true);
+			break;
+
+		case PG_DIAG_MESSAGE_HINT:
+			set_field(&edata->hint, str, true);
+			break;
+
+		case PG_DIAG_CONTEXT:
+			set_field(&edata->context, str, true);
+			break;
+
+		case PG_DIAG_COLUMN_NAME:
+			set_field(&edata->column_name, str, true);
+			break;
+
+		case PG_DIAG_TABLE_NAME:
+			set_field(&edata->table_name, str, true);
+			break;
+
+		case PG_DIAG_SCHEMA_NAME:
+			set_field(&edata->schema_name, str, true);
+			break;
+
+		case PG_DIAG_CONSTRAINT_NAME:
+			set_field(&edata->constraint_name, str, true);
+			break;
+
+		case PG_DIAG_CONSTRAINT_TABLE:
+			set_field(&edata->constraint_table, str, true);
+			break;
+
+		case PG_DIAG_CONSTRAINT_SCHEMA:
+			set_field(&edata->constraint_schema, str, true);
+			break;
+
+		/*
+		 * setup of routine_name, routine_schema, trigger_name,
+		 * trigger_table, trigger_schema is processed together
+		 * with collecting context. Only first values are valid,
+		 * so we should to protect these values.
+		 */
+		case PG_DIAG_ROUTINE_NAME:
+			set_field(&edata->routine_name, str, false);
+			break;
+
+		case PG_DIAG_ROUTINE_SCHEMA:
+			set_field(&edata->routine_schema, str, false);
+			break;
+
+		case PG_DIAG_TRIGGER_NAME:
+			set_field(&edata->trigger_name, str, false);
+			break;
+
+		case PG_DIAG_TRIGGER_TABLE:
+			set_field(&edata->trigger_table, str, false);
+			break;
+
+		case PG_DIAG_TRIGGER_SCHEMA:
+			set_field(&edata->trigger_schema, str, false);
+			break;
+
+		default:
+			elog(ERROR, "unknown ErrorData field id %d",
+						    field);
+	}
+
+	return 0;			/* return value does not matter */
+}
+
+/*
  * geterrcode --- return the currently set SQLSTATE error code
  *
  * This is only intended for use in error callback subroutines, since there
@@ -1352,6 +1527,28 @@ CopyErrorData(void)
 		newedata->context = pstrdup(newedata->context);
 	if (newedata->internalquery)
 		newedata->internalquery = pstrdup(newedata->internalquery);
+	if (newedata->column_name)
+		newedata->column_name = pstrdup(newedata->column_name);
+	if (newedata->table_name)
+		newedata->table_name = pstrdup(newedata->table_name);
+	if (newedata->schema_name)
+		newedata->schema_name = pstrdup(newedata->schema_name);
+	if (newedata->constraint_name)
+		newedata->constraint_name = pstrdup(newedata->constraint_name);
+	if (newedata->constraint_table)
+		newedata->constraint_table = pstrdup(newedata->constraint_table);
+	if (newedata->constraint_schema)
+		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+	if (newedata->routine_name)
+		newedata->routine_name = pstrdup(newedata->routine_name);
+	if (newedata->routine_schema)
+		newedata->routine_schema = pstrdup(newedata->routine_schema);
+	if (newedata->trigger_name)
+		newedata->trigger_name = pstrdup(newedata->trigger_name);
+	if (newedata->trigger_table)
+		newedata->trigger_table = pstrdup(newedata->trigger_table);
+	if (newedata->trigger_schema)
+		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
 
 	return newedata;
 }
@@ -1377,6 +1574,28 @@ FreeErrorData(ErrorData *edata)
 		pfree(edata->context);
 	if (edata->internalquery)
 		pfree(edata->internalquery);
+	if (edata->column_name)
+		pfree(edata->column_name);
+	if (edata->table_name)
+		pfree(edata->table_name);
+	if (edata->schema_name)
+		pfree(edata->schema_name);
+	if (edata->constraint_name)
+		pfree(edata->constraint_name);
+	if (edata->constraint_table)
+		pfree(edata->constraint_table);
+	if (edata->constraint_schema)
+		pfree(edata->constraint_schema);
+	if (edata->routine_name)
+		pfree(edata->routine_name);
+	if (edata->routine_schema)
+		pfree(edata->routine_schema);
+	if (edata->trigger_name)
+		pfree(edata->trigger_name);
+	if (edata->trigger_table)
+		pfree(edata->trigger_table);
+	if (edata->trigger_schema)
+		pfree(edata->trigger_schema);
 	pfree(edata);
 }
 
@@ -1449,6 +1668,28 @@ ReThrowError(ErrorData *edata)
 		newedata->context = pstrdup(newedata->context);
 	if (newedata->internalquery)
 		newedata->internalquery = pstrdup(newedata->internalquery);
+	if (newedata->column_name)
+		newedata->column_name = pstrdup(newedata->column_name);
+	if (newedata->table_name)
+		newedata->table_name = pstrdup(newedata->table_name);
+	if (newedata->schema_name)
+		newedata->schema_name = pstrdup(newedata->schema_name);
+	if (newedata->constraint_name)
+		newedata->constraint_name = pstrdup(newedata->constraint_name);
+	if (newedata->constraint_table)
+		newedata->constraint_table = pstrdup(newedata->constraint_table);
+	if (newedata->constraint_schema)
+		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+	if (newedata->routine_name)
+		newedata->routine_name = pstrdup(newedata->routine_name);
+	if (newedata->routine_schema)
+		newedata->routine_schema = pstrdup(newedata->routine_schema);
+	if (newedata->trigger_name)
+		newedata->trigger_name = pstrdup(newedata->trigger_name);
+	if (newedata->trigger_table)
+		newedata->trigger_table = pstrdup(newedata->trigger_table);
+	if (newedata->trigger_schema)
+		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
 
 	recursion_depth--;
 	PG_RE_THROW();
@@ -2259,6 +2500,39 @@ write_csvlog(ErrorData *edata)
 	/* application name */
 	if (application_name)
 		appendCSVLiteral(&buf, application_name);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->column_name);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->table_name);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->schema_name);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->constraint_name);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->constraint_table);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->constraint_schema);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->routine_name);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->routine_schema);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->trigger_name);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->trigger_table);
+	appendStringInfoChar(&buf, ',');
+
+	appendCSVLiteral(&buf, edata->trigger_schema);
 
 	appendStringInfoChar(&buf, '\n');
 
@@ -2377,6 +2651,83 @@ send_message_to_server_log(ErrorData *edata)
 				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
 								 edata->filename, edata->lineno);
 			}
+			if (edata->column_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("COLUMN NAME:  "));
+				append_with_tabs(&buf, edata->column_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->table_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TABLE NAME:  "));
+				append_with_tabs(&buf, edata->table_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->schema_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("SCHEMA NAME:  "));
+				append_with_tabs(&buf, edata->schema_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->constraint_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("CONSTRAINT NAME:  "));
+				append_with_tabs(&buf, edata->constraint_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->constraint_table)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("CONSTRAINT TABLE:  "));
+				append_with_tabs(&buf, edata->constraint_table);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->constraint_schema)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("CONSTRAINT SCHEMA:  "));
+				append_with_tabs(&buf, edata->constraint_schema);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->routine_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("ROUTINE NAME:  "));
+				append_with_tabs(&buf, edata->routine_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->routine_schema)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("ROUTINE SCHEMA:  "));
+				append_with_tabs(&buf, edata->routine_schema);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->trigger_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TRIGGER NAME:  "));
+				append_with_tabs(&buf, edata->trigger_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->trigger_table)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TRIGGER TABLE:  "));
+				append_with_tabs(&buf, edata->trigger_table);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->trigger_schema)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TRIGGER SCHEMA:  "));
+				append_with_tabs(&buf, edata->trigger_schema);
+				appendStringInfoChar(&buf, '\n');
+			}
 		}
 	}
 
@@ -2673,6 +3024,72 @@ send_message_to_frontend(ErrorData *edata)
 			err_sendstring(&msgbuf, edata->funcname);
 		}
 
+		if (edata->column_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+			err_sendstring(&msgbuf, edata->column_name);
+		}
+
+		if (edata->table_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+			err_sendstring(&msgbuf, edata->table_name);
+		}
+
+		if (edata->schema_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+			err_sendstring(&msgbuf, edata->schema_name);
+		}
+
+		if (edata->constraint_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+			err_sendstring(&msgbuf, edata->constraint_name);
+		}
+
+		if (edata->constraint_table)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_TABLE);
+			err_sendstring(&msgbuf, edata->constraint_table);
+		}
+
+		if (edata->constraint_schema)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_SCHEMA);
+			err_sendstring(&msgbuf, edata->constraint_schema);
+		}
+
+		if (edata->routine_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_NAME);
+			err_sendstring(&msgbuf, edata->routine_name);
+		}
+
+		if (edata->routine_schema)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_SCHEMA);
+			err_sendstring(&msgbuf, edata->routine_schema);
+		}
+
+		if (edata->trigger_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_NAME);
+			err_sendstring(&msgbuf, edata->trigger_name);
+		}
+
+		if (edata->trigger_table)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_TABLE);
+			err_sendstring(&msgbuf, edata->trigger_table);
+		}
+
+		if (edata->trigger_schema)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_SCHEMA);
+			err_sendstring(&msgbuf, edata->trigger_schema);
+		}
+
 		pq_sendbyte(&msgbuf, '\0');		/* terminator */
 	}
 	else
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index d5a2003..3a3c663 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -112,6 +112,7 @@
 #include "utils/memutils.h"
 #include "utils/pg_rusage.h"
 #include "utils/rel.h"
+#include "utils/relerror.h"
 #include "utils/sortsupport.h"
 #include "utils/tuplesort.h"
 
@@ -3090,7 +3091,8 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 						RelationGetRelationName(state->indexRel)),
 				 errdetail("Key %s is duplicated.",
 						   BuildIndexValueDescription(state->indexRel,
-													  values, isnull))));
+													  values, isnull)),
+				 errrelation(state->indexRel)));
 	}
 
 	/*
diff --git a/src/include/postgres_ext.h b/src/include/postgres_ext.h
index b6ebb7a..829114a 100644
--- a/src/include/postgres_ext.h
+++ b/src/include/postgres_ext.h
@@ -55,5 +55,16 @@ typedef unsigned int Oid;
 #define PG_DIAG_SOURCE_FILE		'F'
 #define PG_DIAG_SOURCE_LINE		'L'
 #define PG_DIAG_SOURCE_FUNCTION 'R'
+#define PG_DIAG_COLUMN_NAME	'c'
+#define PG_DIAG_TABLE_NAME	't'
+#define PG_DIAG_SCHEMA_NAME	's'
+#define PG_DIAG_CONSTRAINT_NAME		'n'
+#define PG_DIAG_CONSTRAINT_TABLE	'o'
+#define PG_DIAG_CONSTRAINT_SCHEMA	'm'
+#define PG_DIAG_ROUTINE_NAME		'r'
+#define PG_DIAG_ROUTINE_SCHEMA		'u'
+#define PG_DIAG_TRIGGER_NAME		'g'
+#define PG_DIAG_TRIGGER_TABLE		'i'
+#define PG_DIAG_TRIGGER_SCHEMA		'h'
 
 #endif
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 1bbfd2b..c897073 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -190,6 +190,8 @@ extern int	geterrcode(void);
 extern int	geterrposition(void);
 extern int	getinternalerrposition(void);
 
+extern int	erritem(int field, const char *str);
+
 
 /*----------
  * Old-style error reporting API: to be used in this way:
@@ -321,6 +323,17 @@ typedef struct ErrorData
 	char	   *detail_log;		/* detail error message for server log only */
 	char	   *hint;			/* hint message */
 	char	   *context;		/* context message */
+	char	   *column_name;		/* name of column */
+	char	   *table_name;			/* name of table */
+	char	   *schema_name;		/* name of schema */
+	char	   *constraint_name;		/* name of constraint */
+	char	   *constraint_table;		/* name of table related to constraint */
+	char	   *constraint_schema;		/* name of schema with constraint */
+	char	   *routine_name;		/* name of function that caused error */
+	char	   *routine_schema;		/* schema name of function that caused error */
+	char	   *trigger_name;		/* name of trigger that caused error */
+	char	   *trigger_table;		/* table of trigger that caused error */
+	char	   *trigger_schema;		/* schema of trigger that caused error */
 	int			cursorpos;		/* cursor index into query string */
 	int			internalpos;	/* cursor index into internalquery */
 	char	   *internalquery;	/* text of internally-generated query */
diff --git a/src/include/utils/relerror.h b/src/include/utils/relerror.h
new file mode 100644
index 0000000..357222e
--- /dev/null
+++ b/src/include/utils/relerror.h
@@ -0,0 +1,21 @@
+/*-------------------------------------------------------------------------
+ *
+ * relerror.h
+ *	  setting ErrorData fields related to Relation struct
+ *
+ * Copyright (c) 2007-2012, PostgreSQL Global Development Group
+ *
+ * src/include/utils/relerror.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef RELERROR_H
+#define RELERROR_H
+
+#include "utils/relcache.h"
+
+extern int errrelation_column(Relation rel, const char *colname);
+extern int errrelation(Relation rel);
+extern int errconstraint(Relation rel, const char *cname);
+
+#endif   /* RELERROR_H */
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index 173af2e..e83a8b7 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -980,6 +980,40 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 								  valf, vall);
 			appendPQExpBufferChar(&workBuf, '\n');
 		}
+
+		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("COLUMN NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TABLE NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("SCHEMA NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_TABLE);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT TABLE:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_SCHEMA);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT SCHEMA:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_ROUTINE_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("ROUTINE NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_ROUTINE_SCHEMA);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("ROUTINE SCHEMA:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TRIGGER_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TRIGGER_TABLE);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER TABLE:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TRIGGER_SCHEMA);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER SCHEMA:  %s\n"), val);
 	}
 
 	/*

diff --git a/doc/src/sgml/plpgsql.sgml b/doc/src/sgml/plpgsql.sgml
index ba2c57b..a8f9a85 100644
--- a/doc/src/sgml/plpgsql.sgml
+++ b/doc/src/sgml/plpgsql.sgml
@@ -2640,6 +2640,61 @@ GET STACKED DIAGNOSTICS <replaceable>variable</replaceable> = <replaceable>item<
          <entry>text</entry>
          <entry>line(s) of text describing the call stack</entry>
         </row>
+        <row>
+         <entry><literal>COLUMN_NAME</literal></entry>
+         <entry>text</entry>
+         <entry>the name of column related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>TABLE_NAME</literal></entry>
+         <entry>text</entry>
+         <entry>the name of table related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>SCHEMA_NAME</literal></entry>
+         <entry>text</entry>
+         <entry>the name table's schema related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>CONSTRAINT_NAME</literal></entry>
+         <entry>text</entry>
+         <entry>the name of constraint related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>CONSTRAINT_TABLE</literal></entry>
+         <entry>text</entry>
+         <entry>the table of constraint related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>CONSTRAINT_SCHEMA</literal></entry>
+         <entry>text</entry>
+         <entry>the constaint's schema related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>ROUTINE_NAME</literal></entry>
+         <entry>text</entry>
+         <entry>the name of routine related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>ROUTINE_SCHEMA</literal></entry>
+         <entry>text</entry>
+         <entry>the schema of routine related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>TRIGGER_NAME</literal></entry>
+         <entry>text</entry>
+         <entry>the name of trigger related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>TRIGGER_TABLE</literal></entry>
+         <entry>text</entry>
+         <entry>the table of trigger related to error, if any</entry>
+        </row>
+        <row>
+         <entry><literal>TRIGGER_SCHEMA</literal></entry>
+         <entry>text</entry>
+         <entry>the schema of trigger related to error, if any</entry>
+        </row>
        </tbody>
       </tgroup>
      </table>
@@ -3277,7 +3332,11 @@ RAISE NOTICE 'Calling cs_create_job(%)', v_job_id;
     class="parameter">expression</replaceable> items.  The allowed
     <replaceable class="parameter">option</replaceable> keywords are
     <literal>MESSAGE</>, <literal>DETAIL</>, <literal>HINT</>, and
-    <literal>ERRCODE</>, while each <replaceable
+    , <literal>COLUMN_NAME</>, <literal>TABLE_NAME</>,
+    <literal>SCHEMA_NAME</>, <literal>CONSTRAINT_NAME</>,
+    <literal>CONSTRAINT_TABLE</literal>, <literal>CONSTRAINT_SCHEMA</>, 
+    <literal>ROUTINE_NAME</>, <literal>ROUTINE_SCHEMA</>, <literal>TRIGGER_NAME</>,
+    <literal>TRIGGER_TABLE</literal>, <literal>TRIGGER_SCHEMA</> while each <replaceable
     class="parameter">expression</replaceable> can be any string-valued
     expression.
     <literal>MESSAGE</> sets the error message text (this option can't
@@ -3287,7 +3346,17 @@ RAISE NOTICE 'Calling cs_create_job(%)', v_job_id;
     <literal>HINT</> supplies a hint message.
     <literal>ERRCODE</> specifies the error code (SQLSTATE) to report,
     either by condition name as shown in <xref linkend="errcodes-appendix">,
-    or directly as a five-character SQLSTATE code.
+    or directly as a five-character SQLSTATE code. <literal>COLUMN_NAME</>
+    sets the name of column related to error. <literal>TABLE_NAME</>
+    sets the name of table related to error. <literal>SCHEMA_NAME</> sets
+    the schema of table related to error. <literal>CONSTRAINT_NAME</> sets
+    name of constraint. <literal>CONSTRAINT_TABLE</literal> sets a table
+    related to constraint. <literal>CONSTRAINT_SCHEMA</> sets a schema of constraint
+    related to error. <literal>ROUTINE_NAME</> sets a name of routine related
+    to error. <literal>ROUTINE_SCHEMA</> sets a schema of routine related to error.
+    <literal>TRIGGER_NAME</> sets a name of trigger related to error.
+    <literal>TRIGGER_TABLE</> sets a table of trigger related to error.
+    <literal>TRIGGER_SCHEMA</> sets a schema of trigger related to error.
    </para>
 
    <para>
diff --git a/src/pl/plpgsql/src/gram.y b/src/pl/plpgsql/src/gram.y
index 4b2dce8..e0e9970 100644
--- a/src/pl/plpgsql/src/gram.y
+++ b/src/pl/plpgsql/src/gram.y
@@ -259,6 +259,17 @@ static	List			*read_raise_options(void);
 %token <keyword>	K_DECLARE
 %token <keyword>	K_DEFAULT
 %token <keyword>	K_DETAIL
+%token <keyword>	K_DIAG_COLUMN_NAME
+%token <keyword>	K_DIAG_TABLE_NAME
+%token <keyword>	K_DIAG_SCHEMA_NAME
+%token <keyword>	K_DIAG_CONSTRAINT_NAME
+%token <keyword>	K_DIAG_CONSTRAINT_TABLE
+%token <keyword>	K_DIAG_CONSTRAINT_SCHEMA
+%token <keyword>	K_DIAG_ROUTINE_NAME
+%token <keyword>	K_DIAG_ROUTINE_SCHEMA
+%token <keyword>	K_DIAG_TRIGGER_NAME
+%token <keyword>	K_DIAG_TRIGGER_TABLE
+%token <keyword>	K_DIAG_TRIGGER_SCHEMA
 %token <keyword>	K_DIAGNOSTICS
 %token <keyword>	K_DUMP
 %token <keyword>	K_ELSE
@@ -877,6 +888,17 @@ stmt_getdiag	: K_GET getdiag_area_opt K_DIAGNOSTICS getdiag_list ';'
 								case PLPGSQL_GETDIAG_ERROR_HINT:
 								case PLPGSQL_GETDIAG_RETURNED_SQLSTATE:
 								case PLPGSQL_GETDIAG_MESSAGE_TEXT:
+								case PLPGSQL_GETDIAG_COLUMN_NAME:
+								case PLPGSQL_GETDIAG_TABLE_NAME:
+								case PLPGSQL_GETDIAG_SCHEMA_NAME:
+								case PLPGSQL_GETDIAG_CONSTRAINT_NAME:
+								case PLPGSQL_GETDIAG_CONSTRAINT_TABLE:
+								case PLPGSQL_GETDIAG_CONSTRAINT_SCHEMA:
+								case PLPGSQL_GETDIAG_ROUTINE_NAME:
+								case PLPGSQL_GETDIAG_ROUTINE_SCHEMA:
+								case PLPGSQL_GETDIAG_TRIGGER_NAME:
+								case PLPGSQL_GETDIAG_TRIGGER_TABLE:
+								case PLPGSQL_GETDIAG_TRIGGER_SCHEMA:
 									if (!new->is_stacked)
 										ereport(ERROR,
 												(errcode(ERRCODE_SYNTAX_ERROR),
@@ -956,6 +978,39 @@ getdiag_item :
 						else if (tok_is_keyword(tok, &yylval,
 												K_RETURNED_SQLSTATE, "returned_sqlstate"))
 							$$ = PLPGSQL_GETDIAG_RETURNED_SQLSTATE;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_COLUMN_NAME, "column_name"))
+							$$ = PLPGSQL_GETDIAG_COLUMN_NAME;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_TABLE_NAME, "table_name"))
+							$$ = PLPGSQL_GETDIAG_TABLE_NAME;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_SCHEMA_NAME, "schema_name"))
+							$$ = PLPGSQL_GETDIAG_SCHEMA_NAME;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_CONSTRAINT_NAME, "constraint_name"))
+							$$ = PLPGSQL_GETDIAG_CONSTRAINT_NAME;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_CONSTRAINT_TABLE, "constraint_table"))
+							$$ = PLPGSQL_GETDIAG_CONSTRAINT_TABLE;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_CONSTRAINT_SCHEMA, "constraint_schema"))
+							$$ = PLPGSQL_GETDIAG_CONSTRAINT_SCHEMA;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_ROUTINE_NAME, "routine_name"))
+							$$ = PLPGSQL_GETDIAG_ROUTINE_NAME;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_ROUTINE_SCHEMA, "routine_schema"))
+							$$ = PLPGSQL_GETDIAG_ROUTINE_SCHEMA;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_TRIGGER_NAME, "trigger_name"))
+							$$ = PLPGSQL_GETDIAG_TRIGGER_NAME;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_TRIGGER_TABLE, "trigger_table"))
+							$$ = PLPGSQL_GETDIAG_TRIGGER_TABLE;
+						else if (tok_is_keyword(tok, &yylval,
+												K_DIAG_TRIGGER_SCHEMA, "trigger_schema"))
+							$$ = PLPGSQL_GETDIAG_TRIGGER_SCHEMA;
 						else
 							yyerror("unrecognized GET DIAGNOSTICS item");
 					}
@@ -2204,7 +2259,11 @@ unreserved_keyword	:
 				| K_ALIAS
 				| K_ARRAY
 				| K_BACKWARD
+				| K_DIAG_COLUMN_NAME
 				| K_CONSTANT
+				| K_DIAG_CONSTRAINT_NAME
+				| K_DIAG_CONSTRAINT_TABLE
+				| K_DIAG_CONSTRAINT_SCHEMA
 				| K_CURRENT
 				| K_CURSOR
 				| K_DEBUG
@@ -2234,12 +2293,19 @@ unreserved_keyword	:
 				| K_RESULT_OID
 				| K_RETURNED_SQLSTATE
 				| K_REVERSE
+				| K_DIAG_ROUTINE_NAME
+				| K_DIAG_ROUTINE_SCHEMA
 				| K_ROW_COUNT
 				| K_ROWTYPE
+				| K_DIAG_SCHEMA_NAME
 				| K_SCROLL
 				| K_SLICE
 				| K_SQLSTATE
 				| K_STACKED
+				| K_DIAG_TABLE_NAME
+				| K_DIAG_TRIGGER_NAME
+				| K_DIAG_TRIGGER_TABLE
+				| K_DIAG_TRIGGER_SCHEMA
 				| K_TYPE
 				| K_USE_COLUMN
 				| K_USE_VARIABLE
@@ -3586,6 +3652,39 @@ read_raise_options(void)
 		else if (tok_is_keyword(tok, &yylval,
 								K_HINT, "hint"))
 			opt->opt_type = PLPGSQL_RAISEOPTION_HINT;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_COLUMN_NAME, "column_name"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_COLUMN_NAME;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_TABLE_NAME, "table_name"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_TABLE_NAME;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_SCHEMA_NAME, "schema_name"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_SCHEMA_NAME;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_CONSTRAINT_NAME, "constraint_name"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_CONSTRAINT_NAME;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_CONSTRAINT_TABLE, "constraint_table"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_CONSTRAINT_TABLE;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_CONSTRAINT_SCHEMA, "constraint_schema"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_CONSTRAINT_SCHEMA;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_ROUTINE_NAME, "routine_name"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_ROUTINE_NAME;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_ROUTINE_SCHEMA, "routine_schema"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_ROUTINE_SCHEMA;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_TRIGGER_NAME, "trigger_name"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_TRIGGER_NAME;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_TRIGGER_TABLE, "trigger_table"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_TRIGGER_TABLE;
+		else if (tok_is_keyword(tok, &yylval,
+								K_DIAG_TRIGGER_SCHEMA, "trigger_schema"))
+			opt->opt_type = PLPGSQL_RAISEOPTION_TRIGGER_SCHEMA;
 		else
 			yyerror("unrecognized RAISE statement option");
 
diff --git a/src/pl/plpgsql/src/pl_comp.c b/src/pl/plpgsql/src/pl_comp.c
index 5d2f818..eb20b7a 100644
--- a/src/pl/plpgsql/src/pl_comp.c
+++ b/src/pl/plpgsql/src/pl_comp.c
@@ -342,6 +342,9 @@ do_compile(FunctionCallInfo fcinfo,
 	compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);
 
 	function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
+	function->fn_name = pstrdup(NameStr(procStruct->proname));
+	function->fn_schema = get_namespace_name(procStruct->pronamespace);
+
 	function->fn_oid = fcinfo->flinfo->fn_oid;
 	function->fn_xmin = HeapTupleHeaderGetXmin(procTup->t_data);
 	function->fn_tid = procTup->t_self;
diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c
index 8ca791c..2549d60 100644
--- a/src/pl/plpgsql/src/pl_exec.c
+++ b/src/pl/plpgsql/src/pl_exec.c
@@ -567,6 +567,9 @@ plpgsql_exec_trigger(PLpgSQL_function *func,
 	else
 		elog(ERROR, "unrecognized trigger action: not INSERT, DELETE, or UPDATE");
 
+	estate.tg_name = trigdata->tg_trigger->tgname;
+	estate.tg_schema = get_namespace_name(RelationGetNamespace(trigdata->tg_relation));
+
 	/*
 	 * Assign the special tg_ variables
 	 */
@@ -782,6 +785,22 @@ plpgsql_exec_error_callback(void *arg)
 {
 	PLpgSQL_execstate *estate = (PLpgSQL_execstate *) arg;
 
+	/*
+	 * If we are on top of error callback stack, then set function and
+	 * trigger related diagnostics fields.
+	 */
+	if (error_context_stack->arg == arg)
+	{
+		erritem(PG_DIAG_ROUTINE_NAME, estate->func->fn_name);
+		erritem(PG_DIAG_ROUTINE_SCHEMA, estate->func->fn_schema);
+
+		if (estate->func->fn_is_trigger)
+		{
+			erritem(PG_DIAG_TRIGGER_NAME, estate->tg_name);
+			erritem(PG_DIAG_TRIGGER_SCHEMA, estate->tg_schema);
+		}
+	}
+
 	/* if we are doing RAISE, don't report its location */
 	if (estate->err_text == raise_skip_msg)
 		return;
@@ -1489,6 +1508,61 @@ exec_stmt_getdiag(PLpgSQL_execstate *estate, PLpgSQL_stmt_getdiag *stmt)
 									 estate->cur_error->message);
 				break;
 
+			case PLPGSQL_GETDIAG_COLUMN_NAME:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->column_name);
+				break;
+
+			case PLPGSQL_GETDIAG_TABLE_NAME:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->table_name);
+				break;
+
+			case PLPGSQL_GETDIAG_SCHEMA_NAME:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->schema_name);
+				break;
+
+			case PLPGSQL_GETDIAG_CONSTRAINT_NAME:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->constraint_name);
+				break;
+
+			case PLPGSQL_GETDIAG_CONSTRAINT_TABLE:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->constraint_table);
+				break;
+
+			case PLPGSQL_GETDIAG_CONSTRAINT_SCHEMA:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->constraint_schema);
+				break;
+
+			case PLPGSQL_GETDIAG_ROUTINE_NAME:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->routine_name);
+				break;
+
+			case PLPGSQL_GETDIAG_ROUTINE_SCHEMA:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->routine_schema);
+				break;
+
+			case PLPGSQL_GETDIAG_TRIGGER_NAME:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->trigger_name);
+				break;
+
+			case PLPGSQL_GETDIAG_TRIGGER_TABLE:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->trigger_table);
+				break;
+
+			case PLPGSQL_GETDIAG_TRIGGER_SCHEMA:
+				exec_assign_c_string(estate, var,
+									 estate->cur_error->trigger_schema);
+				break;
+
 			default:
 				elog(ERROR, "unrecognized diagnostic item kind: %d",
 					 diag_item->kind);
@@ -2666,6 +2740,17 @@ exec_stmt_raise(PLpgSQL_execstate *estate, PLpgSQL_stmt_raise *stmt)
 	char	   *err_message = NULL;
 	char	   *err_detail = NULL;
 	char	   *err_hint = NULL;
+	char	   *column_name = NULL;
+	char	   *table_name = NULL;
+	char	   *schema_name = NULL;
+	char	   *constraint_name = NULL;
+	char	   *constraint_table = NULL;
+	char	   *constraint_schema = NULL;
+	char	   *routine_name = NULL;
+	char	   *routine_schema = NULL;
+	char	   *trigger_name = NULL;
+	char	   *trigger_table = NULL;
+	char	   *trigger_schema = NULL;
 	ListCell   *lc;
 
 	/* RAISE with no parameters: re-throw current exception */
@@ -2805,6 +2890,94 @@ exec_stmt_raise(PLpgSQL_execstate *estate, PLpgSQL_stmt_raise *stmt)
 									"HINT")));
 				err_hint = pstrdup(extval);
 				break;
+			case PLPGSQL_RAISEOPTION_COLUMN_NAME:
+				if (column_name)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"COLUMN_NAME")));
+				column_name = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_TABLE_NAME:
+				if (table_name)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"TABLE_NAME")));
+				table_name = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_SCHEMA_NAME:
+				if (schema_name)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"SCHEMA_NAME")));
+				schema_name = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_CONSTRAINT_NAME:
+				if (constraint_name)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"CONSTRAINT_NAME")));
+				constraint_name = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_CONSTRAINT_TABLE:
+				if (constraint_table)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"CONSTRAINT_TABLE")));
+				constraint_table = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_CONSTRAINT_SCHEMA:
+				if (constraint_schema)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"CONSTRAINT_SCHEMA")));
+				constraint_schema = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_ROUTINE_NAME:
+				if (routine_name)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"ROUTINE_NAME")));
+				routine_name = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_ROUTINE_SCHEMA:
+				if (routine_schema)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"ROUTINE_SCHEMA")));
+				routine_schema = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_TRIGGER_NAME:
+				if (trigger_name)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"TRIGGER_NAME")));
+				trigger_name = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_TRIGGER_TABLE:
+				if (trigger_table)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"TRIGGER_TABLE")));
+				trigger_table = pstrdup(extval);
+				break;
+			case PLPGSQL_RAISEOPTION_TRIGGER_SCHEMA:
+				if (trigger_schema)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("RAISE option already specified: %s",
+									"TRIGGER_SCHEMA")));
+				trigger_schema = pstrdup(extval);
+				break;
 			default:
 				elog(ERROR, "unrecognized raise option: %d", opt->opt_type);
 		}
@@ -2837,7 +3010,18 @@ exec_stmt_raise(PLpgSQL_execstate *estate, PLpgSQL_stmt_raise *stmt)
 			(err_code ? errcode(err_code) : 0,
 			 errmsg_internal("%s", err_message),
 			 (err_detail != NULL) ? errdetail_internal("%s", err_detail) : 0,
-			 (err_hint != NULL) ? errhint("%s", err_hint) : 0));
+			 (err_hint != NULL) ? errhint("%s", err_hint) : 0,
+			 (column_name != NULL) ? erritem(PG_DIAG_COLUMN_NAME, column_name) : 0,
+			 (table_name != NULL) ? erritem(PG_DIAG_TABLE_NAME, table_name) : 0,
+			 (schema_name != NULL) ? erritem(PG_DIAG_SCHEMA_NAME, schema_name) : 0,
+			 (constraint_name != NULL) ? erritem(PG_DIAG_CONSTRAINT_NAME, constraint_name) : 0,
+			 (constraint_table != NULL) ? erritem(PG_DIAG_CONSTRAINT_TABLE, constraint_table) : 0,
+			 (constraint_schema != NULL) ? erritem(PG_DIAG_CONSTRAINT_SCHEMA, constraint_schema) : 0,
+			 (routine_name != NULL) ? erritem(PG_DIAG_ROUTINE_NAME, routine_name) : 0,
+			 (routine_schema != NULL) ? erritem(PG_DIAG_ROUTINE_SCHEMA, routine_schema) : 0,
+			 (trigger_name != NULL) ? erritem(PG_DIAG_TRIGGER_NAME, trigger_name) : 0,
+			 (trigger_table != NULL) ? erritem(PG_DIAG_TRIGGER_TABLE, trigger_table) : 0,
+			 (trigger_schema != NULL) ? erritem(PG_DIAG_TRIGGER_SCHEMA, trigger_schema) : 0));
 
 	estate->err_text = NULL;	/* un-suppress... */
 
@@ -2849,6 +3033,28 @@ exec_stmt_raise(PLpgSQL_execstate *estate, PLpgSQL_stmt_raise *stmt)
 		pfree(err_detail);
 	if (err_hint != NULL)
 		pfree(err_hint);
+	if (column_name != NULL)
+		pfree(column_name);
+	if (table_name != NULL)
+		pfree(table_name);
+	if (schema_name != NULL)
+		pfree(schema_name);
+	if (constraint_name != NULL)
+		pfree(constraint_name);
+	if (constraint_table != NULL)
+		pfree(constraint_table);
+	if (constraint_schema != NULL)
+		pfree(constraint_schema);
+	if (routine_name != NULL)
+		pfree(routine_name);
+	if (routine_schema != NULL)
+		pfree(routine_schema);
+	if (trigger_name != NULL)
+		pfree(trigger_name);
+	if (trigger_table != NULL)
+		pfree(trigger_table);
+	if (trigger_schema != NULL)
+		pfree(trigger_schema);
 
 	return PLPGSQL_RC_OK;
 }
@@ -2930,6 +3136,9 @@ plpgsql_estate_setup(PLpgSQL_execstate *estate,
 		if ((*plugin_ptr)->func_setup)
 			((*plugin_ptr)->func_setup) (estate, func);
 	}
+
+	estate->tg_name = NULL;
+	estate->tg_schema = NULL;
 }
 
 /* ----------
diff --git a/src/pl/plpgsql/src/pl_funcs.c b/src/pl/plpgsql/src/pl_funcs.c
index b5a72dd..b76bdca 100644
--- a/src/pl/plpgsql/src/pl_funcs.c
+++ b/src/pl/plpgsql/src/pl_funcs.c
@@ -287,6 +287,28 @@ plpgsql_getdiag_kindname(int kind)
 			return "RETURNED_SQLSTATE";
 		case PLPGSQL_GETDIAG_MESSAGE_TEXT:
 			return "MESSAGE_TEXT";
+		case PLPGSQL_GETDIAG_COLUMN_NAME:
+			return "COLUMN_NAME";
+		case PLPGSQL_GETDIAG_TABLE_NAME:
+			return "TABLE_NAME";
+		case PLPGSQL_GETDIAG_SCHEMA_NAME:
+			return "SCHEMA_NAME";
+		case PLPGSQL_GETDIAG_CONSTRAINT_NAME:
+			return "CONSTRAINT_NAME";
+		case PLPGSQL_GETDIAG_CONSTRAINT_TABLE:
+			return "CONSTRAINT_TABLE";
+		case PLPGSQL_GETDIAG_CONSTRAINT_SCHEMA:
+			return "CONSTRAINT_SCHEMA";
+		case PLPGSQL_GETDIAG_ROUTINE_NAME:
+			return "ROUTINE_NAME";
+		case PLPGSQL_GETDIAG_ROUTINE_SCHEMA:
+			return "ROUTINE_SCHEMA";
+		case PLPGSQL_GETDIAG_TRIGGER_NAME:
+			return "TRIGGER_NAME";
+		case PLPGSQL_GETDIAG_TRIGGER_TABLE:
+			return "TRIGGER_TABLE";
+		case PLPGSQL_GETDIAG_TRIGGER_SCHEMA:
+			return "TRIGGER_SCHEMA";
 	}
 
 	return "unknown";
@@ -1317,6 +1339,39 @@ dump_raise(PLpgSQL_stmt_raise *stmt)
 				case PLPGSQL_RAISEOPTION_HINT:
 					printf("    HINT = ");
 					break;
+				case PLPGSQL_RAISEOPTION_COLUMN_NAME:
+					printf("    COLUMN_NAME = ");
+					break;
+				case PLPGSQL_RAISEOPTION_TABLE_NAME:
+					printf("    TABLE_NAME = ");
+					break;
+				case PLPGSQL_RAISEOPTION_SCHEMA_NAME:
+					printf("    SCHEMA_NAME = ");
+					break;
+				case PLPGSQL_RAISEOPTION_CONSTRAINT_NAME:
+					printf("    CONSTRAINT_NAME = ");
+					break;
+				case PLPGSQL_RAISEOPTION_CONSTRAINT_TABLE:
+					printf("    CONSTRAINT_TABLE = ");
+					break;
+				case PLPGSQL_RAISEOPTION_CONSTRAINT_SCHEMA:
+					printf("    CONSTRAINT_SCHEMA = ");
+					break;
+				case PLPGSQL_RAISEOPTION_ROUTINE_NAME:
+					printf("    ROUTINE_NAME = ");
+					break;
+				case PLPGSQL_RAISEOPTION_ROUTINE_SCHEMA:
+					printf("    ROUTINE_SCHEMA = ");
+					break;
+				case PLPGSQL_RAISEOPTION_TRIGGER_NAME:
+					printf("    TRIGGER_NAME = ");
+					break;
+				case PLPGSQL_RAISEOPTION_TRIGGER_TABLE:
+					printf("    TRIGGER_TABLE = ");
+					break;
+				case PLPGSQL_RAISEOPTION_TRIGGER_SCHEMA:
+					printf("    TRIGGER_SCHEMA = ");
+					break;
 			}
 			dump_expr(opt->expr);
 			printf("\n");
diff --git a/src/pl/plpgsql/src/pl_scanner.c b/src/pl/plpgsql/src/pl_scanner.c
index ebce3fd..600f294 100644
--- a/src/pl/plpgsql/src/pl_scanner.c
+++ b/src/pl/plpgsql/src/pl_scanner.c
@@ -109,7 +109,11 @@ static const ScanKeyword unreserved_keywords[] = {
 	PG_KEYWORD("alias", K_ALIAS, UNRESERVED_KEYWORD)
 	PG_KEYWORD("array", K_ARRAY, UNRESERVED_KEYWORD)
 	PG_KEYWORD("backward", K_BACKWARD, UNRESERVED_KEYWORD)
+	PG_KEYWORD("column_name", K_DIAG_COLUMN_NAME, UNRESERVED_KEYWORD)
 	PG_KEYWORD("constant", K_CONSTANT, UNRESERVED_KEYWORD)
+	PG_KEYWORD("constraint_name", K_DIAG_CONSTRAINT_NAME, UNRESERVED_KEYWORD)
+	PG_KEYWORD("constraint_schema", K_DIAG_CONSTRAINT_SCHEMA, UNRESERVED_KEYWORD)
+	PG_KEYWORD("constraint_table", K_DIAG_CONSTRAINT_TABLE, UNRESERVED_KEYWORD)
 	PG_KEYWORD("current", K_CURRENT, UNRESERVED_KEYWORD)
 	PG_KEYWORD("cursor", K_CURSOR, UNRESERVED_KEYWORD)
 	PG_KEYWORD("debug", K_DEBUG, UNRESERVED_KEYWORD)
@@ -139,12 +143,19 @@ static const ScanKeyword unreserved_keywords[] = {
 	PG_KEYWORD("result_oid", K_RESULT_OID, UNRESERVED_KEYWORD)
 	PG_KEYWORD("returned_sqlstate", K_RETURNED_SQLSTATE, UNRESERVED_KEYWORD)
 	PG_KEYWORD("reverse", K_REVERSE, UNRESERVED_KEYWORD)
+	PG_KEYWORD("routine_name", K_DIAG_ROUTINE_NAME, UNRESERVED_KEYWORD)
+	PG_KEYWORD("routine_schema", K_DIAG_ROUTINE_SCHEMA, UNRESERVED_KEYWORD)
 	PG_KEYWORD("row_count", K_ROW_COUNT, UNRESERVED_KEYWORD)
 	PG_KEYWORD("rowtype", K_ROWTYPE, UNRESERVED_KEYWORD)
+	PG_KEYWORD("schema_name", K_DIAG_SCHEMA_NAME, UNRESERVED_KEYWORD)
 	PG_KEYWORD("scroll", K_SCROLL, UNRESERVED_KEYWORD)
 	PG_KEYWORD("slice", K_SLICE, UNRESERVED_KEYWORD)
 	PG_KEYWORD("sqlstate", K_SQLSTATE, UNRESERVED_KEYWORD)
 	PG_KEYWORD("stacked", K_STACKED, UNRESERVED_KEYWORD)
+	PG_KEYWORD("table_name", K_DIAG_TABLE_NAME, UNRESERVED_KEYWORD)
+	PG_KEYWORD("trigger_name", K_DIAG_TRIGGER_NAME, UNRESERVED_KEYWORD)
+	PG_KEYWORD("trigger_schema", K_DIAG_TRIGGER_SCHEMA, UNRESERVED_KEYWORD)
+	PG_KEYWORD("trigger_table", K_DIAG_TRIGGER_TABLE, UNRESERVED_KEYWORD)
 	PG_KEYWORD("type", K_TYPE, UNRESERVED_KEYWORD)
 	PG_KEYWORD("use_column", K_USE_COLUMN, UNRESERVED_KEYWORD)
 	PG_KEYWORD("use_variable", K_USE_VARIABLE, UNRESERVED_KEYWORD)
diff --git a/src/pl/plpgsql/src/plpgsql.h b/src/pl/plpgsql/src/plpgsql.h
index b63f336..cac98e1 100644
--- a/src/pl/plpgsql/src/plpgsql.h
+++ b/src/pl/plpgsql/src/plpgsql.h
@@ -127,7 +127,18 @@ enum
 	PLPGSQL_GETDIAG_ERROR_DETAIL,
 	PLPGSQL_GETDIAG_ERROR_HINT,
 	PLPGSQL_GETDIAG_RETURNED_SQLSTATE,
-	PLPGSQL_GETDIAG_MESSAGE_TEXT
+	PLPGSQL_GETDIAG_MESSAGE_TEXT,
+	PLPGSQL_GETDIAG_COLUMN_NAME,
+	PLPGSQL_GETDIAG_TABLE_NAME,
+	PLPGSQL_GETDIAG_SCHEMA_NAME,
+	PLPGSQL_GETDIAG_CONSTRAINT_NAME,
+	PLPGSQL_GETDIAG_CONSTRAINT_TABLE,
+	PLPGSQL_GETDIAG_CONSTRAINT_SCHEMA,
+	PLPGSQL_GETDIAG_ROUTINE_NAME,
+	PLPGSQL_GETDIAG_ROUTINE_SCHEMA,
+	PLPGSQL_GETDIAG_TRIGGER_NAME,
+	PLPGSQL_GETDIAG_TRIGGER_TABLE,
+	PLPGSQL_GETDIAG_TRIGGER_SCHEMA
 };
 
 /* --------
@@ -139,7 +150,18 @@ enum
 	PLPGSQL_RAISEOPTION_ERRCODE,
 	PLPGSQL_RAISEOPTION_MESSAGE,
 	PLPGSQL_RAISEOPTION_DETAIL,
-	PLPGSQL_RAISEOPTION_HINT
+	PLPGSQL_RAISEOPTION_HINT,
+	PLPGSQL_RAISEOPTION_COLUMN_NAME,
+	PLPGSQL_RAISEOPTION_TABLE_NAME,
+	PLPGSQL_RAISEOPTION_SCHEMA_NAME,
+	PLPGSQL_RAISEOPTION_CONSTRAINT_NAME,
+	PLPGSQL_RAISEOPTION_CONSTRAINT_TABLE,
+	PLPGSQL_RAISEOPTION_CONSTRAINT_SCHEMA,
+	PLPGSQL_RAISEOPTION_ROUTINE_NAME,
+	PLPGSQL_RAISEOPTION_ROUTINE_SCHEMA,
+	PLPGSQL_RAISEOPTION_TRIGGER_NAME,
+	PLPGSQL_RAISEOPTION_TRIGGER_TABLE,
+	PLPGSQL_RAISEOPTION_TRIGGER_SCHEMA
 };
 
 /* --------
@@ -679,6 +701,8 @@ typedef struct PLpgSQL_func_hashkey
 typedef struct PLpgSQL_function
 {								/* Complete compiled function	  */
 	char	   *fn_signature;
+	char	   *fn_name;
+	char	   *fn_schema;
 	Oid			fn_oid;
 	TransactionId fn_xmin;
 	ItemPointerData fn_tid;
@@ -765,6 +789,10 @@ typedef struct PLpgSQL_execstate
 	const char *err_text;		/* additional state info */
 
 	void	   *plugin_info;	/* reserved for use by optional plugin */
+
+	/* trigger description */
+	char	*tg_name;
+	char	*tg_schema;
 } PLpgSQL_execstate;
 
 
diff --git a/src/test/regress/expected/plpgsql.out b/src/test/regress/expected/plpgsql.out
index fb47fa7..92f1d67 100644
--- a/src/test/regress/expected/plpgsql.out
+++ b/src/test/regress/expected/plpgsql.out
@@ -4719,3 +4719,68 @@ ERROR:  value for domain orderedarray violates check constraint "sorted"
 CONTEXT:  PL/pgSQL function testoa(integer,integer,integer) line 5 at assignment
 drop function arrayassign1();
 drop function testoa(x1 int, x2 int, x3 int);
+create function test_eelog_outer()
+returns void as $$
+declare
+  column_name text;
+  table_name text;
+  schema_name text;
+  constraint_name text;
+  constraint_table text;
+  constraint_schema text;
+  routine_name text;
+  routine_schema text;
+  trigger_name text;
+  trigger_table text;
+  trigger_schema text;
+begin
+  perform test_eelog_inner();
+exception when others then
+  get stacked diagnostics
+    column_name = column_name,
+    table_name = table_name,
+    schema_name = schema_name,
+    constraint_name = constraint_name,
+    constraint_table = constraint_table,
+    constraint_schema = constraint_schema,
+    routine_name = routine_name,
+    routine_schema = routine_schema,
+    trigger_name = trigger_name,
+    trigger_table = trigger_table,
+    trigger_schema = trigger_schema;
+
+  raise notice 'column name: "%":, table name: "%", schema name: "%"', column_name, table_name, schema_name;
+  raise notice 'constraint name: "%", constraint table: %, constraint schema: "%"', constraint_name, constraint_table, constraint_schema;
+  raise notice 'routine name: "%", routine schema: "%"', routine_name, routine_schema;
+  raise notice 'trigger name: "%", trigger table: %, trigger schema: "%"', trigger_name, trigger_table, trigger_schema;
+end;
+$$ language plpgsql;
+create function test_eelog_inner()
+returns void as $$
+begin
+  raise exception 'custom exception'
+    using column_name = 'some_column_name',
+          table_name = 'some_table_name',
+          schema_name = 'some_schema_name',
+          constraint_name = 'some_constraint_name',
+          constraint_table = 'some_constraint_table',
+          constraint_schema = 'some_constraint_schema',
+          routine_name = 'some_routine',
+          routine_schema = 'some_routine_schema',
+          trigger_name = 'some_trigger_name',
+          trigger_table = 'some_trigger_table',
+          trigger_schema = 'some_trigger_schema';
+end;
+$$ language plpgsql;
+select test_eelog_outer();
+NOTICE:  column name: "some_column_name":, table name: "some_table_name", schema name: "some_schema_name"
+NOTICE:  constraint name: "some_constraint_name", constraint table: some_constraint_table, constraint schema: "some_constraint_schema"
+NOTICE:  routine name: "some_routine", routine schema: "some_routine_schema"
+NOTICE:  trigger name: "some_trigger_name", trigger table: some_trigger_table, trigger schema: "some_trigger_schema"
+ test_eelog_outer 
+------------------
+ 
+(1 row)
+
+drop function test_eelog_outer();
+drop function test_eelog_inner();
diff --git a/src/test/regress/sql/plpgsql.sql b/src/test/regress/sql/plpgsql.sql
index 2b60b67..96a3d2e 100644
--- a/src/test/regress/sql/plpgsql.sql
+++ b/src/test/regress/sql/plpgsql.sql
@@ -3723,3 +3723,63 @@ select testoa(1,2,1); -- fail at update
 
 drop function arrayassign1();
 drop function testoa(x1 int, x2 int, x3 int);
+
+create function test_eelog_outer()
+returns void as $$
+declare
+  column_name text;
+  table_name text;
+  schema_name text;
+  constraint_name text;
+  constraint_table text;
+  constraint_schema text;
+  routine_name text;
+  routine_schema text;
+  trigger_name text;
+  trigger_table text;
+  trigger_schema text;
+begin
+  perform test_eelog_inner();
+exception when others then
+  get stacked diagnostics
+    column_name = column_name,
+    table_name = table_name,
+    schema_name = schema_name,
+    constraint_name = constraint_name,
+    constraint_table = constraint_table,
+    constraint_schema = constraint_schema,
+    routine_name = routine_name,
+    routine_schema = routine_schema,
+    trigger_name = trigger_name,
+    trigger_table = trigger_table,
+    trigger_schema = trigger_schema;
+
+  raise notice 'column name: "%":, table name: "%", schema name: "%"', column_name, table_name, schema_name;
+  raise notice 'constraint name: "%", constraint table: %, constraint schema: "%"', constraint_name, constraint_table, constraint_schema;
+  raise notice 'routine name: "%", routine schema: "%"', routine_name, routine_schema;
+  raise notice 'trigger name: "%", trigger table: %, trigger schema: "%"', trigger_name, trigger_table, trigger_schema;
+end;
+$$ language plpgsql;
+
+create function test_eelog_inner()
+returns void as $$
+begin
+  raise exception 'custom exception'
+    using column_name = 'some_column_name',
+          table_name = 'some_table_name',
+          schema_name = 'some_schema_name',
+          constraint_name = 'some_constraint_name',
+          constraint_table = 'some_constraint_table',
+          constraint_schema = 'some_constraint_schema',
+          routine_name = 'some_routine',
+          routine_schema = 'some_routine_schema',
+          trigger_name = 'some_trigger_name',
+          trigger_table = 'some_trigger_table',
+          trigger_schema = 'some_trigger_schema';
+end;
+$$ language plpgsql;
+
+select test_eelog_outer();
+
+drop function test_eelog_outer();
+drop function test_eelog_inner();

diff doc/src/sgml/config.sgml
index 4e0492b..ddaf900
*** a/doc/src/sgml/config.sgml
--- b/doc/src/sgml/config.sgml
*************** CREATE TABLE postgres_log
*** 4183,4188 ****
--- 4183,4198 ----
    query_pos integer,
    location text,
    application_name text,
+   column_name text,
+   table_name text,
+   schema_name text,
+   constraint_name text,
+   constraint_table text,
+   constraint_schema text,
+   routine_name text,
+   trigger_name text,
+   trigger_table text,
+   trigger_schema text,
    PRIMARY KEY (session_id, session_line_num)
  );
  </programlisting>
diff doc/src/sgml/protocol.sgml
index e725563..0c1042f
*** a/doc/src/sgml/protocol.sgml
--- b/doc/src/sgml/protocol.sgml
*************** message.
*** 4720,4732 ****
  </listitem>
  </varlistentry>

  </variablelist>

  <para>
  The client is responsible for formatting displayed information to meet its
  needs; in particular it should break long lines as needed.  Newline characters
  appearing in the error message fields should be treated as paragraph breaks,
! not line breaks.
  </para>

  </sect1>
--- 4720,4865 ----
  </listitem>
  </varlistentry>

+ <varlistentry>
+ <term>
+ <literal>c</>
+ </term>
+ <listitem>
+ <para>
+         Column name: the name of the column associated with the the error, if
+         any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>t</>
+ </term>
+ <listitem>
+ <para>
+         Table name: the name of the table associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>s</>
+ </term>
+ <listitem>
+ <para>
+         Schema name: the name of schema associated with the error.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>n</>
+ </term>
+ <listitem>
+ <para>
+         Constraint name: the name of the constraint associated with the error,
+         if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>o</>
+ </term>
+ <listitem>
+ <para>
+         Constraint table: the table name of the constraint associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>m</>
+ </term>
+ <listitem>
+ <para>
+         Constraint schema: the schema name of the constraint associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>r</>
+ </term>
+ <listitem>
+ <para>
+         Routine name: the name of the routine associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>u</>
+ </term>
+ <listitem>
+ <para>
+         Routine schema: the schema of the routine associated with the error, if
+         any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>g</>
+ </term>
+ <listitem>
+ <para>
+         Trigger name: the name of the trigger associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>i</>
+ </term>
+ <listitem>
+ <para>
+         Trigger table: the name of the table of the trigger associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <literal>h</>
+ </term>
+ <listitem>
+ <para>
+         Trigger schema: the schema name of the trigger associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+
  </variablelist>

  <para>
  The client is responsible for formatting displayed information to meet its
  needs; in particular it should break long lines as needed.  Newline characters
  appearing in the error message fields should be treated as paragraph breaks,
! not line breaks.  Note that certain object names represented as ErrorResponse
! fields, such as Trigger name, are not guaranteed to be unique across a database,
! and such objects cannot generally be uniquely identified by name alone.  It may
! be necessary in these cases to unambiguously establish the identity of the
! object of interest based on a unique combination of the object's name, schema
! name, and, in the case of integrity constraints, table name.
  </para>

  </sect1>
diff src/backend/access/nbtree/nbtinsert.c
index 3ed9b5c..9251508
*** a/src/backend/access/nbtree/nbtinsert.c
--- b/src/backend/access/nbtree/nbtinsert.c
*************** _bt_check_unique(Relation rel, IndexTupl
*** 393,399 ****
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull))));
  					}
  				}
  				else if (all_dead)
--- 393,400 ----
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull)),
! 								 errrel(rel)));
  					}
  				}
  				else if (all_dead)
*************** _bt_check_unique(Relation rel, IndexTupl
*** 455,461 ****
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression.")));

  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
--- 456,463 ----
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression."),
! 		errrel(rel)));

  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
*************** _bt_findinsertloc(Relation rel,
*** 533,539 ****
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing.")));

  	/*----------
  	 * If we will need to split the page to put the item on this page,
--- 535,542 ----
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing."),
! 			errrel(rel)));

  	/*----------
  	 * If we will need to split the page to put the item on this page,
diff src/backend/commands/tablecmds.c
index d69809a..679a89e
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
*************** ATRewriteTable(AlteredTableInfo *tab, Oi
*** 3805,3814 ****
  				int			attn = lfirst_int(l);

  				if (heap_attisnull(tuple, attn + 1))
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(newTupDesc->attrs[attn]->attname))));
  			}

  			foreach(l, tab->constraints)
--- 3805,3821 ----
  				int			attn = lfirst_int(l);

  				if (heap_attisnull(tuple, attn + 1))
+ 				{
+ 					Form_pg_attribute att	= newTupDesc->attrs[attn];
+
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(att->attname)),
! 							 (newrel) ?
! 								errrelcol(newrel, NameStr(att->attname)):
! 									errrelcol(oldrel, NameStr(att->attname))));
! 				}
  			}

  			foreach(l, tab->constraints)
*************** ATRewriteTable(AlteredTableInfo *tab, Oi
*** 3822,3828 ****
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
--- 3829,3841 ----
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name),
! 									 (newrel) ?
! 										errrel(newrel):
! 											errrel(oldrel),
! 									 (newrel) ?
! 										errconstraint(newrel, con->name):
! 											errconstraint(oldrel, con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
*************** validateCheckConstraint(Relation rel, He
*** 6632,6638 ****
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname))));

  		ResetExprContext(econtext);
  	}
--- 6645,6653 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname)),
! 					 errrel(rel),
! 					 errconstraint(rel, NameStr(constrForm->conname))));

  		ResetExprContext(econtext);
  	}
diff src/backend/commands/typecmds.c
index 30850b2..2dfc7c6
*** a/src/backend/commands/typecmds.c
--- b/src/backend/commands/typecmds.c
*************** AlterDomainNotNull(List *names, bool not
*** 2227,2239 ****
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];

  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 										RelationGetRelationName(testrel))));
  				}
  			}
  			heap_endscan(scan);
--- 2227,2240 ----
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
+ 					Form_pg_attribute att =	tupdesc->attrs[attnum - 1];

  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 									NameStr(att->attname), RelationGetRelationName(testrel)),
! 								 errrelcol(testrel, NameStr(att->attname))));
  				}
  			}
  			heap_endscan(scan);
*************** validateDomainConstraint(Oid domainoid,
*** 2602,2608 ****
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
  								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel))));
  			}

  			ResetExprContext(econtext);
--- 2603,2611 ----
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
  								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel)),
! 							 errrelcol(testrel,
! 								NameStr(tupdesc->attrs[attnum - 1]->attname))));
  			}

  			ResetExprContext(econtext);
diff src/backend/executor/execMain.c
index 440438b..dc2d516
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
*************** ExecConstraints(ResultRelInfo *resultRel
*** 1515,1528 ****

  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
! 			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
! 				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64))));
  		}
  	}

--- 1515,1530 ----

  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
! 			Form_pg_attribute Chk = rel->rd_att->attrs[attrChk - 1];
!
! 			if (Chk->attnotnull && slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 								NameStr(Chk->attname)),
  						 errdetail("Failing row contains %s.",
! 								ExecBuildSlotValueDescription(slot, 64)),
! 						 errrelcol(rel, NameStr(Chk->attname))));
  		}
  	}

*************** ExecConstraints(ResultRelInfo *resultRel
*** 1534,1542 ****
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
! 							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64))));
  	}
  }

--- 1536,1546 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
! 								RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 								ExecBuildSlotValueDescription(slot, 64)),
! 					 errrel(rel),
! 					 errconstraint(rel, failed)));
  	}
  }

diff src/backend/executor/execUtils.c
index 2bd8b42..59388c2
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
*************** retry:
*** 1304,1317 ****
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing)));
  	}

  	index_endscan(index_scan);
--- 1304,1319 ----
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							error_new, error_existing),
! 					 errrel(index)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing),
! 					 errrel(index)));
  	}

  	index_endscan(index_scan);
diff src/backend/utils/adt/ri_triggers.c
index 983f631..fa99ad8
*** a/src/backend/utils/adt/ri_triggers.c
--- b/src/backend/utils/adt/ri_triggers.c
*************** RI_FKey_check(TriggerData *trigdata)
*** 338,344 ****
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);

--- 338,346 ----
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 							 errrel(trigdata->tg_relation),
! 							 errconstraint(trigdata->tg_relation, NameStr(riinfo->conname))));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);

*************** RI_Initial_Check(Trigger *trigger, Relat
*** 2466,2472 ****
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));

  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
--- 2468,2477 ----
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 					 errrel(fk_rel),
! 					 errconstraint(fk_rel, NameStr(fake_riinfo.conname))));
!

  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
*************** ri_ReportViolation(const RI_ConstraintIn
*** 3218,3224 ****
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
--- 3223,3231 ----
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel)),
! 				 errrel(fk_rel),
! 				 errconstraint(fk_rel, NameStr(riinfo->conname))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
*************** ri_ReportViolation(const RI_ConstraintIn
*** 3226,3234 ****
  						RelationGetRelationName(pk_rel),
  						NameStr(riinfo->conname),
  						RelationGetRelationName(fk_rel)),
! 			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
! 					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel))));
  }


--- 3233,3243 ----
  						RelationGetRelationName(pk_rel),
  						NameStr(riinfo->conname),
  						RelationGetRelationName(fk_rel)),
! 				 errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
! 						  key_names.data, key_values.data,
! 						  RelationGetRelationName(fk_rel)),
! 				 errrel(pk_rel),
! 				 errconstraint(fk_rel, NameStr(riinfo->conname))));
  }


diff src/backend/utils/error/elog.c
index a40b343..f76e88d
*** a/src/backend/utils/error/elog.c
--- b/src/backend/utils/error/elog.c
***************
*** 75,82 ****
--- 75,84 ----
  #include "storage/proc.h"
  #include "tcop/tcopprot.h"
  #include "utils/guc.h"
+ #include "utils/lsyscache.h"
  #include "utils/memutils.h"
  #include "utils/ps_status.h"
+ #include "utils/rel.h"


  #undef _
*************** static int	syslog_facility = LOG_LOCAL0;
*** 129,134 ****
--- 131,139 ----
  static void write_syslog(int level, const char *line);
  #endif

+ static int	erritem(int field, const char *str);
+ static void	set_errdata_field(char **ptr, const char *str, bool overwrite);
+
  static void write_console(const char *line, int len);

  #ifdef WIN32
*************** errfinish(int dummy,...)
*** 477,482 ****
--- 482,509 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_table)
+ 		pfree(edata->constraint_table);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_table)
+ 		pfree(edata->trigger_table);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);

  	errordata_stack_depth--;

*************** internalerrquery(const char *query)
*** 1079,1084 ****
--- 1106,1248 ----
  }

  /*
+  * errrelcol --- sets column_name, table_name and schema_name of a column
+  * within errordata
+  */
+ int
+ errrelcol(Relation rel, const char *colname)
+ {
+ 	erritem(PG_DIAG_COLUMN_NAME, colname);
+ 	erritem(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+ 	erritem(PG_DIAG_SCHEMA_NAME,
+ 			get_namespace_name(RelationGetNamespace(rel)));
+
+ 	return 0;					/* return value does not matter */
+ }
+
+ /*
+  * errrel --- sets column_name, table_name and schema_name within errordata
+  */
+ int
+ errrel(Relation rel)
+ {
+ 	erritem(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+ 	erritem(PG_DIAG_SCHEMA_NAME,
+ 			get_namespace_name(RelationGetNamespace(rel)));
+
+ 	return 0;					/* return value does not matter */
+ }
+
+ /*
+  * errcontraint --- sets constraint_name, constraint_table and constraint_schema
+  * within errordata.
+  */
+ int
+ errconstraint(Relation rel, const char *cname)
+ {
+ 	erritem(PG_DIAG_CONSTRAINT_NAME, cname);
+ 	erritem(PG_DIAG_CONSTRAINT_TABLE, RelationGetRelationName(rel));
+ 	erritem(PG_DIAG_CONSTRAINT_SCHEMA,
+ 			get_namespace_name(RelationGetNamespace(rel)));
+
+ 	return 0;					/* return value does not matter */
+ }
+
+ /*
+  * erritem -- generic setting of ErrorData string fields
+  */
+ static int
+ erritem(int field, const char *str)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+
+ 	switch (field)
+ 	{
+ 		case PG_DIAG_MESSAGE_PRIMARY:
+ 			set_errdata_field(&edata->message, str, true);
+ 			break;
+ 		case PG_DIAG_MESSAGE_DETAIL:
+ 			set_errdata_field(&edata->detail, str, true);
+ 			break;
+ 		case PG_DIAG_MESSAGE_HINT:
+ 			set_errdata_field(&edata->hint, str, true);
+ 			break;
+ 		case PG_DIAG_CONTEXT:
+ 			set_errdata_field(&edata->context, str, true);
+ 			break;
+ 		case PG_DIAG_COLUMN_NAME:
+ 			set_errdata_field(&edata->column_name, str, true);
+ 			break;
+ 		case PG_DIAG_TABLE_NAME:
+ 			set_errdata_field(&edata->table_name, str, true);
+ 			break;
+ 		case PG_DIAG_SCHEMA_NAME:
+ 			set_errdata_field(&edata->schema_name, str, true);
+ 			break;
+ 		case PG_DIAG_CONSTRAINT_NAME:
+ 			set_errdata_field(&edata->constraint_name, str, true);
+ 			break;
+ 		case PG_DIAG_CONSTRAINT_TABLE:
+ 			set_errdata_field(&edata->constraint_table, str, true);
+ 			break;
+ 		case PG_DIAG_CONSTRAINT_SCHEMA:
+ 			set_errdata_field(&edata->constraint_schema, str, true);
+ 			break;
+
+ 		/*
+ 		 * The remaining fields, once set, will not be set again. We need to
+ 		 * guard against resetting here because there is partial redundancy in
+ 		 * the fields set between some of our potential callers, even though two
+ 		 * or more of them might reasonably coexist within the same ereport
+ 		 * call.
+ 		 */
+ 		case PG_DIAG_ROUTINE_NAME:
+ 			set_errdata_field(&edata->routine_name, str, false);
+ 			break;
+ 		case PG_DIAG_ROUTINE_SCHEMA:
+ 			set_errdata_field(&edata->routine_schema, str, false);
+ 			break;
+ 		case PG_DIAG_TRIGGER_NAME:
+ 			set_errdata_field(&edata->trigger_name, str, false);
+ 			break;
+ 		case PG_DIAG_TRIGGER_TABLE:
+ 			set_errdata_field(&edata->trigger_table, str, false);
+ 			break;
+ 		case PG_DIAG_TRIGGER_SCHEMA:
+ 			set_errdata_field(&edata->trigger_schema, str, false);
+ 			break;
+ 		default:
+ 			elog(ERROR, "unknown ErrorData field identifier %d", field);
+ 	}
+
+ 	return 0;			/* return value does not matter */
+ }
+
+ /*
+  * set_errdata_field --- set an ErrorData string field, while potentially
+  * avoiding overwriting any existing value
+  */
+ static void
+ set_errdata_field(char **ptr, const char *str, bool overwrite)
+ {
+ 	if (*ptr != NULL)
+ 	{
+ 		/* Avoid overwriting existing value entirely */
+ 		if (!overwrite)
+ 			return;
+
+ 		pfree(*ptr);
+ 		*ptr = NULL;
+ 	}
+
+ 	if (str != NULL)
+ 		*ptr = MemoryContextStrdup(ErrorContext, str);
+ }
+
+ /*
   * geterrcode --- return the currently set SQLSTATE error code
   *
   * This is only intended for use in error callback subroutines, since there
*************** CopyErrorData(void)
*** 1352,1357 ****
--- 1516,1543 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_table)
+ 		newedata->constraint_table = pstrdup(newedata->constraint_table);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_table)
+ 		newedata->trigger_table = pstrdup(newedata->trigger_table);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);

  	return newedata;
  }
*************** FreeErrorData(ErrorData *edata)
*** 1377,1382 ****
--- 1563,1590 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_table)
+ 		pfree(edata->constraint_table);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_table)
+ 		pfree(edata->trigger_table);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);
  	pfree(edata);
  }

*************** ReThrowError(ErrorData *edata)
*** 1449,1454 ****
--- 1657,1684 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_table)
+ 		newedata->constraint_table = pstrdup(newedata->constraint_table);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_table)
+ 		newedata->trigger_table = pstrdup(newedata->trigger_table);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);

  	recursion_depth--;
  	PG_RE_THROW();
*************** write_csvlog(ErrorData *edata)
*** 2259,2264 ****
--- 2489,2527 ----
  	/* application name */
  	if (application_name)
  		appendCSVLiteral(&buf, application_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->column_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->table_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->schema_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->constraint_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->constraint_table);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->constraint_schema);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->routine_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->routine_schema);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->trigger_name);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->trigger_table);
+ 	appendStringInfoChar(&buf, ',');
+
+ 	appendCSVLiteral(&buf, edata->trigger_schema);

  	appendStringInfoChar(&buf, '\n');

*************** send_message_to_server_log(ErrorData *ed
*** 2377,2382 ****
--- 2640,2722 ----
  				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
  								 edata->filename, edata->lineno);
  			}
+ 			if (edata->column_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("COLUMN NAME:  "));
+ 				append_with_tabs(&buf, edata->column_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TABLE NAME:  "));
+ 				append_with_tabs(&buf, edata->table_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->schema_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("SCHEMA NAME:  "));
+ 				append_with_tabs(&buf, edata->schema_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT NAME:  "));
+ 				append_with_tabs(&buf, edata->constraint_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_table)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT TABLE:  "));
+ 				append_with_tabs(&buf, edata->constraint_table);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->constraint_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE NAME:  "));
+ 				append_with_tabs(&buf, edata->routine_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->routine_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER NAME:  "));
+ 				append_with_tabs(&buf, edata->trigger_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_table)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER TABLE:  "));
+ 				append_with_tabs(&buf, edata->trigger_table);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->trigger_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
  		}
  	}

*************** send_message_to_frontend(ErrorData *edat
*** 2673,2678 ****
--- 3013,3084 ----
  			err_sendstring(&msgbuf, edata->funcname);
  		}

+ 		if (edata->column_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+ 			err_sendstring(&msgbuf, edata->column_name);
+ 		}
+
+ 		if (edata->table_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+ 			err_sendstring(&msgbuf, edata->table_name);
+ 		}
+
+ 		if (edata->schema_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+ 			err_sendstring(&msgbuf, edata->schema_name);
+ 		}
+
+ 		if (edata->constraint_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+ 			err_sendstring(&msgbuf, edata->constraint_name);
+ 		}
+
+ 		if (edata->constraint_table)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_TABLE);
+ 			err_sendstring(&msgbuf, edata->constraint_table);
+ 		}
+
+ 		if (edata->constraint_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->constraint_schema);
+ 		}
+
+ 		if (edata->routine_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_NAME);
+ 			err_sendstring(&msgbuf, edata->routine_name);
+ 		}
+
+ 		if (edata->routine_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->routine_schema);
+ 		}
+
+ 		if (edata->trigger_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_NAME);
+ 			err_sendstring(&msgbuf, edata->trigger_name);
+ 		}
+
+ 		if (edata->trigger_table)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_TABLE);
+ 			err_sendstring(&msgbuf, edata->trigger_table);
+ 		}
+
+ 		if (edata->trigger_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->trigger_schema);
+ 		}
+
  		pq_sendbyte(&msgbuf, '\0');		/* terminator */
  	}
  	else
diff src/backend/utils/sort/tuplesort.c
index d5a2003..5fce241
*** a/src/backend/utils/sort/tuplesort.c
--- b/src/backend/utils/sort/tuplesort.c
*************** comparetup_index_btree(const SortTuple *
*** 3090,3096 ****
  						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
  						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull))));
  	}

  	/*
--- 3090,3097 ----
  						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
  						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull)),
! 				 errrel(state->indexRel)));
  	}

  	/*
diff src/include/postgres_ext.h
index b6ebb7a..b37adf0
*** a/src/include/postgres_ext.h
--- b/src/include/postgres_ext.h
*************** typedef unsigned int Oid;
*** 55,59 ****
--- 55,70 ----
  #define PG_DIAG_SOURCE_FILE		'F'
  #define PG_DIAG_SOURCE_LINE		'L'
  #define PG_DIAG_SOURCE_FUNCTION 'R'
+ #define PG_DIAG_COLUMN_NAME			'c'
+ #define PG_DIAG_TABLE_NAME			't'
+ #define PG_DIAG_SCHEMA_NAME			's'
+ #define PG_DIAG_CONSTRAINT_NAME		'n'
+ #define PG_DIAG_CONSTRAINT_TABLE	'o'
+ #define PG_DIAG_CONSTRAINT_SCHEMA	'm'
+ #define PG_DIAG_ROUTINE_NAME		'r'
+ #define PG_DIAG_ROUTINE_SCHEMA		'u'
+ #define PG_DIAG_TRIGGER_NAME		'g'
+ #define PG_DIAG_TRIGGER_TABLE		'i'
+ #define PG_DIAG_TRIGGER_SCHEMA		'h'

  #endif
diff src/include/utils/elog.h
index 1bbfd2b..48e9afe
*** a/src/include/utils/elog.h
--- b/src/include/utils/elog.h
*************** extern int	errhidestmt(bool hide_stmt);
*** 183,188 ****
--- 183,195 ----
  extern int	errfunction(const char *funcname);
  extern int	errposition(int cursorpos);

+ /* Pre-declare Relation, in order to avoid a build dependency on rel.h. */
+ typedef struct RelationData *Relation;
+
+ extern int errrelcol(Relation rel, const char *colname);
+ extern int errrel(Relation rel);
+ extern int errconstraint(Relation rel, const char *cname);
+
  extern int	internalerrposition(int cursorpos);
  extern int	internalerrquery(const char *query);

*************** typedef struct ErrorData
*** 321,330 ****
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
! 	int			cursorpos;		/* cursor index into query string */
! 	int			internalpos;	/* cursor index into internalquery */
! 	char	   *internalquery;	/* text of internally-generated query */
! 	int			saved_errno;	/* errno at entry */
  } ErrorData;

  extern void EmitErrorReport(void);
--- 327,347 ----
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
! 	char	   *column_name;	/* name of column */
! 	char	   *table_name;		/* name of table */
! 	char	   *schema_name;	/* name of schema */
! 	char	   *constraint_name;		/* name of constraint */
! 	char	   *constraint_table;		/* name of table related to constraint */
! 	char	   *constraint_schema;		/* name of schema with constraint */
! 	char	   *routine_name;			/* name of function that caused error */
! 	char	   *routine_schema;			/* schema name of function that caused error */
! 	char	   *trigger_name;			/* name of trigger that caused error */
! 	char	   *trigger_table;			/* table of trigger that caused error */
! 	char	   *trigger_schema;			/* schema of trigger that caused error */
! 	int			cursorpos;				/* cursor index into query string */
! 	int			internalpos;			/* cursor index into internalquery */
! 	char	   *internalquery;			/* text of internally-generated query */
! 	int			saved_errno;			/* errno at entry */
  } ErrorData;

  extern void EmitErrorReport(void);
diff src/interfaces/libpq/fe-protocol3.c
index 173af2e..f2616b3
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 980,985 ****
--- 980,1029 ----
  								  valf, vall);
  			appendPQExpBufferChar(&workBuf, '\n');
  		}
+ 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("COLUMN NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TABLE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("SCHEMA NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_TABLE);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT TABLE:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("ROUTINE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("ROUTINE SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_TABLE);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER TABLE:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER SCHEMA:  %s\n"), val);
  	}

  	/*

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 3a0b16d..13c42fa 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -4153,6 +4153,16 @@ CREATE TABLE postgres_log
   query_pos integer,
   location text,
   application_name text,
+  column_name text,
+  table_name text,
+  schema_name text,
+  constraint_name text,
+  constraint_table text,
+  constraint_schema text,
+  routine_name text,
+  trigger_name text,
+  trigger_table text,
+  trigger_schema text,
   PRIMARY KEY (session_id, session_line_num)
 );
 </programlisting>
diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml
index e725563..6f34448 100644
--- a/doc/src/sgml/protocol.sgml
+++ b/doc/src/sgml/protocol.sgml
@@ -4720,6 +4720,127 @@ message.
 </listitem>
 </varlistentry>
 
+<varlistentry>
+<term>
+<literal>c</>
+</term>
+<listitem>
+<para>
+        Column name: the name of column related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>t</>
+</term>
+<listitem>
+<para>
+        Table name: the name of table related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>s</>
+</term>
+<listitem>
+<para>
+        Schema name: the name of schema related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>n</>
+</term>
+<listitem>
+<para>
+        Constraint name: the name of constraint related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>o</>
+</term>
+<listitem>
+<para>
+        Constraint table: the table name of constraint related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>m</>
+</term>
+<listitem>
+<para>
+        Constraint schema: the schema of constraint related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>r</>
+</term>
+<listitem>
+<para>
+        Routine name: the name of routine related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>u</>
+</term>
+<listitem>
+<para>
+        Routine schema: the schema of routine related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>g</>
+</term>
+<listitem>
+<para>
+        Trigger name: the name of trigger related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>i</>
+</term>
+<listitem>
+<para>
+        Trigger table: the table of trigger related to error
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>
+<literal>h</>
+</term>
+<listitem>
+<para>
+        Trigger schema: the schema of trigger related to error
+</para>
+</listitem>
+</varlistentry>
+
 </variablelist>
 
 <para>
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 3ed9b5c..7a5005f 100644
--- a/src/backend/access/nbtree/nbtinsert.c
+++ b/src/backend/access/nbtree/nbtinsert.c
@@ -393,7 +393,8 @@ _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
 										RelationGetRelationName(rel)),
 								 errdetail("Key %s already exists.",
 										   BuildIndexValueDescription(rel,
-														  values, isnull))));
+														  values, isnull)),
+								 errrelation(rel)));
 					}
 				}
 				else if (all_dead)
@@ -455,7 +456,8 @@ _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
 				(errcode(ERRCODE_INTERNAL_ERROR),
 				 errmsg("failed to re-find tuple within index \"%s\"",
 						RelationGetRelationName(rel)),
-		errhint("This may be because of a non-immutable index expression.")));
+		errhint("This may be because of a non-immutable index expression."),
+				 errrelation(rel)));
 
 	if (nbuf != InvalidBuffer)
 		_bt_relbuf(rel, nbuf);
@@ -533,7 +535,8 @@ _bt_findinsertloc(Relation rel,
 				   RelationGetRelationName(rel)),
 		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
 				"Consider a function index of an MD5 hash of the value, "
-				"or use full text indexing.")));
+				"or use full text indexing."),
+				errrelation(rel)));
 
 	/*----------
 	 * If we will need to split the page to put the item on this page,
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 70e408c..1b1877b 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -3808,6 +3808,10 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
 					ereport(ERROR,
 							(errcode(ERRCODE_NOT_NULL_VIOLATION),
 							 errmsg("column \"%s\" contains null values",
+								NameStr(newTupDesc->attrs[attn]->attname)),
+							 (newrel) ? errrelation_column(newrel,
+								NameStr(newTupDesc->attrs[attn]->attname)) :
+							errrelation_column(oldrel,
 								NameStr(newTupDesc->attrs[attn]->attname))));
 			}
 
@@ -3822,7 +3826,9 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
 							ereport(ERROR,
 									(errcode(ERRCODE_CHECK_VIOLATION),
 									 errmsg("check constraint \"%s\" is violated by some row",
-											con->name)));
+											con->name),
+						 (newrel) ? errrelation(newrel) : errrelation(oldrel),
+						 (newrel) ? errconstraint(newrel, con->name) : errconstraint(oldrel, con->name)));
 						break;
 					case CONSTR_FOREIGN:
 						/* Nothing to do here */
@@ -6619,7 +6625,9 @@ validateCheckConstraint(Relation rel, HeapTuple constrtup)
 			ereport(ERROR,
 					(errcode(ERRCODE_CHECK_VIOLATION),
 					 errmsg("check constraint \"%s\" is violated by some row",
-							NameStr(constrForm->conname))));
+							NameStr(constrForm->conname)),
+					 errrelation(rel),
+					 errconstraint(rel, NameStr(constrForm->conname))));
 
 		ResetExprContext(econtext);
 	}
diff --git a/src/backend/commands/typecmds.c b/src/backend/commands/typecmds.c
index 30850b2..0d78c34 100644
--- a/src/backend/commands/typecmds.c
+++ b/src/backend/commands/typecmds.c
@@ -2233,7 +2233,9 @@ AlterDomainNotNull(List *names, bool notNull)
 								(errcode(ERRCODE_NOT_NULL_VIOLATION),
 								 errmsg("column \"%s\" of table \"%s\" contains null values",
 								NameStr(tupdesc->attrs[attnum - 1]->attname),
-										RelationGetRelationName(testrel))));
+										RelationGetRelationName(testrel)),
+								 errrelation_column(testrel,
+								NameStr(tupdesc->attrs[attnum - 1]->attname))));
 				}
 			}
 			heap_endscan(scan);
@@ -2602,7 +2604,9 @@ validateDomainConstraint(Oid domainoid, char *ccbin)
 							(errcode(ERRCODE_CHECK_VIOLATION),
 							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
 								NameStr(tupdesc->attrs[attnum - 1]->attname),
-									RelationGetRelationName(testrel))));
+									RelationGetRelationName(testrel)),
+							errrelation_column(testrel,
+								NameStr(tupdesc->attrs[attnum - 1]->attname))));
 			}
 
 			ResetExprContext(econtext);
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index 440438b..607d661 100644
--- a/src/backend/executor/execMain.c
+++ b/src/backend/executor/execMain.c
@@ -1522,7 +1522,9 @@ ExecConstraints(ResultRelInfo *resultRelInfo,
 						 errmsg("null value in column \"%s\" violates not-null constraint",
 						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
 						 errdetail("Failing row contains %s.",
-								   ExecBuildSlotValueDescription(slot, 64))));
+								   ExecBuildSlotValueDescription(slot, 64)),
+						 errrelation_column(rel,
+							   NameStr(rel->rd_att->attrs[attrChk - 1]->attname))));
 		}
 	}
 
@@ -1536,7 +1538,9 @@ ExecConstraints(ResultRelInfo *resultRelInfo,
 					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
 							RelationGetRelationName(rel), failed),
 					 errdetail("Failing row contains %s.",
-							   ExecBuildSlotValueDescription(slot, 64))));
+							   ExecBuildSlotValueDescription(slot, 64)),
+					 errrelation(rel),
+					 errconstraint(rel, failed)));
 	}
 }
 
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 2bd8b42..805515e 100644
--- a/src/backend/executor/execUtils.c
+++ b/src/backend/executor/execUtils.c
@@ -1304,14 +1304,16 @@ retry:
 					 errmsg("could not create exclusion constraint \"%s\"",
 							RelationGetRelationName(index)),
 					 errdetail("Key %s conflicts with key %s.",
-							   error_new, error_existing)));
+							   error_new, error_existing),
+					 errrelation(index)));
 		else
 			ereport(ERROR,
 					(errcode(ERRCODE_EXCLUSION_VIOLATION),
 					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
 							RelationGetRelationName(index)),
 					 errdetail("Key %s conflicts with existing key %s.",
-							   error_new, error_existing)));
+							   error_new, error_existing),
+					 errrelation(index)));
 	}
 
 	index_endscan(index_scan);
diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c
index 983f631..11f431f 100644
--- a/src/backend/utils/adt/ri_triggers.c
+++ b/src/backend/utils/adt/ri_triggers.c
@@ -338,7 +338,9 @@ RI_FKey_check(TriggerData *trigdata)
 							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
 							  RelationGetRelationName(trigdata->tg_relation),
 									NameStr(riinfo->conname)),
-							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
+							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
+							 errrelation(trigdata->tg_relation),
+						   errconstraint(trigdata->tg_relation, NameStr(riinfo->conname))));
 					heap_close(pk_rel, RowShareLock);
 					return PointerGetDatum(NULL);
 
@@ -2466,7 +2468,10 @@ RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
 					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
 							RelationGetRelationName(fk_rel),
 							NameStr(fake_riinfo.conname)),
-					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
+					 errdetail("match full does not allow mixing of null and nonnull key values."),
+					 errrelation(fk_rel),
+					 errconstraint(fk_rel, NameStr(fake_riinfo.conname))));
+
 
 		/*
 		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
@@ -3218,7 +3223,9 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
 						NameStr(riinfo->conname)),
 				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
 						   key_names.data, key_values.data,
-						   RelationGetRelationName(pk_rel))));
+						   RelationGetRelationName(pk_rel)),
+				 errrelation(fk_rel),
+				 errconstraint(fk_rel, NameStr(riinfo->conname))));
 	else
 		ereport(ERROR,
 				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
@@ -3228,7 +3235,9 @@ ri_ReportViolation(const RI_ConstraintInfo *riinfo,
 						RelationGetRelationName(fk_rel)),
 			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
 					  key_names.data, key_values.data,
-					  RelationGetRelationName(fk_rel))));
+					  RelationGetRelationName(fk_rel)),
+				 errrelation(pk_rel),
+				 errconstraint(fk_rel, NameStr(riinfo->conname))));
 }
 
 
diff --git a/src/backend/utils/error/Makefile b/src/backend/utils/error/Makefile
index 4c313b7..c2ba4d0 100644
--- a/src/backend/utils/error/Makefile
+++ b/src/backend/utils/error/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/utils/error
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = assert.o elog.o
+OBJS = assert.o elog.o relerror.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index a40b343..9a47b99 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -477,6 +477,28 @@ errfinish(int dummy,...)
 		pfree(edata->context);
 	if (edata->internalquery)
 		pfree(edata->internalquery);
+	if (edata->column_name)
+		pfree(edata->column_name);
+	if (edata->table_name)
+		pfree(edata->table_name);
+	if (edata->schema_name)
+		pfree(edata->schema_name);
+	if (edata->constraint_name)
+		pfree(edata->constraint_name);
+	if (edata->constraint_table)
+		pfree(edata->constraint_table);
+	if (edata->constraint_schema)
+		pfree(edata->constraint_schema);
+	if (edata->routine_name)
+		pfree(edata->routine_name);
+	if (edata->routine_schema)
+		pfree(edata->routine_schema);
+	if (edata->trigger_name)
+		pfree(edata->trigger_name);
+	if (edata->trigger_table)
+		pfree(edata->trigger_table);
+	if (edata->trigger_schema)
+		pfree(edata->trigger_schema);
 
 	errordata_stack_depth--;
 
@@ -1079,6 +1101,116 @@ internalerrquery(const char *query)
 }
 
 /*
+ * set ErrorData field - ensure not overwriting for selected fields
+ */
+static void
+set_field(char **ptr, const char *str, bool overwrite)
+{
+	if (*ptr != NULL)
+	{
+		/*
+		 * for some cases like ROUTINE_NAME, ROUTINE_SCHEMA we would
+		 * to get the most older value.
+		 */
+		if (!overwrite)
+			return;
+
+		pfree(*ptr);
+		*ptr = NULL;
+	}
+
+	if (str != NULL)
+		*ptr = MemoryContextStrdup(ErrorContext, str);
+}
+
+/*
+ * err_generic_string -- generic setting of ErrorData string fields
+ */
+int
+err_generic_string(int field, const char *str)
+{
+	ErrorData  *edata = &errordata[errordata_stack_depth];
+
+	/* we don't bother incrementing recursion_depth */
+	CHECK_STACK_DEPTH();
+
+	switch (field)
+	{
+		case PG_DIAG_MESSAGE_PRIMARY:
+			set_field(&edata->message, str, true);
+			break;
+
+		case PG_DIAG_MESSAGE_DETAIL:
+			set_field(&edata->detail, str, true);
+			break;
+
+		case PG_DIAG_MESSAGE_HINT:
+			set_field(&edata->hint, str, true);
+			break;
+
+		case PG_DIAG_CONTEXT:
+			set_field(&edata->context, str, true);
+			break;
+
+		case PG_DIAG_COLUMN_NAME:
+			set_field(&edata->column_name, str, true);
+			break;
+
+		case PG_DIAG_TABLE_NAME:
+			set_field(&edata->table_name, str, true);
+			break;
+
+		case PG_DIAG_SCHEMA_NAME:
+			set_field(&edata->schema_name, str, true);
+			break;
+
+		case PG_DIAG_CONSTRAINT_NAME:
+			set_field(&edata->constraint_name, str, true);
+			break;
+
+		case PG_DIAG_CONSTRAINT_TABLE:
+			set_field(&edata->constraint_table, str, true);
+			break;
+
+		case PG_DIAG_CONSTRAINT_SCHEMA:
+			set_field(&edata->constraint_schema, str, true);
+			break;
+
+		/*
+		 * setup of routine_name, routine_schema, trigger_name,
+		 * trigger_table, trigger_schema is processed together
+		 * with collecting context. Only first values are valid,
+		 * so we should to protect these values.
+		 */
+		case PG_DIAG_ROUTINE_NAME:
+			set_field(&edata->routine_name, str, false);
+			break;
+
+		case PG_DIAG_ROUTINE_SCHEMA:
+			set_field(&edata->routine_schema, str, false);
+			break;
+
+		case PG_DIAG_TRIGGER_NAME:
+			set_field(&edata->trigger_name, str, false);
+			break;
+
+		case PG_DIAG_TRIGGER_TABLE:
+			set_field(&edata->trigger_table, str, false);
+			break;
+
+		case PG_DIAG_TRIGGER_SCHEMA:
+			set_field(&edata->trigger_schema, str, false);
+			break;
+
+		default:
+			elog(ERROR, "unknown ErrorData field id %d",
+						    field);
+	}
+
+	return 0;			/* return value does not matter */
+}
+
+/*
  * geterrcode --- return the currently set SQLSTATE error code
  *
  * This is only intended for use in error callback subroutines, since there
@@ -1352,6 +1484,28 @@ CopyErrorData(void)
 		newedata->context = pstrdup(newedata->context);
 	if (newedata->internalquery)
 		newedata->internalquery = pstrdup(newedata->internalquery);
+	if (newedata->column_name)
+		newedata->column_name = pstrdup(newedata->column_name);
+	if (newedata->table_name)
+		newedata->table_name = pstrdup(newedata->table_name);
+	if (newedata->schema_name)
+		newedata->schema_name = pstrdup(newedata->schema_name);
+	if (newedata->constraint_name)
+		newedata->constraint_name = pstrdup(newedata->constraint_name);
+	if (newedata->constraint_table)
+		newedata->constraint_table = pstrdup(newedata->constraint_table);
+	if (newedata->constraint_schema)
+		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+	if (newedata->routine_name)
+		newedata->routine_name = pstrdup(newedata->routine_name);
+	if (newedata->routine_schema)
+		newedata->routine_schema = pstrdup(newedata->routine_schema);
+	if (newedata->trigger_name)
+		newedata->trigger_name = pstrdup(newedata->trigger_name);
+	if (newedata->trigger_table)
+		newedata->trigger_table = pstrdup(newedata->trigger_table);
+	if (newedata->trigger_schema)
+		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
 
 	return newedata;
 }
@@ -1377,6 +1531,28 @@ FreeErrorData(ErrorData *edata)
 		pfree(edata->context);
 	if (edata->internalquery)
 		pfree(edata->internalquery);
+	if (edata->column_name)
+		pfree(edata->column_name);
+	if (edata->table_name)
+		pfree(edata->table_name);
+	if (edata->schema_name)
+		pfree(edata->schema_name);
+	if (edata->constraint_name)
+		pfree(edata->constraint_name);
+	if (edata->constraint_table)
+		pfree(edata->constraint_table);
+	if (edata->constraint_schema)
+		pfree(edata->constraint_schema);
+	if (edata->routine_name)
+		pfree(edata->routine_name);
+	if (edata->routine_schema)
+		pfree(edata->routine_schema);
+	if (edata->trigger_name)
+		pfree(edata->trigger_name);
+	if (edata->trigger_table)
+		pfree(edata->trigger_table);
+	if (edata->trigger_schema)
+		pfree(edata->trigger_schema);
 	pfree(edata);
 }
 
@@ -1449,6 +1625,28 @@ ReThrowError(ErrorData *edata)
 		newedata->context = pstrdup(newedata->context);
 	if (newedata->internalquery)
 		newedata->internalquery = pstrdup(newedata->internalquery);
+	if (newedata->column_name)
+		newedata->column_name = pstrdup(newedata->column_name);
+	if (newedata->table_name)
+		newedata->table_name = pstrdup(newedata->table_name);
+	if (newedata->schema_name)
+		newedata->schema_name = pstrdup(newedata->schema_name);
+	if (newedata->constraint_name)
+		newedata->constraint_name = pstrdup(newedata->constraint_name);
+	if (newedata->constraint_table)
+		newedata->constraint_table = pstrdup(newedata->constraint_table);
+	if (newedata->constraint_schema)
+		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+	if (newedata->routine_name)
+		newedata->routine_name = pstrdup(newedata->routine_name);
+	if (newedata->routine_schema)
+		newedata->routine_schema = pstrdup(newedata->routine_schema);
+	if (newedata->trigger_name)
+		newedata->trigger_name = pstrdup(newedata->trigger_name);
+	if (newedata->trigger_table)
+		newedata->trigger_table = pstrdup(newedata->trigger_table);
+	if (newedata->trigger_schema)
+		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
 
 	recursion_depth--;
 	PG_RE_THROW();
@@ -2238,7 +2436,7 @@ write_csvlog(ErrorData *edata)
 	appendStringInfoChar(&buf, ',');
 
 	/* file error location */
-	if (Log_error_verbosity >= PGERROR_VERBOSE)
+	
 	{
 		StringInfoData msgbuf;
 
@@ -2259,6 +2457,50 @@ write_csvlog(ErrorData *edata)
 	/* application name */
 	if (application_name)
 		appendCSVLiteral(&buf, application_name);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->column_name);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->table_name);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->schema_name);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->constraint_name);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->constraint_table);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->constraint_schema);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->routine_name);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->routine_schema);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->trigger_name);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->trigger_table);
+	appendStringInfoChar(&buf, ',');
+
+	if (Log_error_verbosity >= PGERROR_VERBOSE)
+		appendCSVLiteral(&buf, edata->trigger_schema);
 
 	appendStringInfoChar(&buf, '\n');
 
@@ -2377,6 +2619,83 @@ send_message_to_server_log(ErrorData *edata)
 				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
 								 edata->filename, edata->lineno);
 			}
+			if (edata->column_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("COLUMN NAME:  "));
+				append_with_tabs(&buf, edata->column_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->table_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TABLE NAME:  "));
+				append_with_tabs(&buf, edata->table_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->schema_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("SCHEMA NAME:  "));
+				append_with_tabs(&buf, edata->schema_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->constraint_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("CONSTRAINT NAME:  "));
+				append_with_tabs(&buf, edata->constraint_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->constraint_table)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("CONSTRAINT TABLE:  "));
+				append_with_tabs(&buf, edata->constraint_table);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->constraint_schema)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("CONSTRAINT SCHEMA:  "));
+				append_with_tabs(&buf, edata->constraint_schema);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->routine_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("ROUTINE NAME:  "));
+				append_with_tabs(&buf, edata->routine_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->routine_schema)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("ROUTINE SCHEMA:  "));
+				append_with_tabs(&buf, edata->routine_schema);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->trigger_name)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TRIGGER NAME:  "));
+				append_with_tabs(&buf, edata->trigger_name);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->trigger_table)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TRIGGER TABLE:  "));
+				append_with_tabs(&buf, edata->trigger_table);
+				appendStringInfoChar(&buf, '\n');
+			}
+			if (edata->trigger_schema)
+			{
+				log_line_prefix(&buf, edata);
+				appendStringInfoString(&buf, _("TRIGGER SCHEMA:  "));
+				append_with_tabs(&buf, edata->trigger_schema);
+				appendStringInfoChar(&buf, '\n');
+			}
 		}
 	}
 
@@ -2673,6 +2992,72 @@ send_message_to_frontend(ErrorData *edata)
 			err_sendstring(&msgbuf, edata->funcname);
 		}
 
+		if (edata->column_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+			err_sendstring(&msgbuf, edata->column_name);
+		}
+
+		if (edata->table_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+			err_sendstring(&msgbuf, edata->table_name);
+		}
+
+		if (edata->schema_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+			err_sendstring(&msgbuf, edata->schema_name);
+		}
+
+		if (edata->constraint_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+			err_sendstring(&msgbuf, edata->constraint_name);
+		}
+
+		if (edata->constraint_table)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_TABLE);
+			err_sendstring(&msgbuf, edata->constraint_table);
+		}
+
+		if (edata->constraint_schema)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_SCHEMA);
+			err_sendstring(&msgbuf, edata->constraint_schema);
+		}
+
+		if (edata->routine_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_NAME);
+			err_sendstring(&msgbuf, edata->routine_name);
+		}
+
+		if (edata->routine_schema)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_SCHEMA);
+			err_sendstring(&msgbuf, edata->routine_schema);
+		}
+
+		if (edata->trigger_name)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_NAME);
+			err_sendstring(&msgbuf, edata->trigger_name);
+		}
+
+		if (edata->trigger_table)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_TABLE);
+			err_sendstring(&msgbuf, edata->trigger_table);
+		}
+
+		if (edata->trigger_schema)
+		{
+			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_SCHEMA);
+			err_sendstring(&msgbuf, edata->trigger_schema);
+		}
+
 		pq_sendbyte(&msgbuf, '\0');		/* terminator */
 	}
 	else
diff --git a/src/backend/utils/error/relerror.c b/src/backend/utils/error/relerror.c
new file mode 100644
index 0000000..5e50333
--- /dev/null
+++ b/src/backend/utils/error/relerror.c
@@ -0,0 +1,61 @@
+/*-------------------------------------------------------------------------
+ *
+ * relerror.c
+ *	  relation error loging functions
+ *
+ *
+ * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *	  src/backend/utils/error/relerror.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "utils/elog.h"
+#include "utils/lsyscache.h"
+#include "utils/rel.h"
+
+/*
+ * Sets column_name, table_name and schema_name in ErrorData related to relation
+ */
+int
+errrelation_column(Relation rel, const char *colname)
+{
+	err_generic_string(PG_DIAG_COLUMN_NAME, colname);
+	err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+	err_generic_string(PG_DIAG_SCHEMA_NAME,
+			get_namespace_name(RelationGetNamespace(rel)));
+
+	return 0;
+}
+
+/*
+ * Sets column_name, table_name and schema_name in ErrorData related to relation
+ */
+int
+errrelation(Relation rel)
+{
+	err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+	err_generic_string(PG_DIAG_SCHEMA_NAME,
+			get_namespace_name(RelationGetNamespace(rel)));
+
+	return 0;
+}
+
+/*
+ * Sets constraint_name, constraint_table  and constraint_schema in ErrorData
+ */
+int
+errconstraint(Relation rel, const char *cname)
+{
+	err_generic_string(PG_DIAG_CONSTRAINT_NAME, cname);
+	err_generic_string(PG_DIAG_CONSTRAINT_TABLE, RelationGetRelationName(rel));
+	err_generic_string(PG_DIAG_CONSTRAINT_SCHEMA,
+			get_namespace_name(RelationGetNamespace(rel)));
+
+	return 0;
+}
diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index d5a2003..e6ecfeb 100644
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -3090,7 +3090,8 @@ comparetup_index_btree(const SortTuple *a, const SortTuple *b,
 						RelationGetRelationName(state->indexRel)),
 				 errdetail("Key %s is duplicated.",
 						   BuildIndexValueDescription(state->indexRel,
-													  values, isnull))));
+													  values, isnull)),
+				 errrelation(state->indexRel)));
 	}
 
 	/*
diff --git a/src/include/postgres_ext.h b/src/include/postgres_ext.h
index b6ebb7a..829114a 100644
--- a/src/include/postgres_ext.h
+++ b/src/include/postgres_ext.h
@@ -55,5 +55,16 @@ typedef unsigned int Oid;
 #define PG_DIAG_SOURCE_FILE		'F'
 #define PG_DIAG_SOURCE_LINE		'L'
 #define PG_DIAG_SOURCE_FUNCTION 'R'
+#define PG_DIAG_COLUMN_NAME	'c'
+#define PG_DIAG_TABLE_NAME	't'
+#define PG_DIAG_SCHEMA_NAME	's'
+#define PG_DIAG_CONSTRAINT_NAME		'n'
+#define PG_DIAG_CONSTRAINT_TABLE	'o'
+#define PG_DIAG_CONSTRAINT_SCHEMA	'm'
+#define PG_DIAG_ROUTINE_NAME		'r'
+#define PG_DIAG_ROUTINE_SCHEMA		'u'
+#define PG_DIAG_TRIGGER_NAME		'g'
+#define PG_DIAG_TRIGGER_TABLE		'i'
+#define PG_DIAG_TRIGGER_SCHEMA		'h'
 
 #endif
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 1bbfd2b..b96adf3 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -190,6 +190,8 @@ extern int	geterrcode(void);
 extern int	geterrposition(void);
 extern int	getinternalerrposition(void);
 
+extern int	err_generic_string(int field, const char *str);
+
 
 /*----------
  * Old-style error reporting API: to be used in this way:
@@ -321,6 +323,17 @@ typedef struct ErrorData
 	char	   *detail_log;		/* detail error message for server log only */
 	char	   *hint;			/* hint message */
 	char	   *context;		/* context message */
+	char	   *column_name;		/* name of column */
+	char	   *table_name;			/* name of table */
+	char	   *schema_name;		/* name of schema */
+	char	   *constraint_name;		/* name of constraint */
+	char	   *constraint_table;		/* name of table related to constraint */
+	char	   *constraint_schema;		/* name of schema with constraint */
+	char	   *routine_name;		/* name of function that caused error */
+	char	   *routine_schema;		/* schema name of function that caused error */
+	char	   *trigger_name;		/* name of trigger that caused error */
+	char	   *trigger_table;		/* table of trigger that caused error */
+	char	   *trigger_schema;		/* schema of trigger that caused error */
 	int			cursorpos;		/* cursor index into query string */
 	int			internalpos;	/* cursor index into internalquery */
 	char	   *internalquery;	/* text of internally-generated query */
diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
index 4669d8a..32dcae4 100644
--- a/src/include/utils/rel.h
+++ b/src/include/utils/rel.h
@@ -394,4 +394,9 @@ typedef struct StdRdOptions
 extern void RelationIncrementReferenceCount(Relation rel);
 extern void RelationDecrementReferenceCount(Relation rel);
 
+/* routines in utils/error/relerror.c */
+extern int errrelation_column(Relation rel, const char *colname);
+extern int errrelation(Relation rel);
+extern int errconstraint(Relation rel, const char *cname);
+
 #endif   /* REL_H */
diff --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index 173af2e..e83a8b7 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -980,6 +980,40 @@ pqGetErrorNotice3(PGconn *conn, bool isError)
 								  valf, vall);
 			appendPQExpBufferChar(&workBuf, '\n');
 		}
+
+		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("COLUMN NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TABLE NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("SCHEMA NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_TABLE);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT TABLE:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_SCHEMA);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("CONSTRAINT SCHEMA:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_ROUTINE_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("ROUTINE NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_ROUTINE_SCHEMA);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("ROUTINE SCHEMA:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TRIGGER_NAME);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER NAME:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TRIGGER_TABLE);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER TABLE:  %s\n"), val);
+		val = PQresultErrorField(res, PG_DIAG_TRIGGER_SCHEMA);
+		if (val)
+			appendPQExpBuffer(&workBuf, libpq_gettext("TRIGGER SCHEMA:  %s\n"), val);
 	}
 
 	/*

*** a/doc/src/sgml/config.sgml
--- b/doc/src/sgml/config.sgml
***************
*** 4165,4170 **** CREATE TABLE postgres_log
--- 4165,4180 ----
    query_pos integer,
    location text,
    application_name text,
+   column_name text,
+   table_name text,
+   schema_name text,
+   constraint_name text,
+   constraint_table text,
+   constraint_schema text,
+   routine_name text,
+   trigger_name text,
+   trigger_table text,
+   trigger_schema text,
    PRIMARY KEY (session_id, session_line_num)
  );
  </programlisting>
*** a/doc/src/sgml/protocol.sgml
--- b/doc/src/sgml/protocol.sgml
***************
*** 4720,4732 **** message.
  </listitem>
  </varlistentry>
  
  </variablelist>
  
  <para>
  The client is responsible for formatting displayed information to meet its
  needs; in particular it should break long lines as needed.  Newline characters
  appearing in the error message fields should be treated as paragraph breaks,
! not line breaks.
  </para>
  
  </sect1>
--- 4720,4865 ----
  </listitem>
  </varlistentry>
  
+ <varlistentry>
+ <term>
+ <literal>c</>
+ </term>
+ <listitem>
+ <para>
+         Column name: the name of the column associated with the the error, if
+         any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>t</>
+ </term>
+ <listitem>
+ <para>
+         Table name: the name of the table associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>s</>
+ </term>
+ <listitem>
+ <para>
+         Schema name: the name of schema associated with the error.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>n</>
+ </term>
+ <listitem>
+ <para>
+         Constraint name: the name of the constraint associated with the error,
+         if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>o</>
+ </term>
+ <listitem>
+ <para>
+         Constraint table: the table name of the constraint associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>m</>
+ </term>
+ <listitem>
+ <para>
+         Constraint schema: the schema name of the constraint associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>r</>
+ </term>
+ <listitem>
+ <para>
+         Routine name: the name of the routine associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>u</>
+ </term>
+ <listitem>
+ <para>
+         Routine schema: the schema of the routine associated with the error, if
+         any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>g</>
+ </term>
+ <listitem>
+ <para>
+         Trigger name: the name of the trigger associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>i</>
+ </term>
+ <listitem>
+ <para>
+         Trigger table: the name of the table of the trigger associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>h</>
+ </term>
+ <listitem>
+ <para>
+         Trigger schema: the schema name of the trigger associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
  </variablelist>
  
  <para>
  The client is responsible for formatting displayed information to meet its
  needs; in particular it should break long lines as needed.  Newline characters
  appearing in the error message fields should be treated as paragraph breaks,
! not line breaks. Note that certain object names represented as ErrorResponse
! fields, such as Trigger name, are not guaranteed to be unique across a database,
! and such objects cannot generally be uniquely identified by name alone.  It may
! be necessary in these cases to unambiguously establish the identity of the
! object of interest based on a unique combination of the object's name, schema
! name, and, in the case of integrity constraints, table name.
  </para>
  
  </sect1>
*** a/src/backend/access/nbtree/nbtinsert.c
--- b/src/backend/access/nbtree/nbtinsert.c
***************
*** 393,399 **** _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull))));
  					}
  				}
  				else if (all_dead)
--- 393,400 ----
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull)),
! 								 errrel(rel)));
  					}
  				}
  				else if (all_dead)
***************
*** 455,461 **** _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression.")));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
--- 456,463 ----
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression."),
! 				 errrel(rel)));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
***************
*** 533,539 **** _bt_findinsertloc(Relation rel,
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing.")));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
--- 535,542 ----
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing."),
! 				errrel(rel)));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 3805,3814 **** ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(newTupDesc->attrs[attn]->attname))));
  			}
  
  			foreach(l, tab->constraints)
--- 3805,3821 ----
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
+ 				{
+ 					Form_pg_attribute att	= newTupDesc->attrs[attn];
+ 
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(att->attname)),
! 							 (newrel) ?
! 								errrelcol(newrel, NameStr(att->attname)) :
! 									errrelcol(oldrel, NameStr(att->attname))));
! 				}
  			}
  
  			foreach(l, tab->constraints)
***************
*** 3822,3828 **** ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
--- 3829,3841 ----
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name),
! 									 (newrel) ?
! 										errrel(newrel) :
! 											errrel(oldrel),
! 									 (newrel) ?
! 										errconstraint(newrel, con->name) :
! 											errconstraint(oldrel, con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
***************
*** 6620,6626 **** validateCheckConstraint(Relation rel, HeapTuple constrtup)
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
--- 6633,6641 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname)),
! 					 errrel(rel),
! 					 errconstraint(rel, NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
*** a/src/backend/commands/typecmds.c
--- b/src/backend/commands/typecmds.c
***************
*** 2233,2245 **** AlterDomainNotNull(List *names, bool notNull)
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 										RelationGetRelationName(testrel))));
  				}
  			}
  			heap_endscan(scan);
--- 2233,2246 ----
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
+ 					Form_pg_attribute att = tupdesc->attrs[attnum - 1];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 									NameStr(att->attname), RelationGetRelationName(testrel)),
! 								 errrelcol(testrel, NameStr(att->attname))));
  				}
  			}
  			heap_endscan(scan);
***************
*** 2608,2614 **** validateDomainConstraint(Oid domainoid, char *ccbin)
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
  								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel))));
  			}
  
  			ResetExprContext(econtext);
--- 2609,2617 ----
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
  								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel)),
! 							errrelcol(testrel,
! 								NameStr(tupdesc->attrs[attnum - 1]->attname))));
  			}
  
  			ResetExprContext(econtext);
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1515,1528 **** ExecConstraints(ResultRelInfo *resultRelInfo,
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64))));
  		}
  	}
  
--- 1515,1531 ----
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
+ 			Form_pg_attribute Chk = rel->rd_att->attrs[attrChk - 1];
+ 
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 						  NameStr(Chk->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64)),
! 						 errrelcol(rel, NameStr(Chk->attname))));
  		}
  	}
  
***************
*** 1536,1542 **** ExecConstraints(ResultRelInfo *resultRelInfo,
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64))));
  	}
  }
  
--- 1539,1547 ----
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							ExecBuildSlotValueDescription(slot, 64)),
! 					 errrel(rel),
! 					 errconstraint(rel, failed)));
  	}
  }
  
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
***************
*** 1304,1317 **** retry:
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing)));
  	}
  
  	index_endscan(index_scan);
--- 1304,1319 ----
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing),
! 					 errrel(index)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing),
! 					 errrel(index)));
  	}
  
  	index_endscan(index_scan);
*** a/src/backend/utils/adt/ri_triggers.c
--- b/src/backend/utils/adt/ri_triggers.c
***************
*** 338,344 **** RI_FKey_check(TriggerData *trigdata)
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
--- 338,346 ----
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 							 errrel(trigdata->tg_relation),
! 							 errconstraint(trigdata->tg_relation, NameStr(riinfo->conname))));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
***************
*** 2466,2472 **** RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
--- 2468,2477 ----
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 					 errrel(fk_rel),
! 					 errconstraint(fk_rel, NameStr(fake_riinfo.conname))));
! 
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
***************
*** 3218,3224 **** ri_ReportViolation(const RI_ConstraintInfo *riinfo,
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
--- 3223,3231 ----
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel)),
! 				 errrel(fk_rel),
! 				 errconstraint(fk_rel, NameStr(riinfo->conname))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
***************
*** 3226,3234 **** ri_ReportViolation(const RI_ConstraintInfo *riinfo,
  						RelationGetRelationName(pk_rel),
  						NameStr(riinfo->conname),
  						RelationGetRelationName(fk_rel)),
! 			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
! 					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel))));
  }
  
  
--- 3233,3243 ----
  						RelationGetRelationName(pk_rel),
  						NameStr(riinfo->conname),
  						RelationGetRelationName(fk_rel)),
! 				 errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
! 						  key_names.data, key_values.data,
! 						  RelationGetRelationName(fk_rel)),
! 				 errrel(pk_rel),
! 				 errconstraint(fk_rel, NameStr(riinfo->conname))));
  }
  
  
*** a/src/backend/utils/error/Makefile
--- b/src/backend/utils/error/Makefile
***************
*** 12,17 **** subdir = src/backend/utils/error
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o relerror.o
  
  include $(top_srcdir)/src/backend/common.mk
*** a/src/backend/utils/error/elog.c
--- b/src/backend/utils/error/elog.c
***************
*** 131,136 **** static void write_syslog(int level, const char *line);
--- 131,139 ----
  
  static void write_console(const char *line, int len);
  
+ static void set_errdata_field(char **ptr, const char *str, bool overwrite);
+ 
+ 
  #ifdef WIN32
  extern char *event_source;
  static void write_eventlog(int level, const char *line, int len);
***************
*** 477,482 **** errfinish(int dummy,...)
--- 480,507 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_table)
+ 		pfree(edata->constraint_table);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_table)
+ 		pfree(edata->trigger_table);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);
  
  	errordata_stack_depth--;
  
***************
*** 1079,1084 **** internalerrquery(const char *query)
--- 1104,1218 ----
  }
  
  /*
+  * err_generic_string -- generic setting of ErrorData string fields
+  */
+ int
+ err_generic_string(int field, const char *str)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+ 
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+ 
+ 	switch (field)
+ 	{
+ 		case PG_DIAG_MESSAGE_PRIMARY:
+ 			set_errdata_field(&edata->message, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_DETAIL:
+ 			set_errdata_field(&edata->detail, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_HINT:
+ 			set_errdata_field(&edata->hint, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONTEXT:
+ 			set_errdata_field(&edata->context, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_COLUMN_NAME:
+ 			set_errdata_field(&edata->column_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_TABLE_NAME:
+ 			set_errdata_field(&edata->table_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_SCHEMA_NAME:
+ 			set_errdata_field(&edata->schema_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_NAME:
+ 			set_errdata_field(&edata->constraint_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_TABLE:
+ 			set_errdata_field(&edata->constraint_table, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_SCHEMA:
+ 			set_errdata_field(&edata->constraint_schema, str, true);
+ 			break;
+ 
+ 		/*
+ 		 * The remaining fields, once set, will not be set again. We need to
+ 		 * guard against resetting here because there is partial redundancy in
+ 		 * the fields set between some of our potential callers, even though two
+ 		 * or more of them might reasonably coexist within the same ereport
+ 		 * call.
+ 		 */
+ 		case PG_DIAG_ROUTINE_NAME:
+ 			set_errdata_field(&edata->routine_name, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_ROUTINE_SCHEMA:
+ 			set_errdata_field(&edata->routine_schema, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_TRIGGER_NAME:
+ 			set_errdata_field(&edata->trigger_name, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_TRIGGER_TABLE:
+ 			set_errdata_field(&edata->trigger_table, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_TRIGGER_SCHEMA:
+ 			set_errdata_field(&edata->trigger_schema, str, false);
+ 			break;
+ 
+ 		default:
+ 			elog(ERROR, "unknown ErrorData field id %d",
+ 						    field);
+ 	}
+ 
+ 	return 0;			/* return value does not matter */
+ }
+ 
+ /*
+  * set_errdata_field --- set an ErrorData string field, while potentially
+  * avoiding overwriting any existing value
+  */
+ static void
+ set_errdata_field(char **ptr, const char *str, bool overwrite)
+ {
+ 	if (*ptr != NULL)
+ 	{
+ 		/* Avoid overwriting existing value entirely */
+ 		if (!overwrite)
+ 			return;
+ 
+ 		pfree(*ptr);
+ 		*ptr = NULL;
+ 	}
+ 
+ 	if (str != NULL)
+ 		*ptr = MemoryContextStrdup(ErrorContext, str);
+ }
+ 
+ /*
   * geterrcode --- return the currently set SQLSTATE error code
   *
   * This is only intended for use in error callback subroutines, since there
***************
*** 1352,1357 **** CopyErrorData(void)
--- 1486,1513 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_table)
+ 		newedata->constraint_table = pstrdup(newedata->constraint_table);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_table)
+ 		newedata->trigger_table = pstrdup(newedata->trigger_table);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
  
  	return newedata;
  }
***************
*** 1377,1382 **** FreeErrorData(ErrorData *edata)
--- 1533,1560 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_table)
+ 		pfree(edata->constraint_table);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_table)
+ 		pfree(edata->trigger_table);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);
  	pfree(edata);
  }
  
***************
*** 1449,1454 **** ReThrowError(ErrorData *edata)
--- 1627,1654 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_table)
+ 		newedata->constraint_table = pstrdup(newedata->constraint_table);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_table)
+ 		newedata->trigger_table = pstrdup(newedata->trigger_table);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
  
  	recursion_depth--;
  	PG_RE_THROW();
***************
*** 2238,2244 **** write_csvlog(ErrorData *edata)
  	appendStringInfoChar(&buf, ',');
  
  	/* file error location */
- 	if (Log_error_verbosity >= PGERROR_VERBOSE)
  	{
  		StringInfoData msgbuf;
  
--- 2438,2443 ----
***************
*** 2259,2264 **** write_csvlog(ErrorData *edata)
--- 2458,2507 ----
  	/* application name */
  	if (application_name)
  		appendCSVLiteral(&buf, application_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->column_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->table_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->schema_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->constraint_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->constraint_table);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->constraint_schema);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->routine_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->routine_schema);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->trigger_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->trigger_table);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->trigger_schema);
  
  	appendStringInfoChar(&buf, '\n');
  
***************
*** 2377,2382 **** send_message_to_server_log(ErrorData *edata)
--- 2620,2702 ----
  				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
  								 edata->filename, edata->lineno);
  			}
+ 			if (edata->column_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("COLUMN NAME:  "));
+ 				append_with_tabs(&buf, edata->column_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TABLE NAME:  "));
+ 				append_with_tabs(&buf, edata->table_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->schema_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("SCHEMA NAME:  "));
+ 				append_with_tabs(&buf, edata->schema_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT NAME:  "));
+ 				append_with_tabs(&buf, edata->constraint_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_table)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT TABLE:  "));
+ 				append_with_tabs(&buf, edata->constraint_table);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->constraint_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE NAME:  "));
+ 				append_with_tabs(&buf, edata->routine_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->routine_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER NAME:  "));
+ 				append_with_tabs(&buf, edata->trigger_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_table)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER TABLE:  "));
+ 				append_with_tabs(&buf, edata->trigger_table);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->trigger_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
  		}
  	}
  
***************
*** 2673,2678 **** send_message_to_frontend(ErrorData *edata)
--- 2993,3064 ----
  			err_sendstring(&msgbuf, edata->funcname);
  		}
  
+ 		if (edata->column_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+ 			err_sendstring(&msgbuf, edata->column_name);
+ 		}
+ 
+ 		if (edata->table_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+ 			err_sendstring(&msgbuf, edata->table_name);
+ 		}
+ 
+ 		if (edata->schema_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+ 			err_sendstring(&msgbuf, edata->schema_name);
+ 		}
+ 
+ 		if (edata->constraint_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+ 			err_sendstring(&msgbuf, edata->constraint_name);
+ 		}
+ 
+ 		if (edata->constraint_table)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_TABLE);
+ 			err_sendstring(&msgbuf, edata->constraint_table);
+ 		}
+ 
+ 		if (edata->constraint_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->constraint_schema);
+ 		}
+ 
+ 		if (edata->routine_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_NAME);
+ 			err_sendstring(&msgbuf, edata->routine_name);
+ 		}
+ 
+ 		if (edata->routine_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->routine_schema);
+ 		}
+ 
+ 		if (edata->trigger_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_NAME);
+ 			err_sendstring(&msgbuf, edata->trigger_name);
+ 		}
+ 
+ 		if (edata->trigger_table)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_TABLE);
+ 			err_sendstring(&msgbuf, edata->trigger_table);
+ 		}
+ 
+ 		if (edata->trigger_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->trigger_schema);
+ 		}
+ 
  		pq_sendbyte(&msgbuf, '\0');		/* terminator */
  	}
  	else
*** a/src/backend/utils/sort/tuplesort.c
--- b/src/backend/utils/sort/tuplesort.c
***************
*** 3090,3096 **** comparetup_index_btree(const SortTuple *a, const SortTuple *b,
  						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
  						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull))));
  	}
  
  	/*
--- 3090,3097 ----
  						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
  						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull)),
! 				 errrel(state->indexRel)));
  	}
  
  	/*
*** a/src/include/postgres_ext.h
--- b/src/include/postgres_ext.h
***************
*** 55,59 **** typedef unsigned int Oid;
--- 55,70 ----
  #define PG_DIAG_SOURCE_FILE		'F'
  #define PG_DIAG_SOURCE_LINE		'L'
  #define PG_DIAG_SOURCE_FUNCTION 'R'
+ #define PG_DIAG_COLUMN_NAME			'c'
+ #define PG_DIAG_TABLE_NAME			't'
+ #define PG_DIAG_SCHEMA_NAME			's'
+ #define PG_DIAG_CONSTRAINT_NAME		'n'
+ #define PG_DIAG_CONSTRAINT_TABLE	'o'
+ #define PG_DIAG_CONSTRAINT_SCHEMA	'm'
+ #define PG_DIAG_ROUTINE_NAME		'r'
+ #define PG_DIAG_ROUTINE_SCHEMA		'u'
+ #define PG_DIAG_TRIGGER_NAME		'g'
+ #define PG_DIAG_TRIGGER_TABLE		'i'
+ #define PG_DIAG_TRIGGER_SCHEMA		'h'
  
  #endif
*** a/src/include/utils/elog.h
--- b/src/include/utils/elog.h
***************
*** 190,195 **** extern int	geterrcode(void);
--- 190,197 ----
  extern int	geterrposition(void);
  extern int	getinternalerrposition(void);
  
+ extern int	err_generic_string(int field, const char *str);
+ 
  
  /*----------
   * Old-style error reporting API: to be used in this way:
***************
*** 321,330 **** typedef struct ErrorData
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
! 	int			cursorpos;		/* cursor index into query string */
! 	int			internalpos;	/* cursor index into internalquery */
! 	char	   *internalquery;	/* text of internally-generated query */
! 	int			saved_errno;	/* errno at entry */
  } ErrorData;
  
  extern void EmitErrorReport(void);
--- 323,343 ----
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
! 	char	   *column_name;	/* name of column */
! 	char	   *table_name;		/* name of table */
! 	char	   *schema_name;	/* name of schema */
! 	char	   *constraint_name;		/* name of constraint */
! 	char	   *constraint_table;		/* name of table related to constraint */
! 	char	   *constraint_schema;		/* name of schema with constraint */
! 	char	   *routine_name;			/* name of function that caused error */
! 	char	   *routine_schema;			/* schema name of function that caused error */
! 	char	   *trigger_name;			/* name of trigger that caused error */
! 	char	   *trigger_table;			/* table of trigger that caused error */
! 	char	   *trigger_schema;			/* schema of trigger that caused error */
! 	int			cursorpos;				/* cursor index into query string */
! 	int			internalpos;			/* cursor index into internalquery */
! 	char	   *internalquery;			/* text of internally-generated query */
! 	int			saved_errno;			/* errno at entry */
  } ErrorData;
  
  extern void EmitErrorReport(void);
*** a/src/include/utils/rel.h
--- b/src/include/utils/rel.h
***************
*** 394,397 **** typedef struct StdRdOptions
--- 394,402 ----
  extern void RelationIncrementReferenceCount(Relation rel);
  extern void RelationDecrementReferenceCount(Relation rel);
  
+ /* routines in utils/error/relerror.c */
+ extern int errrelcol(Relation rel, const char *colname);
+ extern int errrel(Relation rel);
+ extern int errconstraint(Relation rel, const char *cname);
+ 
  #endif   /* REL_H */
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
***************
*** 938,943 **** pqGetErrorNotice3(PGconn *conn, bool isError)
--- 938,988 ----
  								  valf, vall);
  			appendPQExpBufferChar(&workBuf, '\n');
  		}
+ 
+ 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("COLUMN NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TABLE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("SCHEMA NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_TABLE);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT TABLE:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("ROUTINE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("ROUTINE SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_TABLE);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER TABLE:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER SCHEMA:  %s\n"), val);
  	}
  
  	/*

*** a/doc/src/sgml/config.sgml
--- b/doc/src/sgml/config.sgml
***************
*** 4258,4263 **** CREATE TABLE postgres_log
--- 4258,4273 ----
    query_pos integer,
    location text,
    application_name text,
+   column_name text,
+   table_name text,
+   schema_name text,
+   constraint_name text,
+   constraint_table text,
+   constraint_schema text,
+   routine_name text,
+   trigger_name text,
+   trigger_table text,
+   trigger_schema text,
    PRIMARY KEY (session_id, session_line_num)
  );
  </programlisting>
*** a/doc/src/sgml/protocol.sgml
--- b/doc/src/sgml/protocol.sgml
***************
*** 4722,4734 **** message.
  </listitem>
  </varlistentry>
  
  </variablelist>
  
  <para>
  The client is responsible for formatting displayed information to meet its
  needs; in particular it should break long lines as needed.  Newline characters
  appearing in the error message fields should be treated as paragraph breaks,
! not line breaks.
  </para>
  
  </sect1>
--- 4722,4867 ----
  </listitem>
  </varlistentry>
  
+ <varlistentry>
+ <term>
+ <literal>c</>
+ </term>
+ <listitem>
+ <para>
+         Column name: the name of the column associated with the the error, if
+         any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>t</>
+ </term>
+ <listitem>
+ <para>
+         Table name: the name of the table associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>s</>
+ </term>
+ <listitem>
+ <para>
+         Schema name: the name of schema associated with the error.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>n</>
+ </term>
+ <listitem>
+ <para>
+         Constraint name: the name of the constraint associated with the error,
+         if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>o</>
+ </term>
+ <listitem>
+ <para>
+         Constraint table: the table name of the constraint associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>m</>
+ </term>
+ <listitem>
+ <para>
+         Constraint schema: the schema name of the constraint associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>r</>
+ </term>
+ <listitem>
+ <para>
+         Routine name: the name of the routine associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>u</>
+ </term>
+ <listitem>
+ <para>
+         Routine schema: the schema of the routine associated with the error, if
+         any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>g</>
+ </term>
+ <listitem>
+ <para>
+         Trigger name: the name of the trigger associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>i</>
+ </term>
+ <listitem>
+ <para>
+         Trigger table: the name of the table of the trigger associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>h</>
+ </term>
+ <listitem>
+ <para>
+         Trigger schema: the schema name of the trigger associated with the
+         error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
  </variablelist>
  
  <para>
  The client is responsible for formatting displayed information to meet its
  needs; in particular it should break long lines as needed.  Newline characters
  appearing in the error message fields should be treated as paragraph breaks,
! not line breaks. Note that certain object names represented as ErrorResponse
! fields, such as Trigger name, are not guaranteed to be unique across a database,
! and such objects cannot generally be uniquely identified by name alone.  It may
! be necessary in these cases to unambiguously establish the identity of the
! object of interest based on a unique combination of the object's name, schema
! name, and, in the case of integrity constraints, table name.
  </para>
  
  </sect1>
*** a/src/backend/access/nbtree/nbtinsert.c
--- b/src/backend/access/nbtree/nbtinsert.c
***************
*** 393,399 **** _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull))));
  					}
  				}
  				else if (all_dead)
--- 393,400 ----
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull)),
! 								 errrel(rel)));
  					}
  				}
  				else if (all_dead)
***************
*** 455,461 **** _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression.")));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
--- 456,463 ----
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression."),
! 				 errrel(rel)));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
***************
*** 533,539 **** _bt_findinsertloc(Relation rel,
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing.")));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
--- 535,542 ----
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing."),
! 				errrel(rel)));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 3805,3814 **** ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(newTupDesc->attrs[attn]->attname))));
  			}
  
  			foreach(l, tab->constraints)
--- 3805,3821 ----
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
+ 				{
+ 					Form_pg_attribute att	= newTupDesc->attrs[attn];
+ 
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(att->attname)),
! 							 (newrel) ?
! 								errrelcol(newrel, NameStr(att->attname)) :
! 									errrelcol(oldrel, NameStr(att->attname))));
! 				}
  			}
  
  			foreach(l, tab->constraints)
***************
*** 3822,3828 **** ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
--- 3829,3841 ----
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name),
! 									 (newrel) ?
! 										errrel(newrel) :
! 											errrel(oldrel),
! 									 (newrel) ?
! 										errconstraint(newrel, con->name) :
! 											errconstraint(oldrel, con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
***************
*** 6620,6626 **** validateCheckConstraint(Relation rel, HeapTuple constrtup)
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
--- 6633,6641 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname)),
! 					 errrel(rel),
! 					 errconstraint(rel, NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
*** a/src/backend/commands/typecmds.c
--- b/src/backend/commands/typecmds.c
***************
*** 2235,2247 **** AlterDomainNotNull(List *names, bool notNull)
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 										RelationGetRelationName(testrel))));
  				}
  			}
  			heap_endscan(scan);
--- 2235,2248 ----
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
+ 					Form_pg_attribute att = tupdesc->attrs[attnum - 1];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 									NameStr(att->attname), RelationGetRelationName(testrel)),
! 								 errrelcol(testrel, NameStr(att->attname))));
  				}
  			}
  			heap_endscan(scan);
***************
*** 2610,2616 **** validateDomainConstraint(Oid domainoid, char *ccbin)
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
  								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel))));
  			}
  
  			ResetExprContext(econtext);
--- 2611,2619 ----
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
  								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel)),
! 							errrelcol(testrel,
! 								NameStr(tupdesc->attrs[attnum - 1]->attname))));
  			}
  
  			ResetExprContext(econtext);
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1516,1529 **** ExecConstraints(ResultRelInfo *resultRelInfo,
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64))));
  		}
  	}
  
--- 1516,1532 ----
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
+ 			Form_pg_attribute Chk = rel->rd_att->attrs[attrChk - 1];
+ 
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 						  NameStr(Chk->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64)),
! 						 errrelcol(rel, NameStr(Chk->attname))));
  		}
  	}
  
***************
*** 1537,1543 **** ExecConstraints(ResultRelInfo *resultRelInfo,
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64))));
  	}
  }
  
--- 1540,1548 ----
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							ExecBuildSlotValueDescription(slot, 64)),
! 					 errrel(rel),
! 					 errconstraint(rel, failed)));
  	}
  }
  
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
***************
*** 1304,1317 **** retry:
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing)));
  	}
  
  	index_endscan(index_scan);
--- 1304,1319 ----
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing),
! 					 errrel(index)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing),
! 					 errrel(index)));
  	}
  
  	index_endscan(index_scan);
*** a/src/backend/utils/adt/ri_triggers.c
--- b/src/backend/utils/adt/ri_triggers.c
***************
*** 339,345 **** RI_FKey_check(TriggerData *trigdata)
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
--- 339,347 ----
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 							 errrel(trigdata->tg_relation),
! 							 errconstraint(trigdata->tg_relation, NameStr(riinfo->conname))));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
***************
*** 2467,2473 **** RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
--- 2469,2478 ----
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 					 errrel(fk_rel),
! 					 errconstraint(fk_rel, NameStr(fake_riinfo.conname))));
! 
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
***************
*** 3219,3225 **** ri_ReportViolation(const RI_ConstraintInfo *riinfo,
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
--- 3224,3232 ----
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel)),
! 				 errrel(fk_rel),
! 				 errconstraint(fk_rel, NameStr(riinfo->conname))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
***************
*** 3227,3235 **** ri_ReportViolation(const RI_ConstraintInfo *riinfo,
  						RelationGetRelationName(pk_rel),
  						NameStr(riinfo->conname),
  						RelationGetRelationName(fk_rel)),
! 			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
! 					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel))));
  }
  
  
--- 3234,3244 ----
  						RelationGetRelationName(pk_rel),
  						NameStr(riinfo->conname),
  						RelationGetRelationName(fk_rel)),
! 				 errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
! 						  key_names.data, key_values.data,
! 						  RelationGetRelationName(fk_rel)),
! 				 errrel(pk_rel),
! 				 errconstraint(fk_rel, NameStr(riinfo->conname))));
  }
  
  
*** a/src/backend/utils/error/Makefile
--- b/src/backend/utils/error/Makefile
***************
*** 12,17 **** subdir = src/backend/utils/error
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o relerror.o
  
  include $(top_srcdir)/src/backend/common.mk
*** a/src/backend/utils/error/elog.c
--- b/src/backend/utils/error/elog.c
***************
*** 131,136 **** static void write_syslog(int level, const char *line);
--- 131,139 ----
  
  static void write_console(const char *line, int len);
  
+ static void set_errdata_field(char **ptr, const char *str, bool overwrite);
+ 
+ 
  #ifdef WIN32
  extern char *event_source;
  static void write_eventlog(int level, const char *line, int len);
***************
*** 477,482 **** errfinish(int dummy,...)
--- 480,507 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_table)
+ 		pfree(edata->constraint_table);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_table)
+ 		pfree(edata->trigger_table);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);
  
  	errordata_stack_depth--;
  
***************
*** 1079,1084 **** internalerrquery(const char *query)
--- 1104,1218 ----
  }
  
  /*
+  * err_generic_string -- generic setting of ErrorData string fields
+  */
+ int
+ err_generic_string(int field, const char *str)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+ 
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+ 
+ 	switch (field)
+ 	{
+ 		case PG_DIAG_MESSAGE_PRIMARY:
+ 			set_errdata_field(&edata->message, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_DETAIL:
+ 			set_errdata_field(&edata->detail, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_HINT:
+ 			set_errdata_field(&edata->hint, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONTEXT:
+ 			set_errdata_field(&edata->context, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_COLUMN_NAME:
+ 			set_errdata_field(&edata->column_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_TABLE_NAME:
+ 			set_errdata_field(&edata->table_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_SCHEMA_NAME:
+ 			set_errdata_field(&edata->schema_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_NAME:
+ 			set_errdata_field(&edata->constraint_name, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_TABLE:
+ 			set_errdata_field(&edata->constraint_table, str, true);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_SCHEMA:
+ 			set_errdata_field(&edata->constraint_schema, str, true);
+ 			break;
+ 
+ 		/*
+ 		 * The remaining fields, once set, will not be set again. We need to
+ 		 * guard against resetting here because there is partial redundancy in
+ 		 * the fields set between some of our potential callers, even though two
+ 		 * or more of them might reasonably coexist within the same ereport
+ 		 * call.
+ 		 */
+ 		case PG_DIAG_ROUTINE_NAME:
+ 			set_errdata_field(&edata->routine_name, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_ROUTINE_SCHEMA:
+ 			set_errdata_field(&edata->routine_schema, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_TRIGGER_NAME:
+ 			set_errdata_field(&edata->trigger_name, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_TRIGGER_TABLE:
+ 			set_errdata_field(&edata->trigger_table, str, false);
+ 			break;
+ 
+ 		case PG_DIAG_TRIGGER_SCHEMA:
+ 			set_errdata_field(&edata->trigger_schema, str, false);
+ 			break;
+ 
+ 		default:
+ 			elog(ERROR, "unknown ErrorData field id %d",
+ 						    field);
+ 	}
+ 
+ 	return 0;			/* return value does not matter */
+ }
+ 
+ /*
+  * set_errdata_field --- set an ErrorData string field, while potentially
+  * avoiding overwriting any existing value
+  */
+ static void
+ set_errdata_field(char **ptr, const char *str, bool overwrite)
+ {
+ 	if (*ptr != NULL)
+ 	{
+ 		/* Avoid overwriting existing value entirely */
+ 		if (!overwrite)
+ 			return;
+ 
+ 		pfree(*ptr);
+ 		*ptr = NULL;
+ 	}
+ 
+ 	if (str != NULL)
+ 		*ptr = MemoryContextStrdup(ErrorContext, str);
+ }
+ 
+ /*
   * geterrcode --- return the currently set SQLSTATE error code
   *
   * This is only intended for use in error callback subroutines, since there
***************
*** 1352,1357 **** CopyErrorData(void)
--- 1486,1513 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_table)
+ 		newedata->constraint_table = pstrdup(newedata->constraint_table);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_table)
+ 		newedata->trigger_table = pstrdup(newedata->trigger_table);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
  
  	return newedata;
  }
***************
*** 1377,1382 **** FreeErrorData(ErrorData *edata)
--- 1533,1560 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->constraint_table)
+ 		pfree(edata->constraint_table);
+ 	if (edata->constraint_schema)
+ 		pfree(edata->constraint_schema);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 	if (edata->trigger_table)
+ 		pfree(edata->trigger_table);
+ 	if (edata->trigger_schema)
+ 		pfree(edata->trigger_schema);
  	pfree(edata);
  }
  
***************
*** 1449,1454 **** ReThrowError(ErrorData *edata)
--- 1627,1654 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->constraint_table)
+ 		newedata->constraint_table = pstrdup(newedata->constraint_table);
+ 	if (newedata->constraint_schema)
+ 		newedata->constraint_schema = pstrdup(newedata->constraint_schema);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
+ 	if (newedata->trigger_table)
+ 		newedata->trigger_table = pstrdup(newedata->trigger_table);
+ 	if (newedata->trigger_schema)
+ 		newedata->trigger_schema = pstrdup(newedata->trigger_schema);
  
  	recursion_depth--;
  	PG_RE_THROW();
***************
*** 2238,2244 **** write_csvlog(ErrorData *edata)
  	appendStringInfoChar(&buf, ',');
  
  	/* file error location */
- 	if (Log_error_verbosity >= PGERROR_VERBOSE)
  	{
  		StringInfoData msgbuf;
  
--- 2438,2443 ----
***************
*** 2259,2264 **** write_csvlog(ErrorData *edata)
--- 2458,2507 ----
  	/* application name */
  	if (application_name)
  		appendCSVLiteral(&buf, application_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->column_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->table_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->schema_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->constraint_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->constraint_table);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->constraint_schema);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->routine_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->routine_schema);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->trigger_name);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->trigger_table);
+ 	appendStringInfoChar(&buf, ',');
+ 
+ 	if (Log_error_verbosity >= PGERROR_VERBOSE)
+ 		appendCSVLiteral(&buf, edata->trigger_schema);
  
  	appendStringInfoChar(&buf, '\n');
  
***************
*** 2377,2382 **** send_message_to_server_log(ErrorData *edata)
--- 2620,2702 ----
  				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
  								 edata->filename, edata->lineno);
  			}
+ 			if (edata->column_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("COLUMN NAME:  "));
+ 				append_with_tabs(&buf, edata->column_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TABLE NAME:  "));
+ 				append_with_tabs(&buf, edata->table_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->schema_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("SCHEMA NAME:  "));
+ 				append_with_tabs(&buf, edata->schema_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT NAME:  "));
+ 				append_with_tabs(&buf, edata->constraint_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_table)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT TABLE:  "));
+ 				append_with_tabs(&buf, edata->constraint_table);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->constraint_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("CONSTRAINT SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->constraint_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE NAME:  "));
+ 				append_with_tabs(&buf, edata->routine_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->routine_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("ROUTINE SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->routine_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER NAME:  "));
+ 				append_with_tabs(&buf, edata->trigger_name);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_table)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER TABLE:  "));
+ 				append_with_tabs(&buf, edata->trigger_table);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
+ 			if (edata->trigger_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfoString(&buf, _("TRIGGER SCHEMA:  "));
+ 				append_with_tabs(&buf, edata->trigger_schema);
+ 				appendStringInfoChar(&buf, '\n');
+ 			}
  		}
  	}
  
***************
*** 2673,2678 **** send_message_to_frontend(ErrorData *edata)
--- 2993,3064 ----
  			err_sendstring(&msgbuf, edata->funcname);
  		}
  
+ 		if (edata->column_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+ 			err_sendstring(&msgbuf, edata->column_name);
+ 		}
+ 
+ 		if (edata->table_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+ 			err_sendstring(&msgbuf, edata->table_name);
+ 		}
+ 
+ 		if (edata->schema_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+ 			err_sendstring(&msgbuf, edata->schema_name);
+ 		}
+ 
+ 		if (edata->constraint_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+ 			err_sendstring(&msgbuf, edata->constraint_name);
+ 		}
+ 
+ 		if (edata->constraint_table)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_TABLE);
+ 			err_sendstring(&msgbuf, edata->constraint_table);
+ 		}
+ 
+ 		if (edata->constraint_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->constraint_schema);
+ 		}
+ 
+ 		if (edata->routine_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_NAME);
+ 			err_sendstring(&msgbuf, edata->routine_name);
+ 		}
+ 
+ 		if (edata->routine_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->routine_schema);
+ 		}
+ 
+ 		if (edata->trigger_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_NAME);
+ 			err_sendstring(&msgbuf, edata->trigger_name);
+ 		}
+ 
+ 		if (edata->trigger_table)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_TABLE);
+ 			err_sendstring(&msgbuf, edata->trigger_table);
+ 		}
+ 
+ 		if (edata->trigger_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->trigger_schema);
+ 		}
+ 
  		pq_sendbyte(&msgbuf, '\0');		/* terminator */
  	}
  	else
*** /dev/null
--- b/src/backend/utils/error/relerror.c
***************
*** 0 ****
--- 1,63 ----
+ /*-------------------------------------------------------------------------
+  *
+  * relerror.c
+  *	  relation error loging functions
+  *
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *
+  * IDENTIFICATION
+  *	  src/backend/utils/error/relerror.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ #include "utils/elog.h"
+ #include "utils/lsyscache.h"
+ #include "utils/rel.h"
+ 
+ /*
+  * errrelcol --- sets column_name, table_name and schema_name of a column
+  * within errordata
+  */
+ int
+ errrelcol(Relation rel, const char *colname)
+ {
+ 	err_generic_string(PG_DIAG_COLUMN_NAME, colname);
+ 	err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+ 	err_generic_string(PG_DIAG_SCHEMA_NAME,
+ 			get_namespace_name(RelationGetNamespace(rel)));
+ 
+ 	return 0;
+ }
+ 
+ /*
+  * errrel --- sets column_name, table_name and schema_name within errordata
+  */
+ int
+ errrel(Relation rel)
+ {
+ 	err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(rel));
+ 	err_generic_string(PG_DIAG_SCHEMA_NAME,
+ 			get_namespace_name(RelationGetNamespace(rel)));
+ 
+ 	return 0;
+ }
+ 
+ /*
+  * errcontraint --- sets constraint_name, constraint_table and constraint_schema
+  * within errordata.
+  */
+ int
+ errconstraint(Relation rel, const char *cname)
+ {
+ 	err_generic_string(PG_DIAG_CONSTRAINT_NAME, cname);
+ 	err_generic_string(PG_DIAG_CONSTRAINT_TABLE, RelationGetRelationName(rel));
+ 	err_generic_string(PG_DIAG_CONSTRAINT_SCHEMA,
+ 			get_namespace_name(RelationGetNamespace(rel)));
+ 
+ 	return 0;
+ }
*** a/src/backend/utils/sort/tuplesort.c
--- b/src/backend/utils/sort/tuplesort.c
***************
*** 3091,3097 **** comparetup_index_btree(const SortTuple *a, const SortTuple *b,
  						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
  						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull))));
  	}
  
  	/*
--- 3091,3098 ----
  						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
  						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull)),
! 				 errrel(state->indexRel)));
  	}
  
  	/*
*** a/src/include/postgres_ext.h
--- b/src/include/postgres_ext.h
***************
*** 60,64 **** typedef PG_INT64_TYPE pg_int64;
--- 60,75 ----
  #define PG_DIAG_SOURCE_FILE		'F'
  #define PG_DIAG_SOURCE_LINE		'L'
  #define PG_DIAG_SOURCE_FUNCTION 'R'
+ #define PG_DIAG_COLUMN_NAME			'c'
+ #define PG_DIAG_TABLE_NAME			't'
+ #define PG_DIAG_SCHEMA_NAME			's'
+ #define PG_DIAG_CONSTRAINT_NAME		'n'
+ #define PG_DIAG_CONSTRAINT_TABLE	'o'
+ #define PG_DIAG_CONSTRAINT_SCHEMA	'm'
+ #define PG_DIAG_ROUTINE_NAME		'r'
+ #define PG_DIAG_ROUTINE_SCHEMA		'u'
+ #define PG_DIAG_TRIGGER_NAME		'g'
+ #define PG_DIAG_TRIGGER_TABLE		'i'
+ #define PG_DIAG_TRIGGER_SCHEMA		'h'
  
  #endif   /* POSTGRES_EXT_H */
*** a/src/include/utils/elog.h
--- b/src/include/utils/elog.h
***************
*** 195,200 **** extern int	geterrcode(void);
--- 195,202 ----
  extern int	geterrposition(void);
  extern int	getinternalerrposition(void);
  
+ extern int	err_generic_string(int field, const char *str);
+ 
  
  /*----------
   * Old-style error reporting API: to be used in this way:
***************
*** 326,335 **** typedef struct ErrorData
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
! 	int			cursorpos;		/* cursor index into query string */
! 	int			internalpos;	/* cursor index into internalquery */
! 	char	   *internalquery;	/* text of internally-generated query */
! 	int			saved_errno;	/* errno at entry */
  } ErrorData;
  
  extern void EmitErrorReport(void);
--- 328,348 ----
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
! 	char	   *column_name;	/* name of column */
! 	char	   *table_name;		/* name of table */
! 	char	   *schema_name;	/* name of schema */
! 	char	   *constraint_name;		/* name of constraint */
! 	char	   *constraint_table;		/* name of table related to constraint */
! 	char	   *constraint_schema;		/* name of schema with constraint */
! 	char	   *routine_name;			/* name of function that caused error */
! 	char	   *routine_schema;			/* schema name of function that caused error */
! 	char	   *trigger_name;			/* name of trigger that caused error */
! 	char	   *trigger_table;			/* table of trigger that caused error */
! 	char	   *trigger_schema;			/* schema of trigger that caused error */
! 	int			cursorpos;				/* cursor index into query string */
! 	int			internalpos;			/* cursor index into internalquery */
! 	char	   *internalquery;			/* text of internally-generated query */
! 	int			saved_errno;			/* errno at entry */
  } ErrorData;
  
  extern void EmitErrorReport(void);
*** a/src/include/utils/rel.h
--- b/src/include/utils/rel.h
***************
*** 394,397 **** typedef struct StdRdOptions
--- 394,402 ----
  extern void RelationIncrementReferenceCount(Relation rel);
  extern void RelationDecrementReferenceCount(Relation rel);
  
+ /* routines in utils/error/relerror.c */
+ extern int errrelcol(Relation rel, const char *colname);
+ extern int errrel(Relation rel);
+ extern int errconstraint(Relation rel, const char *cname);
+ 
  #endif   /* REL_H */
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
***************
*** 936,941 **** pqGetErrorNotice3(PGconn *conn, bool isError)
--- 936,986 ----
  								  valf, vall);
  			appendPQExpBufferChar(&workBuf, '\n');
  		}
+ 
+ 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("COLUMN NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TABLE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("SCHEMA NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_TABLE);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT TABLE:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("CONSTRAINT SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("ROUTINE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("ROUTINE SCHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_TABLE);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER TABLE:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 								libpq_gettext("TRIGGER SCHEMA:  %s\n"), val);
  	}
  
  	/*

diff doc/src/sgml/config.sgml
index b7df8ce..4b1179f
*** a/doc/src/sgml/config.sgml
--- b/doc/src/sgml/config.sgml
*************** FROM pg_stat_activity;
*** 4246,4255 ****
          error context,
          user query that led to the error (if any and enabled by
          <varname>log_min_error_statement</>),
!         character count of the error position therein,
!         location of the error in the PostgreSQL source code
!         (if <varname>log_error_verbosity</> is set to <literal>verbose</>),
!         and application name.
          Here is a sample table definition for storing CSV-format log output:
  
  <programlisting>
--- 4246,4256 ----
          error context,
          user query that led to the error (if any and enabled by
          <varname>log_min_error_statement</>),
!         character count of the error position therein, and, if
!         <varname>log_error_verbosity</> is set to <literal>verbose</>,
!         column name, table name, constraint name and location of the
!         error in the PostgreSQL source code.
!         Application name is also listed.
          Here is a sample table definition for storing CSV-format log output:
  
  <programlisting>
*************** CREATE TABLE postgres_log
*** 4277,4282 ****
--- 4278,4287 ----
    query text,
    query_pos integer,
    location text,
+   column_name text,
+   table_name text,
+   constraint_name text,
+   schema_name text,
    application_name text,
    PRIMARY KEY (session_id, session_line_num)
  );
diff doc/src/sgml/errcodes.sgml
index 16cb6c7..b3407ef
*** a/doc/src/sgml/errcodes.sgml
--- b/doc/src/sgml/errcodes.sgml
***************
*** 42,47 ****
--- 42,59 ----
   </para>
  
   <para>
+    A small number of error codes listed in
+    <xref linkend="errcodes-table"> are guaranteed to provide
+    additional fields to facilitate applications in recognizing
+    particular domain-specific errors, provided that the the errors are
+    emitted from within the PostgreSQL server itself (it is not
+    strictly guaranteed that an application will not emit an
+    ill-considered error without these field, but with an errorcode
+    documented as providing them).  These additional fields are not
+    described by the SQL standard.
+  </para>
+ 
+  <para>
    The symbol shown in the column <quote>Condition Name</quote> is also
    the condition name to use in <application>PL/pgSQL</>.  Condition
    names can be written in either upper or lower case.  (Note that
diff doc/src/sgml/generate-errcodes-table.pl
index b9c14d3..b4041a9
*** a/doc/src/sgml/generate-errcodes-table.pl
--- b/doc/src/sgml/generate-errcodes-table.pl
*************** while (<$errcodes>)
*** 41,46 ****
--- 41,71 ----
  		next;
  	}
  
+ 	# Emit requirement headers
+ 	if (/^Requirement:/)
+ 	{
+ 		# Replace the Requirement: string
+ 		s/^Requirement: /Provides: /;
+ 
+ 		# Replace "unused"
+ 		if (!s/unused/\(no fields\)/)
+ 		{
+ 			# Use literal for field names if appropriate
+ 			s/: (.*)/: <symbol>$1<\/symbol>/;
+ 		}
+ 
+ 		# Escape dashes for SGML
+ 		s/-/&mdash;/;
+ 
+ 		print "\n\n";
+ 		print "<row>\n";
+ 		print "<entry spanname=\"span12\">";
+ 		print "$_</entry>\n";
+ 		print "</row>\n";
+ 
+ 		next;
+ 	}
+ 
  	die unless /^([^\s]{5})\s+([EWS])\s+([^\s]+)(?:\s+)?([^\s]+)?/;
  
  	(my $sqlstate, my $type, my $errcode_macro, my $condition_name) =
diff doc/src/sgml/protocol.sgml
index f87020c..027c21f
*** a/doc/src/sgml/protocol.sgml
--- b/doc/src/sgml/protocol.sgml
*************** message.
*** 4729,4734 ****
--- 4729,4792 ----
  </listitem>
  </varlistentry>
  
+ <varlistentry>
+ <term>
+ <literal>c</>
+ </term>
+ <listitem>
+ <para>
+         Column name: the name of the column associated with the the
+         error, if any.  This must be a column within the table of the
+         Table name field.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>t</>
+ </term>
+ <listitem>
+ <para>
+         Table name: the name of the table associated with the error,
+         if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>n</>
+ </term>
+ <listitem>
+ <para>
+         Constraint name: the name of the constraint associated with
+         the error, if any.  Note that NOT NULL constraints are not
+         cataloged, and as such will never have a constraint name,
+         though in the case of NOT NULL constraints on columns the
+         column name will be available.  This value is not guaranteed
+         to uniquely identify the constraint.  Even when combined with
+         other fields, constraint name will not unambiguously identify
+         the constraint in all cases, since it is possible for the
+         constraint to be in a different schema to the table associated
+         with the error, or for the constraint to not be associated
+         with a table at all.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>s</>
+ </term>
+ <listitem>
+ <para>
+         Schema name: the name of schema that contains the table
+         associated with the error, if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
  </variablelist>
  
  <para>
diff src/backend/access/nbtree/nbtinsert.c
index 3ed9b5c..27ef0fe
*** a/src/backend/access/nbtree/nbtinsert.c
--- b/src/backend/access/nbtree/nbtinsert.c
*************** _bt_check_unique(Relation rel, IndexTupl
*** 393,399 ****
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull))));
  					}
  				}
  				else if (all_dead)
--- 393,401 ----
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 															values, isnull)),
! 								 errtable(heapRel),
! 								 errconstraint(RelationGetRelationName(rel))));
  					}
  				}
  				else if (all_dead)
*************** _bt_check_unique(Relation rel, IndexTupl
*** 455,461 ****
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression.")));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
--- 457,464 ----
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		 errhint("This may be because of a non-immutable index expression."),
! 				 errtable(heapRel)));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
*************** _bt_findinsertloc(Relation rel,
*** 533,539 ****
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing.")));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
--- 536,543 ----
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing."),
! 				 errtable(heapRel)));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
diff src/backend/commands/tablecmds.c
index 4065740..71f68f7
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
*************** ATRewriteTable(AlteredTableInfo *tab, Oi
*** 3803,3812 ****
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(newTupDesc->attrs[attn]->attname))));
  			}
  
  			foreach(l, tab->constraints)
--- 3803,3819 ----
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
+ 				{
+ 					Form_pg_attribute att = newTupDesc->attrs[attn];
+ 
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 									NameStr(att->attname)),
! 							 (newrel) ?
! 							 errtablecol(newrel, NameStr(att->attname)) :
! 							 errtablecol(oldrel, NameStr(att->attname))));
! 				}
  			}
  
  			foreach(l, tab->constraints)
*************** ATRewriteTable(AlteredTableInfo *tab, Oi
*** 3820,3826 ****
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
--- 3827,3837 ----
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name),
! 									 (newrel) ?
! 									 errtable(newrel) :
! 									 errtable(oldrel),
! 									 errconstraint(con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
*************** validateCheckConstraint(Relation rel, He
*** 6633,6639 ****
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
--- 6644,6652 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname)),
! 					 errtable(rel),
! 					 errconstraint(NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
diff src/backend/commands/typecmds.c
index 36de6d7..4b96d07
*** a/src/backend/commands/typecmds.c
--- b/src/backend/commands/typecmds.c
*************** static Oid	findTypeAnalyzeFunction(List
*** 98,104 ****
  static Oid	findRangeSubOpclass(List *opcname, Oid subtype);
  static Oid	findRangeCanonicalFunction(List *procname, Oid typeOid);
  static Oid	findRangeSubtypeDiffFunction(List *procname, Oid subtype);
! static void validateDomainConstraint(Oid domainoid, char *ccbin);
  static List *get_rels_with_domain(Oid domainOid, LOCKMODE lockmode);
  static void checkEnumOwner(HeapTuple tup);
  static char *domainAddConstraint(Oid domainOid, Oid domainNamespace,
--- 98,104 ----
  static Oid	findRangeSubOpclass(List *opcname, Oid subtype);
  static Oid	findRangeCanonicalFunction(List *procname, Oid typeOid);
  static Oid	findRangeSubtypeDiffFunction(List *procname, Oid subtype);
! static void validateDomainConstraint(Oid domainoid, char *ccbin, char *conname);
  static List *get_rels_with_domain(Oid domainOid, LOCKMODE lockmode);
  static void checkEnumOwner(HeapTuple tup);
  static char *domainAddConstraint(Oid domainOid, Oid domainNamespace,
*************** AlterDomainNotNull(List *names, bool not
*** 2254,2266 ****
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 										RelationGetRelationName(testrel))));
  				}
  			}
  			heap_endscan(scan);
--- 2254,2267 ----
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
+ 					Form_pg_attribute att = tupdesc->attrs[attnum - 1];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 										NameStr(att->attname), RelationGetRelationName(testrel)),
! 								 errtablecol(testrel, NameStr(att->attname))));
  				}
  			}
  			heap_endscan(scan);
*************** AlterDomainAddConstraint(List *names, No
*** 2466,2472 ****
  	 * attributes based on the domain the constraint is being added to.
  	 */
  	if (!constr->skip_validation)
! 		validateDomainConstraint(domainoid, ccbin);
  
  	/* Clean up */
  	heap_close(typrel, RowExclusiveLock);
--- 2467,2473 ----
  	 * attributes based on the domain the constraint is being added to.
  	 */
  	if (!constr->skip_validation)
! 		validateDomainConstraint(domainoid, ccbin, constr->conname);
  
  	/* Clean up */
  	heap_close(typrel, RowExclusiveLock);
*************** AlterDomainValidateConstraint(List *name
*** 2551,2557 ****
  			 HeapTupleGetOid(tuple));
  	conbin = TextDatumGetCString(val);
  
! 	validateDomainConstraint(domainoid, conbin);
  
  	/*
  	 * Now update the catalog, while we have the door open.
--- 2552,2558 ----
  			 HeapTupleGetOid(tuple));
  	conbin = TextDatumGetCString(val);
  
! 	validateDomainConstraint(domainoid, conbin, constrName);
  
  	/*
  	 * Now update the catalog, while we have the door open.
*************** AlterDomainValidateConstraint(List *name
*** 2572,2578 ****
  }
  
  static void
! validateDomainConstraint(Oid domainoid, char *ccbin)
  {
  	Expr	   *expr = (Expr *) stringToNode(ccbin);
  	List	   *rels;
--- 2573,2579 ----
  }
  
  static void
! validateDomainConstraint(Oid domainoid, char *ccbin, char *conname)
  {
  	Expr	   *expr = (Expr *) stringToNode(ccbin);
  	List	   *rels;
*************** validateDomainConstraint(Oid domainoid,
*** 2614,2619 ****
--- 2615,2621 ----
  				Datum		d;
  				bool		isNull;
  				Datum		conResult;
+ 				const char *col = NameStr(tupdesc->attrs[attnum - 1]->attname);
  
  				d = heap_getattr(tuple, attnum, tupdesc, &isNull);
  
*************** validateDomainConstraint(Oid domainoid,
*** 2628,2635 ****
  					ereport(ERROR,
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
! 								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel))));
  			}
  
  			ResetExprContext(econtext);
--- 2630,2640 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
! 									col,
! 									RelationGetRelationName(testrel)),
! 							 errtablecol(testrel, col),
! 							 conname?
! 							 errconstraint(conname):0));
  			}
  
  			ResetExprContext(econtext);
diff src/backend/executor/execMain.c
index 0222d40..3b4022a
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
*************** ExecConstraints(ResultRelInfo *resultRel
*** 1522,1535 ****
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64))));
  		}
  	}
  
--- 1522,1538 ----
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
+ 			Form_pg_attribute Chk = rel->rd_att->attrs[attrChk - 1];
+ 
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 								NameStr(Chk->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64)),
! 						 errtablecol(rel, NameStr(Chk->attname))));
  		}
  	}
  
*************** ExecConstraints(ResultRelInfo *resultRel
*** 1543,1549 ****
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64))));
  	}
  }
  
--- 1546,1554 ----
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64)),
! 					 errtable(rel),
! 					 errconstraint(failed)));
  	}
  }
  
diff src/backend/executor/execQual.c
index 56b106a..526d779
*** a/src/backend/executor/execQual.c
--- b/src/backend/executor/execQual.c
***************
*** 54,59 ****
--- 54,60 ----
  #include "utils/builtins.h"
  #include "utils/lsyscache.h"
  #include "utils/memutils.h"
+ #include "utils/rel.h"
  #include "utils/typcache.h"
  #include "utils/xml.h"
  
*************** ExecEvalCoerceToDomain(CoerceToDomainSta
*** 3864,3869 ****
--- 3865,3876 ----
  	CoerceToDomain *ctest = (CoerceToDomain *) cstate->xprstate.expr;
  	Datum		result;
  	ListCell   *l;
+ 	Relation	heapRel = NULL;
+ 	struct EState *estate = econtext->ecxt_estate;
+ 
+ 	/* Build relation description, if possible */
+ 	if (estate && estate->es_result_relation_info)
+ 		heapRel = estate->es_result_relation_info->ri_RelationDesc;
  
  	result = ExecEvalExpr(cstate->arg, econtext, isNull, isDone);
  
*************** ExecEvalCoerceToDomain(CoerceToDomainSta
*** 3878,3887 ****
  		{
  			case DOM_CONSTRAINT_NOTNULL:
  				if (*isNull)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NOT_NULL_VIOLATION),
! 							 errmsg("domain %s does not allow null values",
! 									format_type_be(ctest->resulttype))));
  				break;
  			case DOM_CONSTRAINT_CHECK:
  				{
--- 3885,3904 ----
  		{
  			case DOM_CONSTRAINT_NOTNULL:
  				if (*isNull)
! 				{
! 					if (heapRel)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_NOT_NULL_VIOLATION),
! 								 errmsg("domain %s does not allow null values",
! 										format_type_be(ctest->resulttype)),
! 								 errtable(heapRel)));
! 
! 					else
! 						ereport(ERROR,
! 								(errcode(ERRCODE_NOT_NULL_VIOLATION),
! 								 errmsg("domain %s does not allow null values",
! 										format_type_be(ctest->resulttype))));
! 				}
  				break;
  			case DOM_CONSTRAINT_CHECK:
  				{
*************** ExecEvalCoerceToDomain(CoerceToDomainSta
*** 3907,3917 ****
  
  					if (!conIsNull &&
  						!DatumGetBool(conResult))
! 						ereport(ERROR,
! 								(errcode(ERRCODE_CHECK_VIOLATION),
! 								 errmsg("value for domain %s violates check constraint \"%s\"",
! 										format_type_be(ctest->resulttype),
! 										con->name)));
  					econtext->domainValue_datum = save_datum;
  					econtext->domainValue_isNull = save_isNull;
  
--- 3924,3946 ----
  
  					if (!conIsNull &&
  						!DatumGetBool(conResult))
! 					{
! 						if (heapRel)
! 							ereport(ERROR,
! 									(errcode(ERRCODE_CHECK_VIOLATION),
! 									 errmsg("value for domain %s violates check constraint \"%s\"",
! 											format_type_be(ctest->resulttype),
! 											con->name),
! 									 errtable(heapRel),
! 									 errconstraint(con->name)));
! 						else
! 							ereport(ERROR,
! 									(errcode(ERRCODE_CHECK_VIOLATION),
! 									 errmsg("value for domain %s violates check constraint \"%s\"",
! 											format_type_be(ctest->resulttype),
! 											con->name),
! 									 errconstraint(con->name)));
! 					}
  					econtext->domainValue_datum = save_datum;
  					econtext->domainValue_isNull = save_isNull;
  
diff src/backend/executor/execUtils.c
index d6cf06c..a85d081
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
*************** retry:
*** 1307,1320 ****
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing)));
  	}
  
  	index_endscan(index_scan);
--- 1307,1324 ----
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing),
! 					 errtable(heap),
! 					 errconstraint(RelationGetRelationName(index))));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing),
! 					 errtable(heap),
! 					 errconstraint(RelationGetRelationName(index))));
  	}
  
  	index_endscan(index_scan);
diff src/backend/utils/adt/domains.c
index 8b51ccf..6d658bb
*** a/src/backend/utils/adt/domains.c
--- b/src/backend/utils/adt/domains.c
***************
*** 36,41 ****
--- 36,42 ----
  #include "lib/stringinfo.h"
  #include "utils/builtins.h"
  #include "utils/lsyscache.h"
+ #include "utils/rel.h"
  
  
  /*
*************** domain_check_input(Datum value, bool isn
*** 123,132 ****
--- 124,140 ----
  		{
  			case DOM_CONSTRAINT_NOTNULL:
  				if (isnull)
+ 				{
+ 					/*
+ 					 * We don't provide errtable here, because it is
+ 					 * unavailable, though we require it anywhere where it is
+ 					 * available in principle.
+ 					 */
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("domain %s does not allow null values",
  									format_type_be(my_extra->domain_type))));
+ 				}
  				break;
  			case DOM_CONSTRAINT_CHECK:
  				{
*************** domain_check_input(Datum value, bool isn
*** 163,169 ****
  								(errcode(ERRCODE_CHECK_VIOLATION),
  								 errmsg("value for domain %s violates check constraint \"%s\"",
  										format_type_be(my_extra->domain_type),
! 										con->name)));
  					break;
  				}
  			default:
--- 171,178 ----
  								(errcode(ERRCODE_CHECK_VIOLATION),
  								 errmsg("value for domain %s violates check constraint \"%s\"",
  										format_type_be(my_extra->domain_type),
! 										con->name),
! 								 errconstraint(con->name)));
  					break;
  				}
  			default:
diff src/backend/utils/adt/ri_triggers.c
index 97e68b1..474dc2a
*** a/src/backend/utils/adt/ri_triggers.c
--- b/src/backend/utils/adt/ri_triggers.c
*************** RI_FKey_check(TriggerData *trigdata)
*** 339,345 ****
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
--- 339,347 ----
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 							 errtable(trigdata->tg_relation),
! 							 errconstraint(NameStr(riinfo->conname))));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
*************** RI_Initial_Check(Trigger *trigger, Relat
*** 2467,2473 ****
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
--- 2469,2478 ----
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 					 errtable(fk_rel),
! 					 errconstraint(NameStr(fake_riinfo.conname))));
! 
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
*************** ri_ReportViolation(const RI_ConstraintIn
*** 3219,3225 ****
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
--- 3224,3232 ----
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel)),
! 				 errtable(fk_rel),
! 				 errconstraint(NameStr(riinfo->conname))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
*************** ri_ReportViolation(const RI_ConstraintIn
*** 3229,3235 ****
  						RelationGetRelationName(fk_rel)),
  			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
  					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel))));
  }
  
  
--- 3236,3244 ----
  						RelationGetRelationName(fk_rel)),
  			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
  					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel)),
! 				 errtable(pk_rel),
! 				 errconstraint(NameStr(riinfo->conname))));
  }
  
  
diff src/backend/utils/errcodes.txt
index 3e04164..8e2ba49
*** a/src/backend/utils/errcodes.txt
--- b/src/backend/utils/errcodes.txt
*************** Section: Class 22 - Data Exception
*** 200,213 ****
  2200S    E    ERRCODE_INVALID_XML_COMMENT                                    invalid_xml_comment
  2200T    E    ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION                     invalid_xml_processing_instruction
  
  Section: Class 23 - Integrity Constraint Violation
! 
  23000    E    ERRCODE_INTEGRITY_CONSTRAINT_VIOLATION                         integrity_constraint_violation
  23001    E    ERRCODE_RESTRICT_VIOLATION                                     restrict_violation
  23502    E    ERRCODE_NOT_NULL_VIOLATION                                     not_null_violation
  23503    E    ERRCODE_FOREIGN_KEY_VIOLATION                                  foreign_key_violation
  23505    E    ERRCODE_UNIQUE_VIOLATION                                       unique_violation
  23514    E    ERRCODE_CHECK_VIOLATION                                        check_violation
  23P01    E    ERRCODE_EXCLUSION_VIOLATION                                    exclusion_violation
  
  Section: Class 24 - Invalid Cursor State
--- 200,227 ----
  2200S    E    ERRCODE_INVALID_XML_COMMENT                                    invalid_xml_comment
  2200T    E    ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION                     invalid_xml_processing_instruction
  
+ # Postgres coding standards mandate that certain fields be available in all
+ # instances for some of the Class 23 errcodes, documented under "Requirement: "
+ # here.  Some other errcode's ereport sites may, at their own discretion, make
+ # errcolumn, errtable, errconstraint and errschema fields available too.
+ # Furthermore, it is possible to make some fields available beyond those
+ # formally required at callsites involving these Class 23 errcodes with
+ # "Requirements: ".
  Section: Class 23 - Integrity Constraint Violation
! Requirement: unused
  23000    E    ERRCODE_INTEGRITY_CONSTRAINT_VIOLATION                         integrity_constraint_violation
+ Requirement: unused
  23001    E    ERRCODE_RESTRICT_VIOLATION                                     restrict_violation
+ # Note that requirements for ERRCODE_NOT_NULL do not apply to domains:
+ Requirement: schema_name, table_name
  23502    E    ERRCODE_NOT_NULL_VIOLATION                                     not_null_violation
+ Requirement: schema_name, table_name, constraint_name
  23503    E    ERRCODE_FOREIGN_KEY_VIOLATION                                  foreign_key_violation
+ Requirement: schema_name, table_name, constraint_name
  23505    E    ERRCODE_UNIQUE_VIOLATION                                       unique_violation
+ Requirement: constraint_name
  23514    E    ERRCODE_CHECK_VIOLATION                                        check_violation
+ Requirement: schema_name, table_name, constraint_name
  23P01    E    ERRCODE_EXCLUSION_VIOLATION                                    exclusion_violation
  
  Section: Class 24 - Invalid Cursor State
diff src/backend/utils/error/Makefile
index 4c313b7..c2ba4d0
*** a/src/backend/utils/error/Makefile
--- b/src/backend/utils/error/Makefile
*************** subdir = src/backend/utils/error
*** 12,17 ****
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o relerror.o
  
  include $(top_srcdir)/src/backend/common.mk
diff src/backend/utils/error/elog.c
index c22190a..daffe22
*** a/src/backend/utils/error/elog.c
--- b/src/backend/utils/error/elog.c
*************** static void write_syslog(int level, cons
*** 130,135 ****
--- 130,136 ----
  #endif
  
  static void write_console(const char *line, int len);
+ static void set_errdata_field(char **ptr, const char *str);
  
  #ifdef WIN32
  extern char *event_source;
*************** errfinish(int dummy,...)
*** 477,482 ****
--- 478,491 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
  
  	errordata_stack_depth--;
  
*************** internalerrquery(const char *query)
*** 1101,1106 ****
--- 1110,1180 ----
  }
  
  /*
+  * err_generic_string -- used to set individual ErrorData string fields.
+  *
+  * Callers should prefer higher-level abstractions such as those within
+  * relerror.c.
+  */
+ int
+ err_generic_string(int field, const char *str)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+ 
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+ 
+ 	switch (field)
+ 	{
+ 		case PG_DIAG_MESSAGE_PRIMARY:
+ 			set_errdata_field(&edata->message, str);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_DETAIL:
+ 			set_errdata_field(&edata->detail, str);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_HINT:
+ 			set_errdata_field(&edata->hint, str);
+ 			break;
+ 
+ 		case PG_DIAG_CONTEXT:
+ 			set_errdata_field(&edata->context, str);
+ 			break;
+ 
+ 		case PG_DIAG_COLUMN_NAME:
+ 			set_errdata_field(&edata->column_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_TABLE_NAME:
+ 			set_errdata_field(&edata->table_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_SCHEMA_NAME:
+ 			set_errdata_field(&edata->schema_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_NAME:
+ 			set_errdata_field(&edata->constraint_name, str);
+ 			break;
+ 
+ 		default:
+ 			elog(ERROR, "unsupported or unknown ErrorData field id: %d", field);
+ 	}
+ 
+ 	return 0;			/* return value does not matter */
+ }
+ 
+ /*
+  * set_errdata_field --- set an ErrorData string field
+  */
+ static void
+ set_errdata_field(char **ptr, const char *str)
+ {
+ 	Assert(*ptr == NULL);
+ 	*ptr = MemoryContextStrdup(ErrorContext, str);
+ }
+ 
+ /*
   * geterrcode --- return the currently set SQLSTATE error code
   *
   * This is only intended for use in error callback subroutines, since there
*************** CopyErrorData(void)
*** 1374,1379 ****
--- 1448,1461 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
  
  	return newedata;
  }
*************** FreeErrorData(ErrorData *edata)
*** 1399,1404 ****
--- 1481,1494 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
  	pfree(edata);
  }
  
*************** ReThrowError(ErrorData *edata)
*** 1471,1476 ****
--- 1561,1574 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
  
  	recursion_depth--;
  	PG_RE_THROW();
*************** write_csvlog(ErrorData *edata)
*** 2275,2282 ****
  							 edata->filename, edata->lineno);
  		appendCSVLiteral(&buf, msgbuf.data);
  		pfree(msgbuf.data);
  	}
- 	appendStringInfoChar(&buf, ',');
  
  	/* application name */
  	if (application_name)
--- 2373,2393 ----
  							 edata->filename, edata->lineno);
  		appendCSVLiteral(&buf, msgbuf.data);
  		pfree(msgbuf.data);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->column_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->table_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->schema_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->constraint_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
  	}
  
  	/* application name */
  	if (application_name)
*************** send_message_to_server_log(ErrorData *ed
*** 2385,2391 ****
  		}
  		if (Log_error_verbosity >= PGERROR_VERBOSE)
  		{
! 			/* assume no newlines in funcname or filename... */
  			if (edata->funcname && edata->filename)
  			{
  				log_line_prefix(&buf, edata);
--- 2496,2505 ----
  		}
  		if (Log_error_verbosity >= PGERROR_VERBOSE)
  		{
! 			/*
! 			 * assume no newlines in funcname, filename, column_name,
! 			 * table_name, constraint_name or schema_name...
! 			 */
  			if (edata->funcname && edata->filename)
  			{
  				log_line_prefix(&buf, edata);
*************** send_message_to_server_log(ErrorData *ed
*** 2399,2404 ****
--- 2513,2542 ----
  				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
  								 edata->filename, edata->lineno);
  			}
+ 			if (edata->column_name && edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("COLUMN NAME:  %s:%s\n"),
+ 								 edata->table_name, edata->column_name);
+ 			}
+ 			else if (edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("TABLE NAME:  %s\n"),
+ 								 edata->table_name);
+ 			}
+ 			if (edata->constraint_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("CONSTRAINT NAME:  %s\n"),
+ 								 edata->constraint_name);
+ 			}
+ 			if (edata->schema_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("SCHEMA NAME:  %s\n"),
+ 								 edata->schema_name);
+ 			}
  		}
  	}
  
*************** send_message_to_frontend(ErrorData *edat
*** 2695,2700 ****
--- 2833,2862 ----
  			err_sendstring(&msgbuf, edata->funcname);
  		}
  
+ 		if (edata->column_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+ 			err_sendstring(&msgbuf, edata->column_name);
+ 		}
+ 
+ 		if (edata->table_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+ 			err_sendstring(&msgbuf, edata->table_name);
+ 		}
+ 
+ 		if (edata->constraint_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+ 			err_sendstring(&msgbuf, edata->constraint_name);
+ 		}
+ 
+ 		if (edata->schema_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+ 			err_sendstring(&msgbuf, edata->schema_name);
+ 		}
+ 
  		pq_sendbyte(&msgbuf, '\0');		/* terminator */
  	}
  	else
diff src/backend/utils/error/relerror.c
new file mode 100644
index ...19d1435
*** a/src/backend/utils/error/relerror.c
--- b/src/backend/utils/error/relerror.c
***************
*** 0 ****
--- 1,65 ----
+ /*-------------------------------------------------------------------------
+  *
+  * relerror.c
+  *	  relation error logging functions
+  *
+  *
+  * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group
+  * Portions Copyright (c) 1994, Regents of the University of California
+  *
+  *
+  * IDENTIFICATION
+  *	  src/backend/utils/error/relerror.c
+  *
+  *-------------------------------------------------------------------------
+  */
+ #include "postgres.h"
+ 
+ #include "utils/elog.h"
+ #include "utils/lsyscache.h"
+ #include "utils/rel.h"
+ 
+ /*
+  * errtablecol --- sets schema_name, table_name and column_name of a column within
+  * errordata.  Since table and table schema are set, rel must be an ordinary
+  * table.
+  */
+ int
+ errtablecol(Relation table, const char *colname)
+ {
+ 	Assert(table->rd_rel->relkind == RELKIND_RELATION);
+ 
+ 	err_generic_string(PG_DIAG_SCHEMA_NAME,
+ 					   get_namespace_name(RelationGetNamespace(table)));
+ 	err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(table));
+ 	err_generic_string(PG_DIAG_COLUMN_NAME, colname);
+ 
+ 	return 0;
+ }
+ 
+ /*
+  * errtable --- sets schema_name and table_name within errordata.  Since table and
+  * table schema are set, rel must be an ordinary table.
+  */
+ int
+ errtable(Relation table)
+ {
+ 	Assert(table->rd_rel->relkind == RELKIND_RELATION);
+ 
+ 	err_generic_string(PG_DIAG_SCHEMA_NAME,
+ 					   get_namespace_name(RelationGetNamespace(table)));
+ 	err_generic_string(PG_DIAG_TABLE_NAME, RelationGetRelationName(table));
+ 
+ 	return 0;
+ }
+ 
+ /*
+  * errcontraint --- sets constraint_name within errordata.
+  */
+ int
+ errconstraint(const char *cname)
+ {
+ 	err_generic_string(PG_DIAG_CONSTRAINT_NAME, cname);
+ 
+ 	return 0;
+ }
diff src/backend/utils/generate-errcodes.pl
index ee76cef..e92b644
*** a/src/backend/utils/generate-errcodes.pl
--- b/src/backend/utils/generate-errcodes.pl
*************** while (<$errcodes>)
*** 28,33 ****
--- 28,39 ----
  		print "\n/* $header */\n";
  		next;
  	}
+ 	elsif (/(^Requirement:.*)/)
+ 	{
+ 		my $header = $1;
+ 		print "/* $header */\n";
+ 		next;
+ 	}
  
  	die "unable to parse errcodes.txt"
  	  unless /^([^\s]{5})\s+[EWS]\s+([^\s]+)/;
diff src/backend/utils/sort/tuplesort.c
index ce27e40..e5d048f
*** a/src/backend/utils/sort/tuplesort.c
--- b/src/backend/utils/sort/tuplesort.c
*************** comparetup_index_btree(const SortTuple *
*** 3014,3019 ****
--- 3014,3020 ----
  	 * for equal keys at the end.
  	 */
  	ScanKey		scanKey = state->indexScanKey;
+ 	Relation	indexRel = state->indexRel;
  	IndexTuple	tuple1;
  	IndexTuple	tuple2;
  	int			keysz;
*************** comparetup_index_btree(const SortTuple *
*** 3038,3044 ****
  	tuple1 = (IndexTuple) a->tuple;
  	tuple2 = (IndexTuple) b->tuple;
  	keysz = state->nKeys;
! 	tupDes = RelationGetDescr(state->indexRel);
  	scanKey++;
  	for (nkey = 2; nkey <= keysz; nkey++, scanKey++)
  	{
--- 3039,3045 ----
  	tuple1 = (IndexTuple) a->tuple;
  	tuple2 = (IndexTuple) b->tuple;
  	keysz = state->nKeys;
! 	tupDes = RelationGetDescr(indexRel);
  	scanKey++;
  	for (nkey = 2; nkey <= keysz; nkey++, scanKey++)
  	{
*************** comparetup_index_btree(const SortTuple *
*** 3075,3080 ****
--- 3076,3083 ----
  	{
  		Datum		values[INDEX_MAX_KEYS];
  		bool		isnull[INDEX_MAX_KEYS];
+ 		const char *indrelname = RelationGetRelationName(indexRel);
+ 		Relation	heapRel = RelationIdGetRelation(indexRel->rd_index->indrelid);
  
  		/*
  		 * Some rather brain-dead implementations of qsort (such as the one in
*************** comparetup_index_btree(const SortTuple *
*** 3088,3097 ****
  		ereport(ERROR,
  				(errcode(ERRCODE_UNIQUE_VIOLATION),
  				 errmsg("could not create unique index \"%s\"",
! 						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
! 						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull))));
  	}
  
  	/*
--- 3091,3101 ----
  		ereport(ERROR,
  				(errcode(ERRCODE_UNIQUE_VIOLATION),
  				 errmsg("could not create unique index \"%s\"",
! 						indrelname),
  				 errdetail("Key %s is duplicated.",
! 						   BuildIndexValueDescription(indexRel, values, isnull)),
! 				 errtable(heapRel),
! 				 errconstraint(indrelname)));
  	}
  
  	/*
diff src/include/postgres_ext.h
index 5ba379f..9776541
*** a/src/include/postgres_ext.h
--- b/src/include/postgres_ext.h
*************** typedef PG_INT64_TYPE pg_int64;
*** 60,64 ****
--- 60,68 ----
  #define PG_DIAG_SOURCE_FILE		'F'
  #define PG_DIAG_SOURCE_LINE		'L'
  #define PG_DIAG_SOURCE_FUNCTION 'R'
+ #define PG_DIAG_COLUMN_NAME			'c'
+ #define PG_DIAG_TABLE_NAME			't'
+ #define PG_DIAG_CONSTRAINT_NAME		'n'
+ #define PG_DIAG_SCHEMA_NAME			's'
  
  #endif   /* POSTGRES_EXT_H */
diff src/include/utils/elog.h
index 42c22cd..0358dfa
*** a/src/include/utils/elog.h
--- b/src/include/utils/elog.h
*************** extern int	geterrcode(void);
*** 206,211 ****
--- 206,212 ----
  extern int	geterrposition(void);
  extern int	getinternalerrposition(void);
  
+ extern int	err_generic_string(int field, const char *str);
  
  /*----------
   * Old-style error reporting API: to be used in this way:
*************** typedef struct ErrorData
*** 338,343 ****
--- 339,348 ----
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
+ 	char	   *column_name;	/* name of column */
+ 	char	   *table_name;		/* name of table */
+ 	char	   *constraint_name;	/* name of constraint */
+ 	char	   *schema_name;	/* name of schema */
  	int			cursorpos;		/* cursor index into query string */
  	int			internalpos;	/* cursor index into internalquery */
  	char	   *internalquery;	/* text of internally-generated query */
diff src/include/utils/rel.h
index 4669d8a..9c0176f
*** a/src/include/utils/rel.h
--- b/src/include/utils/rel.h
*************** typedef struct StdRdOptions
*** 394,397 ****
--- 394,402 ----
  extern void RelationIncrementReferenceCount(Relation rel);
  extern void RelationDecrementReferenceCount(Relation rel);
  
+ /* routines in utils/error/relerror.c */
+ extern int	errtablecol(Relation table, const char *colname);
+ extern int	errtable(Relation table);
+ extern int	errconstraint(const char *cname);
+ 
  #endif   /* REL_H */
diff src/interfaces/libpq/fe-protocol3.c
index c605bcd..4d70a1a
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
*************** pqGetErrorNotice3(PGconn *conn, bool isE
*** 936,941 ****
--- 936,958 ----
  								  valf, vall);
  			appendPQExpBufferChar(&workBuf, '\n');
  		}
+ 
+ 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("COLUMN NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("TABLE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("SCHEMA NAME:  %s\n"), val);
  	}
  
  	/*
diff src/pl/plpgsql/src/generate-plerrcodes.pl
index 89c6a13..c8b4b5d
*** a/src/pl/plpgsql/src/generate-plerrcodes.pl
--- b/src/pl/plpgsql/src/generate-plerrcodes.pl
*************** while (<$errcodes>)
*** 20,27 ****
  	next if /^#/;
  	next if /^\s*$/;
  
! 	# Skip section headers
! 	next if /^Section:/;
  
  	die unless /^([^\s]{5})\s+([EWS])\s+([^\s]+)(?:\s+)?([^\s]+)?/;
  
--- 20,27 ----
  	next if /^#/;
  	next if /^\s*$/;
  
! 	# Skip section headers, and requirement notes
! 	next if /^Section:/ or /^Requirement:/;
  
  	die unless /^([^\s]{5})\s+([EWS])\s+([^\s]+)(?:\s+)?([^\s]+)?/;
  

*** a/doc/src/sgml/config.sgml
--- b/doc/src/sgml/config.sgml
***************
*** 4246,4255 **** FROM pg_stat_activity;
          error context,
          user query that led to the error (if any and enabled by
          <varname>log_min_error_statement</>),
!         character count of the error position therein,
!         location of the error in the PostgreSQL source code
!         (if <varname>log_error_verbosity</> is set to <literal>verbose</>),
!         and application name.
          Here is a sample table definition for storing CSV-format log output:
  
  <programlisting>
--- 4246,4256 ----
          error context,
          user query that led to the error (if any and enabled by
          <varname>log_min_error_statement</>),
!         character count of the error position therein, and, if
!         <varname>log_error_verbosity</> is set to <literal>verbose</>,
!         column name, table name, constraint name and location of the
!         error in the PostgreSQL source code.
!         Application name is also listed.
          Here is a sample table definition for storing CSV-format log output:
  
  <programlisting>
***************
*** 4277,4282 **** CREATE TABLE postgres_log
--- 4278,4291 ----
    query text,
    query_pos integer,
    location text,
+   column_name text,
+   table_name text,
+   constraint_name text,
+   schema_name text,
+   routine_name text,
+   routine_schema text,
+   routine_oid oid,
+   trigger_name text,
    application_name text,
    PRIMARY KEY (session_id, session_line_num)
  );
*** a/doc/src/sgml/errcodes.sgml
--- b/doc/src/sgml/errcodes.sgml
***************
*** 42,47 ****
--- 42,59 ----
   </para>
  
   <para>
+    A small number of error codes listed in
+    <xref linkend="errcodes-table"> are guaranteed to provide
+    additional fields to facilitate applications in recognizing
+    particular domain-specific errors, provided that the the errors are
+    emitted from within the PostgreSQL server itself (it is not
+    strictly guaranteed that an application will not emit an
+    ill-considered error without these field, but with an errorcode
+    documented as providing them).  These additional fields are not
+    described by the SQL standard.
+  </para>
+ 
+  <para>
    The symbol shown in the column <quote>Condition Name</quote> is also
    the condition name to use in <application>PL/pgSQL</>.  Condition
    names can be written in either upper or lower case.  (Note that
*** a/doc/src/sgml/generate-errcodes-table.pl
--- b/doc/src/sgml/generate-errcodes-table.pl
***************
*** 41,46 **** while (<$errcodes>)
--- 41,71 ----
  		next;
  	}
  
+ 	# Emit requirement headers
+ 	if (/^Requirement:/)
+ 	{
+ 		# Replace the Requirement: string
+ 		s/^Requirement: /Provides: /;
+ 
+ 		# Replace "unused"
+ 		if (!s/unused/\(no fields\)/)
+ 		{
+ 			# Use literal for field names if appropriate
+ 			s/: (.*)/: <symbol>$1<\/symbol>/;
+ 		}
+ 
+ 		# Escape dashes for SGML
+ 		s/-/&mdash;/;
+ 
+ 		print "\n\n";
+ 		print "<row>\n";
+ 		print "<entry spanname=\"span12\">";
+ 		print "$_</entry>\n";
+ 		print "</row>\n";
+ 
+ 		next;
+ 	}
+ 
  	die unless /^([^\s]{5})\s+([EWS])\s+([^\s]+)(?:\s+)?([^\s]+)?/;
  
  	(my $sqlstate, my $type, my $errcode_macro, my $condition_name) =
*** a/doc/src/sgml/protocol.sgml
--- b/doc/src/sgml/protocol.sgml
***************
*** 4786,4791 **** message.
--- 4786,4881 ----
  </listitem>
  </varlistentry>
  
+ <varlistentry>
+ <term>
+ <literal>c</>
+ </term>
+ <listitem>
+ <para>
+         Column name: the name of the column associated with the the
+         error, if any.  This must be a column within the table of the
+         Table name field.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>t</>
+ </term>
+ <listitem>
+ <para>
+         Table name: the name of the table associated with the error,
+         if any.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>n</>
+ </term>
+ <listitem>
+ <para>
+         Constraint name: the name of the constraint associated with
+         the error, if any.  Note that NOT NULL constraints are not
+         cataloged, and as such will never have a constraint name,
+         though in the case of NOT NULL constraints on columns the
+         column name will be available.  This value is not guaranteed
+         to uniquely identify the constraint.  Even when combined with
+         other fields, constraint name will not unambiguously identify
+         the constraint in all cases, since it is possible for the
+         constraint to be in a different schema to the table associated
+         with the error, or for the constraint to not be associated
+         with a table at all.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>r</>
+ </term>
+ <listitem>
+ <para>
+         Routine name: the name of routine that reports error.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>u</>
+ </term>
+ <listitem>
+ <para>
+         Routine schema: the schema of routine that reports error.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>O</>
+ </term>
+ <listitem>
+ <para>
+         Routine oid: the object id of routine that reports error.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
+ <varlistentry>
+ <term>
+ <literal>T</>
+ </term>
+ <listitem>
+ <para>
+         Trigger name: the name of trigger that caused error.
+ </para>
+ </listitem>
+ </varlistentry>
+ 
  </variablelist>
  
  <para>
*** a/src/backend/access/nbtree/nbtinsert.c
--- b/src/backend/access/nbtree/nbtinsert.c
***************
*** 393,399 **** _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 														  values, isnull))));
  					}
  				}
  				else if (all_dead)
--- 393,401 ----
  										RelationGetRelationName(rel)),
  								 errdetail("Key %s already exists.",
  										   BuildIndexValueDescription(rel,
! 															values, isnull)),
! 								 errtable(heapRel),
! 								 errconstraint(RelationGetRelationName(rel))));
  					}
  				}
  				else if (all_dead)
***************
*** 455,461 **** _bt_check_unique(Relation rel, IndexTuple itup, Relation heapRel,
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		errhint("This may be because of a non-immutable index expression.")));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
--- 457,464 ----
  				(errcode(ERRCODE_INTERNAL_ERROR),
  				 errmsg("failed to re-find tuple within index \"%s\"",
  						RelationGetRelationName(rel)),
! 		 errhint("This may be because of a non-immutable index expression."),
! 				 errtable(heapRel)));
  
  	if (nbuf != InvalidBuffer)
  		_bt_relbuf(rel, nbuf);
***************
*** 533,539 **** _bt_findinsertloc(Relation rel,
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing.")));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
--- 536,543 ----
  				   RelationGetRelationName(rel)),
  		errhint("Values larger than 1/3 of a buffer page cannot be indexed.\n"
  				"Consider a function index of an MD5 hash of the value, "
! 				"or use full text indexing."),
! 				 errtable(heapRel)));
  
  	/*----------
  	 * If we will need to split the page to put the item on this page,
*** a/src/backend/commands/tablecmds.c
--- b/src/backend/commands/tablecmds.c
***************
*** 3819,3828 **** ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 								NameStr(newTupDesc->attrs[attn]->attname))));
  			}
  
  			foreach(l, tab->constraints)
--- 3819,3835 ----
  				int			attn = lfirst_int(l);
  
  				if (heap_attisnull(tuple, attn + 1))
+ 				{
+ 					Form_pg_attribute att = newTupDesc->attrs[attn];
+ 
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("column \"%s\" contains null values",
! 									NameStr(att->attname)),
! 							 (newrel) ?
! 							 errtablecol(newrel, NameStr(att->attname)) :
! 							 errtablecol(oldrel, NameStr(att->attname))));
! 				}
  			}
  
  			foreach(l, tab->constraints)
***************
*** 3836,3842 **** ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
--- 3843,3853 ----
  							ereport(ERROR,
  									(errcode(ERRCODE_CHECK_VIOLATION),
  									 errmsg("check constraint \"%s\" is violated by some row",
! 											con->name),
! 									 (newrel) ?
! 									 errtable(newrel) :
! 									 errtable(oldrel),
! 									 errconstraint(con->name)));
  						break;
  					case CONSTR_FOREIGN:
  						/* Nothing to do here */
***************
*** 6653,6659 **** validateCheckConstraint(Relation rel, HeapTuple constrtup)
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
--- 6664,6672 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_CHECK_VIOLATION),
  					 errmsg("check constraint \"%s\" is violated by some row",
! 							NameStr(constrForm->conname)),
! 					 errtable(rel),
! 					 errconstraint(NameStr(constrForm->conname))));
  
  		ResetExprContext(econtext);
  	}
*** a/src/backend/commands/typecmds.c
--- b/src/backend/commands/typecmds.c
***************
*** 98,104 **** static Oid	findTypeAnalyzeFunction(List *procname, Oid typeOid);
  static Oid	findRangeSubOpclass(List *opcname, Oid subtype);
  static Oid	findRangeCanonicalFunction(List *procname, Oid typeOid);
  static Oid	findRangeSubtypeDiffFunction(List *procname, Oid subtype);
! static void validateDomainConstraint(Oid domainoid, char *ccbin);
  static List *get_rels_with_domain(Oid domainOid, LOCKMODE lockmode);
  static void checkEnumOwner(HeapTuple tup);
  static char *domainAddConstraint(Oid domainOid, Oid domainNamespace,
--- 98,104 ----
  static Oid	findRangeSubOpclass(List *opcname, Oid subtype);
  static Oid	findRangeCanonicalFunction(List *procname, Oid typeOid);
  static Oid	findRangeSubtypeDiffFunction(List *procname, Oid subtype);
! static void validateDomainConstraint(Oid domainoid, char *ccbin, char *conname);
  static List *get_rels_with_domain(Oid domainOid, LOCKMODE lockmode);
  static void checkEnumOwner(HeapTuple tup);
  static char *domainAddConstraint(Oid domainOid, Oid domainNamespace,
***************
*** 2258,2270 **** AlterDomainNotNull(List *names, bool notNull)
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 										RelationGetRelationName(testrel))));
  				}
  			}
  			heap_endscan(scan);
--- 2258,2271 ----
  				for (i = 0; i < rtc->natts; i++)
  				{
  					int			attnum = rtc->atts[i];
+ 					Form_pg_attribute att = tupdesc->attrs[attnum - 1];
  
  					if (heap_attisnull(tuple, attnum))
  						ereport(ERROR,
  								(errcode(ERRCODE_NOT_NULL_VIOLATION),
  								 errmsg("column \"%s\" of table \"%s\" contains null values",
! 										NameStr(att->attname), RelationGetRelationName(testrel)),
! 								 errtablecol(testrel, NameStr(att->attname))));
  				}
  			}
  			heap_endscan(scan);
***************
*** 2470,2476 **** AlterDomainAddConstraint(List *names, Node *newConstraint)
  	 * attributes based on the domain the constraint is being added to.
  	 */
  	if (!constr->skip_validation)
! 		validateDomainConstraint(domainoid, ccbin);
  
  	/* Clean up */
  	heap_close(typrel, RowExclusiveLock);
--- 2471,2477 ----
  	 * attributes based on the domain the constraint is being added to.
  	 */
  	if (!constr->skip_validation)
! 		validateDomainConstraint(domainoid, ccbin, constr->conname);
  
  	/* Clean up */
  	heap_close(typrel, RowExclusiveLock);
***************
*** 2555,2561 **** AlterDomainValidateConstraint(List *names, char *constrName)
  			 HeapTupleGetOid(tuple));
  	conbin = TextDatumGetCString(val);
  
! 	validateDomainConstraint(domainoid, conbin);
  
  	/*
  	 * Now update the catalog, while we have the door open.
--- 2556,2562 ----
  			 HeapTupleGetOid(tuple));
  	conbin = TextDatumGetCString(val);
  
! 	validateDomainConstraint(domainoid, conbin, constrName);
  
  	/*
  	 * Now update the catalog, while we have the door open.
***************
*** 2576,2582 **** AlterDomainValidateConstraint(List *names, char *constrName)
  }
  
  static void
! validateDomainConstraint(Oid domainoid, char *ccbin)
  {
  	Expr	   *expr = (Expr *) stringToNode(ccbin);
  	List	   *rels;
--- 2577,2583 ----
  }
  
  static void
! validateDomainConstraint(Oid domainoid, char *ccbin, char *conname)
  {
  	Expr	   *expr = (Expr *) stringToNode(ccbin);
  	List	   *rels;
***************
*** 2618,2623 **** validateDomainConstraint(Oid domainoid, char *ccbin)
--- 2619,2625 ----
  				Datum		d;
  				bool		isNull;
  				Datum		conResult;
+ 				const char *col = NameStr(tupdesc->attrs[attnum - 1]->attname);
  
  				d = heap_getattr(tuple, attnum, tupdesc, &isNull);
  
***************
*** 2632,2639 **** validateDomainConstraint(Oid domainoid, char *ccbin)
  					ereport(ERROR,
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
! 								NameStr(tupdesc->attrs[attnum - 1]->attname),
! 									RelationGetRelationName(testrel))));
  			}
  
  			ResetExprContext(econtext);
--- 2634,2644 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_CHECK_VIOLATION),
  							 errmsg("column \"%s\" of table \"%s\" contains values that violate the new constraint",
! 									col,
! 									RelationGetRelationName(testrel)),
! 							 errtablecol(testrel, col),
! 							 conname?
! 							 errconstraint(conname):0));
  			}
  
  			ResetExprContext(econtext);
*** a/src/backend/executor/execMain.c
--- b/src/backend/executor/execMain.c
***************
*** 1522,1535 **** ExecConstraints(ResultRelInfo *resultRelInfo,
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 						  NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64))));
  		}
  	}
  
--- 1522,1538 ----
  
  		for (attrChk = 1; attrChk <= natts; attrChk++)
  		{
+ 			Form_pg_attribute Chk = rel->rd_att->attrs[attrChk - 1];
+ 
  			if (rel->rd_att->attrs[attrChk - 1]->attnotnull &&
  				slot_attisnull(slot, attrChk))
  				ereport(ERROR,
  						(errcode(ERRCODE_NOT_NULL_VIOLATION),
  						 errmsg("null value in column \"%s\" violates not-null constraint",
! 								NameStr(Chk->attname)),
  						 errdetail("Failing row contains %s.",
! 								   ExecBuildSlotValueDescription(slot, 64)),
! 						 errtablecol(rel, NameStr(Chk->attname))));
  		}
  	}
  
***************
*** 1543,1549 **** ExecConstraints(ResultRelInfo *resultRelInfo,
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64))));
  	}
  }
  
--- 1546,1554 ----
  					 errmsg("new row for relation \"%s\" violates check constraint \"%s\"",
  							RelationGetRelationName(rel), failed),
  					 errdetail("Failing row contains %s.",
! 							   ExecBuildSlotValueDescription(slot, 64)),
! 					 errtable(rel),
! 					 errconstraint(failed)));
  	}
  }
  
*** a/src/backend/executor/execQual.c
--- b/src/backend/executor/execQual.c
***************
*** 54,59 ****
--- 54,60 ----
  #include "utils/builtins.h"
  #include "utils/lsyscache.h"
  #include "utils/memutils.h"
+ #include "utils/rel.h"
  #include "utils/typcache.h"
  #include "utils/xml.h"
  
***************
*** 3864,3869 **** ExecEvalCoerceToDomain(CoerceToDomainState *cstate, ExprContext *econtext,
--- 3865,3876 ----
  	CoerceToDomain *ctest = (CoerceToDomain *) cstate->xprstate.expr;
  	Datum		result;
  	ListCell   *l;
+ 	Relation	heapRel = NULL;
+ 	struct EState *estate = econtext->ecxt_estate;
+ 
+ 	/* Build relation description, if possible */
+ 	if (estate && estate->es_result_relation_info)
+ 		heapRel = estate->es_result_relation_info->ri_RelationDesc;
  
  	result = ExecEvalExpr(cstate->arg, econtext, isNull, isDone);
  
***************
*** 3878,3887 **** ExecEvalCoerceToDomain(CoerceToDomainState *cstate, ExprContext *econtext,
  		{
  			case DOM_CONSTRAINT_NOTNULL:
  				if (*isNull)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_NOT_NULL_VIOLATION),
! 							 errmsg("domain %s does not allow null values",
! 									format_type_be(ctest->resulttype))));
  				break;
  			case DOM_CONSTRAINT_CHECK:
  				{
--- 3885,3904 ----
  		{
  			case DOM_CONSTRAINT_NOTNULL:
  				if (*isNull)
! 				{
! 					if (heapRel)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_NOT_NULL_VIOLATION),
! 								 errmsg("domain %s does not allow null values",
! 										format_type_be(ctest->resulttype)),
! 								 errtable(heapRel)));
! 
! 					else
! 						ereport(ERROR,
! 								(errcode(ERRCODE_NOT_NULL_VIOLATION),
! 								 errmsg("domain %s does not allow null values",
! 										format_type_be(ctest->resulttype))));
! 				}
  				break;
  			case DOM_CONSTRAINT_CHECK:
  				{
***************
*** 3907,3917 **** ExecEvalCoerceToDomain(CoerceToDomainState *cstate, ExprContext *econtext,
  
  					if (!conIsNull &&
  						!DatumGetBool(conResult))
! 						ereport(ERROR,
! 								(errcode(ERRCODE_CHECK_VIOLATION),
! 								 errmsg("value for domain %s violates check constraint \"%s\"",
! 										format_type_be(ctest->resulttype),
! 										con->name)));
  					econtext->domainValue_datum = save_datum;
  					econtext->domainValue_isNull = save_isNull;
  
--- 3924,3946 ----
  
  					if (!conIsNull &&
  						!DatumGetBool(conResult))
! 					{
! 						if (heapRel)
! 							ereport(ERROR,
! 									(errcode(ERRCODE_CHECK_VIOLATION),
! 									 errmsg("value for domain %s violates check constraint \"%s\"",
! 											format_type_be(ctest->resulttype),
! 											con->name),
! 									 errtable(heapRel),
! 									 errconstraint(con->name)));
! 						else
! 							ereport(ERROR,
! 									(errcode(ERRCODE_CHECK_VIOLATION),
! 									 errmsg("value for domain %s violates check constraint \"%s\"",
! 											format_type_be(ctest->resulttype),
! 											con->name),
! 									 errconstraint(con->name)));
! 					}
  					econtext->domainValue_datum = save_datum;
  					econtext->domainValue_isNull = save_isNull;
  
*** a/src/backend/executor/execUtils.c
--- b/src/backend/executor/execUtils.c
***************
*** 1307,1320 **** retry:
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing)));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing)));
  	}
  
  	index_endscan(index_scan);
--- 1307,1324 ----
  					 errmsg("could not create exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with key %s.",
! 							   error_new, error_existing),
! 					 errtable(heap),
! 					 errconstraint(RelationGetRelationName(index))));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_EXCLUSION_VIOLATION),
  					 errmsg("conflicting key value violates exclusion constraint \"%s\"",
  							RelationGetRelationName(index)),
  					 errdetail("Key %s conflicts with existing key %s.",
! 							   error_new, error_existing),
! 					 errtable(heap),
! 					 errconstraint(RelationGetRelationName(index))));
  	}
  
  	index_endscan(index_scan);
*** a/src/backend/utils/adt/domains.c
--- b/src/backend/utils/adt/domains.c
***************
*** 36,41 ****
--- 36,42 ----
  #include "lib/stringinfo.h"
  #include "utils/builtins.h"
  #include "utils/lsyscache.h"
+ #include "utils/rel.h"
  
  
  /*
***************
*** 123,132 **** domain_check_input(Datum value, bool isnull, DomainIOData *my_extra)
--- 124,140 ----
  		{
  			case DOM_CONSTRAINT_NOTNULL:
  				if (isnull)
+ 				{
+ 					/*
+ 					 * We don't provide errtable here, because it is
+ 					 * unavailable, though we require it anywhere where it is
+ 					 * available in principle.
+ 					 */
  					ereport(ERROR,
  							(errcode(ERRCODE_NOT_NULL_VIOLATION),
  							 errmsg("domain %s does not allow null values",
  									format_type_be(my_extra->domain_type))));
+ 				}
  				break;
  			case DOM_CONSTRAINT_CHECK:
  				{
***************
*** 163,169 **** domain_check_input(Datum value, bool isnull, DomainIOData *my_extra)
  								(errcode(ERRCODE_CHECK_VIOLATION),
  								 errmsg("value for domain %s violates check constraint \"%s\"",
  										format_type_be(my_extra->domain_type),
! 										con->name)));
  					break;
  				}
  			default:
--- 171,178 ----
  								(errcode(ERRCODE_CHECK_VIOLATION),
  								 errmsg("value for domain %s violates check constraint \"%s\"",
  										format_type_be(my_extra->domain_type),
! 										con->name),
! 								 errconstraint(con->name)));
  					break;
  				}
  			default:
*** a/src/backend/utils/adt/ri_triggers.c
--- b/src/backend/utils/adt/ri_triggers.c
***************
*** 339,345 **** RI_FKey_check(TriggerData *trigdata)
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
--- 339,347 ----
  							 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							  RelationGetRelationName(trigdata->tg_relation),
  									NameStr(riinfo->conname)),
! 							 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 							 errtable(trigdata->tg_relation),
! 							 errconstraint(NameStr(riinfo->conname))));
  					heap_close(pk_rel, RowShareLock);
  					return PointerGetDatum(NULL);
  
***************
*** 2467,2473 **** RI_Initial_Check(Trigger *trigger, Relation fk_rel, Relation pk_rel)
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values.")));
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
--- 2469,2478 ----
  					 errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
  							RelationGetRelationName(fk_rel),
  							NameStr(fake_riinfo.conname)),
! 					 errdetail("MATCH FULL does not allow mixing of null and nonnull key values."),
! 					 errtable(fk_rel),
! 					 errconstraint(NameStr(fake_riinfo.conname))));
! 
  
  		/*
  		 * We tell ri_ReportViolation we were doing the RI_PLAN_CHECK_LOOKUPPK
***************
*** 3219,3225 **** ri_ReportViolation(const RI_ConstraintInfo *riinfo,
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
--- 3224,3232 ----
  						NameStr(riinfo->conname)),
  				 errdetail("Key (%s)=(%s) is not present in table \"%s\".",
  						   key_names.data, key_values.data,
! 						   RelationGetRelationName(pk_rel)),
! 				 errtable(fk_rel),
! 				 errconstraint(NameStr(riinfo->conname))));
  	else
  		ereport(ERROR,
  				(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
***************
*** 3229,3235 **** ri_ReportViolation(const RI_ConstraintInfo *riinfo,
  						RelationGetRelationName(fk_rel)),
  			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
  					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel))));
  }
  
  
--- 3236,3244 ----
  						RelationGetRelationName(fk_rel)),
  			errdetail("Key (%s)=(%s) is still referenced from table \"%s\".",
  					  key_names.data, key_values.data,
! 					  RelationGetRelationName(fk_rel)),
! 				 errtable(pk_rel),
! 				 errconstraint(NameStr(riinfo->conname))));
  }
  
  
*** a/src/backend/utils/errcodes.txt
--- b/src/backend/utils/errcodes.txt
***************
*** 200,213 **** Section: Class 22 - Data Exception
  2200S    E    ERRCODE_INVALID_XML_COMMENT                                    invalid_xml_comment
  2200T    E    ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION                     invalid_xml_processing_instruction
  
  Section: Class 23 - Integrity Constraint Violation
! 
  23000    E    ERRCODE_INTEGRITY_CONSTRAINT_VIOLATION                         integrity_constraint_violation
  23001    E    ERRCODE_RESTRICT_VIOLATION                                     restrict_violation
  23502    E    ERRCODE_NOT_NULL_VIOLATION                                     not_null_violation
  23503    E    ERRCODE_FOREIGN_KEY_VIOLATION                                  foreign_key_violation
  23505    E    ERRCODE_UNIQUE_VIOLATION                                       unique_violation
  23514    E    ERRCODE_CHECK_VIOLATION                                        check_violation
  23P01    E    ERRCODE_EXCLUSION_VIOLATION                                    exclusion_violation
  
  Section: Class 24 - Invalid Cursor State
--- 200,227 ----
  2200S    E    ERRCODE_INVALID_XML_COMMENT                                    invalid_xml_comment
  2200T    E    ERRCODE_INVALID_XML_PROCESSING_INSTRUCTION                     invalid_xml_processing_instruction
  
+ # Postgres coding standards mandate that certain fields be available in all
+ # instances for some of the Class 23 errcodes, documented under "Requirement: "
+ # here.  Some other errcode's ereport sites may, at their own discretion, make
+ # errcolumn, errtable, errconstraint and errschema fields available too.
+ # Furthermore, it is possible to make some fields available beyond those
+ # formally required at callsites involving these Class 23 errcodes with
+ # "Requirements: ".
  Section: Class 23 - Integrity Constraint Violation
! Requirement: unused
  23000    E    ERRCODE_INTEGRITY_CONSTRAINT_VIOLATION                         integrity_constraint_violation
+ Requirement: unused
  23001    E    ERRCODE_RESTRICT_VIOLATION                                     restrict_violation
+ # Note that requirements for ERRCODE_NOT_NULL do not apply to domains:
+ Requirement: schema_name, table_name
  23502    E    ERRCODE_NOT_NULL_VIOLATION                                     not_null_violation
+ Requirement: schema_name, table_name, constraint_name
  23503    E    ERRCODE_FOREIGN_KEY_VIOLATION                                  foreign_key_violation
+ Requirement: schema_name, table_name, constraint_name
  23505    E    ERRCODE_UNIQUE_VIOLATION                                       unique_violation
+ Requirement: constraint_name
  23514    E    ERRCODE_CHECK_VIOLATION                                        check_violation
+ Requirement: schema_name, table_name, constraint_name
  23P01    E    ERRCODE_EXCLUSION_VIOLATION                                    exclusion_violation
  
  Section: Class 24 - Invalid Cursor State
*** a/src/backend/utils/error/Makefile
--- b/src/backend/utils/error/Makefile
***************
*** 12,17 **** subdir = src/backend/utils/error
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o
  
  include $(top_srcdir)/src/backend/common.mk
--- 12,17 ----
  top_builddir = ../../../..
  include $(top_builddir)/src/Makefile.global
  
! OBJS = assert.o elog.o relerror.o
  
  include $(top_srcdir)/src/backend/common.mk
*** a/src/backend/utils/error/elog.c
--- b/src/backend/utils/error/elog.c
***************
*** 130,135 **** static void write_syslog(int level, const char *line);
--- 130,136 ----
  #endif
  
  static void write_console(const char *line, int len);
+ static void set_errdata_field(char **ptr, const char *str);
  
  #ifdef WIN32
  extern char *event_source;
***************
*** 477,482 **** errfinish(int dummy,...)
--- 478,497 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
  
  	errordata_stack_depth--;
  
***************
*** 1101,1106 **** internalerrquery(const char *query)
--- 1116,1214 ----
  }
  
  /*
+  * errroutineid -- set routine_oid of top custom functions
+  */
+ int
+ errroutineid(Oid routineid)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+ 
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+ 
+ 	edata->routine_oid = routineid;
+ 
+ 	return 0;					/* return value does not matter */
+ }
+ 
+ /*
+  * err_generic_string -- used to set individual ErrorData string fields.
+  *
+  * Callers should prefer higher-level abstractions such as those within
+  * relerror.c.
+  */
+ int
+ err_generic_string(int field, const char *str)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+ 
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+ 
+ 	switch (field)
+ 	{
+ 		case PG_DIAG_MESSAGE_PRIMARY:
+ 			set_errdata_field(&edata->message, str);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_DETAIL:
+ 			set_errdata_field(&edata->detail, str);
+ 			break;
+ 
+ 		case PG_DIAG_MESSAGE_HINT:
+ 			set_errdata_field(&edata->hint, str);
+ 			break;
+ 
+ 		case PG_DIAG_CONTEXT:
+ 			set_errdata_field(&edata->context, str);
+ 			break;
+ 
+ 		case PG_DIAG_COLUMN_NAME:
+ 			set_errdata_field(&edata->column_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_TABLE_NAME:
+ 			set_errdata_field(&edata->table_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_SCHEMA_NAME:
+ 			set_errdata_field(&edata->schema_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_CONSTRAINT_NAME:
+ 			set_errdata_field(&edata->constraint_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_ROUTINE_NAME:
+ 			set_errdata_field(&edata->routine_name, str);
+ 			break;
+ 
+ 		case PG_DIAG_ROUTINE_SCHEMA:
+ 			set_errdata_field(&edata->routine_schema, str);
+ 			break;
+ 
+ 		case PG_DIAG_TRIGGER_NAME:
+ 			set_errdata_field(&edata->trigger_name, str);
+ 			break;
+ 
+ 		default:
+ 			elog(ERROR, "unsupported or unknown ErrorData field id: %d", field);
+ 	}
+ 
+ 	return 0;			/* return value does not matter */
+ }
+ 
+ /*
+  * set_errdata_field --- set an ErrorData string field
+  */
+ static void
+ set_errdata_field(char **ptr, const char *str)
+ {
+ 	Assert(*ptr == NULL);
+ 	*ptr = MemoryContextStrdup(ErrorContext, str);
+ }
+ 
+ /*
   * geterrcode --- return the currently set SQLSTATE error code
   *
   * This is only intended for use in error callback subroutines, since there
***************
*** 1374,1379 **** CopyErrorData(void)
--- 1482,1501 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
  
  	return newedata;
  }
***************
*** 1399,1404 **** FreeErrorData(ErrorData *edata)
--- 1521,1541 ----
  		pfree(edata->context);
  	if (edata->internalquery)
  		pfree(edata->internalquery);
+ 	if (edata->column_name)
+ 		pfree(edata->column_name);
+ 	if (edata->table_name)
+ 		pfree(edata->table_name);
+ 	if (edata->schema_name)
+ 		pfree(edata->schema_name);
+ 	if (edata->constraint_name)
+ 		pfree(edata->constraint_name);
+ 	if (edata->routine_name)
+ 		pfree(edata->routine_name);
+ 	if (edata->routine_schema)
+ 		pfree(edata->routine_schema);
+ 	if (edata->trigger_name)
+ 		pfree(edata->trigger_name);
+ 
  	pfree(edata);
  }
  
***************
*** 1471,1476 **** ReThrowError(ErrorData *edata)
--- 1608,1627 ----
  		newedata->context = pstrdup(newedata->context);
  	if (newedata->internalquery)
  		newedata->internalquery = pstrdup(newedata->internalquery);
+ 	if (newedata->column_name)
+ 		newedata->column_name = pstrdup(newedata->column_name);
+ 	if (newedata->table_name)
+ 		newedata->table_name = pstrdup(newedata->table_name);
+ 	if (newedata->schema_name)
+ 		newedata->schema_name = pstrdup(newedata->schema_name);
+ 	if (newedata->constraint_name)
+ 		newedata->constraint_name = pstrdup(newedata->constraint_name);
+ 	if (newedata->routine_name)
+ 		newedata->routine_name = pstrdup(newedata->routine_name);
+ 	if (newedata->routine_schema)
+ 		newedata->routine_schema = pstrdup(newedata->routine_schema);
+ 	if (newedata->trigger_name)
+ 		newedata->trigger_name = pstrdup(newedata->trigger_name);
  
  	recursion_depth--;
  	PG_RE_THROW();
***************
*** 2275,2282 **** write_csvlog(ErrorData *edata)
  							 edata->filename, edata->lineno);
  		appendCSVLiteral(&buf, msgbuf.data);
  		pfree(msgbuf.data);
  	}
- 	appendStringInfoChar(&buf, ',');
  
  	/* application name */
  	if (application_name)
--- 2426,2457 ----
  							 edata->filename, edata->lineno);
  		appendCSVLiteral(&buf, msgbuf.data);
  		pfree(msgbuf.data);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->column_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->table_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->schema_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->constraint_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->routine_name);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->routine_schema);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendStringInfo(&buf, "%d", edata->routine_oid);
+ 		appendStringInfoChar(&buf, ',');
+ 
+ 		appendCSVLiteral(&buf, edata->trigger_name);
+ 		appendStringInfoChar(&buf, ',');
  	}
  
  	/* application name */
  	if (application_name)
***************
*** 2385,2391 **** send_message_to_server_log(ErrorData *edata)
  		}
  		if (Log_error_verbosity >= PGERROR_VERBOSE)
  		{
! 			/* assume no newlines in funcname or filename... */
  			if (edata->funcname && edata->filename)
  			{
  				log_line_prefix(&buf, edata);
--- 2560,2569 ----
  		}
  		if (Log_error_verbosity >= PGERROR_VERBOSE)
  		{
! 			/*
! 			 * assume no newlines in funcname, filename, column_name,
! 			 * table_name, constraint_name or schema_name...
! 			 */
  			if (edata->funcname && edata->filename)
  			{
  				log_line_prefix(&buf, edata);
***************
*** 2399,2404 **** send_message_to_server_log(ErrorData *edata)
--- 2577,2630 ----
  				appendStringInfo(&buf, _("LOCATION:  %s:%d\n"),
  								 edata->filename, edata->lineno);
  			}
+ 			if (edata->column_name && edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("COLUMN NAME:  %s:%s\n"),
+ 								 edata->table_name, edata->column_name);
+ 			}
+ 			else if (edata->table_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("TABLE NAME:  %s\n"),
+ 								 edata->table_name);
+ 			}
+ 			if (edata->constraint_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("CONSTRAINT NAME:  %s\n"),
+ 								 edata->constraint_name);
+ 			}
+ 			if (edata->schema_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("SCHEMA NAME:  %s\n"),
+ 								 edata->schema_name);
+ 			}
+ 			if (edata->routine_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("ROUTINE NAME:  %s\n"),
+ 								 edata->routine_name);
+ 			}
+ 			if (edata->routine_schema)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("ROUTINE SCHEMA:  %s\n"),
+ 								 edata->routine_schema);
+ 			}
+ 			if (edata->routine_oid != InvalidOid)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("ROUTINE OID:  %d\n"),
+ 								 edata->routine_oid);
+ 			}
+ 			if (edata->trigger_name)
+ 			{
+ 				log_line_prefix(&buf, edata);
+ 				appendStringInfo(&buf, _("TRIGGER NAME:  %s\n"),
+ 								 edata->trigger_name);
+ 			}
  		}
  	}
  
***************
*** 2695,2700 **** send_message_to_frontend(ErrorData *edata)
--- 2921,2975 ----
  			err_sendstring(&msgbuf, edata->funcname);
  		}
  
+ 		if (edata->column_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_COLUMN_NAME);
+ 			err_sendstring(&msgbuf, edata->column_name);
+ 		}
+ 
+ 		if (edata->table_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TABLE_NAME);
+ 			err_sendstring(&msgbuf, edata->table_name);
+ 		}
+ 
+ 		if (edata->constraint_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_CONSTRAINT_NAME);
+ 			err_sendstring(&msgbuf, edata->constraint_name);
+ 		}
+ 
+ 		if (edata->schema_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_SCHEMA_NAME);
+ 			err_sendstring(&msgbuf, edata->schema_name);
+ 		}
+ 
+ 		if (edata->routine_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_NAME);
+ 			err_sendstring(&msgbuf, edata->routine_name);
+ 		}
+ 
+ 		if (edata->routine_schema)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_SCHEMA);
+ 			err_sendstring(&msgbuf, edata->routine_schema);
+ 		}
+ 
+ 		if (edata->routine_oid != InvalidOid)
+ 		{
+ 			snprintf(tbuf, sizeof(tbuf), "%d", edata->routine_oid);
+ 			pq_sendbyte(&msgbuf, PG_DIAG_ROUTINE_OID);
+ 			err_sendstring(&msgbuf, tbuf);
+ 		}
+ 
+ 		if (edata->trigger_name)
+ 		{
+ 			pq_sendbyte(&msgbuf, PG_DIAG_TRIGGER_NAME);
+ 			err_sendstring(&msgbuf, edata->trigger_name);
+ 		}
+ 
  		pq_sendbyte(&msgbuf, '\0');		/* terminator */
  	}
  	else
*** a/src/backend/utils/generate-errcodes.pl
--- b/src/backend/utils/generate-errcodes.pl
***************
*** 28,33 **** while (<$errcodes>)
--- 28,39 ----
  		print "\n/* $header */\n";
  		next;
  	}
+ 	elsif (/(^Requirement:.*)/)
+ 	{
+ 		my $header = $1;
+ 		print "/* $header */\n";
+ 		next;
+ 	}
  
  	die "unable to parse errcodes.txt"
  	  unless /^([^\s]{5})\s+[EWS]\s+([^\s]+)/;
*** a/src/backend/utils/sort/tuplesort.c
--- b/src/backend/utils/sort/tuplesort.c
***************
*** 3014,3019 **** comparetup_index_btree(const SortTuple *a, const SortTuple *b,
--- 3014,3020 ----
  	 * for equal keys at the end.
  	 */
  	ScanKey		scanKey = state->indexScanKey;
+ 	Relation	indexRel = state->indexRel;
  	IndexTuple	tuple1;
  	IndexTuple	tuple2;
  	int			keysz;
***************
*** 3038,3044 **** comparetup_index_btree(const SortTuple *a, const SortTuple *b,
  	tuple1 = (IndexTuple) a->tuple;
  	tuple2 = (IndexTuple) b->tuple;
  	keysz = state->nKeys;
! 	tupDes = RelationGetDescr(state->indexRel);
  	scanKey++;
  	for (nkey = 2; nkey <= keysz; nkey++, scanKey++)
  	{
--- 3039,3045 ----
  	tuple1 = (IndexTuple) a->tuple;
  	tuple2 = (IndexTuple) b->tuple;
  	keysz = state->nKeys;
! 	tupDes = RelationGetDescr(indexRel);
  	scanKey++;
  	for (nkey = 2; nkey <= keysz; nkey++, scanKey++)
  	{
***************
*** 3075,3080 **** comparetup_index_btree(const SortTuple *a, const SortTuple *b,
--- 3076,3083 ----
  	{
  		Datum		values[INDEX_MAX_KEYS];
  		bool		isnull[INDEX_MAX_KEYS];
+ 		const char *indrelname = RelationGetRelationName(indexRel);
+ 		Relation	heapRel = RelationIdGetRelation(indexRel->rd_index->indrelid);
  
  		/*
  		 * Some rather brain-dead implementations of qsort (such as the one in
***************
*** 3088,3097 **** comparetup_index_btree(const SortTuple *a, const SortTuple *b,
  		ereport(ERROR,
  				(errcode(ERRCODE_UNIQUE_VIOLATION),
  				 errmsg("could not create unique index \"%s\"",
! 						RelationGetRelationName(state->indexRel)),
  				 errdetail("Key %s is duplicated.",
! 						   BuildIndexValueDescription(state->indexRel,
! 													  values, isnull))));
  	}
  
  	/*
--- 3091,3101 ----
  		ereport(ERROR,
  				(errcode(ERRCODE_UNIQUE_VIOLATION),
  				 errmsg("could not create unique index \"%s\"",
! 						indrelname),
  				 errdetail("Key %s is duplicated.",
! 						   BuildIndexValueDescription(indexRel, values, isnull)),
! 				 errtable(heapRel),
! 				 errconstraint(indrelname)));
  	}
  
  	/*
*** a/src/include/postgres_ext.h
--- b/src/include/postgres_ext.h
***************
*** 60,64 **** typedef PG_INT64_TYPE pg_int64;
--- 60,72 ----
  #define PG_DIAG_SOURCE_FILE		'F'
  #define PG_DIAG_SOURCE_LINE		'L'
  #define PG_DIAG_SOURCE_FUNCTION 'R'
+ #define PG_DIAG_COLUMN_NAME			'c'
+ #define PG_DIAG_TABLE_NAME			't'
+ #define PG_DIAG_CONSTRAINT_NAME		'n'
+ #define PG_DIAG_SCHEMA_NAME			's'
+ #define PG_DIAG_ROUTINE_NAME		'r'
+ #define PG_DIAG_ROUTINE_SCHEMA		'u'
+ #define PG_DIAG_ROUTINE_OID		'O'
+ #define PG_DIAG_TRIGGER_NAME			'T'
  
  #endif   /* POSTGRES_EXT_H */
*** a/src/include/utils/elog.h
--- b/src/include/utils/elog.h
***************
*** 206,211 **** extern int	geterrcode(void);
--- 206,213 ----
  extern int	geterrposition(void);
  extern int	getinternalerrposition(void);
  
+ extern int	errroutineid(Oid routineid);
+ extern int	err_generic_string(int field, const char *str);
  
  /*----------
   * Old-style error reporting API: to be used in this way:
***************
*** 338,343 **** typedef struct ErrorData
--- 340,353 ----
  	char	   *detail_log;		/* detail error message for server log only */
  	char	   *hint;			/* hint message */
  	char	   *context;		/* context message */
+ 	char	   *column_name;	/* name of column */
+ 	char	   *table_name;		/* name of table */
+ 	char	   *constraint_name;	/* name of constraint */
+ 	char	   *schema_name;	/* name of schema */
+ 	char	   *routine_name;	/* name of routine */
+ 	char	   *routine_schema;	/* schema of routine */
+ 	Oid	   routine_oid;		/* oid of routine */
+ 	char	   *trigger_name;	/* name of trigger */
  	int			cursorpos;		/* cursor index into query string */
  	int			internalpos;	/* cursor index into internalquery */
  	char	   *internalquery;	/* text of internally-generated query */
*** a/src/include/utils/rel.h
--- b/src/include/utils/rel.h
***************
*** 398,401 **** typedef struct StdRdOptions
--- 398,406 ----
  extern void RelationIncrementReferenceCount(Relation rel);
  extern void RelationDecrementReferenceCount(Relation rel);
  
+ /* routines in utils/error/relerror.c */
+ extern int	errtablecol(Relation table, const char *colname);
+ extern int	errtable(Relation table);
+ extern int	errconstraint(const char *cname);
+ 
  #endif   /* REL_H */
*** a/src/interfaces/libpq/fe-protocol3.c
--- b/src/interfaces/libpq/fe-protocol3.c
***************
*** 936,941 **** pqGetErrorNotice3(PGconn *conn, bool isError)
--- 936,974 ----
  								  valf, vall);
  			appendPQExpBufferChar(&workBuf, '\n');
  		}
+ 
+ 		val = PQresultErrorField(res, PG_DIAG_COLUMN_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("COLUMN NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TABLE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("TABLE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_CONSTRAINT_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("CONSTRAINT NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_SCHEMA_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("SCHEMA NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("ROUTINE NAME:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_SCHEMA);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("ROUTINE SHEMA:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_ROUTINE_OID);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("ROUTINE OID:  %s\n"), val);
+ 		val = PQresultErrorField(res, PG_DIAG_TRIGGER_NAME);
+ 		if (val)
+ 			appendPQExpBuffer(&workBuf,
+ 							  libpq_gettext("TRIGGER NAME:  %s\n"), val);
  	}
  
  	/*
*** a/src/pl/plpgsql/src/generate-plerrcodes.pl
--- b/src/pl/plpgsql/src/generate-plerrcodes.pl
***************
*** 20,27 **** while (<$errcodes>)
  	next if /^#/;
  	next if /^\s*$/;
  
! 	# Skip section headers
! 	next if /^Section:/;
  
  	die unless /^([^\s]{5})\s+([EWS])\s+([^\s]+)(?:\s+)?([^\s]+)?/;
  
--- 20,27 ----
  	next if /^#/;
  	next if /^\s*$/;
  
! 	# Skip section headers, and requirement notes
! 	next if /^Section:/ or /^Requirement:/;
  
  	die unless /^([^\s]{5})\s+([EWS])\s+([^\s]+)(?:\s+)?([^\s]+)?/;
  
*** a/src/pl/plpgsql/src/pl_comp.c
--- b/src/pl/plpgsql/src/pl_comp.c
***************
*** 344,349 **** do_compile(FunctionCallInfo fcinfo,
--- 344,351 ----
  	compile_tmp_cxt = MemoryContextSwitchTo(func_cxt);
  
  	function->fn_signature = format_procedure(fcinfo->flinfo->fn_oid);
+ 	function->fn_name = get_func_name(fcinfo->flinfo->fn_oid);
+ 	function->fn_schema = get_namespace_name(get_func_namespace(fcinfo->flinfo->fn_oid));
  	function->fn_oid = fcinfo->flinfo->fn_oid;
  	function->fn_xmin = HeapTupleHeaderGetXmin(procTup->t_data);
  	function->fn_tid = procTup->t_self;
*** a/src/pl/plpgsql/src/pl_exec.c
--- b/src/pl/plpgsql/src/pl_exec.c
***************
*** 583,588 **** plpgsql_exec_trigger(PLpgSQL_function *func,
--- 583,590 ----
  	var->isnull = false;
  	var->freeval = true;
  
+ 	estate.trigger_name = trigdata->tg_trigger->tgname;
+ 
  	var = (PLpgSQL_var *) (estate.datums[func->tg_when_varno]);
  	if (TRIGGER_FIRED_BEFORE(trigdata->tg_event))
  		var->value = CStringGetTextDatum("BEFORE");
***************
*** 917,922 **** plpgsql_exec_error_callback(void *arg)
--- 919,941 ----
  	else
  		errcontext("PL/pgSQL function %s",
  				   estate->func->fn_signature);
+ 
+ 	/*
+ 	 * if execution of this function is on top of error_context_stack,
+ 	 * then set enhanced diagnostics fields related to function.
+ 	 */
+ 	if (error_context_stack->callback == plpgsql_exec_error_callback &&
+ 			(PLpgSQL_execstate *) error_context_stack->arg == estate)
+ 	{
+ 		PLpgSQL_function *func = estate->func;
+ 
+ 		errroutineid(func->fn_oid);
+ 		err_generic_string(PG_DIAG_ROUTINE_NAME, func->fn_name);
+ 		err_generic_string(PG_DIAG_ROUTINE_SCHEMA, func->fn_schema);
+ 
+ 		if (func->fn_is_trigger != PLPGSQL_NOT_TRIGGER)
+ 			err_generic_string(PG_DIAG_TRIGGER_NAME, estate->trigger_name);
+ 	}
  }
  
  
***************
*** 3053,3058 **** plpgsql_estate_setup(PLpgSQL_execstate *estate,
--- 3072,3078 ----
  
  	estate->err_stmt = NULL;
  	estate->err_text = NULL;
+ 	estate->trigger_name = NULL;
  
  	estate->plugin_info = NULL;
  
*** a/src/pl/plpgsql/src/plpgsql.h
--- b/src/pl/plpgsql/src/plpgsql.h
***************
*** 686,691 **** typedef enum PLpgSQL_trigtype
--- 686,693 ----
  typedef struct PLpgSQL_function
  {								/* Complete compiled function	  */
  	char	   *fn_signature;
+ 	char		*fn_schema;
+ 	char		*fn_name;				/* fields for enhanced diagnostics */
  	Oid			fn_oid;
  	TransactionId fn_xmin;
  	ItemPointerData fn_tid;
***************
*** 754,759 **** typedef struct PLpgSQL_execstate
--- 756,762 ----
  	char	   *exitlabel;		/* the "target" label of the current EXIT or
  								 * CONTINUE stmt, if any */
  	ErrorData  *cur_error;		/* current exception handler's error */
+ 	char	*trigger_name;		/* name of trigger for enhanced diagnostics */
  
  	Tuplestorestate *tuple_store;		/* SRFs accumulate results here */
  	MemoryContext tuple_store_cxt;