diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index e58dc18..fadc9a8 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -4158,6 +4158,14 @@ 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_schema text,
+ routine_name text,
+ trigger_name text,
+ trigger_schema text,
PRIMARY KEY (session_id, session_line_num)
);
diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml
index 71c40cc..03b2bc2 100644
--- a/doc/src/sgml/protocol.sgml
+++ b/doc/src/sgml/protocol.sgml
@@ -4720,6 +4720,105 @@ message.
+
+
+c
+
+
+
+ Column name: the name of column related to error
+
+
+
+
+
+
+t
+
+
+
+ Table name: the name of table related to error
+
+
+
+
+
+
+s
+
+
+
+ Schema name: the name of schema related to error
+
+
+
+
+
+
+n
+
+
+
+ Constraint name: the name of constraint related to error
+
+
+
+
+
+
+m
+
+
+
+ Constraint schema: the schema of constraint related to error
+
+
+
+
+
+
+r
+
+
+
+ Routine name: the name of routine related to error
+
+
+
+
+
+
+u
+
+
+
+ Routine schema: the schema of routine related to error
+
+
+
+
+
+
+g
+
+
+
+ Trigger name: the name of trigger related to error
+
+
+
+
+
+
+h
+
+
+
+ Trigger schema: the schema of trigger related to error
+
+
+
+
diff --git a/src/backend/access/nbtree/nbtinsert.c b/src/backend/access/nbtree/nbtinsert.c
index 3ed9b5c..a5e5d12 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)),
+ constraint_relation_error(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."),
+ relation_error(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."),
+ relation_error(rel)));
/*----------
* If we will need to split the page to put the item on this page,
diff --git a/src/backend/executor/execMain.c b/src/backend/executor/execMain.c
index fbb36fa..ef9740d 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)),
+ relation_column_error(rel, NameStr(rel->rd_att->attrs[attrChk - 1]->attname)),
+ constraint_error(rel, "not_null_violation")));
}
}
@@ -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)),
+ relation_error(rel),
+ constraint_error(rel, failed)));
}
}
diff --git a/src/backend/executor/execUtils.c b/src/backend/executor/execUtils.c
index 40cd5ce..153ea1a 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),
+ 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)));
+ error_new, error_existing),
+ constraint_relation_error(index)));
}
index_endscan(index_scan);
diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c
index dd58f4e..c8f13b1 100644
--- a/src/backend/utils/adt/ri_triggers.c
+++ b/src/backend/utils/adt/ri_triggers.c
@@ -409,7 +409,9 @@ RI_FKey_check(PG_FUNCTION_ARGS)
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."),
+ relation_error(trigdata->tg_relation),
+ constraint_error(trigdata->tg_relation, NameStr(riinfo.conname))));
heap_close(pk_rel, RowShareLock);
return PointerGetDatum(NULL);
@@ -2841,7 +2843,9 @@ 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),
constrname),
- 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."),
+ relation_error(fk_rel),
+ constraint_error(fk_rel, constrname)));
}
/*
@@ -3536,7 +3540,9 @@ ri_ReportViolation(RI_QueryKey *qkey, const char *constrname,
errmsg("insert or update on table \"%s\" violates foreign key constraint \"%s\"",
RelationGetRelationName(fk_rel), constrname),
errdetail("No rows were found in \"%s\".",
- RelationGetRelationName(pk_rel))));
+ RelationGetRelationName(pk_rel)),
+ relation_error(fk_rel),
+ constraint_error(fk_rel, constrname)));
}
/* Get printable versions of the keys involved */
@@ -3569,7 +3575,9 @@ ri_ReportViolation(RI_QueryKey *qkey, const char *constrname,
RelationGetRelationName(fk_rel), constrname),
errdetail("Key (%s)=(%s) is not present in table \"%s\".",
key_names.data, key_values.data,
- RelationGetRelationName(pk_rel))));
+ RelationGetRelationName(pk_rel)),
+ relation_error(fk_rel),
+ constraint_error(fk_rel, constrname)));
else
ereport(ERROR,
(errcode(ERRCODE_FOREIGN_KEY_VIOLATION),
@@ -3578,7 +3586,9 @@ ri_ReportViolation(RI_QueryKey *qkey, const char *constrname,
constrname, 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)),
+ relation_error(pk_rel),
+ constraint_error(fk_rel, constrname)));
}
/* ----------
diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c
index 44dab82..d9fbdf0 100644
--- a/src/backend/utils/cache/lsyscache.c
+++ b/src/backend/utils/cache/lsyscache.c
@@ -2924,3 +2924,18 @@ get_range_subtype(Oid rangeOid)
else
return InvalidOid;
}
+
+/*
+ * Sets column_name, table_name and schema_name in ErrorData
+ */
+inline int
+rel_column_error(Oid table_oid, const char *colname)
+{
+ if (colname != NULL)
+ erritem(PG_DIAG_COLUMN_NAME, colname);
+
+ erritem(PG_DIAG_TABLE_NAME, get_rel_name(table_oid));
+ erritem(PG_DIAG_SCHEMA_NAME, get_namespace_name(get_rel_namespace(table_oid)));
+
+ return 0;
+}
diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c
index 7f0e20e..4d3fd87 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -4623,3 +4623,51 @@ unlink_initfile(const char *initfilename)
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 --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 65c28a7..77aa9b9 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -477,6 +477,24 @@ 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_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--;
@@ -1078,6 +1096,98 @@ internalerrquery(const char *query)
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
*
@@ -1352,6 +1462,24 @@ 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_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;
}
@@ -1377,6 +1505,24 @@ 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_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);
}
@@ -1449,6 +1595,24 @@ 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_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();
@@ -2259,6 +2423,33 @@ 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_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');
@@ -2377,6 +2568,69 @@ 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_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');
+ }
}
}
@@ -2673,6 +2927,60 @@ 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_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
@@ -2977,3 +3285,19 @@ trace_recovery(int trace_level)
return trace_level;
}
+
+/*
+ * Sets column_name, table_name and schema_name in ErrorData
+ */
+inline int
+schema_table_column_error(const char *schema_name, const char *table_name, const char *colname)
+{
+ if (colname != NULL)
+ erritem(PG_DIAG_COLUMN_NAME, colname);
+ if (table_name != NULL)
+ erritem(PG_DIAG_TABLE_NAME, table_name);
+ if (schema_name != NULL)
+ erritem(PG_DIAG_SCHEMA_NAME, schema_name);
+
+ return 0; /* return value does not matter */
+}
diff --git a/src/include/postgres_ext.h b/src/include/postgres_ext.h
index b6ebb7a..833c59e 100644
--- a/src/include/postgres_ext.h
+++ b/src/include/postgres_ext.h
@@ -55,5 +55,14 @@ 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_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 --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 1bbfd2b..3ee120c 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -80,7 +80,6 @@
#endif
#endif
-
/*----------
* New-style error reporting API: to be used in this way:
* ereport(ERROR,
@@ -190,6 +189,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:
@@ -296,6 +297,7 @@ extern PGDLLIMPORT ErrorContextCallback *error_context_stack;
extern PGDLLIMPORT sigjmp_buf *PG_exception_stack;
+
/* Stuff that error handlers might want to use */
/*
@@ -321,6 +323,15 @@ 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_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 */
@@ -378,4 +389,7 @@ write_stderr(const char *fmt,...)
the supplied arguments. */
__attribute__((format(PG_PRINTF_ATTRIBUTE, 1, 2)));
+extern inline int schema_table_column_error(const char *schema_name, const char *table_name,
+ const char *colname);
+
#endif /* ELOG_H */
diff --git a/src/include/utils/lsyscache.h b/src/include/utils/lsyscache.h
index 696ca77..4bd17da 100644
--- a/src/include/utils/lsyscache.h
+++ b/src/include/utils/lsyscache.h
@@ -157,4 +157,6 @@ extern Oid get_range_subtype(Oid rangeOid);
#define TypeIsToastable(typid) (get_typstorage(typid) != 'p')
+extern inline int rel_column_error(Oid table_oid, const char *colname);
+
#endif /* LSYSCACHE_H */
diff --git a/src/include/utils/rel.h b/src/include/utils/rel.h
index d404c2a..9ea47d1 100644
--- a/src/include/utils/rel.h
+++ b/src/include/utils/rel.h
@@ -394,4 +394,11 @@ typedef struct StdRdOptions
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 --git a/src/interfaces/libpq/fe-protocol3.c b/src/interfaces/libpq/fe-protocol3.c
index a773d7a..b935a84 100644
--- a/src/interfaces/libpq/fe-protocol3.c
+++ b/src/interfaces/libpq/fe-protocol3.c
@@ -980,6 +980,34 @@ 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_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);
}
/*