duckdb::JSONParser Struct Reference

Inheritance diagram for duckdb::JSONParser:

Collaboration diagram for duckdb::JSONParser:

Classes
struct	Separator

Public Member Functions
bool	Process (const string &value)

Protected Types
enum class	JSONState { REGULAR , IN_QUOTE , ESCAPE }

Protected Member Functions
virtual void	HandleNull ()
virtual void	HandleBracketOpen (char bracket)
virtual void	HandleBracketClose (char bracket)
virtual void	HandleQuoteStart (char quote)
virtual void	HandleQuoteEnd (char quote)
virtual void	HandleComma (char comma)
virtual void	HandleColon ()
virtual void	HandleCharacter (char c)
virtual void	HandleEscapeStart (char c)
virtual void	Finish ()
bool	SeparatorIsMatching (Separator &sep, char closing_sep)
idx_t	Depth () const

Protected Attributes
JSONState	state = JSONState::REGULAR
vector< Separator >	separators
idx_t	pos = 0
bool	success = true

Member Enumeration Documentation

JSONState

enum class duckdb::JSONParser::JSONState

strongprotected

{ REGULAR, IN_QUOTE, ESCAPE };

Member Function Documentation

Process()

bool duckdb::JSONParser::Process

(

const string &

value

)

                                            {
    separators.clear();
    state = JSONState::REGULAR;
    char quote_char = '"';
    bool can_parse_value = false;
    bool in_unquoted_value = false;
    pos = 0;
    for (; success && pos < value.size(); pos++) {
        auto c = value[pos];
        if (state == JSONState::REGULAR) {
            if (can_parse_value) {
                // check if this is "null"
                if (pos + 4 < value.size() && StringUtil::CharacterToLower(c) == 'n' &&
                    StringUtil::CharacterToLower(value[pos + 1]) == 'u' &&
                    StringUtil::CharacterToLower(value[pos + 2]) == 'l' &&
                    StringUtil::CharacterToLower(value[pos + 3]) == 'l') {
                    HandleNull();
                    pos += 3;
                    continue;
                }
            }
            switch (c) {
            case '[':
            case '{': {
                // add a newline and indentation based on the separator count
                separators.push_back(c);
                HandleBracketOpen(c);
                can_parse_value = c == '[';
                break;
            }
            case '}':
            case ']': {
                // closing bracket - move to next line and pop back the separator
                if (separators.empty() || !SeparatorIsMatching(separators.back(), c)) {
                    throw InternalException("Failed to parse JSON string %s - invalid JSON", value);
                }
                separators.pop_back();
                HandleBracketClose(c);
                in_unquoted_value = false;
                break;
            }
            case '"':
            case '\'':
                HandleQuoteStart(c);
                quote_char = c;
                state = JSONState::IN_QUOTE;
                break;
            case ',':
                // comma - move to next line
                HandleComma(c);
                in_unquoted_value = false;
                break;
            case ':':
                HandleColon();
                can_parse_value = true;
                break;
            case '\\':
                // skip literal "\n" and "\t" (these were escaped previously by our rendering algorithm)
                if (pos + 1 < value.size() && IsWhitespaceEscape(value[pos + 1])) {
                    pos++;
                    break;
                }
                // if this is not a whitespace escape just handle it
                HandleCharacter(c);
                break;
            case ' ':
                if (in_unquoted_value) {
                    HandleCharacter(c);
                }
                break;
            case '\t':
            case '\n':
                // skip whitespace
                break;
            default:
                in_unquoted_value = true;
                HandleCharacter(c);
                break;
            }
        } else if (state == JSONState::IN_QUOTE) {
            if (c == quote_char) {
                // break out of quotes
                state = JSONState::REGULAR;
                HandleQuoteEnd(c);
            } else if (c == '\\') {
                // escape
                state = JSONState::ESCAPE;
                HandleEscapeStart(c);
            } else {
                HandleCharacter(c);
            }
        } else if (state == JSONState::ESCAPE) {
            state = JSONState::IN_QUOTE;
            HandleCharacter(c);
        } else {
            throw InternalException("Invalid json state");
        }
    }
    if (!success) {
        return false;
    }
    Finish();
    return true;
}

HandleNull()

virtual void duckdb::JSONParser::HandleNull ( )

inlineprotectedvirtual

                              {
    }

HandleBracketOpen()

virtual void duckdb::JSONParser::HandleBracketOpen ( char  bracket )

inlineprotectedvirtual

                                                 {
    }

HandleBracketClose()

virtual void duckdb::JSONParser::HandleBracketClose ( char  bracket )

inlineprotectedvirtual

                                                  {
    }

HandleQuoteStart()

virtual void duckdb::JSONParser::HandleQuoteStart ( char  quote )

inlineprotectedvirtual

                                              {
    }

HandleQuoteEnd()

virtual void duckdb::JSONParser::HandleQuoteEnd ( char  quote )

inlineprotectedvirtual

                                            {
    }

HandleComma()

virtual void duckdb::JSONParser::HandleComma ( char  comma )

inlineprotectedvirtual

                                         {
    }

HandleColon()

virtual void duckdb::JSONParser::HandleColon ( )

inlineprotectedvirtual

                               {
    }

HandleCharacter()

virtual void duckdb::JSONParser::HandleCharacter ( char  c )

inlineprotectedvirtual

                                         {
    }

HandleEscapeStart()

virtual void duckdb::JSONParser::HandleEscapeStart ( char  c )

inlineprotectedvirtual

                                           {
    }

Finish()

virtual void duckdb::JSONParser::Finish ( )

inlineprotectedvirtual

                          {
    }

SeparatorIsMatching()

bool duckdb::JSONParser::SeparatorIsMatching ( Separator &  sep, char  closing_sep  )

protected

                                                                     {
    if (sep.sep == '{' && closing_sep == '}') {
        return true;
    }
    if (sep.sep == '[' && closing_sep == ']') {
        return true;
    }
    return false;
}

Depth()

idx_t duckdb::JSONParser::Depth ( ) const

inlineprotected

                        {
        return separators.size();
    }

---

The documentation for this struct was generated from the following file:

• external/duckdb/duckdb.cpp