TiDB源码阅读：用 PostgreSQL 客户端连接到 TiDB

爱被打了一巴掌 2023-10-03 10:51 30阅读 0赞

### 前言 ###

众所周知，TiDB 兼容 MySQL 协议，用 MySQL 客户端是可以直接连上 TiDB 的，但是现实往往会有众多不合理的需求砸过来，比如说我 PosrgreSQL 凭什么就不能连上 TiDB？我 Oracle 凭什么就不能连？是不是你 TiDB 不行？是不是你程序猿不行？

嗯？ 听到这个话我就不乐意，你可以说 TiDB 不行，你能说我程序猿不行嘛？当时我就不乐意了，抄起家伙就是干，不就是搬个协议的问题，我把 PgSQL 协议跟您搬过来不就完了，于是我就开启了改造代码的工程了。（开个玩笑， TiDB还是挺强大的，手动滑稽保命）

下面开始描述一下工程量，要使用 PostgreSQL 连上 TiDB 主要是改通信协议就行了，并不是非常难，TiDB使用的是 MySQL 协议，所以只是将 MySQL协议改为 PostgreSQL 协议即可，当然这里强调一下，本片文章由于长度有限，只做了 PostgreSQL 客户端连上 TiDB 的任务，如果要进行增删改查的SQL操作，可以关注一下，我们以后再详细讲述。

### 源码改造 ###

回到正文，要是搬迁 PgSQL 协议， 我们得首先了解一下 PgSQL 通信协议中的握手流程，和 MySQL 还是有非常大的差距的。可以参考我的另一篇文章，关于两者的协议对比：

[MySQL&PgSQL 协议解析和对比][MySQL_PgSQL]

PostgreSQL 前后端协议的官方文档供参考：[PostgreSQL: Documentation: 13: Chapter 52. Frontend/Backend Protocol][PostgreSQL_ Documentation_ 13_ Chapter 52. Frontend_Backend Protocol] （开发的话不要总是百度，bing或者谷歌搜，有时候会走弯路，直接上官方文档会清楚很多，PostgreSQL将 客户端和服务端 称为 前后端）

这里还是简单的描述一下整个 PostgreSQL 的握手流程（V3 版本），在建立TCP连接之后，前后端会如下通信（方便阅读和区分，前端表示为 Client，后端表示为 服务端）：

1.  PostgreSQL Client 会先发送一个 SSLRequest 报文，询问服务端是否开启 SSL 通信。
2.  服务端是存在参数控制是否开启 SSL，如果开启则服务端回复一个字节 'S'， 如果不开启则回复一个字节 'N'。
3.  当 PostgreSQL Client 收到 'S' 时则会开始进行 SSL 握手流程，然后后面的所有通信都进行加密通信。
4.  完成 SSL 握手流程后 或者 收到 'N'时，PostgreSQL Client 会发送一个 StarupMessage 给服务端，我们称之为启动包。
5.  启动包中会带有连接信息，包括用户名，服务端通过用户名来判断该用户是否需要验证，如果需要则会发送一个 AuthenticationRequest 来请求认证信息，如果不需要验证则直接发送 AuthenticationOK。
6.  PostgreSQL 支持非常多的认证方式，这里不一一描述了，最后通过认证是否成功，服务端会发送 AuthenticationOK 或者 ErrorResponse。
7.  完成用户验证后，服务端会向 Client 发送一些参数信息，包括服务端版本，编码类型等，称为 ParameterStatus。
8.  最后服务端会发送一个 ReadyForQuery 来表示一切准备就绪，连接已经创建成功，Client 可以发送查询请求了。
9.  PostgreSQL Client 从收到 AuthenticationOK 到 ReadyForQuery 这段时间不发送任何报文，会一直等待。
10. 当 Client 收到 ReadyForQuery 后就可以开始进行查询了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70][]

**注意： 在第 6 步中，如果 Client 使用的是 SQL Shell（psql） 的话，那么 Client 在收到 AuthenticationRequest 会断开这个连接，待用户输入完密码后，会重新建立一个新的连接进行通信。**

将整个通讯流程完成后放到 TiDB 中，我们就实现了老板们的需求，用 PostgreSQL Client 连上 TiDB，上面会涉及到许多报文，报文内容和格式是通信中的难点，这一点在上面的官方文档中都有非常详细的解释，这里就不每个都讲解，可以挑几个重要的在后面介绍下，同时这里提供一个第三方包，非常的好用，我的实现也是基于这个包：[jackc/pgproto3 (github.com)][jackc_pgproto3 _github.com] 里面实现了每一个通信报文的解码和编码方法，可以直接用。

重点来了，怎么放到TiDB中，这里就得回到前面的笔记 [启动TiDB][TiDB] ，在TiDB server/server.go 文件中的 func (s \*Server) onConn(conn \*clientConn) 方法里面改造一下，当 TiDB 和 Client 建立 TCP 请求后会在 onConn 中进行处理。

**onConn**

// onConn runs in its own goroutine, handles queries from this connection.
    func (s *Server) onConn(conn *clientConn) {
       ctx := logutil.WithConnID(context.Background(), conn.connectionID)
    
       // 在这里原方法中是执行了一个 conn.handshake(ctx) 的方法来进行 MySQL 的通信流程
       // 加一个判断，isPgProtocol, 是一个常量,如果是 PostgreSQL 通信,则调用一个新的方法,也就是 conn.pgHandshake(ctx)
       // conn.pgHandshake(ctx) 是我们自己需要实现的一个方法，用来完成 PgSQL 的通信流程
       if isPgProtocol {
          err = conn.pgHandshake(ctx)
       } else {
          err = conn.handshake(ctx)
       }
       
       ......
    
       connectedTime := time.Now()
       conn.Run(ctx)
       ......
    }

下面开始实现 conn.pgHandshake(ctx) 首先他是 conn 也就是 clientConn 这个结构体的一个方法，所有要进入到 Server 包中，创建一个 pg\_conn.go 的文件夹，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 1][]

在 pg\_conn.go 来敲我们的代码，咱们开发的时候，尽量不要去修改源码，代码入侵越小越好，先实现一个 pgHandshake(ctx) 的方法：

**pgHandshake(ctx)**

func (cc *clientConn) pgHandshake(ctx context.Context) error {
       // 第一次接收的启动包并不是真正的启动包
       // 一般会先接收 SSLRequest 报文，决定是否开启 SSL 后，才会再次接收 StartUpMessage
       m, err := cc.ReceiveStartupMessage()
       if err != nil{
          logutil.Logger(ctx).Debug(err.Error())
          return err
       }
    
       switch m.(type){
       case *pgproto3.CancelRequest:
          // todo 结束连接
          return err
       case *pgproto3.SSLRequest:
          if err := cc.handleSSLRequest(ctx);err != nil{
             logutil.Logger(ctx).Debug(err.Error())
          }
          return err
       default:
          err = errors.New("received is not a SSLRequest packet")
          logutil.Logger(ctx).Debug(err.Error())
          return err
       }
    }

代码不用细讲，对应前面握手流程的第一步，Client 发送的第一个报文是 SSL Request， 这里调用了一个 ReceiveStartupMessage 的方法，就需要介绍一下了，PostgreSQL 的报文格式，一种是启动包报文格式，一种是普通通信格式。这个在我的MySQL与PgSQL协议对比中都详细解析过，大家花几分钟看一下。

启动包格式中是没有第一个消息类型的指定，所以当我们读启动包的时候直接就会读到 4个字节的长度，然后读取后面的内容，使用启动包格式的一共有四种消息，第一种前面介绍的 StartupMessage， 第二种是 SSLRequest， 第三种是 CancelRequest， 第四种则是 GssEncRequest，后面两种暂时都用不到，先不管。

**ReceiveStartupMessage**

// 不同类型包对应的编码
    const ProtocolVersionNumber = 196608 // 3.0
    const sslRequestNumber = 80877103
    const cancelRequestCode = 80877102
    const gssEncReqNumber = 80877104
    
    
    // ReceiveStartupMessage receives the initial connection message. This method is used of the normal Receive method
    // because the initial connection message is "special" and does not include the message type as the first byte. This
    // will return either a StartupMessage, SSLRequest, GSSEncRequest, or CancelRequest.
    func (cc *clientConn) ReceiveStartupMessage() (pgproto3.FrontendMessage, error) {
       header := make([]byte, 4)
       if _, err := io.ReadFull(cc.bufReadConn, header); err != nil{
          return nil, err
       }
       msgLen := int(binary.BigEndian.Uint32(header) - 4)
    
       msg := make([]byte, msgLen)
       if _, err := io.ReadFull(cc.bufReadConn, msg); err != nil{
          return nil, err
       }
    
       // 对内容进行编码转为 Uint32 来判断是哪一类消息
       code := binary.BigEndian.Uint32(msg)
    
       switch code {
       case ProtocolVersionNumber:
          startMessage := &pgproto3.StartupMessage{}
          if err := startMessage.Decode(msg); err != nil{
             return nil, err
          }
          return startMessage, nil
       case sslRequestNumber:
          sslRequest := &pgproto3.SSLRequest{}
          if err := sslRequest.Decode(msg); err != nil {
             return nil, err
          }
          return sslRequest, nil
       case cancelRequestCode:
          cancelRequest := &pgproto3.CancelRequest{}
          if err := cancelRequest.Decode(msg); err != nil{
             return nil, err
          }
          return cancelRequest, nil
       case gssEncReqNumber:
          gssEncRequest := &pgproto3.GSSEncRequest{}
          if err := gssEncRequest.Decode(msg); err != nil{
             return nil, err
          }
          return gssEncRequest, nil
       default:
          return nil, errors.New("unknown startup message code: " + string(code))
       }
    }

我们先读取前四个字节，转为长度，这个长度是包括自身四个字节的长度需要减去，然后通过长度读取剩下的内容，再一次转换为 uint32 编码，通过后面的 uint32 编码来判断消息类型，当为 196608 时则是 StarupMessagee， 为 80877103 时则是 SSLRequest， 以此类推，最后用相应的结构体来解码，获取具体的内容信息则可。

回到 onConn 方法中，当接收到第一个 SSLRequest 包后 调用 handSSLRequest(ctx) 方法继续处理。

**handSSLRequest(ctx)**

//接收到来自客户端的SSLRequest之后，服务端需要对其进行一定的处理
    func(cc *clientConn) handleSSLRequest(ctx context.Context) error{
    
       // 服务端是否启用 ssl ,ssl 为常量控制
       if ssl {
          tlsConfig,err := loadSSLCertificates()
          if err != nil {
             logutil.Logger(ctx).Debug(err.Error())
             return err
          }
    
          // 写回 'S' 表示使用 SSL 连接
          if err := cc.WriteSSLRequest('S', ctx); err != nil {
             logutil.Logger(ctx).Debug(err.Error())
             return err
          }
    
          //将现有的连接升级为SSL连接
          if err := cc.upgradeToTLS(tlsConfig);err != nil{
             logutil.Logger(ctx).Debug(err.Error())
             return err
          }
    
       } else {
          // 写回 'S' 表示使用 SSL 连接
          if err := cc.WriteSSLRequest('N', ctx); err != nil {
             logutil.Logger(ctx).Debug(err.Error())
             return err
          }
       }
    
       // 接收完 SSLRequest 包后接收 StartupMessage
       // 重新接收启动包并进行用户验证
       if err := cc.ReceiveStartupMessageAndAuthentication(ctx); err != nil{
          logutil.Logger(ctx).Debug(err.Error())
          return err
       }
    
       // 发送 ParameterStatus
       if err := cc.WriteParameterStatus(); err != nil {
          logutil.Logger(ctx).Debug(err.Error())
          return err
       }
    
       // 发送 ReadyForQuery 表示一切准备就绪。"I"表示空闲(没有在事务中)
       if err := cc.WriteReadForQuery(ctx, 'I'); err != nil{
          logutil.Logger(ctx).Debug("write ReadyForQuery to client failed：" + err.Error())
          return err
       }
    
       return nil
    }

代码注释都比较清晰，和一开始的流程是差不多的，通过 ssl 常量来判断服务端是否开启 ssl 如果开启了则回复一个 'S' 然后进行 ssl 握手，这个地方调用了 cc.upgradeToTLS(tlsConfig) 方法是TiDB提供的SSL握手方法，可以直接用，不需要过多的操作，如果没有开启 ssl 则直接回复一个 'N' 即可。后面开始继续接收真正的启动包 StartupMessage，这个地方注意，当我们开启了 ssl ，也就是调用了 upgradeToTLS 后，连接会被升级，自动帮我们解密和加密，所以我们不需要做过多的操作，后面都是同样的读和写，数据都是原数据，加密和解密是传输中由连接自己控制的。

**cc.ReceiveStartupMessageAndAuthentication(ctx)**

// PgOpenSessionAndDoAuth 需要在SSL Request确认之后在调用
    // 接收客户端StartupMessage，获取客户端信息，初始化Session并进行用户认证
    // 初始化Session时，由于TiDB中存在MySQL协议使用，会有许多参数和 PgSQL 有差异，这里会自定义部分参数直接赋值给Session
    // 用户认证时，客服端可能会断开连接，等待用户输入密码后再重新建立连接，需要注意
    // 最后发送 AuthenticationOK 或 ErrorResponse 来表式认证成功或失败
    func (cc *clientConn) ReceiveStartupMessageAndAuthentication(ctx context.Context) error {
    
       // 接收 StartupPacket
       startupMessage, err := cc.ReceiveStartupMessage()
       if err != nil{
          return errors.New(" " + err.Error())
       }
    
       // 如果不是startupMessage 则报错并退出连接
       msg, ok := startupMessage.(*pgproto3.StartupMessage)
       if !ok {
          return errors.New("received is not a StartupMessage")
       }
    
       cc.user = msg.Parameters["user"]
       cc.dbname = msg.Parameters["database"]
    
       // 这里获取到的启动包后会发现只有部分参数
       // 而MySQL协议会需求更多的参数
       // 所以添加部分常量作为参数 参照客户端为 Mysql 5.6.47
       resp := handshakeResponse41{
          Capability: uint32(8365701),
          Collation: uint8(28),  //gbk_chinese_ci
          User: msg.Parameters["user"],
          DBName: msg.Parameters["database"],
          Attrs: map[string]string{
             "_os":"Win64",
             "_client_name":"libmysql",
             "_pid":"3692",
             "_thread":"480",
             "_platform":"x86_64",
             "program_name":"mysql",
             "_client_version":"5.6.47",
          },
       }
    
       cc.capability = resp.Capability & cc.server.capability
       cc.user = resp.User
       cc.dbname = resp.DBName
       cc.collation = resp.Collation
       cc.attrs = resp.Attrs
    
       if err := cc.PgOpenSessionAndDoAuth(ctx); err!= nil{
          logutil.Logger(ctx).Warn("open new session failure", zap.Error(err))
          return err
       }
    
       return err
    }

每一个方法我都会注释很多，在提醒自己的同时，也让其他的伙伴们能够快速理解代码意思，这个方法就是接收一个 StartupMessage 后会获取一些 Client 的参数信息，但是实际上 MySQL 协议的参数信息要更多更丰富一些，所以在 PgSQL Client 中我们是获取不到这么多的信息，于是我就从MySQL协议中抄了一部分作为常量直接赋值上去了，不要在意，这个对代码整体没多少的影响，最重要的参数是 Capability 和 Collation ，一个是版本兼容号，一个是 Client 的字符集，这两个是后面处理查询时需要用到的，很重要，这里大家可以自己找自己的MySQL Client 跑一边TiDB 源码，获取到这几个值后，偷过来放着。

后面有一个方法是 cc.PgOpenSessionAndDoAuth(ctx)，看名字就知道，是开启会话和用户认证。前面的源码阅读中，我曾经讲到过 TiDB 中 Session 这个概念，没有深入，简单介绍一下，每一次建立连接的时候，都会初始化一个 Session ，里面存着所有的连接信息，包括用户，权限，查询等等，在数据库中进行操作时，都是以 Session 为对象进行操作，中间进行会话记录和验证，所以在这里，我们修改代码时，经量不要去动源码的东西，可能会导致最后启动执行的时候，非常多的东西报错，还找不到原因。下面继续进入 PgOpenSessionAndDoAuth 这个方法， 这个方法的实现其实是仿照的 TiDB 源码的

**openSessionAndDoAuth**

// PgOpenSessionAndDoAuth 对标 openSessionAndDoAuth
    // 初始化Session 并进行用户认证
    // PgSQL 和 MySQL 存在差异，PgSQL客户端只有在收到服务端的 Auth Request 才会将密码发送过来
    // 而 Mysql 客户端一开始如果存在密码则会将密码直接一起发送到服务端
    func (cc *clientConn) PgOpenSessionAndDoAuth(ctx context.Context) error {
       var tlsStatePtr *tls.ConnectionState
       if cc.tlsConn != nil {
          tlsState := cc.tlsConn.ConnectionState()
          tlsStatePtr = &tlsState
       }
       var err error 
    
       // 初始化 Session
       cc.ctx, err = cc.server.driver.OpenCtx(cc.connectionID, cc.capability, cc.collation, cc.dbname, tlsStatePtr)
       if err != nil {
          return err
       }
    
       if err = cc.server.checkConnectionCount(); err != nil {
          return err
       }
    
       // 直接不带密码 也没有认证信息
       hasPassword := "NO"
    
       // 获取 host 信息
       host, err := cc.PeerHost(hasPassword)
       if err != nil {
          return err
       }
    
       // 进行密码认证，这个是 PgSQL 的认证方式与 MySQL 不同
       if err := cc.DoAuth(ctx); err != nil {
          return errAccessDenied.FastGenByArgs(cc.user, host, hasPassword)
       }
    
       // 如果不想进行认证 则直接调用下面的 写回 AuthenticationOK 完成认证即可
       if err := cc.WriteAuthenticationOK(ctx); err != nil {
          return errAccessDenied.FastGenByArgs(cc.user, host, hasPassword)
       }
    
       // 初始化中如果有dbname的信息，则直接使用该 DB
       if cc.dbname != "" {
          err = cc.useDB(context.Background(), cc.dbname)
          if err != nil {
             return err
          }
       }
       cc.ctx.SetSessionManager(cc.server)
       return nil
    }

这个方法和原有的 openSessionAndDoAuth() 没有改太多，唯一修改的位置就是密码认证，因为 MySQL 和 PgSQL 的密码认证流程不一样，而且密码加密方式也不同，代码中是实现了一个 DoAuth() 方法来进行认证，这个地方也不做过多讲解了，我们简单的使用一个固定的密码来进行认证即可，或者建议直接返回 Client 一个 AuthenticationOK，也就是不需要密码认证，写回 AuthenticationOk 就非常简单了，代码如下：

**WriteParameterStatus**

// WriteParameterStatus 用于写回一些参数给客户端 ParameterStatus
    // pgAdmin 需要 client_encoding 这个参数
    func (cc *clientConn) WriteParameterStatus() error {
       parameters := map[string]string{
          "client_encoding": "UTF8",
          "DateStyle": "ISO, YMD",
          "integer_datetimes": "on",
          "is_superuser": "on",
          "server_encoding": "UTF8",
          "server_version": "8.3.11",
          "TimeZone": "PRC",
       }
    
       for k ,v := range parameters{
          parameterStatus := &pgproto3.ParameterStatus{Name: k, Value: v}
          if _, err := cc.pkt.bufWriter.Write(parameterStatus.Encode(nil)); err != nil{
             return errors.New("write ParameterStatus to client failed: " + err.Error())
          }
       }
       return nil
    }
    
    
    // WriteReadForQuery 向客户端写回 ReadyForQuery
    // status 为当前后端事务状态码。"I"表示空闲(没有在事务中)、"T"表示在事务中；"E"表示在失败的事务中(事务块结束前查询都回被驳回)
    func (cc *clientConn) WriteReadForQuery(ctx context.Context, status uint16) error {
       pgStatus, err := convertMySQLServerStatusToPgSQLServerStatus(status)
       if err != nil {
          return err
       }
    
       readForReady := &pgproto3.ReadyForQuery{TxStatus: pgStatus}
       if _, err := cc.pkt.bufWriter.Write(readForReady.Encode(nil)); err != nil{
          return err
       }
    
       return cc.flush(ctx)
    }

代码不是很复杂，看下注释也基本都能懂，其中在 WriteParameterStatus() 这个方法中可以看到有很多参数，这些都是 PgSQL 服务端的参数，都是我自己编的，和 MySQL Client 那个参数是一样的，跑一个正常版本，获取到正常参数，直接偷过来用一用，这个对于 PgSQL Client 没有多大的影响，大家自由发挥即可。

在调用完 WriteReadForQuery 后，其实 PgSQL Client 和 TiDB 之间的连接就建立成功了，大家可以看一下效果图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 2][]

注意，我们一定要用 SQL Shell 去连接，因为其他的工具，比如 Navicat 和 PgAdmin 都会在建立连接后立刻发送一些查询请求，而这些查询请求涉及 Pg 系统表是 TiDB 不支持的，所以会立马报错，无法建立连接，也就看不到连接成功的效果了。

本篇到这里大概就已经完成了老板们的要求，其实整个看下来，代码量并没有多少，对于 TiDB 的源码入侵也是非常的少，基本没有修改，整体的思路是换掉了 TiDB 中 handshake 这个方法，来实现 PgSQL 的握手流程。看的简单，但实际上实验的时候，真的是跑遍了各种网站和文档，查看 MySQL 协议和 PostgreSQL 的协议差别，不知道差别的话，根本无从改起。

完成了连接的下一步是什么？自然是开始进行增删改查的查询请求了，一个数据库光连上能有啥用啊？啥用没有，是吧，那不还是说明咱程序猿不行嘛？ 怎么可能，我们看看下面的操作：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 3][]

完全可以实现增删改查，甚至还能有报错信息，那具体咋实现的呢，这个我们留到下篇文章再介绍了，这边文章内容有限，大家可以看完后，自己实现后面增删改查的部分，并不难的~

该项目我也放到了github上面了，有兴趣可以了解下

[DigitalChinaOpenSource / TiDB-for-PostgreSQL][DigitalChinaOpenSource _ TiDB-for-PostgreSQL]

最后附上 PostgreSQL 通信的流程图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 4][]

[MySQL_PgSQL]: https://zhuanlan.zhihu.com/p/365978287
[PostgreSQL_ Documentation_ 13_ Chapter 52. Frontend_Backend Protocol]: https://link.zhihu.com/?target=https%3A//www.postgresql.org/docs/current/protocol.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2021071316343943.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw==,size_16,color_FFFFFF,t_70
[jackc_pgproto3 _github.com]: https://link.zhihu.com/?target=https%3A//github.com/jackc/pgproto3
[TiDB]: https://zhuanlan.zhihu.com/p/304036138
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210713163534659.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2021071316400085.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210713164042204.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw==,size_16,color_FFFFFF,t_70
[DigitalChinaOpenSource _ TiDB-for-PostgreSQL]: https://github.com/DigitalChinaOpenSource/TiDB-for-PostgreSQL
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210713164127531.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NCR0NhbXB1cw==,size_16,color_FFFFFF,t_70