{

String lower = Poco::toLower(candidate);

for (const auto & [name, _] : FormatFactory::instance().getAllFormats())

if (Poco::toLower(name) == lower)

return name;

return {};

{

Strings result;

String current;

auto flush = [&]()

{

if (!current.empty())

{

String decoded;

Poco::URI::decode(current, decoded);

result.push_back(decoded);

current.clear();

}

};

for (char c : path)

{

if (c == '/')

flush();

else

current += c;

}

flush();

return result;

{

static constexpr std::array<const char *, 7> ops = {">=", "<=", "!=", "<>", ">", "<", "="};

for (const char * op : ops)

{

auto pos = component.find(op);

if (pos == String::npos)

continue;

/// Don't match if op starts at 0 (no name) or extends to end (no value).

size_t op_len = strlen(op);

if (pos == 0 || pos + op_len >= component.size())

continue;

String name = component.substr(0, pos);

String value = component.substr(pos + op_len);

String sql_op(op);

/// Translate `<>` to `!=` for consistency.

if (sql_op == "<>")

sql_op = "!=";

return "(" + backQuoteIfNeed(name) + " " + sql_op + " " + quoteString(value) + ")";

}

return {};

{

if (!isFullyBackQuotedComponent(component))

return component;

const String inner = component.substr(1, component.size() - 2);

String unquoted;

unquoted.reserve(inner.size());

for (size_t i = 0; i < inner.size(); ++i)

{

if (inner[i] == '`' && i + 1 < inner.size() && inner[i + 1] == '`')

{

unquoted += '`';

++i;

}

else

unquoted += inner[i];

}

return unquoted;

{

HTTPPathInfo result;

if (path.empty() || path == "/")

return result;

Strings components = splitPathComponents(path);

if (components.empty())

return result;

/// Walk components in order. Last non-filter component (if any) may be the table.

/// Preceding non-filter components include at most one database.

/// Filter components can be intermixed.

int last_non_filter_index = -1;

/// First pass: identify filters and non-filter components.

std::vector<int> non_filter_indices;

std::vector<String> per_component_filter; // for each index, parsed filter or empty

per_component_filter.resize(components.size());

for (size_t i = 0; i < components.size(); ++i)

{

String filter_expr;

if (allow_filters && !isFullyBackQuotedComponent(components[i]))

filter_expr = tryParseFilterComponent(components[i]);

if (!filter_expr.empty())

{

per_component_filter[i] = filter_expr;

}

else

{

non_filter_indices.push_back(static_cast<int>(i));

last_non_filter_index = static_cast<int>(i);

}

}

/// Determine table component

int table_index = -1;

if (allow_table && last_non_filter_index >= 0)

{

table_index = last_non_filter_index;

}

/// Determine database component (everything else before the table among non-filter indices)

std::vector<int> db_indices;

for (int idx : non_filter_indices)

if (idx != table_index)

db_indices.push_back(idx);

if (!allow_database && !db_indices.empty())

{

/// Non-filter components other than the table cannot be claimed when `http_allow_database_as_path`

/// is off — leave them unclaimed and return an empty result. The path is effectively ignored

/// and the request proceeds as if it had hit the root URL.

return {};

}

if (db_indices.size() > 1)

{

/// A path this deep names no resource: the path form is `/database/table[.format[.compression]]`,

/// so there is nothing for a third component to be. Report it as "not found" rather than as a

/// malformed request, so that enabling `http_allow_path_requests` does not turn the plain 404 an

/// unmatched URL used to get into a 400 (`UNKNOWN_TABLE` maps to HTTP 404, `BAD_ARGUMENTS` to 400).

throw Exception(ErrorCodes::UNKNOWN_TABLE,

"There is no table at the HTTP URL path: it has more than one database component "

"('{}' and '{}'). The path form is /database/table[.format[.compression]].",

components[db_indices[0]], components[db_indices[1]]);

}

/// Special case: if there is exactly one non-filter component and allow_database is on

/// but allow_table is off, that single component is the database (not the table).

if (!allow_table && allow_database && non_filter_indices.size() == 1)

{

result.database = unquoteBackQuotedComponent(components[non_filter_indices[0]]);

}

else

{

if (!db_indices.empty())

result.database = unquoteBackQuotedComponent(components[db_indices[0]]);

if (table_index >= 0)

{

/// Parse table[.format[.compression]] from the last component.

const String & raw = components[table_index];

/// A fully back-quoted component is a *literal* table name: its dots are part of the name

/// and no format/compression suffix is stripped from it. This mirrors SQL identifier quoting

/// (where `db.table` is always `database.identifier` and a dotted name must be back-quoted)

/// and is the escape hatch for a table whose name ends in (or contains) a registered format

/// or compression token. For example `` /db/`events.JSON` `` reads the table named

/// `events.JSON`, whereas the unquoted `/db/events.JSON` reads table `events` with format

/// `JSON`. When the name is back-quoted, specify the format/compression via the `format` /

/// `compression` URL parameters (or the `format` setting) instead of a path suffix.

/// A backtick travels in a URL percent-encoded as `%60`; `HTTPHandler` URL-decodes the path

/// before calling this, so `/db/%60events.JSON%60` arrives here as `` `events.JSON` ``.

if (isFullyBackQuotedComponent(raw))

{

const String unquoted = unquoteBackQuotedComponent(raw);

result.table = unquoted;

result.format = {};

result.compression = {};

result.filename_for_disposition = unquoted;

}

else

{

/// Try splitting from the right.

String table_part = raw;

String format_part;

String compression_part;

String disposition_filename = raw;

auto last_dot = table_part.rfind('.');

if (last_dot != String::npos)

{

String maybe_extension = table_part.substr(last_dot + 1);

String maybe_compression_name = canonicalizeCompressionExtension(maybe_extension);

if (!maybe_compression_name.empty())

{

compression_part = maybe_compression_name;

/// Canonicalize the compression extension in the disposition filename so an accepted

/// alias (`.zstd` / `.gzip` / `.lzma` / `.bzip2`) is not duplicated when `HTTPHandler`

/// appends the canonical suffix (`.zst` / `.gz` / `.xz` / `.bz2`). For example

/// `/db/hits.Native.zstd` yields the filename `hits.Native.zst`, not `hits.Native.zstd.zst`.

if (maybe_compression_name != maybe_extension)

disposition_filename = raw.substr(0, last_dot + 1) + maybe_compression_name;

table_part = table_part.substr(0, last_dot);

last_dot = table_part.rfind('.');

if (last_dot != String::npos)

{

String fmt_candidate = table_part.substr(last_dot + 1);

String canonical_format = findFormatCaseInsensitive(fmt_candidate);

if (canonical_format.empty())

{

throw Exception(ErrorCodes::UNKNOWN_FORMAT,

"Unknown format '{}' in URL path. Compression cannot be specified without a known format.", fmt_candidate);

}

format_part = canonical_format;

table_part = table_part.substr(0, last_dot);

}

else

{

throw Exception(ErrorCodes::BAD_ARGUMENTS,

"Compression extension '{}' specified without a format in URL path.", compression_part);

}

}

else

{

/// Maybe just a format extension (no compression).

String canonical_format = findFormatCaseInsensitive(maybe_extension);

if (!canonical_format.empty())

{

format_part = canonical_format;

table_part = table_part.substr(0, last_dot);

}

/// Otherwise leave it as part of the table name.

}

}

result.table = table_part;

result.format = format_part;

result.compression = compression_part;

result.filename_for_disposition = disposition_filename;

}

}

}

/// Collect filters in their path order.

for (size_t i = 0; i < components.size(); ++i)

if (!per_component_filter[i].empty())

result.path_filters.push_back(per_component_filter[i]);

return result;

{

if (name.empty())

return {};

/// Case 1: HTMLForm splits a URL parameter on the first `=`. For two-character operators

/// that end in `=` (`!=`, `>=`, `<=`), the operator's `=` ends up as that separator, leaving

/// the leading character of the operator stuck to the end of the name and the literal in the value.

/// Examples:

/// `?a!=2` -> name `a!` and value `2` -> `a != 2`

/// `?a>=2` -> name `a>` and value `2` -> `a >= 2`

/// `?a<=2` -> name `a<` and value `2` -> `a <= 2`

if (name.size() > 1

&& (name.back() == '!' || name.back() == '>' || name.back() == '<'))

{

char op_char = name.back();

String identifier = name.substr(0, name.size() - 1);

if (!identifier.empty())

{

String op;

if (op_char == '!')

op = "!=";

else if (op_char == '>')

op = ">=";

else /* '<' */

op = "<=";

return "(" + backQuoteIfNeed(identifier) + " " + op + " " + quoteString(value) + ")";

}

}

/// Case 2: The full operator survived inside `name` because the URL had no `=` to split on

/// (e.g. `?a>2`, `?a<>2`, `?f(x)>3`). Treat the reassembled `name[=value]` as a SQL expression.

static constexpr std::array<const char *, 6> compare_ops = {">=", "<=", "!=", "<>", ">", "<"};

auto has_compare_op = [&](const String & s)

{

for (const char * op : compare_ops)

if (s.contains(op))

return true;

return false;

};

if (has_compare_op(name))

{

String full = value.empty() ? name : name + "=" + value;

return "(" + full + ")";

}

/// Case 3: Plain `name=value` -> `name = value` with quoted literal.

return "(" + backQuoteIfNeed(name) + " = " + quoteString(value) + ")";

{

if (format_name.empty())

return false;

try

{

String content_type = FormatFactory::instance().getContentType(format_name, {});

/// Common binary content types.

if (startsWith(content_type, "application/octet-stream"))

return true;

if (startsWith(content_type, "application/x-parquet"))

return true;

/// Heuristic: any content type that starts with "application/" but isn't json/xml/x-www-form is binary-ish.

if (startsWith(content_type, "application/"))

{

if (content_type.contains("json"))

return false;

if (content_type.contains("xml"))

return false;

return true;

}

return false;

}

catch (...) /// Ok: unknown / malformed format name — fall back to "not binary".

{

return false;

}

{

String lower = Poco::toLower(ext);

/// Supported compression methods recognized by `wrapWriteBufferWithCompressionMethod`.

/// Map common file extensions to the canonical name expected by `chooseCompressionMethod`.

if (lower == "gz" || lower == "gzip")

return "gz";

if (lower == "br")

return "br";

if (lower == "zst" || lower == "zstd")

return "zst";

if (lower == "xz" || lower == "lzma")

return "xz";

if (lower == "lz4")

return "lz4";

if (lower == "bz2" || lower == "bzip2")

return "bz2";

if (lower == "deflate")

return "deflate";

/// NOTE: Snappy is intentionally not listed: it has only a read wrapper

/// (`HadoopSnappyReadBuffer`), and `wrapWriteBufferWithCompressionMethod` throws

/// `NOT_IMPLEMENTED` for it. Advertising `.snappy` as a response-compression extension would let

/// `/table.CSV.snappy` parse as valid and then fail only at response-buffer setup.

return {};