void KoXmlWriter::addProcessingInstruction( const char* cstr )
{
prepareForTextNode();
writeCString( "<?" );
addTextNode( cstr );
writeCString( "?>");
}
void CollectAliases::dump(WriteBuffer & out) const
{
/// For need of tests, we need to dump result in some fixed order.
std::vector<Aliases::const_iterator> vec;
vec.reserve(aliases.size());
for (auto it = aliases.begin(); it != aliases.end(); ++it)
vec.emplace_back(it);
std::sort(vec.begin(), vec.end(), [](const auto & a, const auto & b) { return a->first < b->first; });
for (const auto & it : vec)
{
writeProbablyBackQuotedString(it->first, out);
writeCString(" -> ", out);
switch (it->second.kind)
{
case Kind::Expression:
writeCString("(expression) ", out);
break;
case Kind::Table:
writeCString("(table) ", out);
break;
case Kind::ArrayJoin:
writeCString("(array join) ", out);
break;
}
std::stringstream formatted_ast;
formatAST(*it->second.node, formatted_ast, 0, false, true);
writeString(formatted_ast.str(), out);
writeChar('\n', out);
}
}
void
drawMenu(int option)
{
SDL_Rect a,b;
/* erase the screen */
SDL_FillRect(screen,NULL,SDL_MapRGB(screen->format,0,0,0));
/* BETA */
a.x=97;//77
a.y=20;
b.x=100;
b.y=46;
b.w=125;//166
b.h=15;
SDL_BlitSurface(gfx, &b, screen, &a);
/* options */
writeCString(gfx, screen, 105, 50, "play", (option==1));//orig diff=17 now 26
writeCString(gfx, screen, 105, 76, "hall of fame", (option==2));//105, 94 option==3
writeCString(gfx, screen, 105, 102, "options", (option==3));//105, 111 option==4
writeCString(gfx, screen, 105, 128, "about", (option==4));//105, 138 option==5
writeCString(gfx, screen, 105, 154, "exit game", (option==5));//105, 155 option==6
/* some credit
a.x=154;
a.y=184;
b.x=268;
b.y=57;
b.w=166;
b.h=16;
SDL_BlitSurface(gfx, &b, screen, &a);*/
SDL_Flip(screen);
}
void
drawHiscores(int max)
{
int i;
SDL_Rect a,b;
/* erase the screen */
SDL_FillRect(screen,NULL,SDL_MapRGB(screen->format,0,0,0));
/* DD2 characters */
a.x=60;
a.y=5;
b.x=450;
b.y=43;
b.w=211;
b.h=190;
SDL_BlitSurface(gfx, &b, screen, &a);
/* header */
writeCString(gfx, screen, 80, 2, "the hall of fame", 1);
for(i=0;i<max;i++) {
writeNumber(gfx, screen, 10, 23+i*17, i+1, 2);
writeCString(gfx, screen, 30, 20+i*17, hiscore[i].name, 0);
writeCString(gfx, screen, 180, 20+i*17, "st",0);
writeNumber(gfx, screen, 200, 23+i*17, hiscore[i].stage,2);
writeCString(gfx, screen, 236, 20+i*17, "sc",0);
writeNumber(gfx, screen, 260, 23+i*17, hiscore[i].score,6);
}
SDL_Flip(screen);
}
String ASTFunction::getColumnNameImpl() const
{
WriteBufferFromOwnString wb;
writeString(name, wb);
if (parameters)
{
writeChar('(', wb);
for (ASTs::const_iterator it = parameters->children.begin(); it != parameters->children.end(); ++it)
{
if (it != parameters->children.begin())
writeCString(", ", wb);
writeString((*it)->getColumnName(), wb);
}
writeChar(')', wb);
}
writeChar('(', wb);
for (ASTs::const_iterator it = arguments->children.begin(); it != arguments->children.end(); ++it)
{
if (it != arguments->children.begin())
writeCString(", ", wb);
writeString((*it)->getColumnName(), wb);
}
writeChar(')', wb);
return wb.str();
}
void VerticalRowOutputStream::writeSpecialRow(const Block & block, size_t row_num, const char * title)
{
writeCString("\n", ostr);
row_number = 0;
field_number = 0;
size_t columns = block.columns();
writeCString(title, ostr);
writeCString(":\n", ostr);
size_t width = strlen(title) + 1;
for (size_t i = 0; i < width; ++i)
writeCString("─", ostr);
writeChar('\n', ostr);
for (size_t i = 0; i < columns; ++i)
{
if (i != 0)
writeFieldDelimiter();
auto & col = block.getByPosition(i);
writeField(*col.column, *col.type, row_num);
}
}
void JSONRowOutputStream::writeField(const IColumn & column, const IDataType & type, size_t row_num)
{
writeCString("\t\t\t", *ostr);
writeString(fields[field_number].name, *ostr);
writeCString(": ", *ostr);
type.serializeTextJSON(column, row_num, *ostr, force_quoting_64bit_integers);
++field_number;
}
void JSONRowOutputStream::writeRowsBeforeLimitAtLeast()
{
if (applied_limit)
{
writeCString(",\n\n", *ostr);
writeCString("\t\"rows_before_limit_at_least\": ", *ostr);
writeIntText(rows_before_limit, *ostr);
}
}
void XMLRowOutputStream::writeRowsBeforeLimitAtLeast()
{
if (applied_limit)
{
writeCString("\t<rows_before_limit_at_least>", *ostr);
writeIntText(rows_before_limit, *ostr);
writeCString("</rows_before_limit_at_least>\n", *ostr);
}
}
void XMLRowOutputStream::writeExtremes()
{
if (extremes)
{
writeCString("\t<extremes>\n", *ostr);
writeExtremesElement("min", extremes, 0, field_tag_names, *ostr);
writeExtremesElement("max", extremes, 1, field_tag_names, *ostr);
writeCString("\t</extremes>\n", *ostr);
}
}
void XMLRowOutputStream::writeField(const IColumn & column, const IDataType & type, size_t row_num)
{
writeCString("\t\t\t<", *ostr);
writeString(field_tag_names[field_number], *ostr);
writeCString(">", *ostr);
type.serializeTextXML(column, row_num, *ostr);
writeCString("</", *ostr);
writeString(field_tag_names[field_number], *ostr);
writeCString(">\n", *ostr);
++field_number;
}
void DataTypeTuple::serializeTextXML(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
{
writeCString("<tuple>", ostr);
for (const auto i : ext::range(0, ext::size(elems)))
{
writeCString("<elem>", ostr);
elems[i]->serializeTextXML(extractElementColumn(column, i), row_num, ostr);
writeCString("</elem>", ostr);
}
writeCString("</tuple>", ostr);
}
void KoXmlWriter::addAttribute( const char* attrName, const char* value )
{
writeChar( ' ' );
writeCString( attrName );
writeCString("=\"");
char* escaped = escapeForXML( value, -1 );
writeCString( escaped );
if(escaped != m_escapeBuffer)
delete[] escaped;
writeChar( '"' );
}
void KoXmlWriter::addAttribute(const char* attrName, const QByteArray& value)
{
// Same as the const char* one, but here we know the size
writeChar(' ');
writeCString(attrName);
writeCString("=\"");
char* escaped = escapeForXML(value.constData(), value.size());
writeCString(escaped);
if (escaped != d->escapeBuffer)
delete[] escaped;
writeChar('"');
}
void PrettySpaceBlockOutputStream::writeSuffix()
{
if (total_rows >= max_rows)
{
writeCString("\nShowed first ", ostr);
writeIntText(max_rows, ostr);
writeCString(".\n", ostr);
}
total_rows = 0;
writeTotals();
writeExtremes();
}
void PrettyCompactMonoBlockOutputStream::writeSuffix()
{
if (blocks.empty())
return;
Widths_t max_widths;
Widths_t name_widths;
for (size_t i = 0; i < blocks.size(); ++i)
calculateWidths(blocks[i], max_widths, name_widths);
writeHeader(blocks.front(), max_widths, name_widths);
size_t row_count = 0;
for (size_t block_id = 0; block_id < blocks.size() && row_count < max_rows; ++block_id)
{
const Block & block = blocks[block_id];
size_t rows = block.rows();
for (size_t i = 0; i < rows && row_count < max_rows; ++i)
{
writeRow(i, block, max_widths, name_widths);
++row_count;
}
}
writeBottom(max_widths);
if (total_rows >= max_rows)
{
writeCString(" Showed first ", ostr);
writeIntText(max_rows, ostr);
writeCString(".\n", ostr);
}
total_rows = 0;
if (totals)
{
writeCString("\nTotals:\n", ostr);
PrettyCompactBlockOutputStream::write(totals);
}
if (extremes)
{
writeCString("\nExtremes:\n", ostr);
PrettyCompactBlockOutputStream::write(extremes);
}
}
void XMLRowOutputStream::writeSuffix()
{
writeCString("\t</data>\n", *ostr);
writeTotals();
writeExtremes();
writeCString("\t<rows>", *ostr);
writeIntText(row_count, *ostr);
writeCString("</rows>\n", *ostr);
writeRowsBeforeLimitAtLeast();
writeCString("</result>\n", *ostr);
ostr->next();
}
void VerticalRowOutputStream::writeSuffix()
{
if (row_number > format_settings.pretty.max_rows)
{
writeCString("Showed first ", ostr);
writeIntText(format_settings.pretty.max_rows, ostr);
writeCString(".\n", ostr);
}
if (totals || extremes)
{
writeCString("\n", ostr);
writeTotals();
writeExtremes();
}
}
VerticalRowOutputStream::VerticalRowOutputStream(
WriteBuffer & ostr_, const Block & sample_, const FormatSettings & format_settings)
: ostr(ostr_), sample(sample_), format_settings(format_settings)
{
size_t columns = sample.columns();
using Widths = std::vector<size_t>;
Widths name_widths(columns);
size_t max_name_width = 0;
String serialized_value;
for (size_t i = 0; i < columns; ++i)
{
/// Note that number of code points is just a rough approximation of visible string width.
const String & name = sample.getByPosition(i).name;
name_widths[i] = UTF8::countCodePoints(reinterpret_cast<const UInt8 *>(name.data()), name.size());
if (name_widths[i] > max_name_width)
max_name_width = name_widths[i];
}
names_and_paddings.resize(columns);
for (size_t i = 0; i < columns; ++i)
{
WriteBufferFromString out(names_and_paddings[i]);
writeString(sample.getByPosition(i).name, out);
writeCString(": ", out);
}
for (size_t i = 0; i < columns; ++i)
names_and_paddings[i].resize(max_name_width + strlen(": "), ' ');
}
void VerticalRowOutputStream::writeRowStartDelimiter()
{
++row_number;
if (row_number > format_settings.pretty.max_rows)
return;
writeCString("Row ", ostr);
writeIntText(row_number, ostr);
writeCString(":\n", ostr);
size_t width = log10(row_number + 1) + 1 + strlen("Row :");
for (size_t i = 0; i < width; ++i)
writeCString("─", ostr);
writeChar('\n', ostr);
}
void MergeTreePartition::serializeText(const MergeTreeData & storage, WriteBuffer & out, const FormatSettings & format_settings) const
{
size_t key_size = storage.partition_key_sample.columns();
if (key_size == 0)
{
writeCString("tuple()", out);
}
else if (key_size == 1)
{
const DataTypePtr & type = storage.partition_key_sample.getByPosition(0).type;
auto column = type->createColumn();
column->insert(value[0]);
type->serializeAsText(*column, 0, out, format_settings);
}
else
{
DataTypes types;
Columns columns;
for (size_t i = 0; i < key_size; ++i)
{
const auto & type = storage.partition_key_sample.getByPosition(i).type;
types.push_back(type);
auto column = type->createColumn();
column->insert(value[i]);
columns.push_back(std::move(column));
}
DataTypeTuple tuple_type(types);
auto tuple_column = ColumnTuple::create(columns);
tuple_type.serializeText(*tuple_column, 0, out, format_settings);
}
}
void JSONRowOutputStream::writeRowEndDelimiter()
{
writeChar('\n', *ostr);
writeCString("\t\t}", *ostr);
field_number = 0;
++row_count;
}
void VerticalRowOutputStream::writeRowBetweenDelimiter()
{
if (row_number > format_settings.pretty.max_rows)
return;
writeCString("\n", ostr);
field_number = 0;
}
void KoXmlWriter::addTextNode( const char* cstr )
{
prepareForTextNode();
char* escaped = escapeForXML( cstr, -1 );
writeCString( escaped );
if(escaped != m_escapeBuffer)
delete[] escaped;
}
void JSONCompactRowOutputStream::writeExtremes()
{
if (extremes)
{
writeCString(",\n", *ostr);
writeChar('\n', *ostr);
writeCString("\t\"extremes\":\n", *ostr);
writeCString("\t{\n", *ostr);
writeExtremesElement("min", extremes, 0, *ostr, settings);
writeCString(",\n", *ostr);
writeExtremesElement("max", extremes, 1, *ostr, settings);
writeChar('\n', *ostr);
writeCString("\t}", *ostr);
}
}
void JSONRowOutputStream::writeExtremes()
{
if (extremes)
{
writeCString(",\n", *ostr);
writeChar('\n', *ostr);
writeCString("\t\"extremes\":\n", *ostr);
writeCString("\t{\n", *ostr);
writeExtremesElement("min", extremes, 0, *ostr, force_quoting_64bit_integers);
writeCString(",\n", *ostr);
writeExtremesElement("max", extremes, 1, *ostr, force_quoting_64bit_integers);
writeChar('\n', *ostr);
writeCString("\t}", *ostr);
}
}
void JSONRowOutputStream::writeTotals()
{
if (totals)
{
writeCString(",\n", *ostr);
writeChar('\n', *ostr);
writeCString("\t\"totals\":\n", *ostr);
writeCString("\t{\n", *ostr);
size_t totals_columns = totals.columns();
for (size_t i = 0; i < totals_columns; ++i)
{
const ColumnWithTypeAndName & column = totals.safeGetByPosition(i);
if (i != 0)
writeCString(",\n", *ostr);
writeCString("\t\t", *ostr);
writeJSONString(column.name, *ostr);
writeCString(": ", *ostr);
column.type->serializeTextJSON(*column.column.get(), 0, *ostr, force_quoting_64bit_integers);
}
writeChar('\n', *ostr);
writeCString("\t}", *ostr);
}
}
static void writeExtremesElement(const char * title, const Block & extremes, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings)
{
writeCString("\t\t\"", ostr);
writeCString(title, ostr);
writeCString("\": [", ostr);
size_t extremes_columns = extremes.columns();
for (size_t i = 0; i < extremes_columns; ++i)
{
if (i != 0)
writeChar(',', ostr);
const ColumnWithTypeAndName & column = extremes.safeGetByPosition(i);
column.type->serializeTextJSON(*column.column.get(), row_num, ostr, settings);
}
writeChar(']', ostr);
}
void DataTypeNullable::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
{
const ColumnNullable & col = static_cast<const ColumnNullable &>(column);
if (col.isNullAt(row_num))
writeCString("\\N", ostr);
else
nested_data_type->serializeTextEscaped(*col.getNestedColumn(), row_num, ostr);
}
void KoXmlWriter::addTextNode(const QByteArray& cstr)
{
// Same as the const char* version below, but here we know the size
prepareForTextNode();
char* escaped = escapeForXML(cstr.constData(), cstr.size());
writeCString(escaped);
if (escaped != d->escapeBuffer)
delete[] escaped;
}
