#include <Client/ClientBaseHelpers.h>

#include <Common/DateLUT.h>

#include <Common/DateLUTImpl.h>

#include <Common/LocalDate.h>

#include <Parsers/Lexer.h>

#include <Parsers/ParserQuery.h>

#include <Parsers/parseQuery.h>

#include <Parsers/ASTInsertQuery.h>

#include <Common/StringUtils.h>

#include <Common/UTF8Helpers.h>

#include <Core/Settings.h>

#include <Interpreters/Context.h>

#include <base/find_symbols.h>

#include <Poco/String.h>

#include <algorithm>

#include <cctype>

#include <string_view>

#include <unordered_set>

#include <vector>

#if USE_REPLXX

namespace replxx { char const * ansi_color(Replxx::Color); }

#endif

namespace DB

{

namespace Setting

{

extern const SettingsBool implicit_select;

extern const SettingsUInt64 max_parser_depth;

extern const SettingsUInt64 max_parser_backtracks;

}

bool isNewYearMode()

}

bool isChineseNewYearMode(const String & local_tz)

}

std::string getChineseZodiac()

}

bool isCloudEndpoint(const std::string & host)

{

return endsWith(host, ".clickhouse.cloud") || endsWith(host, ".clickhouse-staging.com") || endsWith(host, ".clickhouse-dev.com");

}

#if USE_REPLXX

static size_t countCodePointsWithSeqLength(const String & query, const char * end)

}

static void highlightWithLexer(const String & query, std::vector<replxx::Replxx::Color> & colors)

};

const char * const begin = query.data();

const char * const end = begin + query.size();

/// Tokenize the whole input first so that a `BareWord` can peek at the following token to tell a

/// function call (`name(`) from a plain identifier — exactly as the line editor and the Web UI do.

std::vector<Token> tokens;

Lexer lexer(begin, end);

while (true)

{

Token token = lexer.nextToken();

tokens.push_back(token);

if (token.isEnd() || token.isError())

break;

}

size_t code_point_pos = 0;

const char * char_pos = begin;

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

{

const Token & token = tokens[i];

if (token.isEnd())

break;

Replxx::Color color = Replxx::Color::DEFAULT;

switch (token.type)

{

case TokenType::Comment: color = Replxx::Color::GRAY; break;

case TokenType::Number: color = replxx::color::rgb666(0, 4, 0); break;

case TokenType::StringLiteral:

case TokenType::HereDoc: color = Replxx::Color::GREEN; break;

case TokenType::QuotedIdentifier: color = replxx::color::rgb666(0, 4, 4); break;

case TokenType::BareWord: {

String upper(token.begin, token.end);

std::transform(

upper.begin(), upper.end(), upper.begin(), [](char c) { return std::toupper(static_cast<unsigned char>(c)); });

if (keywords.contains(upper))

color = replxx::color::bold(Replxx::Color::DEFAULT);

else

{

/// A bare word immediately followed by `(` is a function; otherwise an identifier.

color = Replxx::Color::CYAN;

for (size_t j = i + 1; j < tokens.size(); ++j)

{

if (tokens[j].type == TokenType::Whitespace || tokens[j].type == TokenType::Comment)

continue;

if (tokens[j].type == TokenType::OpeningRoundBracket)

color = Replxx::Color::BROWN;

break;

}

}

break;

}

default:

if (token.isError())

color = Replxx::Color::RED;

/// Operators, brackets and punctuation keep the default color.

break;

}

/// Map the token's byte range to code-point positions in `colors`.

while (char_pos < token.begin && code_point_pos < colors.size())

{

++code_point_pos;

char_pos += UTF8::seqLength(*char_pos);

}

while (char_pos < token.end && code_point_pos < colors.size())

{

colors[code_point_pos] = color;

++code_point_pos;

char_pos += UTF8::seqLength(*char_pos);

}

}

}

void highlight(const String & query, std::vector<replxx::Replxx::Color> & colors, const Context & context, int cursor_position, bool rainbow_parentheses, bool lexer_fallback)

}

String highlighted(const String & query, const Context & context, bool rainbow_parentheses, bool lexer_fallback)

}

#endif

void skipSpacesAndComments(const char*& pos, const char* end, std::function<void(std::string_view)> comment_callback)

}

String formatQuery(String query)

}

}