src/libpq/include/utils/elog.h

Ir a la documentación de este archivo.

/*-------------------------------------------------------------------------
 *
 * elog.h
 *        POSTGRES error reporting/logging definitions.
 *
 *
 * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * $PostgreSQL: pgsql/src/include/utils/elog.h,v 1.81 2005/10/15 02:49:46 momjian Exp $
 *
 *-------------------------------------------------------------------------
 */
#ifndef ELOG_H
#define ELOG_H

#include <setjmp.h>

/* Error level codes */
#define DEBUG5          10                      /* Debugging messages, in categories of
                                                                 * decreasing detail. */
#define DEBUG4          11
#define DEBUG3          12
#define DEBUG2          13
#define DEBUG1          14                      /* used by GUC debug_* variables */
#define LOG                     15                      /* Server operational messages; sent only to
                                                                 * server log by default. */
#define COMMERROR       16                      /* Client communication problems; same as LOG
                                                                 * for server reporting, but never sent to
                                                                 * client. */
#define INFO            17                      /* Informative messages that are always sent
                                                                 * to client;  is not affected by
                                                                 * client_min_messages */
#define NOTICE          18                      /* Helpful messages to users about query
                                                                 * operation;  sent to client and server log
                                                                 * by default. */
#define WARNING         19                      /* Warnings.  NOTICE is for expected messages
                                                                 * like implicit sequence creation by SERIAL.
                                                                 * WARNING is for unexpected messages. */
#define ERROR           20                      /* user error - abort transaction; return to
                                                                 * known state */
/* Save ERROR value in PGERROR so it can be restored when Win32 includes
 * modify it.  We have to use a constant rather than ERROR because macros
 * are expanded only when referenced outside macros.
 */
#ifdef WIN32
#define PGERROR         20
#endif
#define FATAL           21                      /* fatal error - abort process */
#define PANIC           22                      /* take down the other backends with me */

 /* #define DEBUG DEBUG1 */     /* Backward compatibility with pre-7.3 */


/* macros for representing SQLSTATE strings compactly */
#define PGSIXBIT(ch)    (((ch) - '0') & 0x3F)
#define PGUNSIXBIT(val) (((val) & 0x3F) + '0')

#define MAKE_SQLSTATE(ch1,ch2,ch3,ch4,ch5)      \
        (PGSIXBIT(ch1) + (PGSIXBIT(ch2) << 6) + (PGSIXBIT(ch3) << 12) + \
         (PGSIXBIT(ch4) << 18) + (PGSIXBIT(ch5) << 24))

/* These macros depend on the fact that '0' becomes a zero in SIXBIT */
#define ERRCODE_TO_CATEGORY(ec)  ((ec) & ((1 << 12) - 1))
#define ERRCODE_IS_CATEGORY(ec)  (((ec) & ~((1 << 12) - 1)) == 0)

/* SQLSTATE codes for errors are defined in a separate file */
#include "utils/errcodes.h"

/* Which __func__ symbol do we have, if any? */
#ifdef HAVE_FUNCNAME__FUNC
//#include "HISTORY"
#define PG_FUNCNAME_MACRO       __func__
#else
#ifdef HAVE_FUNCNAME__FUNCTION
#define PG_FUNCNAME_MACRO       __FUNCTION__
#else
#define PG_FUNCNAME_MACRO       NULL
#endif
#endif


/*----------
 * New-style error reporting API: to be used in this way:
 *              ereport(ERROR,
 *                              (errcode(ERRCODE_UNDEFINED_CURSOR),
 *                               errmsg("portal \"%s\" not found", stmt->portalname),
 *                               ... other errxxx() fields as needed ...));
 *
 * The error level is required, and so is a primary error message (errmsg
 * or errmsg_internal).  All else is optional.  errcode() defaults to
 * ERRCODE_INTERNAL_ERROR if elevel is ERROR or more, ERRCODE_WARNING
 * if elevel is WARNING, or ERRCODE_SUCCESSFUL_COMPLETION if elevel is
 * NOTICE or below.
 *----------
 */
#define ereport(elevel, rest)  \
        (errstart(elevel, __FILE__, __LINE__, PG_FUNCNAME_MACRO) ? \
         (errfinish rest) : (void) 0)

extern bool errstart(int elevel, const char *filename, int lineno,
                 const char *funcname);
extern void errfinish(int dummy,...);

extern int      errcode(int sqlerrcode);

extern int      errcode_for_file_access(void);
extern int      errcode_for_socket_access(void);

extern int
errmsg(const char *fmt,...)
/* This extension allows gcc to check the format string for consistency with
   the supplied arguments. */
__attribute__((format(printf, 1, 2)));

extern int
errmsg_internal(const char *fmt,...)
/* This extension allows gcc to check the format string for consistency with
   the supplied arguments. */
__attribute__((format(printf, 1, 2)));

extern int
errdetail(const char *fmt,...)
/* This extension allows gcc to check the format string for consistency with
   the supplied arguments. */
__attribute__((format(printf, 1, 2)));

extern int
errhint(const char *fmt,...)
/* This extension allows gcc to check the format string for consistency with
   the supplied arguments. */
__attribute__((format(printf, 1, 2)));

extern int
errcontext(const char *fmt,...)
/* This extension allows gcc to check the format string for consistency with
   the supplied arguments. */
__attribute__((format(printf, 1, 2)));

extern int      errfunction(const char *funcname);
extern int      errposition(int cursorpos);

extern int      internalerrposition(int cursorpos);
extern int      internalerrquery(const char *query);

extern int      geterrposition(void);
extern int      getinternalerrposition(void);


/*----------
 * Old-style error reporting API: to be used in this way:
 *              elog(ERROR, "portal \"%s\" not found", stmt->portalname);
 *----------
 */
#define elog    elog_start(__FILE__, __LINE__, PG_FUNCNAME_MACRO), elog_finish

extern void elog_start(const char *filename, int lineno, const char *funcname);
extern void
elog_finish(int elevel, const char *fmt,...)
/* This extension allows gcc to check the format string for consistency with
   the supplied arguments. */
__attribute__((format(printf, 2, 3)));


/* Support for attaching context information to error reports */

typedef struct ErrorContextCallback
{
        struct ErrorContextCallback *previous;
        void            (*callback) (void *arg);
        void       *arg;
} ErrorContextCallback;

extern DLLIMPORT ErrorContextCallback *error_context_stack;


/*----------
 * API for catching ereport(ERROR) exits.  Use these macros like so:
 *
 *              PG_TRY();
 *              {
 *                      ... code that might throw ereport(ERROR) ...
 *              }
 *              PG_CATCH();
 *              {
 *                      ... error recovery code ...
 *              }
 *              PG_END_TRY();
 *
 * (The braces are not actually necessary, but are recommended so that
 * pg_indent will indent the construct nicely.)  The error recovery code
 * can optionally do PG_RE_THROW() to propagate the same error outwards.
 *
 * Note: while the system will correctly propagate any new ereport(ERROR)
 * occurring in the recovery section, there is a small limit on the number
 * of levels this will work for.  It's best to keep the error recovery
 * section simple enough that it can't generate any new errors, at least
 * not before popping the error stack.
 *----------
 */
#define PG_TRY()  \
        do { \
                sigjmp_buf *save_exception_stack = PG_exception_stack; \
                ErrorContextCallback *save_context_stack = error_context_stack; \
                sigjmp_buf local_sigjmp_buf; \
                if (sigsetjmp(local_sigjmp_buf, 0) == 0) \
                { \
                        PG_exception_stack = &local_sigjmp_buf

#define PG_CATCH()      \
                } \
                else \
                { \
                        PG_exception_stack = save_exception_stack; \
                        error_context_stack = save_context_stack

#define PG_END_TRY()  \
                } \
                PG_exception_stack = save_exception_stack; \
                error_context_stack = save_context_stack; \
        } while (0)

#define PG_RE_THROW()  \
        siglongjmp(*PG_exception_stack, 1)

extern DLLIMPORT sigjmp_buf *PG_exception_stack;


/* Stuff that error handlers might want to use */

/*
 * ErrorData holds the data accumulated during any one ereport() cycle.
 * Any non-NULL pointers must point to palloc'd data.
 * (The const pointers are an exception; we assume they point at non-freeable
 * constant strings.)
 */
typedef struct ErrorData
{
        int                     elevel;                 /* error level */
        bool            output_to_server;               /* will report to server log? */
        bool            output_to_client;               /* will report to client? */
        bool            show_funcname;  /* true to force funcname inclusion */
        const char *filename;           /* __FILE__ of ereport() call */
        int                     lineno;                 /* __LINE__ of ereport() call */
        const char *funcname;           /* __func__ of ereport() call */
        int                     sqlerrcode;             /* encoded ERRSTATE */
        char       *message;            /* primary error message */
        char       *detail;                     /* detail error message */
        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);
extern ErrorData *CopyErrorData(void);
extern void FreeErrorData(ErrorData *edata);
extern void FlushErrorState(void);
extern void ReThrowError(ErrorData *edata);


/* GUC-configurable parameters */

typedef enum
{
        PGERROR_TERSE,                          /* single-line error messages */
        PGERROR_DEFAULT,                        /* recommended style */
        PGERROR_VERBOSE                         /* all the facts, ma'am */
} PGErrorVerbosity;

extern PGErrorVerbosity Log_error_verbosity;
extern char *Log_line_prefix;
extern int      Log_destination;

/* Log destination bitmap */
#define LOG_DESTINATION_STDERR   1
#define LOG_DESTINATION_SYSLOG   2
#define LOG_DESTINATION_EVENTLOG 4

/* Other exported functions */
extern void DebugFileOpen(void);
extern char *unpack_sql_state(int sql_state);

#ifdef HAVE_SYSLOG
extern void set_syslog_parameters(const char *ident, int facility);
#endif

/*
 * Write errors to stderr (or by equal means when stderr is
 * not available). Used before ereport/elog can be used
 * safely (memory context, GUC load etc)
 */
extern void
write_stderr(const char *fmt,...)
/* This extension allows gcc to check the format string for consistency with
   the supplied arguments. */
__attribute__((format(printf, 1, 2)));

#endif   /* ELOG_H */