duckdb::BoxRenderer Class Reference

Collaboration diagram for duckdb::BoxRenderer:

Public Member Functions
	BoxRenderer (BoxRendererConfig config_p=BoxRendererConfig())
string	ToString (ClientContext &context, const vector< string > &names, const ColumnDataCollection &op)
unique_ptr< BoxRendererState >	Prepare (ClientContext &context, const vector< string > &names, const ColumnDataCollection &op)
void	Render (ClientContext &context, const vector< string > &names, const ColumnDataCollection &op, BaseResultRenderer &ss)
void	Print (ClientContext &context, const vector< string > &names, const ColumnDataCollection &op)

Static Public Member Functions
static string	TryFormatLargeNumber (const string &numeric, char decimal_sep)
static string	TruncateValue (const string &value, idx_t column_width, idx_t &pos, idx_t &current_render_width)

Private Attributes
BoxRendererConfig	config
	The configuration used for rendering.

Constructor & Destructor Documentation

BoxRenderer()

duckdb::BoxRenderer::BoxRenderer ( BoxRendererConfig  config_p = BoxRendererConfig() )

explicit

                                                   : config(std::move(config_p)) {
}

Member Function Documentation

ToString()

string duckdb::BoxRenderer::ToString	(	ClientContext &	context,
		const vector< string > &	names,
		const ColumnDataCollection &	op
	)

                                                                                                                    {
    StringResultRenderer ss;
    Render(context, names, result, ss);
    return ss.str();
}

Prepare()

unique_ptr< BoxRendererState > duckdb::BoxRenderer::Prepare	(	ClientContext &	context,
		const vector< string > &	names,
		const ColumnDataCollection &	op
	)

                                                                                      {
    return make_uniq<BoxRendererImplementation>(config, context, names, result);
}

Render()

void duckdb::BoxRenderer::Render	(	ClientContext &	context,
		const vector< string > &	names,
		const ColumnDataCollection &	op,
		BaseResultRenderer &	ss
	)

                                                 {
    auto state = Prepare(context, names, result);
    state->Render(ss);
}

Print()

void duckdb::BoxRenderer::Print	(	ClientContext &	context,
		const vector< string > &	names,
		const ColumnDataCollection &	op
	)

                                                                                                               {
    Printer::Print(ToString(context, names, result));
}

TryFormatLargeNumber()

string duckdb::BoxRenderer::TryFormatLargeNumber ( const string &  numeric, char  decimal_sep  )

static

                                                                                {
    // we only return a readable rendering if the number is > 1 million
    if (numeric.size() <= 5) {
        // number too small for sure
        return string();
    }
    // get the number to summarize
    idx_t number = 0;
    bool negative = false;
    idx_t i = 0;
    if (numeric[0] == '-') {
        negative = true;
        i++;
    }
    for (; i < numeric.size(); i++) {
        char c = numeric[i];
        if (c == '.') {
            break;
        }
        if (c < '0' || c > '9') {
            // not a number or something funky (e.g. 1.23e7)
            // we could theoretically summarize numbers with exponents
            return string();
        }
        if (number >= 1000000000000000000ULL) {
            // number too big
            return string();
        }
        number = number * 10 + static_cast<idx_t>(c - '0');
    }
    struct UnitBase {
        idx_t base;
        const char *name;
    };
    static constexpr idx_t BASE_COUNT = 5;
    UnitBase bases[] = {{1000000ULL, "million"},
                        {1000000000ULL, "billion"},
                        {1000000000000ULL, "trillion"},
                        {1000000000000000ULL, "quadrillion"},
                        {1000000000000000000ULL, "quintillion"}};
    idx_t base = 0;
    string unit;
    for (idx_t i = 0; i < BASE_COUNT; i++) {
        // round the number according to this base
        idx_t rounded_number = number + ((bases[i].base / 100ULL) / 2);
        if (rounded_number >= bases[i].base) {
            base = bases[i].base;
            unit = bases[i].name;
        }
    }
    if (unit.empty()) {
        return string();
    }
    number += (base / 100ULL) / 2;
    idx_t decimal_unit = number / (base / 100ULL);
    string decimal_str = to_string(decimal_unit);
    string result;
    if (negative) {
        result += "-";
    }
    result += decimal_str.substr(0, decimal_str.size() - 2);
    result += decimal_sep == '\0' ? '.' : decimal_sep;
    result += decimal_str.substr(decimal_str.size() - 2, 2);
    result += " ";
    result += unit;
    return result;
}

TruncateValue()

string duckdb::BoxRenderer::TruncateValue ( const string &  value, idx_t  column_width, idx_t &  pos, idx_t &  current_render_width  )

static

                                                                                                                  {
    idx_t start_pos = pos;
    while (pos < value.size()) {
        if (value[pos] == '\n') {
            // newline character - stop rendering for this line - but skip the newline
            idx_t render_pos = pos;
            pos++;
            return value.substr(start_pos, render_pos - start_pos);
        }
        // check if this character fits...
        auto char_size = Utf8Proc::RenderWidth(value.c_str(), value.size(), pos);
        if (current_render_width + char_size > column_width) {
            // it doesn't! stop
            break;
        }
        // it does! move to the next character
        current_render_width += char_size;
        pos = Utf8Proc::NextGraphemeCluster(value.c_str(), value.size(), pos);
    }
    return value.substr(start_pos, pos - start_pos);
}

---

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

• external/duckdb/duckdb.cpp