sedna 0.5.1 → 0.6.0

data/vendor/sedna/kernel/common/errdbg/event_log.h

@@ -0,0 +1,226 @@
+/*
+ * File:  event_log.h
+ * Copyright (C) 2006 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+/* 
+ * Architecture of the event log: 
+ * Event logger is represented as a daemon thread in a main process (in the 
+ * governor). Other processes should call init function before writing to log 
+ * (otherwise the message would be written to stderr). 
+ * Event log writing macros are thread safe.
+ */
+
+#ifndef _EVENT_LOG_H
+#define _EVENT_LOG_H
+
+#include "common/sedna.h"
+#include "common/u/uhdd.h"
+
+/* Error level codes */
+#define EL_DBG      8    /* debugging messages */
+#define EL_LOG      7    /* server operational messages */
+#define EL_COMM     6    /* client communication problems */
+#define EL_INFO	    5    /* informative messages (like current values of some parameters) */
+#define EL_WARN	    4    /* warning - inform that something is going not as well as it could be */
+#define EL_ERROR    3    /* user error (corresponds to SednaUserException) */
+#define EL_SYS      2    /* system call error */
+#define EL_FATAL    1    /* fatal error - perform soft fault (corresponds to SednaSystemException) */
+
+
+#define SE_EVENT_LOG_FILENAME_LEN      128
+#define SE_EVENT_LOG_FUNCNAME_LEN      128
+#define SE_EVENT_LOG_CONTENT_LEN       1024
+
+#define SE_SOFT_FAULT_LOG_DIR          "fault-"
+#define SE_LAST_SOFT_FAULT_DIR         "fault-last"
+#define SE_ASSERT_FAILED_FILE_NAME     "assert_failed"
+#define SE_SOFT_FAULT_LOG_CONTENT_LEN  1024
+
+/* Component codes */
+#define EL_UNK      0
+#define EL_CDB      1
+#define EL_DDB      2
+#define EL_GOV      3
+#define EL_RC       4
+#define EL_SM       5
+#define EL_SMSD     6
+#define EL_STOP     7
+#define EL_TRN      8
+#define EL_RCV      9
+
+
+typedef struct event_log_msg
+{
+    int  processed;
+    int  global_elevel;
+
+    int  type;
+    int  elevel;
+    int  component;
+    char component_detail[SE_MAX_DB_NAME_LENGTH + 1];
+    int  sid;
+    int  trid;
+    int  pid;
+    int  lineno;
+    char filename[SE_EVENT_LOG_FILENAME_LEN];
+    char funcname[SE_EVENT_LOG_FUNCNAME_LEN];
+    char content[SE_EVENT_LOG_CONTENT_LEN];
+} event_log_msg;
+
+
+
+
+
+/*----------
+ * Error reporting API for short messages (less than SE_EVENT_LOG_CONTENT_LEN)
+ * to be used in this way:
+ *      elog(EL_ERROR,
+ *           ("Not enough resources to complete the query (mem_free = %d, mem_used = %d)", mem_free, mem_used));
+ *----------
+ */
+#define elog(elevel, rest) \
+        ((elevel) <= event_log_elevel \
+         ? ((event_log_initialized) ? (event_log_short_msg_macro((elevel), \
+                                                                 __FILE__, \
+                                                                 __LINE__, \
+                                                                 __SE_FUNCTION__, \
+                                                                 (event_log_short_msg_param rest))) \
+                                    : (event_log_short_write_to_stderr rest)) \
+         : 0)
+
+/*----------
+ * Error reporting API for long messages to be used in this way:
+ *      elog_long(EL_LOG, "User query: ", query);
+ *----------
+ */
+#define elog_long(elevel, short_str, long_str) \
+        ((elevel) <= event_log_elevel \
+         ? ((event_log_initialized) ? (event_log_long_msg((elevel), \
+                                                          __FILE__, \
+                                                          __LINE__, \
+                                                          __SE_FUNCTION__, \
+                                                          (short_str), \
+                                                          (long_str))) \
+                                    : (event_log_long_write_to_stderr((short_str), (long_str)))) \
+         : 0)
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Event log set up parameters
+ */
+extern int event_log_elevel;            /* current event log error level */
+extern int event_log_location;          /* output the originator of record (GOV, SM, etc.)*/
+extern int event_log_detailed_location; /* output filename, function, line */
+extern int event_log_recommended_size;  /* after exceeding this size the log file rotate is done */
+extern int event_log_truncate;          /* delete file after log rotation? */
+
+extern int event_log_initialized;
+
+/* ============================================================================
+ * Client functions for logging short messages
+ * ============================================================================
+ */
+int event_log_short_msg_macro(int elevel,
+                              const char *filename,
+                              int lineno,
+                              const char *funcname,
+                              int content_len);
+
+int event_log_short_msg_param(const char *s, 
+                              ...);
+
+int event_log_short_msg(int elevel, 
+                        const char *filename, 
+                        int lineno, 
+                        const char *funcname, 
+                        const char *s, 
+                        ...);
+
+int event_log_short_write_to_stderr(const char *s, ...);
+
+
+/* ============================================================================
+ * Client functions for logging long messages
+ * ============================================================================
+ */
+int event_log_long_msg(int elevel,
+                       const char *filename,
+                       int lineno,
+                       const char *funcname,
+                       const char *short_str,
+                       const char *long_str);
+
+int event_log_long_write_to_stderr(const char *short_str, const char *long_str);
+
+
+/* ============================================================================
+ * Init/release functions
+ * ============================================================================
+ */
+
+/*
+ * Start/shutdown event logging daemon 
+ * (call these functions in the 'main' process)
+ * 
+ */
+int event_logger_start_daemon(int elevel, global_name shm_name, global_name sems_name);
+int event_logger_shutdown_daemon();
+
+/*
+ * Init/release event log 
+ * (call these functions in the 'client' processes)
+ */
+int event_logger_init(int component, const char* component_detail, global_name shm_name, global_name sems_name);
+int event_logger_release();
+
+
+/* ============================================================================
+ * Set/get functions
+ * ============================================================================
+ */
+
+/*
+ * Set session id for trn process
+ */
+int event_logger_set_sid(int sid);
+
+/*
+ * Set transaction id for trn process
+ */
+int event_logger_set_trid(int trid);
+
+/*
+* Converts level provided from the command line/configuration file to
+* the one of the known by event log (EL_LOG, EL_ERRORS, etc).
+*/
+int el_convert_log_level(int level);
+
+/*
+ * Creates a file for soft fault log
+ */
+UFile sedna_soft_fault_log_fh(int component, const char *suffix);
+
+/*
+ * Creates a separate file with soft fault log (log_message) for the component (component).
+ */
+void sedna_soft_fault_log(const char* log_message, int  component);
+
+/*
+ *  Sedna soft fault function. 
+ *  !! two sedna_soft_fault functions are defined in exceptions.h 
+ */
+
+void sedna_soft_fault(int component);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /*_EVENT_LOG_H*/

data/vendor/sedna/kernel/common/errdbg/exceptions.cpp

@@ -0,0 +1,155 @@
+/*
+ * File:  exceptions.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#include "common/sedna.h"
+#include "common/errdbg/exceptions.h"
+#include "common/u/uprocess.h"
+#include "common/errdbg/event_log.h"
+
+/*	SednaException is derived from std::exception, hence
+	it must implement the following method:
+	
+	const char *what() const throw();
+
+	SednaException defines virtual function to obtain
+	error description as std::string, namely getMsg2().
+	The string must not vanish when what() function
+	returns. We have descriptCache member for this purpose.
+*/ 
+const std::string &SednaException::getMsg() const
+{
+	if (descriptCache.empty()) 
+	{
+		std::string descript = getMsg2();
+		descriptCache.swap(descript);
+	}
+	return descriptCache;
+}
+
+std::string SednaSystemException::getMsg2() const
+{
+    std::string res;
+	res.reserve(1024);
+    res += "SEDNA Message: FATAL ERROR\n";
+    res += "System error. This error means system malfunction.\n";
+    res += "Details: " + err_msg + "\n";
+#if (EL_DEBUG == 1)
+    res += "Position: [" + file + ":" + function + ":" + int2string(line) + "]\n";
+#endif
+    return res;
+}
+	
+std::string SednaSystemEnvException::getMsg2() const
+{
+    std::string res;
+	res.reserve(1024);
+    res += "SEDNA Message: FATAL ERROR\n";
+    res += "Environment error. This error is caused by environment (operating system) and ";
+    res += "it means that the system cannot continue execution anymore.\n";
+    res += "Details: " + err_msg + "\n";
+#if (EL_DEBUG == 1)
+    res += "Position: [" + file + ":" + function + ":" + int2string(line) + "]\n";
+#endif
+    return res;
+}
+
+std::string SednaUserException::getMsg2() const
+{
+    std::string res;
+	res.reserve(1024);
+    res += "SEDNA Message: ERROR ";
+    res += std::string(user_error_code_entries[internal_code].code) + "\n";
+    res += std::string(user_error_code_entries[internal_code].descr) + "\n";
+    if (err_msg.length() != 0)
+    {
+        res += "Details: " + err_msg + "\n";
+    }
+#if (EL_DEBUG == 1)
+    res += "Position: [" + file + ":" + function + ":" + int2string(line) + "]\n";
+#endif
+    return res;
+}
+
+std::string SednaUserExceptionFnError::getMsg2() const
+{
+    U_ASSERT(error_name.size() != 0);
+
+    std::string res;
+	res.reserve(1024);
+    res += "SEDNA Message: ERROR ";
+    res += error_name + "\n";
+    res += "    " + (error_descr.size() == 0 ? std::string("User defined error") : error_descr) + "\n";
+#if (EL_DEBUG == 1)
+    res += "Position: [" + file + ":" + function + ":" + int2string(line) + "]\n";
+#endif
+    return res;
+}
+
+std::string SednaUserEnvException::getDescription() const 
+{ 
+    return err_msg + 
+            (explanation.length() != 0 ? " (" + explanation + ")"
+                                        : ""); 
+}
+
+std::string SednaUserEnvException::getMsg2() const
+{
+    std::string res;
+	res.reserve(1024);
+    res += "SEDNA Message: ERROR ";
+    res += std::string(user_error_code_entries[internal_code].code) + "\n";
+    res += std::string(user_error_code_entries[internal_code].descr) + "\n";
+    res += "Details: " + err_msg;
+    if (explanation.length() != 0)
+    {
+        res += " (" + explanation + ")";
+    }
+    res += "\n";
+#if (EL_DEBUG == 1)
+    res += "Position: [" + file + ":" + function + ":" + int2string(line) + "]\n";
+#endif
+    return res;
+}
+
+
+void sedna_soft_fault(const SednaException &e,  int component)
+{
+    SEDNA_SOFT_FAULT_BASE_MSG;
+
+	char log_message[SE_SOFT_FAULT_LOG_CONTENT_LEN];
+    int log_message_len = e.getDescription().length();
+
+    if (log_message_len != 0)
+        fprintf(stderr, "Details: %s\n", e.getDescription().c_str());
+    if(log_message_len < SE_SOFT_FAULT_LOG_CONTENT_LEN)
+        strcpy(log_message, e.getDescription().c_str());
+    else
+        strcpy(log_message, "Failed to record exception description into the log\n");
+#if (EL_DEBUG == 1)
+    fprintf(stderr, "Position: [%s:%s:%d]\n", e.getFile().c_str(), e.getFunction().c_str(), e.getLine());
+	sprintf(log_message+(log_message_len),"\nPosition: [%s:%s:%d]\n", e.getFile().c_str(), e.getFunction().c_str(), e.getLine());
+#endif
+	
+    sedna_soft_fault_log(log_message, component);
+#ifdef SE_MEMORY_TRACK
+	DumpUnfreed(component);
+#endif
+
+    SEDNA_SOFT_FAULT_FINALIZER;
+}
+
+void sedna_soft_fault(const char* s, int  component)
+{
+    SEDNA_SOFT_FAULT_BASE_MSG;
+    fprintf(stderr, "Details: %s\n", s);
+	sedna_soft_fault_log(s, component);
+
+#ifdef SE_MEMORY_TRACK
+	DumpUnfreed(component);
+#endif
+
+    SEDNA_SOFT_FAULT_FINALIZER;
+}
+

data/vendor/sedna/kernel/common/errdbg/exceptions.h

@@ -0,0 +1,559 @@
+/*
+ * File:  exceptions.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+
+/**
+The following primary exceptions are defined for Sedna (later referred as 
+"the system").
+
+                         SednaException
+                         //          \\______________________
+                        //            \\_____________________\\
+                       //                                     \\
+       SednaSystemException                               SednaUserException  ______________________________
+               ||                                ________//      ||       \\____________    _______________\\
+               ||                              / ________/       ||        \____________\\                  \\
+               ||                             //                 ||                      \\                  \\
+     SednaSystemEnvException   SednaUserExceptionFnError SednaUserEnvException SednaUserSoftException SednaXQueryException
+
+
+SednaException -- abstract base exception class. You cannot use it for raising
+exceptions
+
+SednaSystemException -- use it when some system error happens. This error means
+that the system is completely malfunction. The reaction on this error is hard 
+stopping of all components currently running.
+
+SednaSystemEnvException -- the same as SednaSystemException except one point.
+The output to a user produced as the reaction to this error says that it was 
+environment (operating system) fault and the system can not be longer running.
+For the previous exception responsibility is on the developers.
+
+SednaUserException -- use it when some kind of error happens but this error
+is not fatal for the system but rather a recoverable error. Most errors of 
+this type are errors caused by users (wrong queries they sends). But they can
+be other errors such as "can not connect to sm because sm is not running"
+caused by trn. The reaction on this error is to produce correct message to the
+user with an explanation of the problem. Error codes and descriptions of errors
+are defined in error.codes file, which is in the same directory as the file you
+are reading now.
+
+SednaXQueryException -- use it within physical plan operations (PP*). It has 
+semantic as SednaUserException with better diagnostic. Line of the XQuery query
+must be provided with which error is connected. 0 means 'I can't say exact line'.
+
+SednaUserExceptionFnError -- use it for errors raised by users (fn:error function).
+
+SednaUserEnvException -- the same as SednaUserException with a bit different
+semantics.  Use this exception to notify the user that the system cannot do
+something because of the environment (operating system). You need not define 
+error code for this kind of error (it is already defined), but you
+rather need to provide a correct description. This exception is needed to
+simplify the life of the developers, because it allow them not to define
+enormous number of error codes for routine operations such as semaphore
+creation.
+The example of using this exception is the following:
+
+if (<cannot create semaphore during startup>)
+   throw USER_ENV_EXCEPTION("Cannot create semaphore <the name of the semaphore>",
+                            false);
+
+SednaUserSoftException -- this exception class rather differs from other 
+exceptions. It is used for correct program termination instead of signaling
+some error condition. Its purpose can be clarified by the following example.
+Suppose you have to parse command line arguments for already started (and 
+initialized) process. If you find some error in command line parameters its your
+obligatory to finish the process and bring the error message to the user. If you
+just simply write error message to console and exit from the process, it may
+crash the system because in this case you avoid process deinitialization, which
+is performed by the program code somewhere else in the program. From the other
+hand, if you raise SednaUserException then you have to supply error code and,
+what is more important, the error message that is identified by this error
+code will be enlarged with additional information such as error code and a 
+comment. The solution to this problem is to use SednaUserSoftException for raising
+the error. In this case process deinitialization will be completed as a part
+of the standard error handling mechanism and the user will see exactly the same
+error message that you have supplied.
+
+
+
+
+For raising exception it is better to use these macroses:
+
+#define SYSTEM_EXCEPTION(msg)						SednaSystemException(__FILE__, __FUNCTION__, __LINE__, msg)
+#define SYSTEM_ENV_EXCEPTION(msg)					SednaSystemEnvException(__FILE__, __FUNCTION__, __LINE__, msg)
+#define USER_EXCEPTION(code)						SednaUserException(__FILE__, __FUNCTION__, __LINE__, code)
+#define USER_EXCEPTION2(code, details)				SednaUserException(__FILE__, __FUNCTION__, __LINE__, details, code)
+#define XQUERY_EXCEPTION(code)						SednaUserException(__FILE__, __FUNCTION__, __LINE__, code, __current_physop)
+#define XQUERY_EXCEPTION2(code, details)			SednaUserException(__FILE__, __FUNCTION__, __LINE__, details, code, __current_physop)
+#define USER_EXCEPTION_FNERROR(err_name, err_descr) SednaUserException(__FILE__, __SE_FUNCTION__, __LINE__, err_name, err_descr))
+#define USER_ENV_EXCEPTION(msg, rollback)			SednaUserEnvException(__FILE__, __FUNCTION__, __LINE__, msg, rollback)
+#define USER_ENV_EXCEPTION2(msg, expl, rollback)	SednaUserEnvException(__FILE__, __FUNCTION__, __LINE__, msg, expl, rollback)
+#define USER_SOFT_EXCEPTION(msg)					SednaUserSoftException(__FILE__, __FUNCTION__, __LINE__, msg)
+
+Their names are straightfoward. Parameters are:
+msg                     -- a textual message (some kind of error description)
+code                    -- the code for user defined error (use constants defined in 
+                           error_codes.h; example is SE1001)
+details                 -- details for user error
+expl                    -- explanation of error
+rollback                -- does the error leads to rollback?
+__current_physop        -- defines current physical operation
+
+
+
+Errors could be outputted to the user in the format of <sedna-message>:
+
+<sedna-message. ::=
+"SEDNA Message: " <problem> <line-break>
+<description> <line-break>
+[ "Details: " <details> <line-break> ]
+[ "Position: [" <file> ":" <function> ":" <line> "]" <line-break> ]
+
+<problem> ::= "ERROR " <code>
+            | "FATAL ERROR"
+
+<description> ::= <string-without-without-line-break>
+
+<file> ::= <string-without-without-line-break>
+
+<function> ::= <string-without-without-line-break>
+
+<line> ::= <integer>
+
+<code> ::= <code-from-(error.codes)>
+
+*/
+
+
+
+#ifndef __EXCEPTIONS_H
+#define __EXCEPTIONS_H
+
+#include <stdexcept>
+#include <string>
+#include "common/utils.h"
+#include "common/errdbg/error_codes.h"
+
+/*	Never use catch(...), use catch(ANY_SE_EXCEPTION) instead. Catch(...) 
+	statement is missinterpreted by cl version 13 and earlier ones. It catches
+	not just any C++ object coming from 'throw' statement (as per C++ standard)
+	but also access violations and other exceptional conditions reported by OS.
+	For catch(ANY_SE_EXCEPTION) to work properly ensure that all exceptions
+	in the project are descendants of std::exception class. */ 
+#define ANY_SE_EXCEPTION	std::exception &
+
+#define SYSTEM_EXCEPTION(msg) \
+    ((U_ASSERT_MACRO(false)), \
+     elog(EL_FATAL, (msg)), \
+     SednaSystemException(__FILE__, __SE_FUNCTION__, __LINE__, msg))
+
+#define SYSTEM_ENV_EXCEPTION(msg) \
+    (elog(EL_FATAL, (msg)), \
+     SednaSystemEnvException(__FILE__, __SE_FUNCTION__, __LINE__, msg))
+
+#define USER_EXCEPTION(internal_code) \
+    (elog(EL_ERROR, ("(%s) %s", \
+                     user_error_code_entries[internal_code].code, \
+                     user_error_code_entries[internal_code].descr)), \
+     SednaUserException(__FILE__, __SE_FUNCTION__, __LINE__, internal_code))
+
+#define USER_EXCEPTION2(internal_code, details) \
+    (elog(EL_ERROR, ("(%s) %s Details: %s", \
+                     user_error_code_entries[internal_code].code, \
+                     user_error_code_entries[internal_code].descr, \
+                     details)), \
+     SednaUserException(__FILE__, __SE_FUNCTION__, __LINE__, details, internal_code))
+
+#define XQUERY_EXCEPTION(internal_code) \
+    (elog(EL_ERROR, ("(%s) %s", \
+                     user_error_code_entries[internal_code].code, \
+                     user_error_code_entries[internal_code].descr)), \
+     SednaXQueryException(__FILE__, __SE_FUNCTION__, __LINE__, internal_code, executor_globals::__current_physop))
+
+#define XQUERY_EXCEPTION2(internal_code, details) \
+    (elog(EL_ERROR, ("(%s) %s Details: %s", \
+                     user_error_code_entries[internal_code].code, \
+                     user_error_code_entries[internal_code].descr, \
+                     details)), \
+     SednaXQueryException(__FILE__, __SE_FUNCTION__, __LINE__, details, internal_code, executor_globals::__current_physop))
+
+#define USER_EXCEPTION_FNERROR(err_name, err_descr) \
+    (elog(EL_ERROR, ("(%s) %s", \
+                     err_name, \
+                     err_descr)), \
+     SednaUserExceptionFnError(__FILE__, __SE_FUNCTION__, __LINE__, err_name, err_descr))
+
+#define USER_ENV_EXCEPTION(msg, rollback) \
+    (elog(EL_ERROR, ("(%s) %s Details: %s", \
+                     user_error_code_entries[0].code, \
+                     user_error_code_entries[0].descr, \
+                     msg)), \
+     SednaUserEnvException(__FILE__, __SE_FUNCTION__, __LINE__, msg, rollback))
+
+
+#define USER_ENV_EXCEPTION2(msg, expl, rollback) \
+    (elog(EL_ERROR, ("(%s) %s Details: %s (%s)", \
+                     user_error_code_entries[0].code, \
+                     user_error_code_entries[0].descr, \
+                     msg, \
+                     expl)), \
+     SednaUserEnvException(__FILE__, __SE_FUNCTION__, __LINE__, msg, expl, rollback))
+
+#define USER_SOFT_EXCEPTION(msg) \
+     SednaUserSoftException(__FILE__, __SE_FUNCTION__, __LINE__, msg)
+
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaException
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaException : public std::exception
+{
+private:
+	/* see SednaException::getMsg() for explanation (in cpp file) */ 
+	mutable std::string descriptCache;
+
+protected:
+    std::string file; 
+    std::string function;
+    int line;
+    std::string err_msg;
+
+    virtual std::string getMsg2()         const = 0;
+
+public:
+	/*	Since SednaException is derived from std::exception, throw() specification
+		established in base class must be met. The compiler-generated destructor
+		has wrong throw() specification since std::string destructor doesn't
+		manifest anything about exceptions. 
+		
+		GCC is the jerk! */ 
+	~SednaException() throw() { ; }
+
+	SednaException(const char* _file_, 
+                   const char* _function_,
+                   int _line_,
+                   const char* _err_msg_) : file(_file_),
+                                            function(_function_),
+                                            line(_line_),
+                                            err_msg(_err_msg_) {}
+
+	const std::string &getMsg()          const;
+    virtual std::string getDescription() const { return err_msg; }
+    virtual std::string getFile()        const { return file; }
+    virtual std::string getFunction()    const { return function; }
+    virtual int         getLine()        const { return line; }
+
+	/*	Throw self. Used somewhere to determine the preciese type
+		of the exception object given a reference to SednaException.
+		The code is similar to this snippet:
+		
+		void DispatchSednaException(SednaException *e)
+		{
+			try
+			{
+				e.rase();
+			}
+			catch(const SednaSystemEnvException &sysEnvE)
+			{
+				-- the exception is SednaSystemEnvException, act accordingly --
+			}
+			catch(const SednaSystemException &sysE)
+			{
+				-- the exception is SednaSystemException, act accordingly --
+			}
+			-- etc --
+		}*/ 
+	virtual void raise() const = 0;
+
+	/*	The standard method to obtain exception info defined by 
+		all std::exception descendants. */ 
+	const char *what() const throw() { return getMsg().c_str(); }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaSystemException
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaSystemException : public SednaException
+{
+protected:
+	virtual std::string getMsg2() const;
+
+public:
+    SednaSystemException(const char* _file_, 
+                         const char* _function_,
+                         int _line_,
+                         const char* _err_msg_) : SednaException(_file_,
+                                                                        _function_,
+                                                                        _line_,
+                                                                        _err_msg_) {}
+	virtual void raise() const { throw *this; }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaSystemEnvException
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaSystemEnvException : public SednaSystemException
+{
+protected:
+	virtual std::string getMsg2() const;
+
+public:
+    SednaSystemEnvException(const char* _file_, 
+                            const char* _function_,
+                            int _line_,
+                            const char* _err_msg_) : SednaSystemException(_file_, 
+                                                                                 _function_, 
+                                                                                 _line_, 
+                                                                                 _err_msg_) {}
+	virtual void raise() const { throw *this; }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaUserException
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaUserException : public SednaException
+{
+protected:
+    int internal_code;
+	virtual std::string getMsg2() const;
+
+public:
+    SednaUserException(const char* _file_, 
+                       const char* _function_,
+                       int _line_,
+                       int _internal_code_) : SednaException(_file_,
+                                                             _function_,
+                                                             _line_,
+                                                             ""), 
+                                              internal_code(_internal_code_) {}
+    SednaUserException(const char* _file_, 
+                       const char* _function_,
+                       int _line_,
+                       const char* _err_msg_,
+                       int _internal_code_) : SednaException(_file_,
+                                                             _function_,
+                                                             _line_,
+                                                             _err_msg_), 
+                                              internal_code(_internal_code_) {}
+    virtual int  get_code() const { return internal_code; }
+    virtual bool need_rollback() 
+	{
+		return user_error_code_entries[internal_code].act == ueca_ROLLBACK_TRN; 
+	}
+	virtual void raise() const { throw *this; }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaUserExceptionFnError
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaUserExceptionFnError : public SednaUserException
+{
+protected:
+    std::string error_name;
+    std::string error_descr;
+	virtual std::string getMsg2() const;
+
+public:
+	/* see ~SednaException() for explanation */ 
+	~SednaUserExceptionFnError() throw() { ; }
+
+    SednaUserExceptionFnError(const char* _file_, 
+                              const char* _function_,
+                              int _line_,
+                              const char* _error_name_,
+                              const char* _error_descr_) : 
+                                    SednaUserException(_file_,
+                                                       _function_,
+                                                       _line_,
+                                                       SE9000), 
+                                    error_name(_error_name_),
+                                    error_descr(_error_descr_ ? _error_descr_ : "") {}
+
+    virtual int  get_code() const { return internal_code; }
+    virtual bool need_rollback() { return true; }
+	virtual void raise() const { throw *this; }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaUserEnvException
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaUserEnvException : public SednaUserException
+{
+protected:
+    bool rollback;
+    std::string explanation;
+	virtual std::string getMsg2() const;
+
+public:
+	/* see ~SednaException() for explanation */ 
+	~SednaUserEnvException() throw() { ; }
+
+    SednaUserEnvException(const char* _file_, 
+                          const char* _function_,
+                          int _line_,
+                          const char* _err_msg_,
+                          bool _rollback_) : SednaUserException(_file_,
+                                                                _function_,
+                                                                _line_,
+                                                                _err_msg_,
+                                                                0),
+                                             rollback(_rollback_) {}
+    SednaUserEnvException(const char* _file_, 
+                          const char* _function_,
+                          int _line_,
+                          const char* _err_msg_,
+                          const char* _explanation_,
+                          bool _rollback_) : SednaUserException(_file_,
+                                                                _function_,
+                                                                _line_,
+                                                                _err_msg_,
+                                                                0),
+                                             rollback(_rollback_),
+					     explanation(_explanation_){}
+
+    virtual std::string getDescription() const;
+    virtual bool need_rollback() { return rollback; }
+	virtual void raise() const { throw *this; }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaUserSoftException
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaUserSoftException : public SednaUserException
+{
+protected:
+	virtual std::string getMsg2() const { return err_msg; }
+
+public:
+    SednaUserSoftException(const char* _file_, 
+                           const char* _function_,
+                           int _line_,
+                           const char* _err_msg_) : SednaUserException(_file_,
+                                                                       _function_,
+                                                                       _line_,
+                                                                       _err_msg_,
+                                                                       -1) {}
+    virtual bool need_rollback() { return false; }
+	virtual void raise() const { throw *this; }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+/// SednaXQueryException - in PPBase.h
+//////////////////////////////////////////////////////////////////////////////
+
+class SednaXQueryException;
+
+//////////////////////////////////////////////////////////////////////////////
+/// Sedna soft fault fuctions.
+/// 'sedna_soft_fault' fuction with no message parameter is defined in event_loc.h
+//////////////////////////////////////////////////////////////////////////////
+
+void sedna_soft_fault(const SednaException &e, int component);
+void sedna_soft_fault(const char* s, int  component);
+
+
+//////////////////////////////////////////////////////////////////////////////
+/// Under Darwin we need this hack to compile Sedna with gcc 4.0.1
+//////////////////////////////////////////////////////////////////////////////
+
+#if defined(DARWIN)
+
+#ifdef    SYSTEM_EXCEPTION
+#undef    SYSTEM_EXCEPTION
+#define   SYSTEM_EXCEPTION(msg) __system_exception(__FILE__, __SE_FUNCTION__, __LINE__, msg)
+#endif /* SYSTEM_EXCEPTION */
+
+#ifdef    SYSTEM_ENV_EXCEPTION
+#undef    SYSTEM_ENV_EXCEPTION
+#define   SYSTEM_ENV_EXCEPTION(msg) __system_env_exception(__FILE__, __SE_FUNCTION__, __LINE__, msg)
+#endif /* SYSTEM_ENV_EXCEPTION */
+
+#ifdef    USER_EXCEPTION2
+#undef    USER_EXCEPTION2
+#define   USER_EXCEPTION2(internal_code, details) __user_exception2(__FILE__, __SE_FUNCTION__, __LINE__, internal_code, details)
+#endif /* USER_EXCEPTION2 */
+
+#ifdef    XQUERY_EXCEPTION2
+#undef    XQUERY_EXCEPTION2
+#define   XQUERY_EXCEPTION2(internal_code, details) __xquery_exception2(__FILE__, __SE_FUNCTION__, __LINE__, internal_code, details)
+#endif /* XQUERY_EXCEPTION2 */
+
+#ifdef    USER_EXCEPTION_FNERROR
+#undef    USER_EXCEPTION_FNERROR
+#define   USER_EXCEPTION_FNERROR(err_name, err_descr) __user_exception_fnerror(__FILE__, __SE_FUNCTION__, __LINE__, err_name, err_descr)
+#endif /* USER_EXCEPTION_FNERROR */
+
+#ifdef    USER_ENV_EXCEPTION
+#undef    USER_ENV_EXCEPTION
+#define   USER_ENV_EXCEPTION(msg, rollback) __user_env_exception(__FILE__, __SE_FUNCTION__, __LINE__, msg, rollback)
+#endif /* USER_ENV_EXCEPTION */
+
+#ifdef    USER_ENV_EXCEPTION2
+#undef    USER_ENV_EXCEPTION2
+#define   USER_ENV_EXCEPTION2(msg, expl, rollback) __user_env_exception2(__FILE__, __SE_FUNCTION__, __LINE__, msg, expl, rollback)
+#endif /* USER_ENV_EXCEPTION2 */
+
+#ifdef    USER_SOFT_EXCEPTION
+#undef    USER_SOFT_EXCEPTION
+#define   USER_SOFT_EXCEPTION(msg) __user_soft_exception(__FILE__, __SE_FUNCTION__, __LINE__, msg)
+#endif /* USER_SOFT_EXCEPTION */
+
+
+inline SednaSystemException __system_exception(const char *file, const char *func, int line, const char *msg) {
+    return ((U_ASSERT_MACRO(false)), 
+             elog(EL_FATAL, (msg)), 
+             SednaSystemException(file, func, line, msg)); }
+
+inline SednaSystemEnvException __system_env_exception(const char *file, const char *func, int line, const char *msg) {
+    return (elog(EL_FATAL, (msg)), 
+            SednaSystemEnvException(file, func, line, msg)); }
+
+inline SednaUserException __user_exception2(const char *file, const char *func, int line, int code, const char * details) {
+    return (elog(EL_ERROR, ("(%s) %s Details: %s", 
+                            user_error_code_entries[code].code, 
+                            user_error_code_entries[code].descr,
+                            details)), 
+            SednaUserException(file, func, line, details, code)); }
+
+inline SednaUserExceptionFnError __user_exception_fnerror(const char *file, const char *func, int line, const char *err_name, const char* err_descr) {
+    return (elog(EL_ERROR, ("(%s) %s", 
+                            err_name, 
+                            err_descr)), 
+            SednaUserExceptionFnError(file, func, line, err_name, err_descr)); }
+
+inline SednaUserEnvException __user_env_exception(const char *file, const char *func, int line, const char *msg, bool rollback) {
+    return (elog(EL_ERROR, ("(%s) %s Details: %s", 
+                            user_error_code_entries[0].code, 
+                            user_error_code_entries[0].descr,
+                            msg)), 
+            SednaUserEnvException(file, func, line, msg, rollback)); }
+
+inline SednaUserEnvException __user_env_exception2(const char *file, const char *func, int line, const char *msg, const char* expl, bool rollback) {
+    return (elog(EL_ERROR, ("(%s) %s Details: %s (%s)", 
+                            user_error_code_entries[0].code, 
+                            user_error_code_entries[0].descr,
+                            msg,
+                            expl)), 
+            SednaUserEnvException(file, func, line, msg, expl, rollback)); }
+
+inline SednaUserSoftException __user_soft_exception(const char *file, const char *func, int line, const char *msg) {
+    return SednaUserSoftException(file, func, line, msg); }
+
+
+#endif /* DARWIN */
+
+//////////////////////////////////////////////////////////////////////////////
+
+
+#endif