ClickHouse 源码深度剖析文档

# 1. 克隆代码仓库
git clone --recursive https://github.com/ClickHouse/ClickHouse.git
cd ClickHouse

# 2. 创建构建目录
mkdir build
cd build

# 3. 配置CMake
cmake .. -DCMAKE_BUILD_TYPE=Release

# 4. 编译（使用多线程）
make -j$(nproc)

# 5. 安装
sudo make install

# 启用测试
-DENABLE_TESTS=ON

# 启用调试符号
-DCMAKE_BUILD_TYPE=Debug

# 启用静态链接
-DENABLE_STATIC_LINKING=ON

# 启用特定存储引擎
-DENABLE_LIBRARIES=ON

ClickHouse/
├── base/                    # 基础库和工具
├── cmake/                   # CMake配置文件
├── contrib/                 # 第三方依赖库
├── docs/                    # 文档
├── programs/                # 可执行程序
│   ├── client/             # ClickHouse客户端
│   ├── server/             # ClickHouse服务器
│   ├── keeper/             # ClickHouse Keeper
│   └── local/              # 本地模式
├── src/                     # 核心源代码
│   ├── Access/             # 访问控制
│   ├── AggregateFunctions/ # 聚合函数
│   ├── Analyzer/           # 查询分析器
│   ├── Client/             # 客户端库
│   ├── Common/             # 通用工具
│   ├── Core/               # 核心组件
│   ├── Databases/          # 数据库引擎
│   ├── DataTypes/          # 数据类型
│   ├── Functions/          # 内置函数
│   ├── Interpreters/       # 查询解释器
│   ├── IO/                 # 输入输出
│   ├── Parsers/            # SQL解析器
│   ├── Processors/         # 数据处理器
│   ├── Server/             # 服务器组件
│   └── Storages/           # 存储引擎
├── tests/                   # 测试用例
└── utils/                   # 实用工具

{
  "cmake.buildDirectory": "${workspaceFolder}/build",
  "cmake.configureArgs": [
    "-DCMAKE_BUILD_TYPE=Debug",
    "-DENABLE_TESTS=ON"
  ],
  "clang-tidy.checks": [
    "readability-*",
    "modernize-*",
    "performance-*"
  ]
}

# .gdbinit
set print pretty on
set print object on
set print static-members on
set print vtbl on
set print demangle on

graph TB
    %% 客户端层
    subgraph "客户端层 (Client Layer)"
        CLI[ClickHouse Client]
        HTTP_CLIENT[HTTP Client]
        JDBC[JDBC Driver]
        ODBC[ODBC Driver]
        NATIVE[Native Client]
    end

    %% 协议接口层
    subgraph "协议接口层 (Protocol Layer)"
        HTTP_HANDLER[HTTP Handler]
        TCP_HANDLER[TCP Handler]
        MYSQL_HANDLER[MySQL Handler]
        POSTGRES_HANDLER[PostgreSQL Handler]
        GRPC_HANDLER[gRPC Handler]
    end

    %% 服务层
    subgraph "服务层 (Service Layer)"
        SERVER[ClickHouse Server]
        KEEPER[ClickHouse Keeper]
        LOCAL[ClickHouse Local]
    end

    %% 查询处理层
    subgraph "查询处理层 (Query Processing Layer)"
        PARSER[SQL Parser]
        ANALYZER[Query Analyzer]
        PLANNER[Query Planner]
        INTERPRETER[Query Interpreter]
        OPTIMIZER[Query Optimizer]
    end

    %% 执行引擎层
    subgraph "执行引擎层 (Execution Engine)"
        PIPELINE[Query Pipeline]
        PROCESSORS[Processors]
        FUNCTIONS[Functions]
        AGGREGATES[Aggregate Functions]
    end

    %% 存储层
    subgraph "存储层 (Storage Layer)"
        MERGETREE[MergeTree Engine]
        REPLICATEDMT[ReplicatedMergeTree]
        MEMORY[Memory Engine]
        DISTRIBUTED[Distributed Engine]
        EXTERNAL[External Storages]
    end

    %% 基础设施层
    subgraph "基础设施层 (Infrastructure Layer)"
        IO[I/O System]
        COMPRESSION[Compression]
        FORMATS[Data Formats]
        DISKS[Disk Management]
        COORDINATION[Coordination Service]
    end

    %% 系统组件
    subgraph "系统组件 (System Components)"
        ACCESS[Access Control]
        BACKUP[Backup/Restore]
        MONITORING[Monitoring]
        CONFIG[Configuration]
    end

    %% 连接关系
    CLI --> TCP_HANDLER
    HTTP_CLIENT --> HTTP_HANDLER
    JDBC --> TCP_HANDLER
    ODBC --> TCP_HANDLER
    NATIVE --> TCP_HANDLER

    HTTP_HANDLER --> SERVER
    TCP_HANDLER --> SERVER
    MYSQL_HANDLER --> SERVER
    POSTGRES_HANDLER --> SERVER
    GRPC_HANDLER --> SERVER

    SERVER --> PARSER
    PARSER --> ANALYZER
    ANALYZER --> PLANNER
    PLANNER --> INTERPRETER
    INTERPRETER --> OPTIMIZER
    OPTIMIZER --> PIPELINE

    PIPELINE --> PROCESSORS
    PROCESSORS --> FUNCTIONS
    PROCESSORS --> AGGREGATES
    PROCESSORS --> MERGETREE
    PROCESSORS --> REPLICATEDMT
    PROCESSORS --> MEMORY
    PROCESSORS --> DISTRIBUTED
    PROCESSORS --> EXTERNAL

    MERGETREE --> IO
    REPLICATEDMT --> COORDINATION
    IO --> COMPRESSION
    IO --> FORMATS
    IO --> DISKS

    SERVER --> ACCESS
    SERVER --> BACKUP
    SERVER --> MONITORING
    SERVER --> CONFIG

    KEEPER --> COORDINATION

sequenceDiagram
    participant Client as HTTP Client
    participant HTTPHandler as HTTP Handler
    participant Server as ClickHouse Server
    participant Parser as SQL Parser
    participant Interpreter as Query Interpreter
    participant Pipeline as Query Pipeline
    participant Storage as Storage Engine

    Client->>HTTPHandler: POST /query
    HTTPHandler->>Server: 创建会话
    Server->>Parser: 解析SQL语句
    Parser-->>Server: 返回AST
    Server->>Interpreter: 创建查询解释器
    Interpreter->>Pipeline: 构建查询管道
    Pipeline->>Storage: 执行数据读取
    Storage-->>Pipeline: 返回数据块
    Pipeline-->>Interpreter: 处理数据
    Interpreter-->>Server: 返回结果
    Server-->>HTTPHandler: 格式化响应
    HTTPHandler-->>Client: 返回HTTP响应

sequenceDiagram
    participant Client as Native Client
    participant TCPHandler as TCP Handler
    participant Server as ClickHouse Server
    participant Parser as SQL Parser
    participant Interpreter as Query Interpreter
    participant Pipeline as Query Pipeline
    participant Storage as Storage Engine

    Client->>TCPHandler: 建立TCP连接
    TCPHandler->>TCPHandler: 握手协议
    Client->>TCPHandler: 发送查询请求
    TCPHandler->>Server: 创建查询上下文
    Server->>Parser: 解析SQL
    Parser-->>Server: 返回AST
    Server->>Interpreter: 执行查询
    Interpreter->>Pipeline: 构建执行管道
    
    loop 数据处理循环
        Pipeline->>Storage: 读取数据块
        Storage-->>Pipeline: 返回数据块
        Pipeline->>TCPHandler: 发送数据块
        TCPHandler->>Client: 传输数据
    end
    
    TCPHandler->>Client: 发送查询完成

// src/QueryPipeline/QueryPipeline.h
class QueryPipeline
{
private:
    Processors processors;
    InputPorts input_ports;
    OutputPorts output_ports;
    
public:
    void addTransform(ProcessorPtr processor);
    void addSource(ProcessorPtr source);
    void addSink(ProcessorPtr sink);
    void execute();
};

// src/Storages/StorageFactory.h
class StorageFactory : public boost::noncopyable
{
public:
    static StorageFactory & instance();
    
    StoragePtr get(
        const ASTCreateQuery & query,
        const String & relative_data_path,
        ContextPtr context) const;
        
    void registerStorage(const String & name, CreatorFn creator_fn);
};

// src/Parsers/ASTVisitor.h
template <typename T>
class ASTVisitor
{
public:
    virtual T visit(const ASTPtr & node) = 0;
    virtual T visitSelectQuery(const ASTSelectQuery & select) = 0;
    virtual T visitInsertQuery(const ASTInsertQuery & insert) = 0;
};

// src/Server/HTTPHandler.h
class HTTPHandler : public HTTPRequestHandler
{
public:
    HTTPHandler(IServer & server_, const HTTPHandlerConnectionConfig & connection_config_, 
                const std::string & name, const HTTPResponseHeaderSetup & http_response_headers_override_);
    
    void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response, 
                      const ProfileEvents::Event & write_event) override;

    virtual void customizeContext(HTTPServerRequest & request, ContextMutablePtr context, ReadBuffer & body) {}
    virtual bool customizeQueryParam(ContextMutablePtr context, const std::string & key, const std::string & value) = 0;
    virtual std::string getQuery(HTTPServerRequest & request, HTMLForm & params, ContextMutablePtr context) = 0;

private:
    void processQuery(HTTPServerRequest & request, HTMLForm & params, HTTPServerResponse & response,
                     Output & used_output, std::optional<CurrentThread::QueryScope> & query_scope,
                     const ProfileEvents::Event & write_event);
};

// src/Server/HTTPHandler.cpp - processQuery方法核心逻辑
void HTTPHandler::processQuery(HTTPServerRequest & request, HTMLForm & params, 
                              HTTPServerResponse & response, Output & used_output,
                              std::optional<CurrentThread::QueryScope> & query_scope,
                              const ProfileEvents::Event & write_event)
{
    // 1. 创建或获取会话
    auto session_id = params.get("session_id", "");
    auto session_timeout = parseSessionTimeout(params);
    session = makeSession(session_id, session_timeout);
    
    // 2. 创建查询上下文
    auto context = session->makeQueryContext();
    
    // 3. 设置数据库和格式
    std::string database = request.get("X-ClickHouse-Database", params.get("database", ""));
    if (!database.empty())
        context->setCurrentDatabase(database);
        
    std::string default_format = request.get("X-ClickHouse-Format", params.get("default_format", ""));
    if (!default_format.empty())
        context->setDefaultFormat(default_format);
    
    // 4. 设置只读模式（对于非POST请求）
    setReadOnlyIfHTTPMethodIdempotent(context, request.getMethod());
    
    // 5. 设置查询ID
    context->setCurrentQueryId(params.get("query_id", request.get("X-ClickHouse-Query-Id", "")));
    
    // 6. 处理外部数据
    bool has_external_data = startsWith(request.getContentType(), "multipart/form-data");
    
    // 7. 获取查询文本
    std::string query = getQuery(request, params, context);
    
    // 8. 执行查询
    executeQuery(query, context, used_output.out_maybe_delayed_and_compressed, 
                query_scope, write_event);
}

// src/Server/TCPHandler.h
class TCPHandler : public Poco::Net::TCPServerConnection
{
public:
    TCPHandler(IServer & server_, TCPServer & tcp_server_, const Poco::Net::StreamSocket & socket_,
               bool parse_proxy_protocol_, String server_display_name_, String host_name_,
               const ProfileEvents::Event & read_event_ = ProfileEvents::end(),
               const ProfileEvents::Event & write_event_ = ProfileEvents::end());
    
    void run() override;
    virtual void customizeContext(ContextMutablePtr context) {}

private:
    // 连接管理
    void runImpl();
    void extractConnectionSettingsFromContext(const ContextPtr & context);
    std::unique_ptr<Session> makeSession();
    
    // 协议处理
    void receiveHello();
    void sendHello();
    bool receivePacketsExpectQuery(std::optional<QueryState> & state);
    bool receivePacketsExpectData(QueryState & state);
    
    // 查询处理
    void processQuery(std::optional<QueryState> & state);
    void processOrdinaryQuery(QueryState & state);
    void processInsertQuery(QueryState & state);
    
    // 数据传输
    void sendData(QueryState & state, const Block & block);
    void sendProgress(QueryState & state);
    void sendException(const Exception & e, bool with_stack_trace);
};

// src/Server/TCPHandler.cpp - 握手实现
void TCPHandler::receiveHello()
{
    /// Receive hello packet.
    UInt64 packet_type = 0;
    String user;
    String password;
    
    readVarUInt(packet_type, *in);
    if (packet_type != Protocol::Client::Hello)
        throw Exception("Unexpected packet type received from client", ErrorCodes::UNEXPECTED_PACKET_FROM_CLIENT);
    
    readStringBinary(client_name, *in);
    readVarUInt(client_version_major, *in);
    readVarUInt(client_version_minor, *in);
    readVarUInt(client_tcp_protocol_version, *in);
    readStringBinary(default_database, *in);
    readStringBinary(user, *in);
    readStringBinary(password, *in);
    
    // 创建会话并认证
    session = makeSession();
    session->authenticate(user, password, Poco::Net::SocketAddress());
}

void TCPHandler::sendHello()
{
    writeVarUInt(Protocol::Server::Hello, *out);
    writeStringBinary(DBMS_NAME, *out);
    writeVarUInt(DBMS_VERSION_MAJOR, *out);
    writeVarUInt(DBMS_VERSION_MINOR, *out);
    writeVarUInt(DBMS_TCP_PROTOCOL_VERSION, *out);
    
    if (client_tcp_protocol_version >= DBMS_MIN_REVISION_WITH_SERVER_TIMEZONE)
        writeStringBinary(DateLUT::instance().getTimeZone(), *out);
        
    if (client_tcp_protocol_version >= DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME)
        writeStringBinary(server_display_name, *out);
        
    out->next();
}

// src/Server/TCPHandler.h - QueryState结构
struct QueryState
{
    String query_id;                    // 查询ID
    ContextMutablePtr query_context;    // 查询上下文
    
    QueryProcessingStage::Enum stage = QueryProcessingStage::Complete;
    Protocol::Compression compression = Protocol::Compression::Disable;
    
    // 日志和性能事件队列
    InternalTextLogsQueuePtr logs_queue;
    std::unique_ptr<NativeWriter> logs_block_out;
    InternalProfileEventsQueuePtr profile_queue;
    std::unique_ptr<NativeWriter> profile_events_block_out;
    
    // 数据输入输出
    std::shared_ptr<ReadBuffer> maybe_compressed_in;
    std::unique_ptr<NativeReader> block_in;
    std::shared_ptr<WriteBuffer> maybe_compressed_out;
    std::unique_ptr<NativeWriter> block_out;
    
    String query;                       // 查询文本
    ASTPtr parsed_query;               // 解析后的AST
    BlockIO io;                        // 查询执行的输入输出流
    
    // 状态标志
    bool sent_all_data = false;
    bool need_receive_data_for_insert = false;
    bool read_all_data = true;
    bool skipping_data = false;
    
    Progress progress;                  // 查询进度
    Stopwatch watch;                   // 计时器
};

// src/Server/MySQLHandler.h
class MySQLHandler : public Poco::Net::TCPServerConnection
{
public:
    MySQLHandler(IServer & server_, LoggerPtr log_, const ProfileEvents::Event & read_event_,
                const ProfileEvents::Event & write_event_, bool ssl_enabled, uint32_t connection_id_);
    
    void run() override;

private:
    // MySQL协议处理
    void comQuery(ReadBuffer & payload, bool binary_protocol);
    void comFieldList(ReadBuffer & payload);
    void comPing();
    void comInitDB(ReadBuffer & payload);
    
    // 认证处理
    void authenticate(const String & user_name, const String & auth_plugin_name, const String & initial_auth_response);
    void authPluginSSL();
    void finishHandshake(MySQLProtocol::ConnectionPhase::Enum next_phase);
    
    // 查询替换（MySQL兼容性）
    std::unordered_map<std::string, std::function<std::string(const std::string &)>> queries_replacements;
    std::unordered_map<std::string, std::string> settings_replacements;
};

// src/Server/MySQLHandler.cpp - 查询替换逻辑
void MySQLHandler::comQuery(ReadBuffer & payload, bool binary_protocol)
{
    String query = String(payload.position(), payload.buffer().end());
    
    String replacement_query;
    bool should_replace = false;
    
    // 查询替换
    for (auto const & [query_to_replace, replacement_fn] : queries_replacements)
    {
        if (checkShouldReplaceQuery(query, query_to_replace))
        {
            should_replace = true;
            replacement_query = replacement_fn(query);
            break;
        }
    }
    
    // 设置替换
    if (!should_replace)
    {
        for (auto const & [mysql_setting, clickhouse_setting] : settings_replacements)
        {
            const auto replacement_query_opt = setSettingReplacementQuery(query, mysql_setting, clickhouse_setting);
            if (replacement_query_opt.has_value())
            {
                should_replace = true;
                replacement_query = replacement_query_opt.value();
                break;
            }
        }
    }
    
    // 执行查询
    auto query_context = session->makeQueryContext();
    executeQuery(should_replace ? replacement_query : query, query_context, mysql_output_format);
}

// src/Server/grpc_protos/clickhouse_grpc.proto
service ClickHouse {
    rpc ExecuteQuery(QueryInfo) returns (Result) {}
    rpc ExecuteQueryWithStreamInput(stream QueryInfo) returns (Result) {}
    rpc ExecuteQueryWithStreamOutput(QueryInfo) returns (stream Result) {}
    rpc ExecuteQueryWithStreamIO(stream QueryInfo) returns (stream Result) {}
}

message QueryInfo {
    string query = 1;
    string query_id = 2;
    map<string, string> settings = 3;
    string database = 4;
    string input_format = 5;
    string output_format = 6;
    bytes input_data = 7;
    repeated ExternalTable external_tables = 8;
    string user_name = 9;
    string password = 10;
    string quota_key = 11;
    string session_id = 12;
    bool session_check = 13;
    uint32 session_timeout = 14;
    bool cancel = 15;
    bool next_query_info = 16;
}

message Result {
    string query_id = 9;
    string time_zone = 10;
    string output_format = 11;
    repeated NameAndType output_columns = 12;
    bytes output = 1;
    bytes totals = 2;
    bytes extremes = 3;
    repeated LogEntry logs = 4;
    Progress progress = 5;
    Stats stats = 6;
    Exception exception = 7;
    bool cancelled = 8;
}

graph TB
    subgraph "Parser Module"
        LEXER[Lexer 词法分析器]
        PARSER[Parser 语法分析器]
        AST[AST 抽象语法树]
        VISITOR[AST Visitor]
    end
    
    subgraph "Parser Components"
        SELECT_PARSER[SelectQueryParser]
        INSERT_PARSER[InsertQueryParser]
        CREATE_PARSER[CreateQueryParser]
        ALTER_PARSER[AlterQueryParser]
        EXPRESSION_PARSER[ExpressionParser]
    end
    
    SQL_TEXT[SQL Text] --> LEXER
    LEXER --> PARSER
    PARSER --> SELECT_PARSER
    PARSER --> INSERT_PARSER
    PARSER --> CREATE_PARSER
    PARSER --> ALTER_PARSER
    SELECT_PARSER --> AST
    INSERT_PARSER --> AST
    CREATE_PARSER --> AST
    ALTER_PARSER --> AST
    AST --> VISITOR

// src/Parsers/ParserQuery.h
class ParserQuery : public IParserBase
{
protected:
    const char * getName() const override { return "Query"; }
    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
    
private:
    ParserQueryWithOutput query_with_output_p;
    ParserInsertQuery insert_p;
    ParserUseQuery use_p;
    ParserSetQuery set_p;
    ParserSystemQuery system_p;
};

// src/Parsers/ParserSelectQuery.cpp - SELECT查询解析核心逻辑
bool ParserSelectQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{
    auto select_query = std::make_shared<ASTSelectQuery>();
    node = select_query;
    
    // 解析WITH子句
    if (s_with.ignore(pos, expected))
    {
        if (!ParserExpressionList(false).parse(pos, select_query->with(), expected))
            return false;
    }
    
    // 解析SELECT子句
    if (!s_select.ignore(pos, expected))
        return false;
        
    if (s_distinct.ignore(pos, expected))
        select_query->distinct = true;
        
    if (!ParserExpressionList(false).parse(pos, select_query->select(), expected))
        return false;
    
    // 解析FROM子句
    if (s_from.ignore(pos, expected))
    {
        if (!ParserTablesInSelectQuery().parse(pos, select_query->tables(), expected))
            return false;
    }
    
    // 解析WHERE子句
    if (s_where.ignore(pos, expected))
    {
        if (!ParserExpressionWithOptionalAlias(false).parse(pos, select_query->where(), expected))
            return false;
    }
    
    // 解析GROUP BY子句
    if (s_group_by.ignore(pos, expected))
    {
        if (!ParserExpressionList(false).parse(pos, select_query->groupBy(), expected))
            return false;
    }
    
    // 解析HAVING子句
    if (s_having.ignore(pos, expected))
    {
        if (!ParserExpressionWithOptionalAlias(false).parse(pos, select_query->having(), expected))
            return false;
    }
    
    // 解析ORDER BY子句
    if (s_order_by.ignore(pos, expected))
    {
        if (!ParserOrderByExpressionList().parse(pos, select_query->orderBy(), expected))
            return false;
    }
    
    // 解析LIMIT子句
    if (s_limit.ignore(pos, expected))
    {
        if (!ParserLimit().parse(pos, select_query->limitByLength(), expected))
            return false;
    }
    
    return true;
}

// src/Parsers/ASTSelectQuery.h
class ASTSelectQuery : public IAST
{
public:
    enum class Expression : uint8_t
    {
        WITH,
        SELECT,
        TABLES,
        PREWHERE,
        WHERE,
        GROUP_BY,
        HAVING,
        WINDOW,
        ORDER_BY,
        LIMIT_BY_OFFSET,
        LIMIT_BY_LENGTH,
        LIMIT_OFFSET,
        LIMIT_LENGTH,
        SETTINGS
    };
    
    // 查询子句
    ASTPtr with();
    ASTPtr select();
    ASTPtr tables();
    ASTPtr prewhere();
    ASTPtr where();
    ASTPtr groupBy();
    ASTPtr having();
    ASTPtr orderBy();
    ASTPtr limitBy();
    
    // 查询属性
    bool distinct = false;
    bool group_by_with_totals = false;
    bool group_by_with_rollup = false;
    bool group_by_with_cube = false;
    bool group_by_with_grouping_sets = false;
    
    String getID(char) const override { return "SelectQuery"; }
    ASTPtr clone() const override;
    void formatImpl(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const override;
};

graph TB
    subgraph "Analyzer Module"
        QUERY_ANALYZER[QueryAnalyzer 查询分析器]
        SCOPE_ANALYZER[ScopeAnalyzer 作用域分析器]
        TYPE_ANALYZER[TypeAnalyzer 类型分析器]
        FUNCTION_ANALYZER[FunctionAnalyzer 函数分析器]
    end
    
    subgraph "Analysis Components"
        NAME_RESOLVER[NameResolver 名称解析]
        TYPE_CHECKER[TypeChecker 类型检查]
        AGGREGATE_CHECKER[AggregateChecker 聚合检查]
        WINDOW_CHECKER[WindowChecker 窗口函数检查]
    end
    
    AST[AST] --> QUERY_ANALYZER
    QUERY_ANALYZER --> SCOPE_ANALYZER
    QUERY_ANALYZER --> TYPE_ANALYZER
    QUERY_ANALYZER --> FUNCTION_ANALYZER
    SCOPE_ANALYZER --> NAME_RESOLVER
    TYPE_ANALYZER --> TYPE_CHECKER
    FUNCTION_ANALYZER --> AGGREGATE_CHECKER
    FUNCTION_ANALYZER --> WINDOW_CHECKER

// src/Analyzer/QueryAnalyzer.h
class QueryAnalyzer
{
public:
    QueryAnalyzer(bool only_analyze_ = false) : only_analyze(only_analyze_) {}
    
    void resolve(QueryTreeNodePtr query_tree_node, const QueryTreeNodePtr & table_expression, ContextPtr context);

private:
    // 核心分析方法
    void resolveQuery(const QueryTreeNodePtr & query_node, IdentifierResolveScope & scope);
    void resolveSelectQuery(const QueryTreeNodePtr & select_query_node, IdentifierResolveScope & scope);
    void resolveExpressionNode(QueryTreeNodePtr & node, IdentifierResolveScope & scope, bool allow_lambda_expression, bool allow_table_expression);
    
    // 特定表达式解析
    void resolveFunctionNode(QueryTreeNodePtr & node, IdentifierResolveScope & scope, bool allow_lambda_expression);
    void resolveIdentifierNode(QueryTreeNodePtr & node, IdentifierResolveScope & scope);
    void resolveColumnNode(QueryTreeNodePtr & node, IdentifierResolveScope & scope);
    
    // 类型推导
    void resolveExpressionNodeType(QueryTreeNodePtr & node, IdentifierResolveScope & scope, bool allow_lambda_expression, bool allow_table_expression);
    
    bool only_analyze = false;
    std::unordered_set<QueryTreeNodePtr> resolved_expressions;
};

// src/Analyzer/QueryAnalyzer.cpp - 查询解析核心逻辑
void QueryAnalyzer::resolveSelectQuery(const QueryTreeNodePtr & select_query_node, IdentifierResolveScope & scope)
{
    auto & select_query_node_typed = select_query_node->as<SelectQueryNode &>();
    
    // 1. 解析WITH子句
    if (select_query_node_typed.hasWith())
    {
        for (auto & with_node : select_query_node_typed.getWith().getNodes())
            resolveExpressionNode(with_node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);
    }
    
    // 2. 解析FROM子句
    if (select_query_node_typed.hasJoinTree())
    {
        resolveTableExpression(select_query_node_typed.getJoinTree(), scope);
    }
    
    // 3. 解析WHERE子句
    if (select_query_node_typed.hasWhere())
    {
        resolveExpressionNode(select_query_node_typed.getWhere(), scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);
    }
    
    // 4. 解析SELECT子句
    for (auto & projection_node : select_query_node_typed.getProjection().getNodes())
    {
        resolveExpressionNode(projection_node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);
    }
    
    // 5. 解析GROUP BY子句
    if (select_query_node_typed.hasGroupBy())
    {
        for (auto & group_by_node : select_query_node_typed.getGroupBy().getNodes())
        {
            resolveExpressionNode(group_by_node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);
        }
    }
    
    // 6. 解析HAVING子句
    if (select_query_node_typed.hasHaving())
    {
        resolveExpressionNode(select_query_node_typed.getHaving(), scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);
    }
    
    // 7. 解析ORDER BY子句
    if (select_query_node_typed.hasOrderBy())
    {
        for (auto & order_by_node : select_query_node_typed.getOrderBy().getNodes())
        {
            resolveExpressionNode(order_by_node, scope, false /*allow_lambda_expression*/, false /*allow_table_expression*/);
        }
    }
}

graph TB
    subgraph "Interpreter Module"
        INTERPRETER_FACTORY[InterpreterFactory 解释器工厂]
        SELECT_INTERPRETER[SelectQueryInterpreter]
        INSERT_INTERPRETER[InsertQueryInterpreter]
        CREATE_INTERPRETER[CreateQueryInterpreter]
        ALTER_INTERPRETER[AlterQueryInterpreter]
    end
    
    subgraph "Execution Components"
        PIPELINE_BUILDER[PipelineBuilder 管道构建器]
        EXPRESSION_ANALYZER[ExpressionAnalyzer 表达式分析器]
        SYNTAX_ANALYZER[SyntaxAnalyzer 语法分析器]
        AGGREGATE_ANALYZER[AggregateAnalyzer 聚合分析器]
    end
    
    AST[AST] --> INTERPRETER_FACTORY
    INTERPRETER_FACTORY --> SELECT_INTERPRETER
    INTERPRETER_FACTORY --> INSERT_INTERPRETER
    INTERPRETER_FACTORY --> CREATE_INTERPRETER
    INTERPRETER_FACTORY --> ALTER_INTERPRETER
    
    SELECT_INTERPRETER --> PIPELINE_BUILDER
    SELECT_INTERPRETER --> EXPRESSION_ANALYZER
    EXPRESSION_ANALYZER --> SYNTAX_ANALYZER
    EXPRESSION_ANALYZER --> AGGREGATE_ANALYZER

// src/Interpreters/InterpreterSelectQuery.h
class InterpreterSelectQuery : public IInterpreter
{
public:
    InterpreterSelectQuery(
        const ASTPtr & query_ptr_,
        ContextPtr context_,
        const SelectQueryOptions & options_ = {},
        const Names & required_result_column_names_ = {});
    
    BlockIO execute() override;
    QueryPlan buildQueryPlan() override;
    
private:
    // 核心执行方法
    void executeImpl(QueryPlan & query_plan, std::optional<Pipe> prepared_pipe);
    void executeFetchColumns(QueryProcessingStage::Enum processing_stage, QueryPlan & query_plan);
    void executeWhere(QueryPlan & query_plan, const ActionsDAGPtr & expression, bool remove_filter);
    void executeAggregation(QueryPlan & query_plan, const ActionsDAGPtr & expression, bool overflow_row, bool final, InputOrderInfoPtr group_by_info);
    void executeHaving(QueryPlan & query_plan, const ActionsDAGPtr & expression);
    void executeOrderBy(QueryPlan & query_plan, InputOrderInfoPtr sorting_info, UInt64 limit, bool need_merge_sorted_columns);
    void executeLimit(QueryPlan & query_plan);
    void executeProjection(QueryPlan & query_plan, const ActionsDAGPtr & expression);
    
    // 查询分析
    void analyzeExpressions(QueryProcessingStage::Enum from_stage, bool dry_run, const Block & sample_block);
    
    ASTSelectQuery & getSelectQuery() { return query_ptr->as<ASTSelectQuery &>(); }
    
private:
    ASTPtr query_ptr;
    ContextPtr context;
    SelectQueryOptions options;
    
    /// 分析结果
    std::unique_ptr<ExpressionAnalyzer> query_analyzer;
    std::unique_ptr<SyntaxAnalyzer> syntax_analyzer_result;
    
    /// 查询处理阶段
    QueryProcessingStage::Enum from_stage = QueryProcessingStage::FetchColumns;
    
    /// 存储信息
    StoragePtr storage;
    StorageID table_id = StorageID::createEmpty();
    TableLockHolder table_lock;
    
    /// 查询计划
    std::unique_ptr<QueryPlan> query_plan;
};

// src/Interpreters/InterpreterSelectQuery.cpp - 执行逻辑
BlockIO InterpreterSelectQuery::execute()
{
    QueryPlan query_plan;
    buildQueryPlan(query_plan);
    
    auto builder = query_plan.buildQueryPipeline(
        QueryPlanOptimizationSettings::fromContext(context),
        BuildQueryPipelineSettings::fromContext(context));
    
    BlockIO res;
    res.pipeline = std::move(*builder);
    
    return res;
}

void InterpreterSelectQuery::executeImpl(QueryPlan & query_plan, std::optional<Pipe> prepared_pipe)
{
    // 1. 获取数据源
    if (!prepared_pipe.has_value())
        executeFetchColumns(from_stage, query_plan);
    else
        query_plan.addStep(std::make_unique<SourceFromSingleChunk>(prepared_pipe->getHeader(), Chunk()));
    
    // 2. 执行WHERE过滤
    if (expressions.filter_info)
    {
        executeWhere(query_plan, expressions.filter_info->actions, expressions.filter_info->remove_filter_column);
    }
    
    // 3. 执行聚合
    if (expressions.hasAggregation())
    {
        executeAggregation(query_plan, expressions.before_aggregation, expressions.overflow_row, expressions.final, group_by_info);
    }
    
    // 4. 执行HAVING过滤
    if (expressions.hasHaving())
    {
        executeHaving(query_plan, expressions.having);
    }
    
    // 5. 执行ORDER BY排序
    if (expressions.hasOrderBy())
    {
        executeOrderBy(query_plan, sorting_info, query.limitLength(), need_merge_sorted_columns);
    }
    
    // 6. 执行LIMIT限制
    if (query.limitLength())
    {
        executeLimit(query_plan);
    }
    
    // 7. 执行投影
    if (expressions.hasProjection())
    {
        executeProjection(query_plan, expressions.final_projection);
    }
}

graph TB
    subgraph "Storage Engine Layer"
        ISTORAGE[IStorage 存储接口]
        STORAGE_FACTORY[StorageFactory 存储工厂]
    end
    
    subgraph "MergeTree Family"
        MERGETREE[MergeTree]
        REPLICATED_MERGETREE[ReplicatedMergeTree]
        SUMMING_MERGETREE[SummingMergeTree]
        REPLACING_MERGETREE[ReplacingMergeTree]
        AGGREGATING_MERGETREE[AggregatingMergeTree]
        COLLAPSING_MERGETREE[CollapsingMergeTree]
        VERSIONED_COLLAPSING_MERGETREE[VersionedCollapsingMergeTree]
        GRAPHITE_MERGETREE[GraphiteMergeTree]
    end
    
    subgraph "Other Engines"
        MEMORY[Memory]
        DISTRIBUTED[Distributed]
        MERGE[Merge]
        LOG[Log]
        TINY_LOG[TinyLog]
        STRIPE_LOG[StripeLog]
        DICTIONARY[Dictionary]
        EXTERNAL[External Storages]
    end
    
    STORAGE_FACTORY --> ISTORAGE
    ISTORAGE --> MERGETREE
    ISTORAGE --> REPLICATED_MERGETREE
    ISTORAGE --> MEMORY
    ISTORAGE --> DISTRIBUTED
    MERGETREE --> SUMMING_MERGETREE
    MERGETREE --> REPLACING_MERGETREE
    MERGETREE --> AGGREGATING_MERGETREE
    MERGETREE --> COLLAPSING_MERGETREE
    MERGETREE --> VERSIONED_COLLAPSING_MERGETREE
    MERGETREE --> GRAPHITE_MERGETREE

// src/Storages/IStorage.h
class IStorage : public std::enable_shared_from_this<IStorage>, public TypePromotion<IStorage>
{
public:
    IStorage(StorageID storage_id_) : storage_id(std::move(storage_id_)) {}
    virtual ~IStorage() = default;
    
    // 基本信息
    virtual std::string getName() const = 0;
    virtual StorageID getStorageID() const { return storage_id; }
    virtual TableLockHolder tryLockTimed(const RWLockImpl::LockTimeout & timeout, RWLockImpl::Type type) const;
    
    // 表结构
    virtual ColumnsDescription getColumns() const { return columns; }
    virtual void setColumns(ColumnsDescription columns_) { columns = std::move(columns_); }
    virtual ConstraintsDescription getConstraints() const { return constraints; }
    
    // 查询处理
    virtual void read(
        QueryPlan & query_plan,
        const Names & column_names,
        const StorageSnapshotPtr & storage_snapshot,
        SelectQueryInfo & query_info,
        ContextPtr context,
        QueryProcessingStage::Enum processed_stage,
        size_t max_block_size,
        size_t num_streams) = 0;
    
    virtual Pipe read(
        const Names & column_names,
        const StorageSnapshotPtr & storage_snapshot,
        SelectQueryInfo & query_info,
        ContextPtr context,
        QueryProcessingStage::Enum processed_stage,
        size_t max_block_size,
        size_t num_streams);
    
    // 数据写入
    virtual SinkToStoragePtr write(const ASTPtr & query, const StorageMetadataPtr & metadata_snapshot, ContextPtr context, bool async_insert);
    
    // 表操作
    virtual void drop() {}
    virtual void truncate(const ASTPtr & query, const StorageMetadataPtr & metadata_snapshot, ContextPtr context, TableExclusiveLockHolder & lock);
    virtual void alter(const AlterCommands & params, ContextPtr context, AlterLockHolder & alter_lock_holder);
    
    // 分区操作
    virtual void dropPartition(const ASTPtr & partition, bool detach, ContextPtr context);
    virtual void attachPartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, bool part, ContextPtr context);
    
    // 优化操作
    virtual void optimize(const ASTPtr & query, const StorageMetadataPtr & metadata_snapshot, const ASTPtr & partition, bool final, bool deduplicate, const Names & deduplicate_by_columns, ContextPtr context);
    
protected:
    StorageID storage_id;
    ColumnsDescription columns;
    ConstraintsDescription constraints;
    String comment;
};

// src/Storages/MergeTree/MergeTreeData.h
class MergeTreeData : public IStorage
{
public:
    struct DataPart
    {
        String name;
        MergeTreePartInfo info;
        size_t bytes_on_disk = 0;
        size_t rows_count = 0;
        time_t modification_time = 0;
        
        /// 数据部分的列和索引
        NamesAndTypesList columns;
        SerializationInfoByName serialization_infos;
        
        /// 主键和排序键
        size_t primary_key_size = 0;
        Checksums checksums;
        
        /// 分区信息
        String partition_id;
        MergeTreePartition partition;
        
        /// 数据部分状态
        enum State
        {
            Temporary,       /// 临时状态，正在写入
            PreCommitted,    /// 预提交状态
            Committed,       /// 已提交状态
            Outdated,        /// 过时状态，等待删除
            Deleting,        /// 正在删除
            DeleteOnDestroy  /// 析构时删除
        };
        
        State state = Temporary;
    };
    
    using DataPartPtr = std::shared_ptr<const DataPart>;
    using DataPartsVector = std::vector<DataPartPtr>;
    
    // 数据部分管理
    DataPartPtr getPartIfExists(const String & part_name, const DataPartStates & valid_states);
    DataPartsVector getDataPartsVector(const DataPartStates & affordable_states = DataPartStates({DataPartState::Committed})) const;
    
    // 合并操作
    bool selectPartsToMerge(FutureMergedMutatedPart & future_part, bool aggressive, size_t max_total_size_to_merge, const AllowedMergingPredicate & can_merge, String * out_disable_reason = nullptr);
    
    // 数据写入
    MutableDataPartPtr createPart(const String & name, const DataPartType & type, const MergeTreePartInfo & part_info, const VolumePtr & volume, const String & relative_path = "");
    
    // 数据读取
    void read(QueryPlan & query_plan, const Names & column_names, const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, size_t num_streams) override;
    
private:
    // 数据部分集合（使用读写锁保护）
    mutable std::shared_mutex data_parts_mutex;
    DataPartsIndexes data_parts_indexes;
    DataPartsVector data_parts_by_info;
    DataPartsVector data_parts_by_state_and_info;
    
    // 后台任务
    BackgroundSchedulePool::TaskHolder background_operations_assignee;
    BackgroundSchedulePool::TaskHolder background_moves_assignee;
    
    // 合并选择器
    std::unique_ptr<IMergeSelector> merge_selector;
    std::unique_ptr<ITTLMergeSelector> ttl_merge_selector;
    
    // 设置
    MergeTreeSettings storage_settings;
    
    // 主键和排序键
    KeyDescription primary_key;
    KeyDescription sorting_key;
    KeyDescription partition_key;
    KeyDescription sampling_key;
};

// src/Storages/MergeTree/MergeTreeData.cpp - 数据读取实现
void MergeTreeData::read(QueryPlan & query_plan, const Names & column_names, const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, size_t num_streams)
{
    // 1. 获取需要读取的数据部分
    auto parts = getDataPartsVector();
    
    // 2. 根据查询条件过滤数据部分
    auto filtered_parts = filterPartsByPrimaryKey(parts, query_info, context);
    
    // 3. 创建读取管道
    Pipes pipes;
    
    for (const auto & part : filtered_parts)
    {
        auto source = std::make_shared<MergeTreeSequentialSource>(
            *this, storage_snapshot, part, column_names, max_block_size, context);
        pipes.emplace_back(std::move(source));
    }
    
    // 4. 合并管道
    auto pipe = Pipe::unitePipes(std::move(pipes));
    
    // 5. 添加到查询计划
    auto read_from_merge_tree = std::make_unique<ReadFromMergeTree>(std::move(pipe));
    query_plan.addStep(std::move(read_from_merge_tree));
}

graph TB
    subgraph "Processor Framework"
        IPROCESSOR[IProcessor 处理器接口]
        PROCESSOR_FACTORY[ProcessorFactory]
        PIPELINE[QueryPipeline 查询管道]
    end
    
    subgraph "Source Processors"
        SOURCE_FROM_SINGLE_CHUNK[SourceFromSingleChunk]
        SOURCE_FROM_STORAGE[SourceFromStorage]
        MERGE_TREE_SOURCE[MergeTreeSource]
        REMOTE_SOURCE[RemoteSource]
    end
    
    subgraph "Transform Processors"
        FILTER_TRANSFORM[FilterTransform]
        EXPRESSION_TRANSFORM[ExpressionTransform]
        AGGREGATING_TRANSFORM[AggregatingTransform]
        SORTING_TRANSFORM[SortingTransform]
        LIMIT_TRANSFORM[LimitTransform]
    end
    
    subgraph "Sink Processors"
        NULL_SINK[NullSink]
        MERGE_TREE_SINK[MergeTreeSink]
        REMOTE_SINK[RemoteSink]
    end
    
    IPROCESSOR --> SOURCE_FROM_SINGLE_CHUNK
    IPROCESSOR --> SOURCE_FROM_STORAGE
    IPROCESSOR --> FILTER_TRANSFORM
    IPROCESSOR --> EXPRESSION_TRANSFORM
    IPROCESSOR --> AGGREGATING_TRANSFORM
    IPROCESSOR --> NULL_SINK
    IPROCESSOR --> MERGE_TREE_SINK
    
    PIPELINE --> IPROCESSOR

// src/Processors/IProcessor.h
class IProcessor
{
public:
    enum class Status
    {
        NeedData,     /// 需要更多输入数据
        PortFull,     /// 输出端口已满
        Finished,     /// 处理完成
        Ready,        /// 准备处理
        Async,        /// 异步处理中
        ExpandPipeline /// 需要扩展管道
    };
    
    IProcessor() = default;
    virtual ~IProcessor() = default;
    
    // 核心处理方法
    virtual Status prepare() = 0;
    virtual void work();
    virtual Chunk generate();
    virtual void consume(Chunk chunk);
    
    // 端口管理
    virtual InputPorts & getInputs() { return inputs; }
    virtual OutputPorts & getOutputs() { return outputs; }
    
    // 处理器信息
    virtual String getName() const = 0;
    virtual String getDescription() const { return getName(); }
    
    // 资源管理
    virtual void setResourcesProvider(ResourcesProviderPtr resources_provider_) { resources_provider = std::move(resources_provider_); }
    
protected:
    InputPorts inputs;
    OutputPorts outputs;
    ResourcesProviderPtr resources_provider;
    
    // 辅助方法
    void addInputPort(DataTypePtr type, bool is_main = true);
    void addOutputPort(DataTypePtr type, bool is_main = true);
};

// src/Processors/ISimpleTransform.h - 简单变换处理器基类
class ISimpleTransform : public IProcessor
{
public:
    ISimpleTransform(Block input_header, Block output_header, bool skip_empty_chunks_ = true);
    
    Status prepare() override final;
    void work() override final;
    
protected:
    // 子类需要实现的核心方法
    virtual void transform(Chunk & chunk) = 0;
    
    // 可选的钩子方法
    virtual void onConsume(Chunk chunk) { transform(chunk); }
    virtual void onGenerate() {}
    virtual void onFinish() {}
    
private:
    InputPort & input;
    OutputPort & output;
    
    Chunk current_chunk;
    bool has_input = false;
    bool has_output = false;
    bool finished_input = false;
    bool finished_output = false;
    
    const bool skip_empty_chunks = true;
};

// 具体的变换处理器实现示例
class FilterTransform : public ISimpleTransform
{
public:
    FilterTransform(const Block & header_, ExpressionActionsPtr expression_, String filter_column_name_, bool remove_filter_column_);
    
    String getName() const override { return "FilterTransform"; }
    
protected:
    void transform(Chunk & chunk) override;
    
private:
    ExpressionActionsPtr expression;
    String filter_column_name;
    bool remove_filter_column;
    
    size_t filter_column_position = 0;
};

// src/Processors/Transforms/FilterTransform.cpp - 过滤变换实现
void FilterTransform::transform(Chunk & chunk)
{
    size_t num_rows_before_filtration = chunk.getNumRows();
    auto columns = chunk.detachColumns();
    
    // 执行表达式计算
    Block block = getInputPort().getHeader().cloneWithColumns(columns);
    expression->execute(block);
    
    // 获取过滤列
    const auto & filter_column = block.getByName(filter_column_name);
    ConstantFilterDescription constant_filter_description(*filter_column.column);
    
    if (constant_filter_description.always_false)
    {
        // 如果过滤条件总是false，返回空chunk
        chunk.clear();
        return;
    }
    
    if (constant_filter_description.always_true)
    {
        // 如果过滤条件总是true，移除过滤列（如果需要）
        if (remove_filter_column)
            block.erase(filter_column_name);
        chunk.setColumns(block.getColumns(), num_rows_before_filtration);
        return;
    }
    
    // 应用过滤条件
    FilterDescription filter_description(*filter_column.column);
    
    for (size_t i = 0; i < block.columns(); ++i)
    {
        if (remove_filter_column && block.getByPosition(i).name == filter_column_name)
            continue;
            
        block.safeGetByPosition(i).column = block.safeGetByPosition(i).column->filter(*filter_description.data, -1);
    }
    
    if (remove_filter_column)
        block.erase(filter_column_name);
        
    chunk.setColumns(block.getColumns(), block.rows());
}

classDiagram
    class IDataType {
        <<interface>>
        +getName() String
        +getTypeId() TypeIndex
        +serialize() void
        +deserialize() void
        +createColumn() ColumnPtr
    }
    
    class DataTypeNumber {
        +DataTypeNumber()
        +getName() String
        +createColumn() ColumnPtr
    }
    
    class DataTypeString {
        +getName() String
        +createColumn() ColumnPtr
    }
    
    class DataTypeArray {
        -nested_type: DataTypePtr
        +DataTypeArray(DataTypePtr)
        +getName() String
        +createColumn() ColumnPtr
    }
    
    class IColumn {
        <<interface>>
        +size() size_t
        +get(size_t) Field
        +insert(Field) void
        +filter(Filter) ColumnPtr
        +permute(Permutation) ColumnPtr
    }
    
    class ColumnVector {
        -data: PaddedPODArray~T~
        +size() size_t
        +get(size_t) Field
        +insert(Field) void
    }
    
    class ColumnString {
        -chars: PaddedPODArray~UInt8~
        -offsets: PaddedPODArray~UInt64~
        +size() size_t
        +get(size_t) Field
        +insert(Field) void
    }
    
    class ColumnArray {
        -data: ColumnPtr
        -offsets: ColumnPtr
        +size() size_t
        +get(size_t) Field
        +insert(Field) void
    }
    
    IDataType <|-- DataTypeNumber
    IDataType <|-- DataTypeString
    IDataType <|-- DataTypeArray
    
    IColumn <|-- ColumnVector
    IColumn <|-- ColumnString
    IColumn <|-- ColumnArray
    
    DataTypeNumber --> ColumnVector : creates
    DataTypeString --> ColumnString : creates
    DataTypeArray --> ColumnArray : creates

classDiagram
    class IStorage {
        <<interface>>
        +getName() String
        +read() void
        +write() SinkToStoragePtr
        +alter() void
        +drop() void
    }
    
    class MergeTreeData {
        #data_parts: DataPartsVector
        #merge_selector: IMergeSelectorPtr
        +selectPartsToMerge() bool
        +createPart() MutableDataPartPtr
    }
    
    class StorageMergeTree {
        -background_executor: BackgroundJobsExecutor
        +read() void
        +write() SinkToStoragePtr
        +optimize() void
    }
    
    class StorageReplicatedMergeTree {
        -zookeeper: ZooKeeperPtr
        -replica_name: String
        +read() void
        +write() SinkToStoragePtr
        +fetchPart() void
    }
    
    class StorageMemory {
        -data: Blocks
        +read() void
        +write() SinkToStoragePtr
    }
    
    class StorageDistributed {
        -cluster: ClusterPtr
        -sharding_key: ASTPtr
        +read() void
        +write() SinkToStoragePtr
    }
    
    IStorage <|-- MergeTreeData
    MergeTreeData <|-- StorageMergeTree
    MergeTreeData <|-- StorageReplicatedMergeTree
    IStorage <|-- StorageMemory
    IStorage <|-- StorageDistributed

classDiagram
    class IAST {
        <<interface>>
        +clone() ASTPtr
        +getID() String
        +formatImpl() void
    }
    
    class ASTWithAlias {
        +alias: String
        +tryGetAlias() String
    }
    
    class ASTSelectQuery {
        +distinct: bool
        +select() ASTPtr
        +tables() ASTPtr
        +where() ASTPtr
        +groupBy() ASTPtr
        +having() ASTPtr
        +orderBy() ASTPtr
    }
    
    class ASTInsertQuery {
        +database: String
        +table: String
        +columns: ASTPtr
        +select: ASTPtr
    }
    
    class ASTFunction {
        +name: String
        +arguments: ASTPtr
        +parameters: ASTPtr
    }
    
    class ASTIdentifier {
        +name: String
        +compound() bool
    }
    
    IAST <|-- ASTWithAlias
    ASTWithAlias <|-- ASTSelectQuery
    IAST <|-- ASTInsertQuery
    ASTWithAlias <|-- ASTFunction
    ASTWithAlias <|-- ASTIdentifier

// src/Core/Block.h
class Block
{
private:
    using Container = ColumnsWithTypeAndName;
    Container data;
    
public:
    Block() = default;
    Block(std::initializer_list<ColumnWithTypeAndName> il);
    Block(const ColumnsWithTypeAndName & data_);
    
    // 基本操作
    bool operator==(const Block & other) const;
    bool operator!=(const Block & other) const { return !(*this == other); }
    
    // 列操作
    void insert(size_t position, ColumnWithTypeAndName elem);
    void insert(ColumnWithTypeAndName elem);
    void insertUnique(ColumnWithTypeAndName elem);
    void erase(const std::set<size_t> & positions);
    void erase(size_t position);
    void erase(const String & name);
    
    // 访问方法
    ColumnWithTypeAndName & getByPosition(size_t position) { return data[position]; }
    const ColumnWithTypeAndName & getByPosition(size_t position) const { return data[position]; }
    ColumnWithTypeAndName & getByName(const String & name);
    const ColumnWithTypeAndName & getByName(const String & name) const;
    
    // 属性
    size_t rows() const;
    size_t columns() const { return data.size(); }
    size_t bytes() const;
    size_t allocatedBytes() const;
    
    // 转换操作
    Block cloneEmpty() const;
    Block cloneWithColumns(const Columns & columns) const;
    Block cloneWithoutColumns() const;
    Block cloneResized(size_t rows) const;
    
    // 工具方法
    void clear();
    void swap(Block & other) noexcept;
    void updateHash(SipHash & hash) const;
    
    // 调试
    void dumpStructure() const;
    String dumpNames() const;
    String dumpIndex() const;
};