duckdb::JSONFormatter Struct Reference

Inheritance diagram for duckdb::JSONFormatter:

Collaboration diagram for duckdb::JSONFormatter:

Classes
struct	FormatState

Static Public Member Functions
static void	FormatValue (BoxRenderValue &render_value, idx_t max_rows, idx_t max_width)

Protected Types
enum class	InlineMode { STANDARD , INLINED_SINGLE_LINE , INLINED_MULTI_LINE }
Protected Types inherited from duckdb::JSONParser
enum class	JSONState { REGULAR , IN_QUOTE , ESCAPE }

Protected Member Functions
void	HandleNull () override
void	HandleBracketOpen (char bracket) override
void	HandleBracketClose (char bracket) override
void	HandleQuoteStart (char quote) override
void	HandleQuoteEnd (char quote) override
void	HandleComma (char comma) override
void	HandleColon () override
void	HandleCharacter (char c) override
void	HandleEscapeStart (char c) override
void	AddLiteralCharacter (char c)
bool	LiteralFits (FormatState &format_state, idx_t render_width)
bool	LiteralFits (FormatState &format_state, const string &text)
void	AddLiteral (FormatState &format_state, const string &text, bool skip_adding_if_does_not_fit=false)
void	AddSpace (FormatState &format_state)
void	AddNewline (FormatState &format_state)
void	FormatComponent (FormatState &format_state, JSONComponent &component, InlineMode inline_mode)
JSONFormattingResult	TryFormat (JSONFormattingMode mode, BoxRenderValue &render_value, idx_t max_rows, idx_t max_width, idx_t indentation_size=2)
Protected Member Functions inherited from duckdb::JSONParser
virtual void	Finish ()
bool	SeparatorIsMatching (Separator &sep, char closing_sep)
idx_t	Depth () const

Protected Attributes
vector< JSONComponent >	components
Protected Attributes inherited from duckdb::JSONParser
JSONState	state = JSONState::REGULAR
vector< Separator >	separators
idx_t	pos = 0
bool	success = true

Additional Inherited Members
Public Member Functions inherited from duckdb::JSONParser
bool	Process (const string &value)

Member Enumeration Documentation

InlineMode

enum class duckdb::JSONFormatter::InlineMode

strongprotected

{ STANDARD, INLINED_SINGLE_LINE, INLINED_MULTI_LINE };

Constructor & Destructor Documentation

JSONFormatter()

duckdb::JSONFormatter::JSONFormatter ( )

inlineexplicit

                             {
    }

Member Function Documentation

FormatValue()

static void duckdb::JSONFormatter::FormatValue ( BoxRenderValue &  render_value, idx_t  max_rows, idx_t  max_width  )

inlinestatic

                                                                                           {
        // process the components
        JSONFormatter formatter;
        formatter.Process(render_value.text);
 
        idx_t indentation_size = 2;
 
        auto result =
            formatter.TryFormat(JSONFormattingMode::STANDARD, render_value, max_rows, max_width, indentation_size);
        if (result == JSONFormattingResult::SUCCESS) {
            return;
        }
        // if we exceeded the max row count - try in compact mode
        JSONFormattingMode mode;
        if (result == JSONFormattingResult::TOO_WIDE) {
            // reduce indentation size if the result was too wide
            mode = JSONFormattingMode::COMPACT_HORIZONTAL;
            indentation_size = 1;
        } else {
            mode = JSONFormattingMode::COMPACT_VERTICAL;
        }
        result = formatter.TryFormat(mode, render_value, max_rows, max_width, indentation_size);
        if (result == JSONFormattingResult::SUCCESS) {
            return;
        }
    }

HandleNull()

void duckdb::JSONFormatter::HandleNull ( )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                               {
        components.emplace_back(JSONComponentType::NULL_VALUE, "null");
    }

HandleBracketOpen()

void duckdb::JSONFormatter::HandleBracketOpen ( char  bracket )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                                  {
        components.emplace_back(JSONComponentType::BRACKET_OPEN, string(1, bracket));
    }

HandleBracketClose()

void duckdb::JSONFormatter::HandleBracketClose ( char  bracket )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                                   {
        components.emplace_back(JSONComponentType::BRACKET_CLOSE, string(1, bracket));
    }

HandleQuoteStart()

void duckdb::JSONFormatter::HandleQuoteStart ( char  quote )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                               {
        AddLiteralCharacter(quote);
    }

HandleQuoteEnd()

void duckdb::JSONFormatter::HandleQuoteEnd ( char  quote )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                             {
        AddLiteralCharacter(quote);
    }

HandleComma()

void duckdb::JSONFormatter::HandleComma ( char  comma )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                          {
        components.emplace_back(JSONComponentType::COMMA, ",");
    }

HandleColon()

void duckdb::JSONFormatter::HandleColon ( )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                {
        components.emplace_back(JSONComponentType::COLON, ":");
    }

HandleCharacter()

void duckdb::JSONFormatter::HandleCharacter ( char  c )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                          {
        AddLiteralCharacter(c);
    }

HandleEscapeStart()

void duckdb::JSONFormatter::HandleEscapeStart ( char  c )

inlineoverrideprotectedvirtual

Reimplemented from duckdb::JSONParser.

                                            {
        AddLiteralCharacter(c);
    }

AddLiteralCharacter()

void duckdb::JSONFormatter::AddLiteralCharacter ( char  c )

inlineprotected

                                     {
        if (components.empty() || components.back().type != JSONComponentType::LITERAL) {
            components.emplace_back(JSONComponentType::LITERAL, "");
        }
        components.back().text += c;
    }

LiteralFits() [1/2]

bool duckdb::JSONFormatter::LiteralFits ( FormatState &  format_state, idx_t  render_width  )

inlineprotected

                                                                    {
        auto &line_length = format_state.line_length;
        if (line_length + render_width > format_state.max_width) {
            return false;
        }
        return true;
    }

LiteralFits() [2/2]

bool duckdb::JSONFormatter::LiteralFits ( FormatState &  format_state, const string &  text  )

inlineprotected

                                                                    {
        idx_t render_width = Utf8Proc::RenderWidth(text);
        return LiteralFits(format_state, render_width);
    }

AddLiteral()

void duckdb::JSONFormatter::AddLiteral ( FormatState &  format_state, const string &  text, bool  skip_adding_if_does_not_fit = false  )

inlineprotected

                                                                                                             {
        auto &result = format_state.result;
        auto &line_length = format_state.line_length;
        idx_t render_width = Utf8Proc::RenderWidth(text);
        if (!LiteralFits(format_state, render_width)) {
            if (skip_adding_if_does_not_fit) {
                return;
            }
            AddNewline(format_state);
            if (format_state.format_result != JSONFormattingResult::SUCCESS) {
                return;
            }
        }
        result += text;
        line_length += render_width;
        if (line_length > format_state.max_width) {
            format_state.format_result = JSONFormattingResult::TOO_WIDE;
        }
    }

AddSpace()

void duckdb::JSONFormatter::AddSpace ( FormatState &  format_state )

inlineprotected

                                             {
        AddLiteral(format_state, " ", true);
    }

AddNewline()

void duckdb::JSONFormatter::AddNewline ( FormatState &  format_state )

inlineprotected

                                               {
        auto &result = format_state.result;
        auto &depth = format_state.depth;
        auto &row_count = format_state.row_count;
        auto &line_length = format_state.line_length;
        result += '\n';
        result += string(depth, ' ');
        row_count++;
        if (row_count > format_state.max_rows) {
            format_state.format_result = JSONFormattingResult::TOO_MANY_ROWS;
            return;
        }
        line_length = depth;
        if (line_length > format_state.max_width) {
            format_state.format_result = JSONFormattingResult::TOO_WIDE;
        }
    }

FormatComponent()

void duckdb::JSONFormatter::FormatComponent ( FormatState &  format_state, JSONComponent &  component, InlineMode  inline_mode  )

inlineprotected

                                                                                                      {
        auto &depth = format_state.depth;
        auto &line_length = format_state.line_length;
        auto &max_width = format_state.max_width;
        auto &c = format_state.component_idx;
        switch (component.type) {
        case JSONComponentType::BRACKET_OPEN: {
            depth += component.text == "{" ? format_state.indentation_size : 1;
            AddLiteral(format_state, component.text);
            if (inline_mode == InlineMode::STANDARD) {
                // not inlined
                // look forward until the corresponding bracket open - can we inline and not exceed the column width?
                idx_t peek_depth = 0;
                idx_t render_size = line_length;
                idx_t peek_idx;
                InlineMode inline_child_mode = InlineMode::STANDARD;
                for (peek_idx = c + 1; peek_idx < components.size() && render_size <= max_width; peek_idx++) {
                    auto &peek_component = components[peek_idx];
                    if (peek_component.type == JSONComponentType::BRACKET_OPEN) {
                        peek_depth++;
                    } else if (peek_component.type == JSONComponentType::BRACKET_CLOSE) {
                        if (peek_depth == 0) {
                            // close!
                            if (render_size + 1 < max_width) {
                                // fits within a single line - inline on a single line
                                inline_child_mode = InlineMode::INLINED_SINGLE_LINE;
                            }
                            break;
                        }
                        peek_depth--;
                    }
                    render_size += Utf8Proc::RenderWidth(peek_component.text);
                    if (peek_component.type == JSONComponentType::COMMA ||
                        peek_component.type == JSONComponentType::COLON) {
                        render_size++;
                    }
                }
                if (component.text == "[") {
                    // for arrays - we always inline them UNLESS there are complex objects INSIDE of the bracket
                    // scan forward until the end of the array to figure out if this is true or not
                    for (peek_idx = c + 1; peek_idx < components.size(); peek_idx++) {
                        auto &peek_component = components[peek_idx];
                        peek_depth = 0;
                        if (peek_component.type == JSONComponentType::BRACKET_OPEN) {
                            if (peek_component.text == "{") {
                                // nested structure within the array
                                break;
                            }
                            peek_depth++;
                        }
                        if (peek_component.type == JSONComponentType::BRACKET_CLOSE) {
                            if (peek_depth == 0) {
                                inline_child_mode = InlineMode::INLINED_MULTI_LINE;
                                break;
                            }
                            peek_depth--;
                        }
                    }
                }
                if (inline_child_mode != InlineMode::STANDARD) {
                    // we can inline! do it
                    for (idx_t inline_idx = c + 1; inline_idx <= peek_idx; inline_idx++) {
                        auto &inline_component = components[inline_idx];
                        if (inline_child_mode == InlineMode::INLINED_MULTI_LINE && inline_idx + 1 <= peek_idx) {
                            auto &next_component = components[inline_idx + 1];
                            if (next_component.type == JSONComponentType::COMMA ||
                                next_component.type == JSONComponentType::BRACKET_CLOSE) {
                                if (!LiteralFits(format_state, inline_component.text + next_component.text)) {
                                    AddNewline(format_state);
                                }
                            }
                        }
                        FormatComponent(format_state, inline_component, inline_child_mode);
                    }
                    c = peek_idx;
                    return;
                }
                if (format_state.mode == JSONFormattingMode::COMPACT_VERTICAL) {
                    // we can't inline - but is the next token a bracket open?
                    if (c + 1 < components.size() && components[c + 1].type == JSONComponentType::BRACKET_OPEN) {
                        // it is! that bracket open will add a newline - we don't need to do it here
                        return;
                    }
                }
                AddNewline(format_state);
            }
            break;
        }
        case JSONComponentType::BRACKET_CLOSE: {
            idx_t depth_diff = component.text == "}" ? format_state.indentation_size : 1;
            if (depth < depth_diff) {
                // shouldn't happen - but guard against underflows
                depth = 0;
            } else {
                depth -= depth_diff;
            }
            if (inline_mode == InlineMode::STANDARD) {
                AddNewline(format_state);
            }
            AddLiteral(format_state, component.text);
            break;
        }
        case JSONComponentType::COMMA:
        case JSONComponentType::COLON:
            AddLiteral(format_state, component.text);
            bool always_inline;
            if (format_state.mode == JSONFormattingMode::COMPACT_HORIZONTAL) {
                // if we are trying to compact horizontally - don't inline colons unless it fits
                always_inline = false;
            } else {
                // in normal processing we always inline colons
                always_inline = component.type == JSONComponentType::COLON;
            }
            if (inline_mode != InlineMode::STANDARD || always_inline) {
                AddSpace(format_state);
            } else {
                if (format_state.mode != JSONFormattingMode::STANDARD) {
                    // if we are not inlining in compact mode, try to inline until the next comma
                    idx_t peek_depth = 0;
                    idx_t render_size = line_length + 1;
                    idx_t peek_idx;
                    bool inline_comma = false;
                    for (peek_idx = c + 1; peek_idx < components.size() && render_size <= max_width; peek_idx++) {
                        auto &peek_component = components[peek_idx];
                        if (peek_component.type == JSONComponentType::BRACKET_OPEN) {
                            peek_depth++;
                        } else if (peek_component.type == JSONComponentType::BRACKET_CLOSE) {
                            if (peek_depth == 0) {
                                inline_comma = render_size + 1 < max_width;
                                break;
                            }
                            peek_depth--;
                        }
                        if (peek_depth == 0 && peek_component.type == JSONComponentType::COMMA) {
                            // found the next comma - inline!
                            inline_comma = render_size + 2 <= max_width;
                            break;
                        }
                        render_size += Utf8Proc::RenderWidth(peek_component.text);
                        if (peek_component.type == JSONComponentType::COMMA ||
                            peek_component.type == JSONComponentType::COLON) {
                            render_size++;
                        }
                    }
                    if (inline_comma) {
                        // we can inline until the next comma! do it
                        AddSpace(format_state);
                        for (idx_t inline_idx = c + 1; inline_idx < peek_idx; inline_idx++) {
                            auto &inline_component = components[inline_idx];
                            FormatComponent(format_state, inline_component, InlineMode::INLINED_SINGLE_LINE);
                        }
                        c = peek_idx - 1;
                        return;
                    }
                }
                AddNewline(format_state);
            }
            break;
        case JSONComponentType::NULL_VALUE:
        case JSONComponentType::LITERAL:
            AddLiteral(format_state, component.text);
            break;
        default:
            throw InternalException("Unsupported JSON component type");
        }
    }

TryFormat()

JSONFormattingResult duckdb::JSONFormatter::TryFormat ( JSONFormattingMode  mode, BoxRenderValue &  render_value, idx_t  max_rows, idx_t  max_width, idx_t  indentation_size = 2  )

inlineprotected

                                                                                {
        FormatState format_state;
        format_state.mode = mode;
        format_state.max_rows = max_rows;
        format_state.max_width = max_width;
        format_state.indentation_size = indentation_size;
        for (format_state.component_idx = 0; format_state.component_idx < components.size() &&
                                             format_state.format_result == JSONFormattingResult::SUCCESS;
             format_state.component_idx++) {
            auto &component = components[format_state.component_idx];
            FormatComponent(format_state, component, InlineMode::STANDARD);
        }
 
        if (format_state.format_result != JSONFormattingResult::SUCCESS) {
            return format_state.format_result;
        }
        render_value.text = format_state.result;
        return JSONFormattingResult::SUCCESS;
    }

---

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

• external/duckdb/duckdb.cpp