duckdb::ErrorData Class Reference

Collaboration diagram for duckdb::ErrorData:

Public Member Functions
DUCKDB_API	ErrorData ()
	Not initialized, default constructor.
DUCKDB_API	ErrorData (const std::exception &ex)
	From std::exception.
DUCKDB_API	ErrorData (ExceptionType type, const string &raw_message)
	From a raw string and exception type.
DUCKDB_API	ErrorData (const string &raw_message)
	From a raw string.
DUCKDB_API void	Throw (const string &prepended_message="") const
	Throw the error.
DUCKDB_API const ExceptionType &	Type () const
	Get the internal exception type of the error.
DUCKDB_API const string &	Message () const
	Used in clients like C-API, creates the final message and returns a reference to it.
DUCKDB_API const string &	RawMessage () const
DUCKDB_API void	Merge (const ErrorData &other)
DUCKDB_API bool	operator== (const ErrorData &other) const
bool	HasError () const
	Returns true, if this error data contains an exception, else false.
const unordered_map< string, string > &	ExtraInfo () const
DUCKDB_API void	FinalizeError ()
DUCKDB_API void	AddErrorLocation (const string &query)
DUCKDB_API void	ConvertErrorToJSON ()
DUCKDB_API void	AddQueryLocation (optional_idx query_location)
DUCKDB_API void	AddQueryLocation (QueryErrorContext error_context)
DUCKDB_API void	AddQueryLocation (const ParsedExpression &ref)
DUCKDB_API void	AddQueryLocation (const TableRef &ref)

Private Member Functions
DUCKDB_API string	ConstructFinalMessage () const

Static Private Member Functions
static DUCKDB_API string	SanitizeErrorMessage (string error)

Private Attributes
bool	initialized
	Whether this ErrorData contains an exception or not.
ExceptionType	type
	The ExceptionType of the preserved exception.
string	raw_message
	The message the exception was constructed with (does not contain the Exception Type)
string	final_message
	The final message (stored in the preserved error for compatibility reasons with C-API)
unordered_map< string, string >	extra_info
	Extra exception info.

Constructor & Destructor Documentation

ErrorData() [1/4]

duckdb::ErrorData::ErrorData

(

)

Not initialized, default constructor.

                     : initialized(false), type(ExceptionType::INVALID) {
}

ErrorData() [2/4]

duckdb::ErrorData::ErrorData

(

const std::exception &

ex

)

From std::exception.

                                           : ErrorData(ex.what()) {
}

ErrorData() [3/4]

duckdb::ErrorData::ErrorData	(	ExceptionType	type,
		const string &	raw_message
	)

From a raw string and exception type.

    : initialized(true), type(type), raw_message(SanitizeErrorMessage(message)) {
    // In the case of ExceptionType::INTERNAL, the stack trace is part of the final message.
    // To construct it, we need to access extra_info, which has to be initialized first.
    // Thus, we only set final_message in the constructor's body.
    final_message = ConstructFinalMessage();
}

ErrorData() [4/4]

duckdb::ErrorData::ErrorData ( const string &  raw_message )

explicit

From a raw string.

    : initialized(true), type(ExceptionType::INVALID), raw_message(string()), final_message(string()) {
    // parse the constructed JSON
    if (message.empty() || message[0] != '{') {
        // Not a JSON-formatted message.
        // Use the message as a raw Exception message and leave the type as uninitialized.
        if (message == std::bad_alloc().what()) {
            type = ExceptionType::OUT_OF_MEMORY;
            raw_message = "Allocation failure";
        } else {
            raw_message = message;
        }
        final_message = ConstructFinalMessage();
        return;
    }
 
    // JSON-formatted message.
    auto info = StringUtil::ParseJSONMap(message)->Flatten();
    for (auto &entry : info) {
        if (entry.first == "exception_type") {
            type = Exception::StringToExceptionType(entry.second);
        } else if (entry.first == "exception_message") {
            raw_message = SanitizeErrorMessage(entry.second);
        } else {
            extra_info[entry.first] = entry.second;
        }
    }
    final_message = ConstructFinalMessage();
}

Here is the call graph for this function:

Member Function Documentation

Throw()

void duckdb::ErrorData::Throw

(

const string &

prepended_message = ""

)

const

Throw the error.

                                                           {
    D_ASSERT(initialized);
    if (!prepended_message.empty()) {
        string new_message = prepended_message + raw_message;
        throw Exception(extra_info, type, new_message);
    }
    throw Exception(extra_info, type, raw_message);
}

Type()

const ExceptionType & duckdb::ErrorData::Type

(

)

const

Get the internal exception type of the error.

                                           {
    D_ASSERT(initialized);
    return this->type;
}

Message()

DUCKDB_API const string & duckdb::ErrorData::Message ( ) const

inline

Used in clients like C-API, creates the final message and returns a reference to it.

                                             {
        return final_message;
    }

RawMessage()

DUCKDB_API const string & duckdb::ErrorData::RawMessage ( ) const

inline

                                                {
        return raw_message;
    }

Merge()

void duckdb::ErrorData::Merge

(

const ErrorData &

other

)

                                            {
    if (!other.HasError()) {
        return;
    }
    if (!HasError()) {
        *this = other;
        return;
    }
    if (Exception::InvalidatesDatabase(other.Type()) || other.type == ExceptionType::INTERNAL) {
        // inherit severe types
        type = other.type;
    }
    final_message += "\n\n" + other.Message();
}

operator==()

bool duckdb::ErrorData::operator==

(

const ErrorData &

other

)

const

                                                       {
    if (initialized != other.initialized) {
        return false;
    }
    if (type != other.type) {
        return false;
    }
    return raw_message == other.raw_message;
}

HasError()

bool duckdb::ErrorData::HasError ( ) const

inline

Returns true, if this error data contains an exception, else false.

                                 {
        return initialized;
    }

ExtraInfo()

const unordered_map< string, string > & duckdb::ErrorData::ExtraInfo ( ) const

inline

                                                           {
        return extra_info;
    }

FinalizeError()

void duckdb::ErrorData::FinalizeError

(

)

                              {
    auto entry = extra_info.find("stack_trace_pointers");
    if (entry != extra_info.end()) {
        auto stack_trace = StackTrace::ResolveStacktraceSymbols(entry->second);
        extra_info["stack_trace"] = std::move(stack_trace);
        extra_info.erase("stack_trace_pointers");
    }
}

AddErrorLocation()

void duckdb::ErrorData::AddErrorLocation

(

const string &

query

)

                                                    {
    if (!query.empty()) {
        auto entry = extra_info.find("position");
        if (entry != extra_info.end()) {
            raw_message = QueryErrorContext::Format(query, raw_message, std::stoull(entry->second));
            extra_info.erase(entry);
        }
    }
    {
        auto entry = extra_info.find("stack_trace");
        if (entry != extra_info.end() && !entry->second.empty()) {
            raw_message += "\n\nStack Trace:\n" + entry->second;
            entry->second = "";
        }
    }
    final_message = ConstructFinalMessage();
}

ConvertErrorToJSON()

void duckdb::ErrorData::ConvertErrorToJSON

(

)

                                   {
    if (!raw_message.empty() && raw_message[0] == '{') {
        // empty or already JSON
        return;
    }
    raw_message = StringUtil::ExceptionToJSONMap(type, raw_message, extra_info);
    final_message = raw_message;
}

AddQueryLocation() [1/4]

void duckdb::ErrorData::AddQueryLocation

(

optional_idx

query_location

)

                                                            {
    Exception::SetQueryLocation(query_location, extra_info);
}

AddQueryLocation() [2/4]

void duckdb::ErrorData::AddQueryLocation

(

QueryErrorContext

error_context

)

                                                                {
    AddQueryLocation(error_context.query_location);
}

AddQueryLocation() [3/4]

void duckdb::ErrorData::AddQueryLocation

(

const ParsedExpression &

ref

)

                                                            {
    AddQueryLocation(ref.GetQueryLocation());
}

AddQueryLocation() [4/4]

void duckdb::ErrorData::AddQueryLocation

(

const TableRef &

ref

)

                                                    {
    AddQueryLocation(ref.query_location);
}

SanitizeErrorMessage()

string duckdb::ErrorData::SanitizeErrorMessage ( string  error )

staticprivate

                                                   {
    return StringUtil::Replace(std::move(error), string("\0", 1), "\\0");
}

ConstructFinalMessage()

string duckdb::ErrorData::ConstructFinalMessage ( ) const

private

                                              {
    std::string error;
    if (type != ExceptionType::UNKNOWN_TYPE) {
        error = Exception::ExceptionTypeToString(type) + " ";
    }
    error += "Error: " + raw_message;
    if (type == ExceptionType::INTERNAL) {
        error += "\nThis error signals an assertion failure within DuckDB. This usually occurs due to "
                 "unexpected conditions or errors in the program's logic.\nFor more information, see "
                 "https://duckdb.org/docs/stable/dev/internal_errors";
 
        // Ensure that we print the stack trace for internal and fatal exceptions.
        auto entry = extra_info.find("stack_trace_pointers");
        if (entry != extra_info.end()) {
            auto stack_trace = StackTrace::ResolveStacktraceSymbols(entry->second);
            error += "\n\nStack Trace:\n" + stack_trace;
        }
    }
    return error;
}

---

The documentation for this class was generated from the following files:

• external/duckdb/duckdb.hpp
• external/duckdb/duckdb.cpp