Database on NoneBack

MIT6.824 AuroraDB

Tue, 01 Aug 2023 16:11:54 +0800

这篇文章介绍了AWS的数据库产品Aurora的设计考虑，包括存算分离、一写多读、基于Quorum的NRW一致性协议等。同时，文章也提到了PolarDB参考Aurora进行设计，但在网络瓶颈和系统调用方面有所不同。

Aurora是AWS提供的一种数据库产品，主要面向OLTP的业务场景。

设计上，我觉得有这些值得参考的地方：

Aurora设计的前提是，在数据库上云之后，得益于云基础设施的发展，数据库最大的瓶颈从计算和存储变成了网络，这是AWS在设计Aurora的时候一个很重要的前提。基于此前提，Aurora重提Log is Database的论调，只将RedoLog下推至存储层。
存算分离。数据库存储层对接分布式存储底座，通过存储底座提供良好的可靠性和安全性保证。计算和存储层可以独立拓展。同时，存储底座对上层提供的单一数据视图，使得一些核心功能和运维操作效率得到很好的提升（比如备份，数据恢复，HA等）
一些有意思的可靠性保证。比如基于Quorum的NRW一致性协议，存储节点读写都需要多数派的投票。保证双AZ级别的容错；用分片存储减少故障处理时间，以此提升SLA。多数读只发生在数据库恢复的时候，此时数据库需要恢复当前的状态。
一写多读。不同于ShareNothing架构的NewSQL产品，Aurora只提供了单个写节点。数据一致性保证也因此变得简单，因为单写节点可以通过RedoLog LSN作为逻辑时钟，以此维护数据更新操作的偏序关系，只需要把RedoLog下推至所有节点，并基于此顺序对这些操作Apply就可以保证数据的一致性。
事务的实现。由于存储底座对上层提供的单一文件视图，所以对与Aurora来说，其事务的实现几乎与单机事务算法相同，并能提供相同的事务语义。NewSQL的事务一般是基于2PC的分布式事务实现。
后台加速前台处理。类似LevelDB的思路，尽可能将存储节点的一些操作异步化（比如日志Apply），提升前台用户感知性能。这些异步的操作通过维护各种xxLSN来记录当前节点的后台处理进度，比如VLSN，commit-LSN等等

有趣的是，PolarDB虽然是参考Aurora进行的设计，但它的架构设计认为网络并非瓶颈，而是经过OS的各种系统调用拖慢了整体速度。在彼时阿里云存储底座并不稳定的条件下，所以才有了它架构中的PolarStore，用各种硬件以及FUSE等存储技术越过或者优化系统调用，而如今盘古在稳定性和性能上都做的很不错的情况下，弱化PolarStore这个组件也成为了正常的选择。我认为说的不无道理。

另外，为什么他们选择用NWR而不是用Raft之类的一致性协议？目前看上去，NWR在网络上，一次请求的网络比Raft少一轮，可能是这个原因

参考

https://zhuanlan.zhihu.com/p/319806107

http://nil.csail.mit.edu/6.824/2020/notes/l-aurora.txt

论文阅读-Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Database - keys961 | keys961 Blog

Kylin概述

Wed, 10 Nov 2021 23:45:27 +0800

之前就想着能做一个有意思的毕设，奈何周围都没有合适的老师。之前在学院启动选题之前找好了一个感觉不错的老师，但没想到最后把我鸽了。不过之前老师的方向也并不是那么感兴趣，于是也就作罢。最近学院的毕设流程启动了，也在选题里看到了感兴趣的题目，于是便联系老师接了下来。

我选的题目是 《基于差分隐私的数据库查询算法的设计与实现》，方向是Differential Privacy + OLAP，具体一点就是为Kylin添加Differential Privacy的Feature。

总的来说就是如此，至于细节，也许在之后的博客中会写到。这是此系列博客的第一篇。

简介

Kylin是一种分布式的OLAP数据仓库，基于Hbase和Parquet等列存数据库以及Hadoop和Spark等运算调度框架，支持超大规模数据的多维分析。

它采用cube预计算的方法，把前台的实时查询变成了查询预计算结果，利用闲时的计算资源以及存储空间换取查询时间的优化，能极大的减少查询数据的时间。

背景

在Kylin之前，一般使用Hadoop来对大规模数据进行批处理，并将结果存储在Hbase等列式存储中。其中OLAP相关的技术便是大数据并行处理和列式存储。

大规模并行处理：实际上可以调用多台机其来并行处理计算任务，本质上是利用线性增长的计算资源来换取计算时间的线性下降。
列式存储：将记录按照列来存储。这方面主要是和OLAP的查询有关的，OLAP一般是对数据做统计等计算，一般都是同类型的列数据。列式存储使得查询时可以只访问需要的列并且可以充分利用顺序IO，提高性能。

以上两个技术使得Hadoop等平台上对于大数据的SQL查询达到了分钟级。但实际上，分钟级别的SQL查询依旧没法满足交互式分析的需要，效率依旧低下。

其中本质的原因在于，无论是并行计算或者是列式存储，都没有改变查询本身的时间复杂度，没有改变查询时间和数据量的线性增长关系。于是只能通过增加计算资源和利用局部性原理来对查询进行优化，这两种方法在数据量不断增长的情况下，都能明显的预见其成本上和理论上的瓶颈。

基于此，Kylin提出预计算策略，通过对不同的维度进行预计算生成多维cube(实际上就是一个数据表),后续的查询直接基于预计算的结果进行。经过预计算,物化视图的规模就只由维度的基数来决定,而不再随着数据量的增长呈线性增长。

这个策略本质上是利用空闲的计算资源以及额外的存储资源来换取查询时的响应速度，改变了查询时间与数据量之间的正比关系，从而提高效率。

核心概念

Apache Kylin 的工作原理本质上是MOLAP(Multidimensional Online Analytical Processing)Cube,多维立方体分析技术。

维度和度量

维度指用于审视，聚合数据的一种角度，一般是数据记录的某一个属性。度量是基于数据计算出来的具体数值。通过维度来聚合计算出度量值 $$D_1,D_2,D_3,… => S_1,S_2，…$$

cube理论

Data Cube，数据立方体，其主要涉及构建和查询两种操作，构建时对原始数据建立多维度索引以及预计算，以加速查询。

Cuboid: 指在某一维度组合下所计算出的数据
Cube Segment：Cube Segment是Cube的最小构建单位，一个Cube能被拆分为多个Cube Segment。
Cube增量构建：一般来说，增量构建Cube时是基于时间属性来触发的
Cube基数：Cube中所有维度的基数可以体现Cube的复杂度。复杂度高,Cube膨胀的概率会变高（IO,存储放大）。

架构设计

整个Kylin系统分为在线查询和离线构建两部分。

离线构建：主要有数据源，构建引擎，存储引擎三大抽象。从数据源拉取数据构建Cube在存储到列式存储引擎中。
在线查询：主要有接口层和查询引擎，对外部屏蔽Cube等底层概念。外部应用通过Rest API讲查询并转发给查询引擎，查询引擎查询与相关的数据返回结果。

总结

作为一个OLAP引擎，Kylin充分利用了并行计算，列式存储，预计算等优化技术提高其在线查询和离线构建性能，故而有如下几个明显的优缺点：

优点: 标准SQL接口，查询速度快,可拓展架构，BI系统友好
缺点:依赖的外部系统过多，运维困难；预计算与Cube构建导致的IO和存储放大；数据模型以及Cube基数的局限。

参考

美团 : Apache Kylin的实践与优化

Kylin官方文档

Kylin权威指南

MySQL索引浅析

Sun, 21 Mar 2021 20:41:33 +0800

数据库索引，是DBMS中一个排序的数据结构，以协助快速查询、更新数据库中数据。一般来说，用于构建索引的数据结构有B树，B+树，哈希表等。

MySQL中使用的是B+树构建索引。理由是B+树的一个节点可以存储更多的数据，并且B+树中，仅有叶子节点存储数据，非叶子节点仅存储索引，故而能将索引尽量多的保存在内存中，减少了树高，也降低了查询索引时进入磁盘IO的次数，极大提高查询的效率。

Innodb中的索引

聚簇索引与非聚簇索引

索引按照叶子节点保存的数据可分为聚簇索引和非聚簇索引两种

聚簇索引：叶子节点直接保存了数据行，能够直接查询到用户数据
非聚簇索引：叶子节点保存了主键的值，通过回表，查询主键索引查询用户数据

Innodb引擎是利用主键索引组织表中的数据，每个表中一定需要有主键，利用主键构造B+树，得到主键索引，其中主键索引就是聚簇索引，其余的二级索引都是非聚簇索引

联合索引

联合索引是由多个字段组成的索引。

sql

create index index_name on table_name (col_1,col_2...)

相比与单值索引，主要区别在于其遵守最左前缀匹配原则

最左前缀匹配原则：使用联合索引时，索引按照索引字段从左到右的顺序对索引值进行排序

使用索引优化查询性能

由于索引有序，故而能极大的提高查询的效率。使用索引进行查询优化时要遵守一些原则

最左前缀匹配原则

使用联合索引时，索引按照索引字段从左到右的顺序对索引值进行排序。查询索引时，我们也需要满足最左前缀匹配，否则数据的排列是无序的，会导致全表的扫描。

使用 col1,col2,col3构建索引，按照最左前缀匹配，在设计查询语句时我们需要按照col1 -> col2 -> col3的顺序去设计判断条件。

select * from table_name where col1 = 1 and col2 = 2; 走索引

select * from table_name where col2 = 1 and col3 = 2; 不走索引

注：MySQL查询时，会一直向右匹配直到遇到范围查询(>、<、between、like)就停止匹配

索引覆盖原则

索引覆盖，指通过查询索引可以直接查询到需要的值，而不需要回表等操作。设计合理的索引，可以减少回表的次数。

对联合索引(col1,col2,col3)

查询语句 select col1,col2,col3 from test where col1=1 and col2=2可以直接查到col1-col3的值，无需回表，因为他们的值已经被保存在二级索引中了。

实现简单的SQL数据库--前端

Tue, 10 Nov 2020 00:00:00 +0000

一直想去完成pingcap的tanlent Plan里面的tinySql路径，但一直没有开始。最近论坛上发现了pingcap创始人的tanlent plan入坑贴，下面的学长提示了这个从零实现数据库博客入门比较合适，于是写下这个博客。

前端

与编译器类似，一个数据库软件也分为前端和后端。前端部分主要是SQL语句的解析以及一个REPL。

获取tokens

go


type token struct {
 value string
 kind tokenKind
 loc location
}

模拟cursor扫描语句，将sql语句解析为一个一个token，token中包括了单词的种类，位置，值。

获取单个token时，每次扫描结束，如果成功，更新光标，并返回一个新token地址以及更新后的光标位置，ok=true。

如果失败，则返回nil,传入的初始化的光标位置不变，ok=false。

最终处理所有语句，得到token地址数组

go


// 主要流程
func lex(source string) ([]*token, error) {
 tokens := []*token{}
 cur := cursor{}

 for cur.pointer < uint(len(source)) {
 lexers := []lexer{lexKeyword, lexSymbol, lexString, lexNumeric, lexIdentifier}
 isMatched := false
 for _, l := range lexers {
 if token, newCursor, ok := l(source, cur); ok {
 cur = newCursor

 // Omit nil tokens for valid, but empty syntax like newlines
 if token != nil {
 tokens = append(tokens, token)
 }
 isMatched = true
 break
 }
 }

 if isMatched {
 // match the next one
 continue
 }

 hint := ""
 if len(tokens) > 0 {
 hint = " after " + tokens[len(tokens)-1].value
 }
 return nil, fmt.Errorf("Unable to lex token%s, at %d:%d", hint, cur.loc.row, cur.loc.col)
 }
 return tokens, nil
}

获得Ast

第二步，从tokens中，解析出一个抽象语法树。

Ast有statement[]组成，目前的解析器只解析select，insert，create三种语句。

go


type Ast struct {
 Statement []*Statement
}

type Statement struct {
 SelectStatement *SelectStatement
 CreateStatement *CreateStatement
 InsertStatement *InsertStatement
 Kind AstKind
}

解析的思路是按照不同的sql语句，分析出相应的语法成分，最后形成最后的语法树

SELECT语句

语法成分：

SELECT ${ expression[] }$ FROM $ tableName $

example：select id,age,name from students

1.解析出keyword SELECT

2.解析expression[]

3.解析出keyword FROM

4.解析identifier $tableName$

其中重点在于对expressions的理解与解析

go


// parse the token at cursor and return an expression containing literal val and its kind
func parseExpression(tokens []*token, initialCursor uint, _ token) (*expression, uint, bool) {
 cursor := initialCursor

 kinds := []tokenKind{identifierKind, numericKind, stringKind}

 for _, kind := range kinds {
 t, newCursor, ok := parseToken(tokens, cursor, kind)
 if ok {
 return &expression{
 literal: t,
 kind: literalKind,
 }, newCursor, true
 }
 }

 return nil, initialCursor, false
}

expression 只包括了stringKind，numericKind，identifierKind的字符集合。parseexpression读入一个token，如果cursor超出了tokens的长度或者Kind不是这三种，则返回错误的结果，遇到分隔符delimiter则正常返回。

CREATE语句

语法成分

CREATE TABLE $tableName$ ( $columnDef$ )

example:CREATE TABLE students(id string, age int, name string)

1.解析出keyword CREATE

2.解析出keyword TABLE

3.解析identifier $tableName$

4.解析 symbol (

5.解析$columndef$

6.解析symbol )

解析CREATE的语句关键是对$columnDef$的解析

go


//column
type columnDefinition struct {
 name token
 datatype token
}

解析columnDefinitions

1.循环解析token，直到cur超出tokens范围或者解析出现错误

首先解析identifier $name$,keyword $datatype$

解析分隔符 symbol ,

go


// parse col def
//
func parseColumnDefinitions(tokens []*token, initialCursor uint, delimiter token) (*[]*columnDefinition, uint, bool) {
 cursor := initialCursor

 cds := []*columnDefinition{}
 for {
 if cursor >= uint(len(tokens)) {
 return nil, initialCursor, false
 }

 // Look for a delimiter
 current := tokens[cursor]
 if delimiter.equals(current) {
 break
 }

 // Look for a comma
 // col devided by comma
 if len(cds) > 0 {
 if !expectToken(tokens, cursor, tokenFromSymbol(commaSymbol)) {
 helpMessage(tokens, cursor, "Expected comma")
 return nil, initialCursor, false
 }

 cursor++
 }

 // Look for a column name
 id, newCursor, ok := parseToken(tokens, cursor, identifierKind)
 if !ok {
 helpMessage(tokens, cursor, "Expected column name")
 return nil, initialCursor, false
 }
 cursor = newCursor

 // Look for a column type
 //like col_name type
 ty, newCursor, ok := parseToken(tokens, cursor, keywordKind)
 if !ok {
 helpMessage(tokens, cursor, "Expected column type")
 return nil, initialCursor, false
 }
 cursor = newCursor

 cds = append(cds, &columnDefinition{
 name: *id,
 datatype: *ty,
 })
 }

 return &cds, cursor, true
}

INSERT语句

语法成分

INSERT INTO VALUES ( $expression[]$ )

example: INSERT INTO VALUES(1,20,Kate)

1.解析keyword INSERT

2.解析keyword INTO

3.解析keyword VALUES

4.解析symbol (

5.解析 $expression[]$

6.解析symbol )

主函数parse

主函数分号作为分隔符解析三种sql语句

go


func Parse(source string) (*Ast, error) {
 tokens, err := lex(source)
 if err != nil {
 return nil, err
 }

 ast := Ast{}
 cursor := uint(0)
 for cursor < uint(len(source)) {
 //parse each statement divide by ';' and add to ast
 stmt, newCursor, ok := parseStatement(tokens, cursor, tokenFromSymbol(semicolonSymbol))
 if !ok {
 helpMessage(tokens, cursor, "Expected statement")
 return nil, errors.New("Failed to parse,exit")
 }
 cursor = newCursor
 ast.Statement = append(ast.Statement, stmt)

 atLeastOneSemicolon := false
 for expectToken(tokens, cursor, tokenFromSymbol(semicolonSymbol)) {
 cursor++
 atLeastOneSemicolon = true
 }

 if !atLeastOneSemicolon {
 helpMessage(tokens, cursor, "Expected semi-colon delimiter between statements")
 return nil, errors.New("Missing semi-colon between statements")
 }
 }
 return &ast, nil
}

简易后端

本文重点在于解析sql语句以及前端的编写思路，这次仅仅使用一个map in memory 作为后端。

go


// backend in memory
type MemoryBackend struct {
 tables map[string]*table
}

// table
type table struct {
 columns []string
 columnTypes []ColumnType
 rows [][]MemoryCell
}

//Result
type Results struct {
 Columns []struct {
 Type ColumnType
 Name string
 }
 Rows [][]Cell
}

REPL

下面是一个简单的REPL设计思路

go


func main() {
 mb := NewMemoryBackend()

 reader := bufio.NewReader(os.Stdin)
 fmt.Println("Welcome to ")
 for {
 fmt.Print("# ")
 text, err := reader.ReadString('\n')
 text = strings.Replace(text, "\n", "", -1)

 ast, err := Parse(text)
 if err != nil {
 panic(err)
 }

 for _, stmt := range ast.Statements {
 switch stmt.Kind {
 case CreateKind:

 case InsertKind:

 case SelectKind:

 }
 }
}

其他剩余代码见github

参考

Writing a SQL database from scratch in Go

PostgreSQL documentation

gosql