当我谈查询优化器时,我谈些什么 (1)—— IR 设计

TiDB 优化器丨执行计划和 SQL 算子解读最佳实践 导读 在数据库系统中,查询优化器是数据库管理系统的核心组成部分,负责将用户的 SQL 查询转化为高效的执行计划,因而会直接影响用户体感的性能与稳定性。优化器的设计与实现过程充满挑战,有人比喻称这是数据库技术要持续攀登的珠穆朗玛峰,永远没有最优的止境。在一般的数据库系统中,查询优化涉及复杂的算法和数据结构,需要综合考虑多种因素,如数据分布、索引选择、连接顺序等,这些因素直接影响查询的性能和资源利用率。 优化器在 HTAP(Hybrid Transactional and Analytical Processi 阅读详情

作者:雷宇

Databend 优化器负责人

https://github.com/leiysky

图片

这几天和迟先生 (github@skyzh) 聊天时偶然聊到他最近在 CMU 做的 optd 项目(一个基于 Cascades 框架设计的查询优化器库),一起吐槽了各种数据库优化器的设计与实现。这时我突然意识到有些技术上的东西聊起来还是挺有意思的,值得记录下来。

因此我决定开个坑,聊聊查询优化器相关的一切——从算法基础到工程实践,从技术演进到项目落地,甚至是一些行业八卦。

今天先将“IR 设计”相关的内容作为开篇,聊一聊优化器中常见的设计模式,并且讨论其中的设计考量。

什么是查询优化器

在正式开始聊之前,我想先明确一下查询优化器的定义。

在一般语境中,查询优化器特指对查询的执行计划进行优化的一个数据库组件。但是由于各个数据库实现上的不同,查询的优化方式也变得五花八门,比如在 AST 上直接进行 Rewriting,在 AST Lowering 的时候做些转换,在查询执行的时候进行动态的 Rewriting 等等。

为了统一概念,我将从 SQL 解析器 (Parser) 到执行器 (Executor) 之间的所有部分统称为查询优化器 (Query Optimizer)。

什么是 IR

熟悉编译技术的朋友的应该很熟悉 IR 这个词。IR 全称为中间语言 (Intermediate Representation) ,常见于各种编程语言的编译器中,比如 Rust 的 HIR & MIR,LLVM 中的 LLVM IR。IR 被用于结构化表示编程语言,方便编译器进行各种分析与优化。

如果将 SQL 也看成一种编程语言的话,关系型数据库就是运行 SQL 程序的虚拟机,正如 JVM 之于 Java。而查询优化器在其中负责的就是绝大多数的编译工作,将 SQL 语句 (Java code) 翻译成执行计划 (Java bytecode) 交给执行器 (Java runtime) 执行。因此在设计查询优化器时也离不开设计 SQL 的各种 IR。

SQL IR 都长啥样

一般的数据库项目会分为几个模块:解析器 (Parser) ,分析器 (Analyzer/Binder) ,优化器 (Optimizer) ,执行器 (Executor)。SQL 语句会依次经由各组件的处理,最后转化成查询结果。在我们的语境里,优化器囊括了上面提到的分析器和优化器两个模块。

SQL 本身是一种模仿自然语言语法设计的声明式语言,基于关系代数,可以描述集合上的各种运算,并将其映射为对表格数据 (Table) 的查询。

AST

为了方便处理,我们会像绝大多数编译器那样,首先将 SQL 语言解析为 AST(抽象语法树,即 Abstract Syntax Tree)。一个 SQL AST 一般如下图所示:

![Query AST](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/ast.png?msec=1706756281956)

在 SQL AST 中,我们一般将 node 分为两种:Statement(Stmt) 和 Expression(Expr)。每个 SQL AST 的 root node 总是一个 Statement,其中可能包含一些子句 (Clause) 以及 Expression。Expression 是一种递归的结构,其中包含了各种运算符和函数调用,甚至还有嵌套的 Statement (Subqueries)。

在 SQL 中比较有意思的一点是,对于 SELECT Statement 来说 Statement 与 Expression 的界限会比较模糊。因为 SELECT Statement 本身也是递归的,甚至还需要处理运算符优先级的问题 (UNION/EXCEPT/INTERSECT)。与此同时,在 Statement 中也仅有 SELECT Statement 可以与 Expression 互相递归,因此在设计 SQL AST 时需要注意这点。

关系代数

SQL 语言的理论基础是关系代数,每一条查询语句都有对应的关系代数表示,比如:

![Relational algebra](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/relational_algebra.png?msec=1706756281896)

由于关系代数的表达式也是一个递归的树状结构,因此很多系统也很自然地将 SQL AST 转换成了类似下图的执行计划,我们将每个 node 称作算子 (Operator),将整个算子树成为查询计划 (Query plan)。

![Algebra plan](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/algebra_plan.png?msec=1706756281896)

当然众多系统中也有异类,比如身为祖师爷的 IBM 在 Starburst 系统中引入了 Query Graph Model 这种表示方式。这种表示方式相当的抽象,将许多 property 给 hardcode 在了 QGM 中,导致理解起来异常困难,其宣称的可扩展性也令人怀疑。篇幅原因就不在这里展开讲解,有兴趣的话可以去阅读相关论文《Extensible Query Processing in Starburst》以及《Extensible/Rule Based Query Rewrite Optimization in Starburst》。

![QGM](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/QGM.png?msec=1706756282004)

目前主流的数据库基本都采用了关系代数的表示方式(比如 IBM 的 System R 和 DB2,Oracle 的各种数据库产品,微软的 SQL Server 系列,开源的 PostgreSQL 和 MySQL 8.0),也在此基础上衍生出了丰富的优化框架和执行框架,因此在设计 SQL IR 时使用关系代数的抽象是一种不会错的选择。

利用关系型代数的各种公理和定理我们可以对 SQL IR 进行各种转换,在保证正确性的同时达到优化的效果。关于具体的优化规则和算法会在后续的文章中进行讨论。

最佳工程实践(待定)

有一种认知偏差叫做“知识的诅咒”,意指在与他人交流时预设了对方拥有与自己同等的知识背景。

在软件开发领域这种现象非常常见。写过某类代码的人和没写过某类代码的人在交流时总会变成鸡同鸭讲,即便双方已经具备了相同的理论基础(算法,编程语言,甚至是领域知识)依然无法避免。原因在于软件工程具有相当的灵活性,同样的功能可以有许多种实现方式,而不同的实现方式又会有各自的问题。

为了扫除这种沟通上的障碍,各种技术领域都会发展出自己的一系列 idiom 或者 design pattern,新的项目基于这些实践构建可以省去很多不必要的麻烦。数据库领域也是如此,但是由于比较小众,且商业化程度较高,导致坊间流传的知识非常稀少,工程实践也散落在各种开源项目中。

在这篇文章里我会根据我自己的最佳实践从零构建一套 SQL IR,方便渐进式地分享一些设计考量。

因为个人习惯,我会用 Rust 语言来编写代码。不熟悉 Rust 语言的朋友也不用担心,只需要有一定的 C/C++ 基础就可以看懂 Rust 的代码逻辑。

Hello, world!

当我们学习一门新的编程语言时,第一个接触的程序一般都是 hello world。

fn main() {
    println!("Hello, world!");
}

因此我们也先从 SQL 的 hello world 开始构建我们的 IR。

create table t(a int);
select * from t;

这条 SQL 语句翻译成关系代数非常简单,我们将其记为 Get(t),意为返回集合 t 中的所有数据。要表示这样的查询我们可以定义一个简单的 struct 类型。

pub struct Get {
    pub table: String,
}

fn plan() -> Get {
    // select * from t;
    Get {
        table: "t".to_string(),
    }
}

这样简单的一个 SQL IR 就完成了,有了 Get 之后我们就能表示所有类似 select * from xxx 的查询了,是不是很简单?

Select & Project

接下来我们可以为这个 IR 添加更多的功能,支持更多的 SQL 子句。比如:

create table t(a int, b int);
select a from t where a = 1;

这条 SQL 查询翻译成关系代数可以记为 Project(Select(Get(t), a = 1), a),Select 算子可以根据提供的谓词对数据进行过滤,Project 算子可以对集合进行裁剪以获得需要的 attribute。为了表示这样的查询我们需要添加更多的 struct 定义。

pub struct Get {
    pub table: String,
}

pub struct Select {
    pub get: Get,
    pub predicate: String,
}

pub struct Project {
    pub select: Select,
    pub project: String,
}

fn plan() -> Project {
    // select a from t where a = 1;
    Project {
        select: Select {
            get: Get {
                table: "t".to_string(),
            },
            predicate: "a = 1".to_string(),
        },
        project: "a".to_string(),
    }
}

来到这里我们就面临了几个问题:按照关系代数的定理,Project 是不是可以作为 Select 的 child?Select 对于一条 SQL 查询来说是可选的,代码上该如何体现这点?

为了解决这些问题,我们可以引入一些动态分发的特性。在 C++/Java 中一般会使用继承来表示 Opeartor,比如:

class Operator {};
class Get : public Operator {};
class Select : public Operator {
    Operator* _child;
};
class Project : public Operator {
    Operator* _child;
};

在 Rust 中,我们有一个更方便的选择,可以同时享受静态类型和动态分发的优点,那就是 enum。Rust 的 enum 是一种 ADT(Algebraic Data Type),也被称作 tagged union,可以非常方便地表示我们的 operators:

pub enum Operator {
    Get {
        table: String,
    },
    Select {
        child: Box<Self>,
        predicate: String,
    },
    Project {
        child: Box<Self>,
        projects: String,
    },
}

fn plan() -> Operator {
    // select a from t where a = 1;
    Operator::Project {
        child: Box::new(Operator::Select {
            child: Box::new(Operator::Get {
                table: "t".to_string(),
            }),
            predicate: "a = 1".to_string(),
        }),
        project: "a".to_string(),
    }
}

由此一来我们就可以自由表示各种形状的算子树了,IR 的设计开始步入正轨。

Scalar expression

虽然我们已经引入了 Select 和 Project 的算子,但是对于 Select predicate 和 Project expression 还是以字符串的形式存在的,不能满足分析和优化的需求。因此我们需要为这些 expression 也设计一种 IR。

回想一下,SQL 字符串在经过 Parser 处理后就被转换成了 AST,而其中的表达式会变成 Expr node,大概长这样:

pub enum Expr {
    ColumnRef(ColumnRef),
    Literal(Literal),
    Function(Function),
    BinaryOp(BinaryOp),
    UnaryOp(UnaryOp),
    Subquery(SelectStmt),
}

expression 本身是一种递归的结构,AST 的 Expr node 也是一种递归结构,我们是否可以偷懒直接使用 Expr node 作为我们的 SQL IR 的一部分呢?我们可以先试试。

使用 Expr 替换 String 后,我们可以得到:

pub enum Operator {
    Get {
        table: String,
    },
    Select {
        child: Box<Self>,
        predicate: Expr,
    },
    Project {
        child: Box<Self>,
        projects: Vec<Expr>,
    },
}

接下来给定一条 SQL,让我们来试试常用的一些分析,看看好不好使:

select a from t
where exists (select * from t1 where t.a = t1.a)
  1. Q: Project 中的 Expr 依赖了哪些 table 的哪些 columns?A: 使用了一个叫做 a 的 column,但我不知道它是哪个 table 的,或许根本就不存在这个 column
  2. Q: Project 中的 Expr 的返回类型是什么?A: 不知道,Expr 中没有包含任何类型信息
  3. Q: Select 中的 subquery 是 correlated subquery 吗?A: 不知道,Expr 中的 subquery 只是一个未处理过的 AST

Ok,看起来 Expr 并没有我们想象中的那么好用。为了进行上面的这些分析,我们需要设计一套信息更加丰富的 IR。为了与 Expr 进行区分,我们将其命名为 ScalarExpr。

将以上的分析归纳一下,我们对 ScalarExpr 的要求是:

  1. 所有的 identifier 都要 resolve 成 fully qualified name
  2. 类型信息需要被注入,并且需要经过 type check
  3. 所有的 subquery 都要被转换成 SQL IR 的形式

结合以上需求,再加上一些 desugar,ScalarExpr 大概长这样:

pub enum ScalarExpr {
    ColumnRef(Vec<Identifier>, Type),
    Literal(Value, Type),
    Function(Signature, Vec<Self>),
    Subquery(Quantifier, Box<Operator>),
}

如此一来,表达式的 IR 设计也成型了,让我们把整套 SQL IR 整合起来吧。

The IR

经过以上的设计,我们拥有了:

  • 能够灵活表达各种 SQL 查询的算子树结构 Operator
  • 能够提供丰富语义信息的 ScalarExpr

尽管还缺少一些关键的算子,比如 Join, Union, Aggregate 等。但是由于整体框架已经十分清晰,我们可以照葫芦画瓢地把它们也加上。

整合之后我们就有了一套相当完美的 SQL IR:

pub enum ScalarExpr {
    ColumnRef(Vec<Identifier>, Type),
    Literal(Value, Type),
    Function(Signature, Vec<Self>),
    Subquery(Quantifier, Box<Operator>),
}

pub enum Operator {
    Get {
        table: String,
    },
    Select {
        child: Box<Self>,
        predicate: ScalarExpr,
    },
    Project {
        child: Box<Self>,
        projects: Vec<ScalarExpr>,
    },
    Join {
        kind: JoinKind,
        condition: ScalarExpr,
        left: Box<Self>,
        right: Box<Self>,
    },
    UnionAll {
        left: Box<Self>,
        right: Box<Self>,
    },
    Aggregate {
        group_by: Vec<ScalarExpr>,
        aggr_exprs: Vec<ScalarExpr>,
        child: Box<Self>,
    },
}

因为过于完美,我决定给这个 IR 起个霸气的名字——The IR。

Property derivation

当我们想要对 IR 进行分析和优化时,我们总是需要获取一些 IR 的 property。我们可以通过编写 analyzer 遍历整个 IR 来计算出这些 property,但是这样需要耗费大量精力维护 IR 所处上下文的状态。

幸运的是 SQL 作为一个声明式的查询语言数据流相当简单,我们可以利用其特性计算 property。

The IR 中的数据流向和 operator 之间的父子关系紧密相关,整体呈现为一个有向无环图 (DAG),所有的数据都从子节点流向父节点。

![Untitled](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/DAG.png?msec=1706756281896)

在这种特性下,计算某个 The IR 节点的 property 要做的事情很简单,只需递归计算其每个子节点的 property,再根据这些 property 计算出其本身的 property,我们称这个过程为 property derivation。

pub struct Property;

fn derive_property(op: &Operator) -> Property {
    // Calculate the properties of the children operators.
    let children_property: Vec<Property> = op
        .children()
        .map(derive_property)
        .collect();

    // Calculate property with the children properties.
    op.calculate_property(&children_property)
}

在 SQL 优化中,常用的 property 可以分为两类,分别是描述数据集特征的 relational/logical property 和描述数据物理特征的 physical property。

常见的 relational property 有:

  • 数据集中包含的 attributes/columns 信息
  • 数据集的基数 (cardinality),表示数据集中的 record 数量
  • 统计信息 (statistics),表示 attributes 的数据分布
  • 数据约束 (constraints),表示 attributes 的约束,比如 NOT NULL
  • 函数依赖 (functional dependency),表示 attributes 之间的函数依赖关系

常见的 physical property 有:

  • 有序性 (order)
  • 并行度 (DOP)
  • 数据分布 (distribution)
  • 数据分区 (partition)

结合关系代数的性质,我们可以描述 property 种类之间的区别。

假设有关系 R 和 S:R 的 relational property 为 RP_R,physical property 为 PP_R;S 的 relational property 为 RP_S,physical property 为 PP_S。

我们可以得到:

$$ \forall R, S: R = S \implies RP_R = RP_S $$

不难看出两个 relation 的等价关系可以决定 relational property 的等价关系,但是 physical property 的等价关系却不受 relation 的等价关系影响。

关于 property 与具体的查询优化算法结合的内容将在后续的文章里展开讨论。

有了 property derivation 之后,我们就能利用关系代数的定理在保证正确性的情况下对 The IR 进行优化了。

那么接下来的问题就是,property 该长啥样?

Relational properties

在 relational property 中最重要的部分莫过于 attributes 的表示方式。朴素的关系代数中,每一个 relation 都是由 tuples 组成的 set ,tuple 中的每个 attribute 都有自己的 unique name,我们很自然地可以想到直接将 tuple schema 作为 attributes 的表示方式。

我们先回忆一下一个 table 是如何创建的。

create table t(a int);

在 SQL 中我们使用 DDL(Data Definition Language) 来创建和管理各种 table。在创建 table 时我们需要为其指定 table schema,里面包含了 table 中每个 column 的具体定义,对应了关系代数中的 attributes。table schema 的结构大概会长这样:

pub struct TableSchema {
    pub name: String,
    pub columns: Vec<ColumnDefinition>
}

pub struct ColumnDefinition {
    pub name: String,
    pub column_type: Type,
    pub not_null: bool,
}

既然 ColumnDefinition 与 attribute 是一一对应的关系,我们可不可以直接用 ColumnDefinition 来表示 attribute 的 property?

我们可以先来试试,在 The IR 中加上对于 attributes 的支持。

fn derive_attributes(op: &Operator) -> Vec<ColumnDefinition> {
    // Calculate the attributes of the children operators.
    let children_attributes: Vec<Vec<ColumnDefinition>> =
        op.children().iter().map(derive_attributes).collect();

    // Calculate attributes with the children attributes.
    op.calculate_attributes(&children_attributes)
}

我们首先需要对 The IR 做一些修改,为 Get 算子加上 table schema 信息。

pub enum Operator {
    Get {
        table: String,
        schema: Vec<ColumnDefinition>,
    },
    // Nothing changed for other variants
}

然后我们为 Operator 实现 attributes derivation。

impl Operator {
    fn calculate_attributes(&self, children: &[Vec<ColumnDefinition>]) -> Vec<ColumnDefinition> {
        match self {
            Operator::Get { schema, .. } => {
                let attributes = schema.clone();
                attributes
            }
            Operator::Select { .. } => children[0].clone(),
            Operator::Join { .. } => {
                let mut attributes = children[0].clone();
                attributes.extend(children[1].clone());
                attributes
            }
            Operator::UnionAll { .. } => children[0].clone(),

            Operator::Project { .. } => todo!(),
            Operator::Aggregate { .. } => todo!(),
        }
    }
}

大部分的算子实现还是很顺利的,但是可以看到 Project 和 Aggregate 被标成了 todo。我们这时会发现,Project 和 Aggregate 没法直接利用 children attributes 生成他们自己的 attributes。再回到关系代数上,Project 的作用是裁剪 tuple 的形状,抑或是修改 attribute 的 name, SELECT a + 1 AS b FROM t 这种 SQL 根本无法表达为朴素的 Project;至于 Aggregate,朴素的关系代数中根本没有这个运算,这是对关系代数的扩展内容。

关系代数理论不存在了!

但是尽管如此,工程还是得继续进行,我们需要引入一些“村规”来扩展关系代数的定义。我们在此给出 The IR 中的 Project 和 Aggregate 的形式化定义:

  • Project(R, (f_1, …, f_n)) → \{(x_1, …, x_n)\} 表示将关系 R 中的 attributes 作为输入,输出 f_1 到 f_n 的 n 个函数映射组成的 tuple
  • Aggregate(R, (k_1, …, k_m), (f_1, …, f_n)) → \{(x_1, …, x_m, x_m+1, …, x_m+n)\} 表示将关系 R 中的 tuples 按照 k_1 到 k_m 的 m 个 attributes 进行分组,并且对每个分组执行 f_1 到 f_n 的 n 个函数映射,最终输出分组后的 tuples

这个村规最大的改变是引入了 derived column。对于 SQL 中直接来自于 table 的 column,我们称之为 base table column;对于通过 Project/Aggregate 计算出的 column,我们称之为 derived column。在引入 derived column 概念之前我们可以保证所有的数据来源最终都会指向 Get 算子,但是引入之后这个约定就被打破了,出现了类似编程语言中作用域 (scope) 的概念,我们在进行优化时需要更加的注意。

有了村规后我们就可以给 Project 和 Aggregate 也实现 attributes derivation,但与此同时我们也需要对 The IR 的结构做一些修改:

pub enum Operator {
    Project {
        child: Box<Self>,
        projects: Vec<(ScalarExpr, String)>,
    },
    // Others
}

impl Operator {
    fn calculate_attributes(&self, children: &[Vec<ColumnDefinition>]) -> Vec<ColumnDefinition> {
        match self {
            Operator::Project { projects, .. } => {
                let attributes: Vec<ColumnDefinition> = projects
                    .iter()
                    .map(|(expr, alias)| ColumnDefinition {
                        name: alias.clone(),
                        column_type: expr.column_type(),
                        not_null: expr.nullable(),
                    })
                    .collect();

                attributes
            }
            Operator::Aggregate {
                group_by,
                aggr_exprs,
                ..
            } => {
                let mut attributes: Vec<ColumnDefinition> = group_by
                    .iter()
                    .map(|expr| ColumnDefinition {
                        name: expr.name(),
                        column_type: expr.column_type(),
                        not_null: expr.nullable(),
                    })
                    .collect();

                attributes.extend(aggr_exprs.iter().map(|expr| ColumnDefinition {
                    name: expr.name(),
                    column_type: expr.column_type(),
                    not_null: expr.nullable(),
                }));

                attributes
            }
            // Others
        }
    }
}

这样一来对于所有的算子我们都可以计算 attributes property 了,赶紧来试用一下吧。

先来看看 SQL 中最常见也最有效的优化——谓词下推。这个优化可以通过将 Select 算子下推到其他算子内以减少其他算子的计算量,同时还可以保证整个查询的结果不会改变,非常的简洁优雅。

![Select push down](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/select_push_down_project.png?msec=1706756281933)

我们来尝试在 The IR 上实现这个优化。思路上非常简单,根据关系代数定理直接调换 Select 与 Project 的位置即可。但是由于我们引入了 derived column,我们必须检查 Select 中的 predicate 是否依赖了 Project 生成的 column。

fn push_down_select_project(op: &Operator) -> Option<Operator> {
    match op {
        Operator::Select {
            child: project @ box Operator::Project { child, projects },
            predicate,
        } => {
            let project_attributes: Vec<ColumnDefinition> = derive_attributes(&project);
            let predicate_used_columns: Vec<String> = predicate.used_columns();

            // Check if the predicate uses any column from the project.
            let used_derived_columns = predicate_used_columns.iter().any(|used_column| {
                project_attributes
                    .iter()
                    .any(|attr| attr.name == *used_column)
            });

            if used_derived_columns {
                None
            } else {
                Some(Operator::Project {
                    child: Box::new(Operator::Select {
                        child: child.clone(),
                        predicate: predicate.clone(),
                    }),
                    projects: projects.clone(),
                })
            }
        }
        _ => None,
    }
}

看起来已经基本可用了,可喜可贺。我们再来试试更复杂的例子,比如试试有 Join 的 SQL:

![Select push down](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/select_push_down_join.png?msec=1706756281955)

因为 Join 不像 Project 那样会产生额外的 derived column,因此检查的逻辑会相对简单一些。我们先实现一个尝试将 Select 下推到 Join 的 left child 的优化:

fn push_down_select_join_left(op: &Operator) -> Option<Operator> {
    match op {
        Operator::Select {
            child: join @ box Operator::Join { left, right, .. },
            predicate,
        } => {
            let left_attributes: Vec<ColumnDefinition> = derive_attributes(&left);
            let predicate_used_columns: Vec<String> = predicate.used_columns();

            // Check if the predicate only uses column from left.
            let only_left = predicate_used_columns
                .iter()
                .all(|used_column| left_attributes.iter().any(|attr| attr.name == *used_column));

            if only_left {
                Some(Operator::Join {
                    left: Box::new(Operator::Select {
                        child: left.clone(),
                        predicate: predicate.clone(),
                    }),
                    right: right.clone(),
                    ..join.clone()
                })
            } else {
                None
            }
        }
        _ => None,
    }
}

一切看起来都很美好,但是魔鬼往往藏在细节里。我们来看这个例子在 PostgreSQL 中的输出:

leiysky=# create table t(a int);
CREATE TABLE
leiysky=# create table t1(a int);
CREATE TABLE
leiysky=# insert into t values(1);
INSERT 0 1
leiysky=# insert into t1 values(1);
INSERT 0 1
leiysky=# select * from t, t1 where t.a = 1;
 a | a
---+---
 1 | 1
(1 row)

最后返回的结果有两个叫做 a 的 attributes。在 The IR 目前的实现中,我们无法知道这个 Select 该下推到哪边。因为当我们检查依赖了 a 的 predicate 能被下推到哪一侧时,我们会发现 Join 的两侧都可以满足。虽然同一个 table 中不允许存在多个具有相同 name 的 columns,但是不同 table 之间并没有这样的限制。

PostreSQL 作为对 ANSI SQL 支持度最高的开源数据库产品,自然也能很好地处理这种问题。通过 EXPLAIN 语句我们可以看到它将 Select 下推到了正确的地方:

leiysky=# explain(verbose) select * from t, t1 where t.a = 1;
                              QUERY PLAN
----------------------------------------------------------------------
 Nested Loop  (cost=0.00..491.78 rows=33150 width=8)
   Output: t.a, t1.a
   ->  Seq Scan on public.t1  (cost=0.00..35.50 rows=2550 width=4)
         Output: t1.a
   ->  Materialize  (cost=0.00..41.94 rows=13 width=4)
         Output: t.a
         ->  Seq Scan on public.t  (cost=0.00..41.88 rows=13 width=4)
               Output: t.a
               Filter: (t.a = 1)
(9 rows)

The IR 作为完美的 SQL IR,也必须有自己的解决方案。我们仔细观察这条查询的话,会发现 Select 的谓词是用 qualified name 表示的,假如使用 unqualified name 的话 PostgreSQL 会抛出这样的报错:

leiysky=# select * from t, t1 where a = 1;
ERROR:  column reference "a" is ambiguous
LINE 1: select * from t, t1 where a = 1;

因为在当前的上下文中,a 是存在歧义的,但是 t.a 就不存在歧义。我们来试试用 qualified name 表示 attribute property 来解决这个问题,为此我们需要改动一些代码:

pub struct QualifiedName(pub Vec<String>);

impl QualifiedName {
    /// If the current name can be used to refer another name
    pub fn can_refer(&self, other: &Self) -> bool {
        self.0.len() <= other.0.len() 
          && self.0.iter().zip(other.0.iter()).all(|(a, b)| a == b)
    }
}

pub struct ColumnDefinition {
    /// Use qualified name
    pub name: QualifiedName,
    pub column_type: Type,
    pub not_null: bool,
}

fn resolve_attribute(
    attributes: &[ColumnDefinition],
    name: &QualifiedName,
) -> Option<ColumnDefinition> {
    let candidates: Vec<ColumnDefinition> = attributes
        .iter()
        .filter(|attr| attr.name.can_refer(name))
        .collect();

    if candidates.len() == 1 {
        Some(candidates[0].clone())
    } else if candidates.len() > 1 {
        panic!("Watch out, ambiguous reference found!")
    }else {
        None
    }
}

fn push_down_select_join_left(op: &Operator) -> Option<Operator> {
    match op {
        Operator::Select {
            child: join @ box Operator::Join { left, right, .. },
            predicate,
        } => {
            let left_attributes: Vec<ColumnDefinition> = derive_attributes(&left);
            let predicate_used_columns: Vec<QualifiedName> = predicate.used_columns();

            // Check if the predicate only uses column from left.
            let only_left = predicate_used_columns
                .iter()
                .all(|used_column| resolve_attribute(&left_attributes, used_column).is_some());

            if only_left {
                Some(Operator::Join {
                    left: Box::new(Operator::Select {
                        child: left.clone(),
                        predicate: predicate.clone(),
                    }),
                    right: right.clone(),
                    ..join.clone()
                })
            } else {
                None
            }
        }
        _ => None,
    }
}

这样一来上面的问题就解决了,我们有了处理复杂 attribute 引用的能力,但是距离一劳永逸仍有很大的距离。我们再来看一个例子:

leiysky=# select * from (select * from t1) as t, t1 where t.a = 1;
 a | a
---+---
 1 | 1
(1 row)

虽然 SQL 中不允许在同一个 FROM clause 中使用多个同样的 table name,但是我们可以使用 inlined view 或者 CTE 绕过这点。按照我们现在的实现,在处理 t.a = 1 时我们拿到的 attributes 里面有两个 t1.a 而没有 t.a,这是因为我们没有处理 inlined view 的 alias。为此,我们需要增加一个 Project 专门用于给 attributes 做 renaming。

那么问题又来了,由于我们仅仅是为一些 columns 做了 renaming 就将它们当成了 derived columns 来处理,为我们的 Select 下推徒增了很多负担。为此我们必须修改 The IR 的定义和各种相关代码,服务于 name 的 mapping:

pub enum Operator {
    Project {
        child: Box<Self>,
        // (Expression, Source name, Alias)
        projects: Vec<(ScalarExpr, QualifiedName, QualifiedName)>,
    },
    // Others
}

这些问题通过稍微多写点代码还能解决,但是看看接下来的这个例子,我相信大部分人会像我一样直接抓狂:

leiysky=# select a from t natural join t1;
 a
---
 1
(1 row)

leiysky=# select t.a from t natural join t1;
 a
---
 1
(1 row)

leiysky=# select t1.a from t natural join t1;
 a
---
 1
(1 row)

leiysky=# select * from t natural join t1;
 a
---
 1
(1 row)

leiysky=# select a from t join t1 on t.a = t1.a;
ERROR:  column reference "a" is ambiguous
LINE 1: select a from t join t1 on t.a = t1.a;

我们当然可以为代码中再加上各种奇奇怪怪的限制,开各种难以维护的洞来维护这种 property,并且在进行优化的同时保证这些 property 的正确性。但是对于懒惰的程序员们来说,寻找一种更简单的设计才是更好的选择。

欢迎来到深水区。

The IR made simple

最开始的 The IR 是非常简洁而优雅的,但是为了实现更多的功能,支持更复杂的需求,我们为其添加了许多我们不想关注的信息。总的来说,理想状态的 The IR 应该是:

  • 拥有简洁的代数结构
  • Operator 节点之间完全独立
  • 不用处理 names(仅用于 debug 和展示)

让我们在回过头来思考一下,The IR 真的离不开 name 吗?我们最开始使用 name 来表示 attribute 主要是出于直觉,复用了 table schema。但是 name 中融入了许多无用的信息,对我们的优化毫无帮助,就像编程语言中的各种 symbol name 一样,到了程序运行时都会变成内存地址和寄存器编号。

没有 name 便无法区分 attributes,name 岂是如此不便之物?

![Is Name such a inconvenient thing?](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/name_inconvenient.png?msec=1706756281954)

归根结底,我们需要的是为每个 attribute 附上一个 unique id,无论是 integer 还是 string,总之我们的唯一目的就是用 id 来区分和引用 attribute。所有的 name resolution 统统丢进 AST lowering,我只想要 attribute id!

在进行了重新设计之后我们改变了 attribute 的表示方式,同时也更改了一些 The IR 的定义。默认情况下,我们使用 int64 类型作为 attribute id。

pub type Id = i64;

pub struct Attribute {
    pub id: Id,
    pub column_type: Type,
    pub nullable: Type,
}

pub enum ScalarExpr {
    ColumnRef(Id),
    // Others
}

id 的设计一般离不开对应的上下文 (context),在 SQL IR 中 attribute id 的常见设计方式主要可以分为两类:

  • 一种是基于我们之前用到的 tuple attribute 的抽象,将 attribute 在 tuple 中的 index 作为 attribute id,我们将这种 id 称为 local id。这种设计的特点是逻辑上的同一个 attribute 的 id 会随着其所处的 operator 的不同而发生改变。这种 id 的好处是可以从 operator tree 中推理出来,不需要靠外部的状态进行维护。但是缺点就是在对 operator 进行转换时需要频繁的对 id 进行 remapping。
  • 另一种是通过维护一个全局的 id generator,给 SQL IR 中的所有 attribute 赋予一个 unique id,我们将这种 id 称为 global id。这种设计的优点是将 attribute 与 tuple schema 进行了解耦,可以使用 HashMap<Id, Attribute> 这种无序集合结构表示 attributes。同时也可以利用集合运算帮助 property derivation,降低维护复杂度。但是缺点是使用 global id 的 operator tree 需要依赖外部状态,无法独自存在。

使用这两种不同的设计会对优化器的具体实现造成非常大的影响。

比如说对于这个优化:

![Split disjuntion](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/split_disjunction.png?msec=1706756281953)

在有合适的索引可用时,通过这个优化可以避免 full table scan 从而提升性能。

如果使用 local id 的设计,实现这个优化会非常简单,只需要将整个 operator tree 复制一份,最后使用 UnionAll 连接起来即可。

但是如果使用 global id 的设计,这就是一个 non-trivial 的操作,甚至可以说是十分痛苦。为了区分不同的 attribute,我们必须在复制 operator tree 的同时为所有的 attribute 生成新的 id,再将所有引用这些 attribute 的地方替换成新的 id,这在查询较为复杂时会造成很多麻烦。

再比如说进行 join order 优化时:

![Commute join](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/commute_join.png?msec=1706756281936)

根据 Join 算子的交换律,我们可以合法交换 Join 的左右 child。使用 global id 的设计时,因为 attributes 可以表示为无序集合,因此这个操作对于 property derivation 毫无影响。但是使用 local id 的设计时这个操作就会让人痛苦不堪。

除去优化相关的部分,在对于 correlated subquery 的表示上他们的差异也非常巨大。correlated subquery 是一种特殊的 subquery,它可以访问自己的 scope 以外的 attribute,对于这类特殊的 attribute 访问我们称之为 outer reference。

![Correlated subquery](file:///Users/leiwenfang/Downloads/leiysky's blog/assets/correlated_subquery.png?msec=1706756281934)

许多编程语言中也支持类似的操作,可以从函数中访问定义在函数内没有定义的变量,通过与特定环境 (environment) 进行绑定 (bind) 后才能执行。这种特殊的函数叫做闭包 (Closure)。

fn main() {
    let a = 1;
    let f = || {
        let b = a; // a is captured from outside
        println!("{}", b);
    }; // f is a closure

    f(); // stdout: 1
}

使用 global id 的设计可以通过 attribute property 计算出 subquery 是否为 correlated。但是使用 local id 的设计时我们一般会在 scalar expression 的 ColumnRef 中额外维护一个 scope id,实现起来非常麻烦。

correlated subquery 是一个非常大的话题,我们也许会在后续的文章中聊到。

由此可见两种设计各有优缺点,在工程实践中我们要结合自己的需求选择适合自己的设计。就我个人而言,global id 是一种更好的设计,因为它在绝大多数的情况下都能很轻松地解决问题。

使用 global id 进行改造后,The IR 的代码可以得到大幅的简化:

pub type Id = i64;

pub struct Context {
    pub id_gen: Id,
}

pub struct Attribute {
    pub id: Id,
    pub column_type: Type,
    pub nullable: Type,
}

pub type AttributeSet = HashMap<Id, Attribute>;

pub enum ScalarExpr {
    ColumnRef(Id),
    Literal(Value, Type),
    Function(Signature, Vec<Self>),
    Subquery(Quantifier, Box<Operator>),
}

pub enum Operator {
    Get {
        table: String,
        output_columns: AttributeSet,
    },
    Select {
        child: Box<Self>,
        predicate: ScalarExpr,
    },
    Project {
        child: Box<Self>,
        projects: Vec<(ScalarExpr, Id)>,
    },
    Join {
        kind: JoinKind,
        condition: ScalarExpr,
        left: Box<Self>,
        right: Box<Self>,
    },
    UnionAll {
        left: Box<Self>,
        right: Box<Self>,
    },
    Aggregate {
        group_by: Vec<ScalarExpr>,
        aggr_exprs: Vec<(ScalarExpr, Id)>,
        child: Box<Self>,
    },
}

在把复杂度转嫁给 AST lowerer 之后,我们可以自信地说,The IR 已经是个 production ready 的 SQL IR 了。它可以支持所有的 SQL 运算和常用的优化,拥有易用的 API,同时也非常易于理解。更重要的是,没有人比这篇文章的读者更懂 The IR,任何读者都可以根据自己的需求轻松扩展 The IR。

后记

终于到了这篇文章的尾声。

作为系列的开篇,我在这篇文章里只是简单地聊了聊 SQL IR 设计中的一些关注点,并没有深入讨论各种算法的细节。

但是分享 IR 的设计过程是一件很有意思的事情。很多 IR 就像路边的一棵长得歪歪扭扭的树,第一次路过的人都不知道它为什么会长成那样,只有从小住在这里的人才知道在这棵树很小的时候人们总是喜欢在它的树枝上挂腊肉。这件小事是导致最终结果的重要原因,但是它过于微不足道,导致知道的人从来不会主动分享——当然现实中往往也没人关心背后的原因。

数据库开发是一个小众领域,同时又有很多工程化的实践经验。这些经验在坊间少有流传,我不希望它像美国的登月技术一样随着时代的变化而消失,这也是我想到写这个系列文章的初衷。

在下一篇文章里我会分享关于优化器架构的相关内容,敬请期待。

深入LLVM:解读IR设计与Pass框架,从零构建编译器基础设施 编译器是现代软件工业的基石,而LLVM作为一套开源的编译器基础设施,早已成为Clang、Rust、Swift等众多语言后端的事实标准。理解编译器的核心原理,往往从中间表示(IR)开始——它是前端与后端之间的通用协议,通过静态单赋值形式(SSA)和强类型体系,为代码优化提供了稳固的抽象。在此基础上,Pass框架将优化过程拆解为一个个独立单元,使死代码消除、内联等变换可以灵活组合。无论是评估语言后端选型,还是深入源码进行工程实践,掌握LLVM的目录结构、IR形态与Pass开发方法,都能帮助你快速上手这一庞大的开 阅读详情

相关推荐

从LLVM架构到llvmpipe:理解IR、JIT与SIMD优化

编译器是现代软件栈最底层也最重要的基础设施之一。LLVM通过三段式架构将前端、优化器与后端解耦,以中间表示(IR)为基础,实现跨语言、跨平台的代码生成和优化,这一设计使得Rust、Swift等新语言能够快速复用成熟的后端能力。其核心的SSA形式和pass管线,保证了优化过程的语义等价,同时为JIT编译和SIMD向量化提供了灵活的底层支持。在应用层面,llvmpipe基于LLVM的JIT引擎,在CPU上动态编译着色器为高效的机器码,并利用AVX2等256位向量指令模拟GPU的并行管线,使得无GPU环境也能实现

weixin_30512965的博客 332

关于 IR 在程序分析和优化中应用的一些思考

李彬,编程语言 Lab 程序分析应用专家,南京大学计算机系博士。研究领域是程序分析及验证。 本文以技术文章的方式回顾李老师在SIG-程序分析技术沙龙上的分享,回顾视频也已经上传 B 站,欢迎小伙伴们点开观看。 SIG-程序分析技术沙龙回顾|程序分析中的 IR 讨论_哔哩哔哩_bilibili编程语言社区微信公众号/ID:编程语言Lab/HW-PLLab小助手微信:pl_lab_001Gitee信息:https://gitee.com/HW-PLLab/communityhttps://www.bil..

pl_lab_001的博客 1508

TVM Relax抽象层深度解析:从动态形状到控制流的IR设计

编译器中间表示(IR)是机器学习编译优化的核心枢纽。传统静态图IR在处理动态形状、复杂控制流时往往捉襟见肘,难以兼顾表达灵活性与分析透明度。TVM团队为此设计了Relax,一个更贴近高层框架、支持符号形状与显式控制流的可解析IR。它通过函数式、数据流、张量三层抽象,将纯计算与控制流清晰分离,既保留了数据流块内的高效优化潜力,又允许运行时基于实际形状动态调度分支,从而显著简化了变长序列、多模态模型等场景的编译流程。本文从工程实践视角出发,解析Relax的设计动机与三级抽象机制,通过TVMScript示例展示如

weixin_33937778的博客 360

text2sql方法:NatSQL和DIN-SQL

text2sql方法:NatSQL和DIN-SQL思路介绍

beingstrong的博客 2113

别再死记硬背了!用Python+Matlab/Simulink手把手带你理解PID控制器的‘稳、快、准’

本文通过Python编程和Matlab/Simulink仿真,深入解析PID控制器的‘稳、快、准’三大核心指标,帮助读者直观理解PID控制的实现原理与参数整定技巧。内容涵盖经典控制理论和自动控制原理,提供实战案例和高级调参技巧,适合工业自动化领域的学习者和工程师。

weixin_42551227的博客 371

CloudCompare如何进行二次开发?

CloudCompare源代码编译成功后,即可进行二次开发,可以通过修改源码或者制作插件实现二次开发。本文二次开发采用修改CloudCompare的源代码的方式,分别修改mainwindow.ui、mainwindow.h、mainwindow.cpp,实现扩展功能,克隆选中的点云。

【cacrle】的博客 5334

项目经验分享:实现一个昇思MindSpore 图层 IR 融合优化 pass

暑期2021结项审核正在进行中,项目经验分享也未停止。本期分享来自MindSpore 社区的胡秋越同学带来的项目经验:实现一个 MindSpore 图层 IR 融合优化 pass。欢迎大家持续投喂编辑部信箱,积极分享项目经验以及开源心得!邮箱:summer@iscas.ac.cn微信:项目信息项目名称实现一个 MindSpore 图层 IR 融合优化 pass项目背景MindSpore 简介随着近年来深度学习的快速发展,国外大的互联网公司谷歌(Google)和脸书(Facebook)分别推出了自己的深度学习

Kenji_Shinji的博客 608

用友U8自定义按钮开发:从基础配置到实战业务集成

本文详细介绍了用友U8自定义按钮开发的完整流程,从基础配置到实战业务集成。通过实际案例演示如何在U8系统中添加和替换功能按钮,包括数据库配置、SQL脚本编写和VB组件开发等关键技术点,帮助企业用户实现业务场景的深度定制。

weixin_29698641的博客 261

IR对其他代码优化

IR对其他优化也帮助很大 常量折叠(eg x1=4*1024 变成x1=4096) 常量传播(x1=4;y1=x1 变为 x1=4;y1=4) 强度消减(y1=x1*3变为y1=(x1<<1)+x1) 死代码删除(if(2>1){y1=1;}else{y2=1;...

chuju3227的博客 280

机器学习入门指南:Jupyter Notebook实战

对于机器学习工程师而言,他们更擅长的是算法、模型、数据探索的工作,而对于工程化的能力则并不是其擅长的工作。Jupyter Notebook生成PMML文件1​​​​​​​。Jupyter Notebook生成PMML文件2​​​​​​​。PySpark Notebook建模 -折线图​​​​​​​。TensorFlowNotebook建模​​​​​​​。R Notebook建模 - 散点图​​​​​​​。PySpark Notebook建模​​​​​​​。R Notebook获取训练数据集​​​​​​​。

datacreating的博客 1978

用Linkboy玩转Arduino:3小时搞定智能倒车雷达(附仿真文件下载)

本文详细介绍了如何利用Linkboy图形化编程工具,在3小时内快速搭建一个基于Arduino的智能倒车雷达项目。通过仿真环境,初学者无需硬件即可学习超声波测距原理、报警逻辑设计,并完成从虚拟仿真到实体硬件的完整流程。文章提供了清晰的步骤、调试技巧及功能扩展思路,并附有仿真文件,是入门Arduino和智能硬件制作的绝佳实践指南。

weixin_29159441的博客 407

禁用编译优化_MLIR 一种新的IR表示和编译器框架

背景随着深度学习技术的发展,深度学习技术也逐渐从学术研究的方向转向了实践应用的方向,这不仅对深度模型的准确率有了较高的需求,也对深度模型的推理速度有了越来越高的需求。目前深度模型的推理引擎按照实现方式大体分为两类:解释型推理引擎:一般包含一个模型解析器和一个模型解释器,一些推理引擎可能还包含一个模型优化器。模型解析器负责读取和解析模型文件,并将其转换为适用于解释器处理的内存格式;模型优化...

weixin_39950552的博客 1887

Yocto开发讲解系列 - 总目录

Yocto开发讲解系列总纲Yocto开发专栏前言

fulinux的博客 3万+

深入理解HeavyDB查询优化器:JIT编译如何提升查询性能10倍

HeavyDB(原名OmniSciDB)是一个专为大规模数据分析设计的高性能列式数据库,其查询优化器通过创新的JIT编译技术能够将查询性能提升高达10倍。本文将深入解析HeavyDB查询优化器的核心机制,揭示JIT编译如何实现如此显著的性能提升。 HeavyDB的查询优化器采用了多层次优化策略,从查询解析到执行计划生成,再到运行时优化,每个环节都经过精心设计。其中,JIT编译技术是关键的性能加速

gitblog_00234的博客 817

YOLO26涨点改进 |独家创新,小目标涨点改进篇 | Arxiv 2025 | MHAF‑YOLO,引入RepHMS高效特征提取模块,适合轻量级目标检测、小目标检测、图像分类、旋转目标检测、实例分割

本文提出了一种改进的YOLO26目标检测模型,通过引入RepHMS模块和多分支辅助特征金字塔结构(MAFPN),显著提升了模型性能。RepHMS模块采用多分支异构卷积和重参数化策略,在不增加推理开销的情况下增强多尺度特征提取能力,尤其提升了小目标检测效果。实验表明,改进后的MHAF-YOLO模型在COCO数据集上仅用7.1M参数就达到48.9% AP,相比YOLO11-s参数量减少24.4%而性能提升1.9%。文章详细介绍了RepHMS模块的原理、实现代码及在YOLO26中的集成方法,并提供了两种改进配置。

Ai缝合怪、助力小伙伴高效发论文 200

rk3568 点亮双LVDS 屏

承接文章《rk3568点亮LCD(lvds)》中仅仅只能使用亮单LVDS;经过厂商的努力,陆续发布新补丁。目前支持双lvds显示,缺憾是需要自己额外移植相关补丁。受限于通信频率和VOP编码能力,支持最大分辨仍然是1920x1080、60fps。

weixin_35723192的博客 3008

[译] LLVM IR中间码指令集

最近在研究这个东西, 实在百度不到, 最后在谷歌上找到英文手册. 英文手册地址:https://llvm.org/docs/LangRef.html 先说点废话: 国内的IT水平离世界顶级水平差距实在有点大, 个人感觉 有些因素导致这个结果: 1.化身广告商的百度, 想找点专业文章, 没戏. 2.墙. 有用的文档在墙外,不翻墙看不到. 3...

bluehire的专栏 2258

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

LiteDB 共享查询 IR 架构解析:LINQ 与 SQL 的统一逻辑表达式、自动缓存复用与查询优化

LiteDB 通过引入共享的逻辑查询中间表示(Shared Query IR),让 LINQ 表达式与 SQL 语句在前端翻译阶段就统一为同一套 `BsonExpression`/`Query` 逻辑表示,后端则由 `QueryOptimization` 依据实时集合快照选择物理 `QueryPlan`。本文以 [docs/shared-query-ir.md](https://link.gitc

gitblog_00666的博客 1040

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

革命性LLVM优化工具Souper:10分钟掌握超级优化器核心原理

Souper是一款针对LLVM IR的超级优化器,它利用SMT求解器识别LLVM中端优化器中缺失的窥孔优化,帮助开发者显著提升代码性能。本文将带你快速了解这款强大工具的核心原理与使用方法,让你在10分钟内掌握超级优化的关键技术。 ## 🚀 什么是超级优化器? 超级优化器(superoptimizer)是一种能够自动发现最优代码序列的高级优化工具。与传统优化器依赖人工编写的优化规则不同,Sou

gitblog_00601的博客 772

LLVM深度实践:从IR到Pass开发的完整指南

编译器是软件世界的底层引擎,而LLVM作为当前最具影响力的编译器基础设施,早已不是简单的C/C++编译器,而是一套可自由组合的模块化积木。其核心思想是将传统编译器的前端、优化器与后端通过统一的中间表示(IR)解耦,让任何语言只需编写前端即可复用成熟的优化与代码生成能力。Clang、LLD、libc++等子项目共同构建了完整的工具链生态,而IR与Pass机制则是理解整个体系的关键。从源码构建、CMake配置,到使用opt与llc观察代码从高级语言到机器码的蜕变,再到亲手编写一个统计指令数量的LLVM Pass

weixin_33912453的博客 205

LLVM编译器架构详解:从IR到自定义Pass实战

编译器是软件工程的重要基石,而现代编译器设计普遍采用前端、中端、后端解耦的架构。LLVM作为一个开源编译器基础设施,其核心在于统一的中间表示(IR),语言前端将源码转换为IR,优化器在IR层执行数十种Pass变换,后端最终生成目标机器码。这种模块化设计让新语言只需实现前端即可复用全套优化与跨平台能力,也让芯片厂商能专注于后端定制。以llvm-project为主体,覆盖Clang、LLD、MLIR等核心子项目,构建出从编译、链接、调试到高性能计算的完整工具链。本文围绕LLVM整体架构与实际工程实践,详解核心组

weixin_33423874的博客 243

深入浅出LLVM:架构、IR与自定义Pass开发实战

编译器是将高级语言翻译为机器码的工具,其传统实现往往将前端、优化与后端耦合,导致扩展性受限。LLVM作为一套模块化的编译器基础设施,通过定义统一的中间表示(IR)解耦了语言前端与硬件后端,使任何能生成LLVM IR的语言都可自动支持多种指令集。这一设计不仅降低了新语言与新芯片的编译工具链开发门槛,还催生了Clang、lld、MLIR等子项目,广泛应用于Rust、Swift及AI芯片等领域。本文从LLVM架构、IR核心概念、编译流程入手,并通过编写自定义Pass的实践,帮助开发者快速掌握llvm-projec

weixin_34210740的博客 362

LLVM实战指南:从IR到自定义Pass与llvmpipe软渲染

编译器是软件生态的基石,而LLVM作为模块化的编译器基础设施,通过统一的中间表示(IR)驱动前端、优化与后端,让Clang、Rust、Swift乃至Mesa中的llvmpipe软件渲染都从中受益。llvmpipe利用LLVM将着色器编译为CPU指令,并利用AVX2等SIMD宽度实现256 bits的并行处理。掌握llvm-project的构建与自定义Pass开发,是深入理解现代编译技术的关键。本文从源码构建llvmorg-15.0.7开始,演示Clang生成IR、opt优化、编写Pass到llc生成机器码的

weixin_34268310的博客 159

LLVM编译器基础设施核心原理与实战:从IR到Pass机制全解析

编译器是现代软件工程的基石,而LLVM作为一套模块化的编译器基础设施,早已成为Rust、Swift、Clang等工具链的共同底座。它通过前端将高级语言翻译为统一的中间表示(IR),再依托Pass机制完成优化,最终由后端生成高效机器码。理解LLVM的IR与Pass机制,是掌握编译器优化、静态分析乃至JIT技术的关键路径。从传统的GCC整体式编译器到LLVM的组件化解耦,开发者可以像搭积木一样构建定制化工具链。无论是在CPU后端、GPU异构计算,还是数据库运行时JIT场景,LLVM都展现出强大的适应能力。本文从

weixin_34252686的博客 416

HARDBOILED IR:面向张量计算的编译器优化设计

中间表示(IR)是编译器优化的核心组件,其设计质量直接影响代码生成效率。现代硬件加速器(如Intel AMX和NVIDIA WMMA)需要专门的IR系统来充分发挥性能潜力。HARDBOILED IR采用函数式风格设计,通过最小化语法结构捕获硬件特性,支持跨平台优化。其关键技术包括向量化操作支持、显式存储层级区分以及基于egglog规则引擎的四维优化体系。这些设计使得编译器能够自动识别张量计算模式(如矩阵乘法和卷积),并生成高效的硬件指令序列。该IR系统特别适合深度学习推理、科学计算等需要高性能张量运算的场景

weixin_35973118的博客 592
上一篇: Databend 开源周报第 130 期
下一篇: Databend Stream 的设计与实现 | Data Infra 第 18 期
Databend
博客等级 码龄5年 1458粉丝 363原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值