Method RenderTableMetadata

tools/shell/shell_render_table_metadata.cpp:433–636

}

void ShellState::RenderTableMetadata(vector<ShellTableInfo> &tables) {
	idx_t max_render_width = GetMaxRenderWidth();
	duckdb::BoxRendererConfig config;
	// figure out the render width of each table
	vector<ShellTableRenderInfo> table_list;
	for (auto &table : tables) {
		table_list.emplace_back(table, config.decimal_separator);
	}
	for (auto &table : table_list) {
		// optionally truncate each table if we exceed the max render width
		table.Truncate(max_render_width);
	}
	// try to split up large tables
	for (auto &table : table_list) {
		static constexpr const idx_t SPLIT_THRESHOLD = 20;
		D_ASSERT(table.column_renders.size() == 1);
		if (table.column_renders[0].columns.size() <= SPLIT_THRESHOLD) {
			// not that many columns - keep it as-is
			continue;
		}
		// try to split up columns if possible
		idx_t max_split_count = (table.column_renders[0].columns.size() + SPLIT_THRESHOLD - 1) / SPLIT_THRESHOLD;
		idx_t width_per_split = table.PerColumnWidth();
		idx_t max_splits = max_render_width / width_per_split;
		D_ASSERT(max_split_count > 1);
		if (max_splits <= 1) {
			// too wide - cannot split
			continue;
		}
		idx_t split_count = duckdb::MinValue<idx_t>(max_split_count, max_splits);

		vector<ColumnRenderRow> new_renders;
		new_renders.resize(split_count);
		idx_t split_idx = 0;
		for (auto &col : table.column_renders[0].columns) {
			new_renders[split_idx % split_count].columns.push_back(std::move(col));
			split_idx++;
		}
		table.column_renders = std::move(new_renders);
		table.render_width = duckdb::MaxValue<idx_t>(table.render_width, split_count * width_per_split);
	}

	// group tables by db + schema
	duckdb::map<string, duckdb::map<string, vector<ShellTableRenderInfo>>> grouped_tables;
	for (auto &entry : table_list) {
		grouped_tables[entry.table.database_name][entry.table.schema_name].push_back(std::move(entry));
	}

	vector<TableMetadataDisplayInfo> metadata_displays;
	// for each set of table groups - make a list of displays
	for (auto &db_entry : grouped_tables) {
		for (auto &schema_entry : db_entry.second) {
			auto &result = schema_entry.second;
			// sort from biggest to smallest table
			std::sort(result.begin(), result.end(), [](const ShellTableRenderInfo &a, const ShellTableRenderInfo &b) {
				return a.LineCount() > b.LineCount();
			});