跳转至

博客

编译原理 2. 语法分析 - bison

flex 匹配正则表达式，bison 识别整个文法（grammar），将从 flex 中得到的记号组织成树形结构。

一、概述

比如对于一个计算器来说，可能会有如下的文法：

Text Only
1
2
3
statement: NAME '=' expression
expression: NUMBER '+' NUMBER
          | NUMBER '-' NUMBER

| 表示有两种可能性，对于 : 左侧相同的规则可以用这种方式简写。

比如对于这个表达式：

Text Only
1
fred = 12 + 13

它被 flex 解析完毕后大概可以得到如下 记号：

Text Only
1
<NAME, fred> '=' <NUMBER, 12> '+' <NUMBER, 13>

它进而会被 bison 转化为如下的解析树：

  • 分类于 Coding/Golang
  • 需要 3 分钟阅读时间

Golang 文档注释

文档注释（Doc Comments）是一些出现在顶层的包、常量、函数、类型、变量的定义前的文档。

原则上来讲，所有导出的名称都应该有文档注释（就是首字母大写的东西）

这些注释可以被 go/doc 和 go/doc/comment 包从源代码中提取出来形成文档，你在 pkg.go.dev 中的每一个包中看到的文档内容其实都来自于源代码中的注释。

包的注释

每一个包都应该有一段 包的注释 用来介绍这个包的作用并提供一些相关信息。下面是一个例子

Go
1
2
3
4
5
6
7
8
// Package path implements utility routines for manipulating slash-separated
// paths.
//
// The path package should only be used for paths separated by forward
// slashes, such as the paths in URLs. This package does not deal with
// Windows paths with drive letters or backslashes; to manipulate
// operating system paths, use the [path/filepath] package.
package path

其中 [path/filepath] 会在文档中创建一个到 filepath 文件的链接。

Go 的文档注释使用完整的句子。对于包的注释来说，意味着第一个句子应当以 Package 开始。

如果某一个包由多个文件组成，那么包的注释应该只存在于其中一个源文件中。如果多个文件都有包的注释，那么他们最终会被合并。

命令的注释

（暂略

类型的注释

一个 类型的注释 应该解释这个类型表示或提供的示例是什么。

下面是几个示例：

Go
1
2
3
4
5
6
package zip

// A Reader serves content from a ZIP archive.
type Reader struct {
    ...
}
Go
1
2
3
4
5
6
7
8
package regexp

// Regexp is the representation of a compiled regular expression.
// A Regexp is safe for concurrent use by multiple goroutines,
// except for configuration methods, such as Longest.
type Regexp struct {
    ...
}

对于一个有导出属性（首字母大写）的结构体，所有的导出属性要么应该在文档注释中说明，要么应该在每一个属性的注释中说明。

比如这个文档注释就说明了属性的作用：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package io

// A LimitedReader reads from R but limits the amount of
// data returned to just N bytes. Each call to Read
// updates N to reflect the new amount remaining.
// Read returns EOF when N <= 0.
type LimitedReader struct {
    R   Reader // underlying reader
    N   int64  // max bytes remaining
}

而下面这个就是讲这些说明移到了属性的注释中：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
package comment

// A Printer is a doc comment printer.
// The fields in the struct can be filled in before calling
// any of the printing methods
// in order to customize the details of the printing process.
type Printer struct {
    // HeadingLevel is the nesting level used for
    // HTML and Markdown headings.
    // If HeadingLevel is zero, it defaults to level 3,
    // meaning to use <h3> and ###.
    HeadingLevel int
    ...
}

函数的注释

一个函数的注释应该解释清楚函数的返回值或者函数被调用后会有什么作用以及其副作用。

命名了的参数或者返回值可以通过直接卸载注释中来引用（不用转义

下面是两个例子：

Go
1
2
3
4
5
6
7
8
package strconv

// Quote returns a double-quoted Go string literal representing s.
// The returned string uses Go escape sequences (\t, \n, \xFF, \u0100)
// for control characters and non-printable characters as defined by IsPrint.
func Quote(s string) string {
    ...
}
Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
package os

// Exit causes the current program to exit with the given status code.
// Conventionally, code zero indicates success, non-zero an error.
// The program terminates immediately; deferred functions are not run.
//
// For portability, the status code should be in the range [0, 125].
func Exit(code int) {
    ...
}

常量的注释

可以使用一个文档注释来介绍一整组常量：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package scanner // import "text/scanner"

// The result of Scan is one of these tokens or a Unicode character.
const (
    EOF = -(iota + 1)
    Ident
    Int
    Float
    Char
    ...
)

当然有时候常量组并不需要文档注释，而是卸载每个常量后面：

Go
1
2
3
4
5
6
7
8
package unicode // import "unicode"

const (
    MaxRune         = '\U0010FFFF' // maximum valid Unicode code point.
    ReplacementChar = '\uFFFD'     // represents invalid code points.
    MaxASCII        = '\u007F'     // maximum ASCII value.
    MaxLatin1       = '\u00FF'     // maximum Latin-1 value.
)

没有分组的常量往往需要一个完整的文档注释（以变量名为开头）

Go
1
2
3
4
package unicode

// Version is the Unicode edition from which the tables are derived.
const Version = "13.0.0"

变量的注释

同常量。

其他的略了

参考：Go Doc Comments - The Go Programming Language

  • 分类于 Coding/Golang
  • 需要 2 分钟阅读时间

GORM 源码阅读

Migrator

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
// Migrator m struct
type Migrator struct {
    Config
}

// Config schema config
type Config struct {
    CreateIndexAfterCreateTable bool
    DB                          *gorm.DB
    gorm.Dialector
}

工具函数

1. CurrentDatabase
Go
1
2
3
4
func (m Migrator) CurrentDatabase() (name string) {
    m.DB.Raw("SELECT DATABASE()").Row().Scan(&name)
    return
}

对于 PostgreSql 应为 current_database()

2. HasTable
Go
1
2
// HasTable returns table exists or not for value, value could be a struct or string
func (m Migrator) HasTable(value interface{}) bool

基于如下 SQL 语句：

SQL
1
SELECT count(*) FROM information_schema.tables WHERE table_schema = ? AND table_name = ? AND table_type = ?

三个参数分别为 currentDatabase, stmt.Table, "BASE TABLE"

PostgreSQL: Documentation: 15: Chapter 37. The Information Schema

PostgreSQL: Documentation: 15: 37.54. tables

  • table_schema：Name of the schema that contains the table
  • table_name：Name of the table
  • table_type：Type of the table:
  • BASE TABLE for a persistent base table (the normal table type)
  • VIEW for a view
  • FOREIGN for a foreign table
  • LOCAL TEMPORARY for a temporary table
3. CreateTable
4. ColumnTypes
Go
1
2
// ColumnTypes return columnTypes []gorm.ColumnType and execErr error
func (m Migrator) ColumnTypes(value interface{}) ([]gorm.ColumnType, error)
Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
// ColumnType column type interface
type ColumnType interface {
    Name() string
    DatabaseTypeName() string                 // varchar
    ColumnType() (columnType string, ok bool) // varchar(64)
    PrimaryKey() (isPrimaryKey bool, ok bool)
    AutoIncrement() (isAutoIncrement bool, ok bool)
    Length() (length int64, ok bool)
    DecimalSize() (precision int64, scale int64, ok bool)
    Nullable() (nullable bool, ok bool)
    Unique() (unique bool, ok bool)
    ScanType() reflect.Type
    Comment() (value string, ok bool)
    DefaultValue() (value string, ok bool)
}

AutoMigrate

Go
1
func (m Migrator) AutoMigrate(values ...interface{}) error

首先，根据约束条件对 values 进行重新排序：m.ReorderModels(values, true)

然后遍历 values：

  • 如果不存在该表则创建该表，出现错误则返回
  • 如果存在则获取该表的列，并遍历 value 中的每一列进行比较
  • 如果存在对应列，则自动迁移（类型、约束等处理）
  • 如果不存在，则添加该列

PostgreSQL PL_pgSQL

PL/pgSQL 是一个用于 PostgreSQL 的可加载的过程性语言

使用 PL/pgSQL 书写的函数可以接受服务器支持的任何标量或数组数据作为参数，同时它也可以返回任何这些类型。

创建 PL/SQL 函数

通过执行 CREATE FUNCTION 来在服务器创建 PL/pgSQL 函数：

PostgreSQL SQL Dialect
1
2
3
CREATE FUNCTION somefunc(integer, text) RETURNS integer
AS 'function body text'
LANGUAGE plpgsql;

函数体就是个简单的字符串字面值

// TODO: https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-DOLLAR-QUOTING

pg/pgSQL 是一个块结构的语言，一个完整的函数体必须是一个块，块可以通过如下方式定义：

PostgreSQL SQL Dialect
1
2
3
4
5
6
[ <<label>> ]
[ DECLARE
    declarations ]
BEGIN
    statements
END [ label ];

在块中的每一个定义或语句都要以分号结尾

label 只有在你希望制指定使用某一个块用于一个 EXIT 语句的时候需要，或者标识出块中定义的变量。 如果在 END 后写了 label 那么就要和开始的 label 相匹配。

下面是一个详细一些的例子：

PostgreSQL SQL Dialect
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
CREATE FUNCTION somefunc() RETURNS integer AS $$
<< outerblock >>
DECLARE
    quantity integer := 30;
BEGIN
    RAISE NOTICE 'Quantity here is %', quantity;  -- Prints 30
    quantity := 50;
    --
    -- Create a subblock
    --
    DECLARE
        quantity integer := 80;
    BEGIN
        RAISE NOTICE 'Quantity here is %', quantity;  -- Prints 80
        RAISE NOTICE 'Outer quantity here is %', outerblock.quantity;  -- Prints 50
    END;

    RAISE NOTICE 'Quantity here is %', quantity;  -- Prints 50

    RETURN quantity;
END;
$$ LANGUAGE plpgsql;

There is actually a hidden “outer block” surrounding the body of any PL/pgSQL function. This block provides the declarations of the function's parameters (if any), as well as some special variables such as FOUND (see Section 43.5.5). The outer block is labeled with the function's name, meaning that parameters and special variables can be qualified with the function's name.

表达式

所有在 PL/pgSQL 语句中使用的表达式都会使用服务器的主 SQL 执行器处理。 比如如果你写了一个像下面这样的 PL/pgSQL 语句：

PostgreSQL SQL Dialect
1
IF expression THEN ...

那么 PL/pgSQL 就会像下面这样进行一次查询来对表达式求值：

PostgreSQL SQL Dialect
1
SELECT expression

基本语句

1. 赋值

Text Only
1
variable { := | = } expression;

2. 执行 SQL 命令

一般地，任何不返回行的 SQL 命令都可以通过直接写在 PL/pgSQL 中的方式来执行：

PostgreSQL SQL Dialect
1
2
CREATE TABLE mytable (id int primary key, data text);
INSERT INTO mytable VALUES (1,'one'), (2,'two');

而如果一条命令会返回行（比如 SELECT 或带有 RETURNING 的 INSERT/UPDATE/DELETE），有两种方式来执行： - 如果命令只返回一个行或者你只关心输出的第一行，可以通过添加一个 INTO 子句来捕获输出 - 如果要处理所有的输出行，可以将命令作为 FOR 循环的数据源

2.1 执行单行结果的命令

如下：

PostgreSQL SQL Dialect
1
2
3
4
SELECT select_expressions INTO [STRICT] target FROM ...;
INSERT ... RETURNING expressions INTO [STRICT] target;
UPDATE ... RETURNING expressions INTO [STRICT] target;
DELETE ... RETURNING expressions INTO [STRICT] target;

其中 target 可以是一个记录变量、行变量、逗号分割的简单变量和记录/行字段。

  • 分类于 Coding/Golang
  • 需要 3 分钟阅读时间

Golang 标准库之 sql

Golang 标准库中的 database/sql 包提供了访问 SQL（或类 SQL）数据库的通用接口，需要与数据库驱动1结合使用。

本文以 PostgreSQL 数据库为例，使用 jackc/pgx: PostgreSQL driver and toolkit for Go (github.com) 并假设已在本机安装了 PostgreSQL并监听本机的 5432 端口。

database/sql：sql package - database/sql - Go Packages

pgx：pgx package - github.com/jackc/pgx/v5 - Go Packages

一、连接数据库

Open 用于创建一个数据库 handle（根据驱动的不同也许只会验证参数并不会真的创建与数据库的连接）:

Go
1
db, err := sql.Open(driver, dataSourceName)

这里的两个参数都是 string 类型的：

  • driver：指定使用的数据库驱动
  • dataSourceName：指定了数据库连接信息，比如数据库名、验证信息等，也就是数据库 URL。

比如，使用 pgx 数据库驱动可以这么写：

Go
1
2
3
4
5
6
7
// urlExample := "postgres://username:password@localhost:5432/database_name"
db, err := sql.Open("pgx", os.Getenv("DATABASE_URL"))
if err != nil {
    fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
    os.Exit(1)
}
defer db.Close()

Open 函数会返回一个 *DB 类型的值，这个类型有很多方法，很多数据库的操作诸如查询、SQL语句执行等都会用到它。

一些数据库驱动库也会实现自己的相关方法，不过这可能会使得后续的一些操作可能会与其他 SQL 数据库不兼容：

Go
1
2
3
4
5
6
7
// urlExample := "postgres://username:password@localhost:5432/database_name"
conn, err := pgx.Connect(context.Background(), os.Getenv("DATABASE_URL"))
if err != nil {
    fmt.Fprintf(os.Stderr, "Unable to connect to database: %v\n", err)
    os.Exit(1)
}
defer conn.Close(context.Background())

Connect 函数会返回一个 Conn 类型的指针，其实可以发现这个类型与 DB 类型很像。

这里还使用了 context 库，具体见 Golang 标准库之 context。

二、执行 SQL 语句

1. 使用 Exec 执行非查询语句（返回 Result）

DB 类型有这样一个方法用于执行任何 SQL 语句，但是 不会返回任何行：

Go
1
func (db *DB) Exec(query string, args ...any) (Result, error)

以下是 Result 类型的定义：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
type Result interface {
    // LastInsertId 返回数据库为一个命令生成的 ID
    // 一般在向包含 auto increment 列的表插入新行时会用到，
    // （不一定所有的数据库都支持，且不同的数据库的支持也不尽相同）
    LastInsertId() (int64, error)

    // RowsAffected 返回一次 update, insert, 或 delete 影响到的列的数量
    // （不一定所有的数据库都支持）
    RowsAffected() (int64, error)
}

例子：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
id := 47
result, err := db.Exec(ctx, "UPDATE balances SET balance = balance + 10 WHERE user_id = ?", id)
if err != nil {
    log.Fatal(err)
}
rows, err := result.RowsAffected()
if err != nil {
    log.Fatal(err)
}
if rows != 1 {
    log.Fatalf("expected to affect 1 row, affected %d", rows)
}

2. 使用 Query 执行查询命令（返回 Rows）

DB 类型有另一个方法 可以返回行（一般用于 SELECT）：

Go
1
func (db *DB) Query(query string, args ...any) (*Rows, error)

Rows 类型是查询的结果。它的指针从第一行之前开始，可以使用 Next 方法来移动到下一行：

func (rs *Rows) Next() bool

此外还有 NextResultSet 用于移动到下一个结果集：

func (rs *Rows) NextResultSet() bool

它还有一些其他方法：

  • func (rs *Rows) Close() error：用于关闭 Rows 防止 Next 的枚举，在 Next 遍历完所有行后会自动关闭。
  • func (rs *Rows) Columns() ([]string, error)：返回列名。
  • func (rs *Rows) ColumnTypes() ([]*ColumnType, error)：返回列的类型，有关 ColumnType 先咕了，或者看 sql package - database/sql - Go Packages。
  • func (rs *Rows) Scan(dest ...any) error：从当前行赋值所有列到 dest 指向位置（参数数量要与列数量相等）。
  • func (rs *Rows) Err() error：返回在迭代过程中遇到的错误

一个多结果集查询的例子：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
age := 27
q := `
create temp table uid (id bigint); -- Create temp table for queries.
insert into uid
select id from users where age < ?; -- Populate temp table.

-- First result set.
select
users.id, name
from
users
join uid on users.id = uid.id
;

-- Second result set.
select 
ur.user, ur.role
from
user_roles as ur
join uid on uid.id = ur.user
;
`
rows, err := db.Query(q, age)
if err != nil {
    log.Fatal(err)
}
defer rows.Close()

for rows.Next() {
    var (
        id   int64
        name string
    )
    if err := rows.Scan(&id, &name); err != nil {
        log.Fatal(err)
    }
    log.Printf("id %d name is %s\n", id, name)
}
if !rows.NextResultSet() {
    log.Fatalf("expected more result sets: %v", rows.Err())
}
var roleMap = map[int64]string{
    1: "user",
    2: "admin",
    3: "gopher",
}
for rows.Next() {
    var (
        id   int64
        role int64
    )
    if err := rows.Scan(&id, &role); err != nil {
        log.Fatal(err)
    }
    log.Printf("id %d has role %s\n", id, roleMap[role])
}
if err := rows.Err(); err != nil {
    log.Fatal(err)
}

3. 使用 QueryRow 执行查询命令（返回 Row）

如果结果没有包含任何一行，就返回 ErrNoRows，否则就返回第一行并忽略其他行。

例子：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
id := 123
var username string
var created time.Time
err := db.QueryRowContext(ctx, "SELECT username, created_at FROM users WHERE id=?", id).Scan(&username, &created)
switch {
case err == sql.ErrNoRows:
    log.Printf("no user with id %d\n", id)
case err != nil:
    log.Fatalf("query error: %v\n", err)
default:
    log.Printf("username is %q, account created on %s\n", username, created)
}

更多的方法见 文档 2

参考

废文案

  1. https://golang.org/s/sqldrivers ↩↩

  2. sql package - database/sql - Go Packages ↩↩

  • 分类于 Coding/Golang
  • 需要 3 分钟阅读时间

Golang 标准库之 context

一、引入

在使用 goroutine 时会出现这样一个问题：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import "time"

func main() {
    go f()
    for range time.Tick(time.Second) {
        println("main tick")
    }
}

func f() {
    defer func() {
        println("exit f")
    }()
    go ff()
    println("f")
}

func ff() {
    for range time.Tick(time.Second) {
        println("ff tick")
    }
}

如果运行上面这段代码，会发现，创建运行 ff 的 goroutine 的 f 在退出之后 ff 仍在运行。

有时候我们希望这些 goroutine 具有类似主 goroutine 与其他 goroutine 的“父子”关系，即“父” goroutine 退出时终止“子” goroutine。

但是 golang 中的 goroutine 并不这样，但是我们可以通过 context 来是实现它。

再举一个具体点的例子：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
func main()  {
    http.HandleFunc("/", SayHello) // 设置访问的路由
    log.Fatalln(http.ListenAndServe(":8080",nil))
}

func SayHello(writer http.ResponseWriter, request *http.Request)  {
    fmt.Println(&request)

    go func() {
        for range time.Tick(time.Second) {
            fmt.Println("Current request is in progress")
        }
    }()

    time.Sleep(2 * time.Second)
    writer.Write([]byte("Hi, New Request Comes"))
}

每一个 Http 请求都会创建一个 goroutine 用于运行 Handler 函数，在这个例子中的 Handler 函数包含了一段使用 goroutine 运行一个无限循环的例子，这其实很常用（比如创建一个对当前 Handler 的监听器），我们会希望在 Handler 退出时，这个 goroutine 也被终止。但是实际上这段代码像先前的例子一样，这段循环会一直运行。

而 request 其中包含了一个方法让我们得以判断这个 Handler 是否处理完成：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
go func() {
    for range time.Tick(time.Second) {
        select {
        case <- request.Context().Done():
            fmt.Println("request is outgoing")
            return
        default:
            fmt.Println("Current request is in progress")
        }
    }
}()

而 context 便可以像这个例子一样解决我们遇到的问题。

二、什么是 context

官方对于 Context 的介绍是：在截止时间（deadline）、取消信号（cancellation signal）以及其他 request-scoped 的值

在 Golang 标准库的 context 包中，Context 是这样定义的：

Go
1
2
3
4
5
6
type Context interface {
    Deadline() (deadline time.Time, ok bool)
    Done() <-chan struct{}
    Err() error
    Value(key any) any
}
  • Deadline()：返回当工作完成（context 被取消）的截止时间，当没有 deadline 的时候 ok 为 false。
  • Done()：返回一个当工作完成（context 被取消）时关闭的 channel，当 context 永远不会被取消的时候返回 nil。
  • Err()：如果 Done 还没有被关闭，则返回 nil；如果 Done 关闭了，则返回一个非 nil 的 error 解释关闭的原因。
  • Value(key any)：返回通过 key 获取的与此 context 关联的键值对中的值。

有两种最基本的 context，他们都会返回 emptyCtx，即 Deadline() 直接返回而 Done()、Err()、Value(key any) 返回 nil 的 Context：

  • func Background() Context

常用于主函数、初始化、测试，以及作为请求的顶级 Context。

  • func TODO() Context

用于在不确定用何种 Context 或目前不可用时使用。

此外 Golang 在 context 库中提供了很多方便创建 Context 的工具函数：

  • WithCancel

有时我们希望通过关闭 Done channel 来向使用此 context 的 goroutine 传递 context 取消的信息（就像上面的例子），此时便可以使用此函数：

Go
1
func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

这个函数会通过复制一个 parent context 并将其 Done 赋为一个新的 channel 的方式创建一个新的 context 并返回，

同时还会返回一个用于关闭 Done 的函数 cancel。

一个例子：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// gen 会在另一个 goroutine 中生成整数并传入返回的 channel。
// 调用者应当在不再使用 gen 的时候立刻取消 context。
gen := func(ctx context.Context) <-chan int {
    dst := make(chan int)
    n := 1
    go func() {
        for {
            select {
            case <-ctx.Done():
                return // returning not to leak the goroutine
            case dst <- n:
                n++
            }
        }
    }()
    return dst
}

ctx, cancel := context.WithCancel(context.Background())
defer cancel() // 在下面对生成的整数的使用结束时取消 context

for n := range gen(ctx) {
    fmt.Println(n)
    if n == 5 {
        break
    }
}
  • WithCancelCause

与 WithCancel 很像，不过其返回的是一个 CancelCauseFunc，接受一个 error 类型的参数。

使用一个非 nil 的 error（也就是所谓的 cause）会将它记录在 ctx 中，可以使用 Cause(ctx) 来获取它（在 context 被取消时会得到 nil）。

也可以传入 nil 来使用 ctx 原本的 Error。

Go
1
func WithCancelCause(parent Context) (ctx Context, cancel CancelCauseFunc)

一个例子：

Go
1
2
3
4
ctx, cancel := context.WithCancelCause(parent)
cancel(myError)
ctx.Err() // returns context.Canceled
context.Cause(ctx) // returns myError
  • WithDeadline

会通过复制 parent 并使其 Deadline 返回 no later than d。如果 parent 的 Deadline 已经比 d 早了，就不变。

在 deadline 到达时，将会关闭 Done channel。

一个例子：

Go
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
func main() {
  d := time.Now().Add(1 * time.Millisecond)
  ctx, cancel := context.WithDeadline(context.Background(), d)

  // 即便 ctx 会由于 deadline 被取消，依旧使用 defer 将其取消是一个好习惯
  defer cancel()

  select {
  case <-time.After(1 * time.Second):
      fmt.Println("overslept")
  case <-ctx.Done():
      fmt.Println(ctx.Err())
  }

}

输出：context deadline exceeded

  • WithTimeout
Go
1
func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

就是 WithDeadline(parent, time.Now().Add(timeout))。

  • WithValue

func WithValue(parent Context, key, val any) Context：其源码是用参数创建一个 valueCtx 并返回（要求 parent 非空，key 非空 key 可以比较）

用于传递值。Use context Values only for request-scoped data that transits processes and APIs, not for passing optional parameters to functions.

valueCtx：

递归定义，以此可以保存多对 key val，其 Value 函数基于 key 是否相等的比较返回 val。

Go
1
2
3
4
type valueCtx struct {
  Context
  key, val any
}

参考

GO语言基础进阶教程：Go语言的协程——Goroutine - 知乎 (zhihu.com)

深入理解Golang中的Context包_golang context_沈子恒的博客-CSDN博客、

  • 分类于 Linux/NixOS
  • 需要 9 分钟阅读时间

Nix Pills 笔记 —— 第6~7章 Derivation

Chapter 6. Our First Derivation

从文件系统的角度来看，Derivation 是 Nix 系统的组成部分，而 Nix 语言就是用于描述它的。

一、创建 Derivation

derivation 内置函数1 就是用于创建 Derivation 的。

Derivation 其实就是一个带有一些属性的集合。

derivation 函数接受一个至少包含以下三个属性的集合作为它的第一个参数：

  • name：此 Derivation 的名字。在 nix store 格式就是 hash-name

  • system：此 Derivation 可以被构建的系统

可以使用 builtins.currentSystem 获取：

Bash Session
1
2
nix-repl> builtins.currentSystem
"x86_64-linux"
  • builder：构建 Derivation 的二进制程序

下面我们来创建一个 Derivation 并将其赋给 d：

Bash Session
1
2
3
nix-repl> d = derivation { name = "myname"; builder = "mybuilder"; system = "mysystem"; }
nix-repl> d
«derivation /nix/store/z3hhlxbckx4g3n9sw91nnvlkjvyw754p-myname.drv»

nix repl 并不会构建 Derivation，但是它会创建 .drv 文件。

那么什么是 .drv 文件呢？

做一个类比，如果将 .nix 文件比作 .c 文件，那么 .drv 文件就是像 .o 文件一样的中间文件，它包含描述如何构建一个 Derivation 的最少的信息，而最终我们的路径就是构建的结果。

我们可以使用 nix show-derivation 来查看一个 .drv 文件的内容：

Bash Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
$ nix show-derivation /nix/store/z3hhlxbckx4g3n9sw91nnvlkjvyw754p-myname.drv
{
  "/nix/store/z3hhlxbckx4g3n9sw91nnvlkjvyw754p-myname.drv": {
    "outputs": {
      "out": {
        "path": "/nix/store/40s0qmrfb45vlh6610rk29ym318dswdr-myname"
      }
    },
    "inputSrcs": [],
    "inputDrvs": {},
    "platform": "mysystem",
    "builder": "mybuilder",
    "args": [],
    "env": {
      "builder": "mybuilder",
      "name": "myname",
      "out": "/nix/store/40s0qmrfb45vlh6610rk29ym318dswdr-myname",
      "system": "mysystem"
    }
  }
}

其中包含：

  • 输出路径（可以有多个），默认 Nix 会创建一个叫做 out 的输出路径

out 路径的 hash 完全基于当前版本的 Nix 中的输入 Derivation，而非构建的内容（保留疑惑）

  • 输入的 Derivation 的列表

  • 系统和构建器的可执行文件

  • 一系列传递给构建器的环境变量

二、构建 Derivation

在 nix repl 中可以使用 :b 来构建一个 Derivation，更多 nix repl 中的命令可以查看 :? 的输出。

Bash Session
1
2
3
4
5
6
7
nix-repl> d = derivation { name = "myname"; builder = "mybuilder"; system = "mysystem"; }
nix-repl> :b d
[...]
these derivations will be built:
  /nix/store/z3hhlxbckx4g3n9sw91nnvlkjvyw754p-myname.drv
building path(s) `/nix/store/40s0qmrfb45vlh6610rk29ym318dswdr-myname'
error: a `mysystem' is required to build `/nix/store/z3hhlxbckx4g3n9sw91nnvlkjvyw754p-myname.drv', but I am a `x86_64-linux'

在 nix repl 外可以使用 nix-store -r 来 realise 一个 .drv 文件（输出同上）：

Bash Session
1
$ nix-store -r /nix/store/z3hhlxbckx4g3n9sw91nnvlkjvyw754p-myname.drv

可以看到提示需要在 mysystem 系统上才可以构建，而目前的系统为 x86_64-linux，我们稍作更改再尝试一次：

Bash Session
1
2
3
4
nix-repl> d = derivation { name = "myname"; builder = "mybuilder"; system = builtins.currentSystem; }
nix-repl> :b d
[...]
build error: invalid file name `mybuilder'

这次提示 mybuilder 并不存在。

derivation 的返回值其实是一个属性集：

builtins.isAttrs 判断传入参数是否为一个属性集

builtins.attrNames 返回传入属性集的所有键的列表

Bash Session
1
2
3
4
5
nix-repl> d = derivation { name = "myname"; builder = "mybuilder"; system = "mysystem"; }
nix-repl> builtins.isAttrs d
true
nix-repl> builtins.attrNames d
[ "all" "builder" "drvAttrs" "drvPath" "name" "out" "outPath" "outputName" "system" "type" ]

我们来看一看其中都有哪些属性：

  • drvAttrs：这基本上其实就是 derivation 函数的传入参数
Bash Session
1
2
nix-repl> d.drvAttrs
{ builder = "mybuilder"; name = "myname"; system = "mysystem"; }

  • name、system、builder 也是

  • out：也就是 Derivation 自己

Bash Session
1
2
nix-repl> (d == d.out)
true

  • drvPath：就是 .drv 文件的路径

  • type：值为 derivation

如果你创建一个带有值为 derivation 的 type 属性的集合，那么它其实就是 Derivation 类型：

Bash Session
1
2
nix-repl> { type = "derivation"; }
«derivation ???»
  • outPath：构建的输出路径

三、引用其他 Derivation

首先介绍一个 Nix 的 Set 到 String 的转换：

Bash Session
1
2
3
4
nix-repl> builtins.toString { outPath = "foo"; }
"foo"
nix-repl> builtins.toString { a = "b"; }
error: cannot coerce a set to a string, at (string):1:1

如果一个集合带有一个 outPath 属性，那么它就可以被转换为一个字符串。

比如我们想要使用来自 coreutils 的二进制文件（暂时忽略 nixpkgs 之类的东西）：

Bash Session
1
2
3
4
5
6
nix-repl> :l <nixpkgs>
Added 3950 variables.
nix-repl> coreutils
«derivation /nix/store/1zcs1y4n27lqs0gw4v038i303pb89rw6-coreutils-8.21.drv»
nix-repl> builtins.toString coreutils
"/nix/store/8w4cbiy7wqvaqsnsnb3zvabq1cp2zhyz-coreutils-8.21"

在字符串中可以插入 Nix 表达式的值：

Bash Session
1
2
3
4
nix-repl> "${d}"
"/nix/store/40s0qmrfb45vlh6610rk29ym318dswdr-myname"
nix-repl> "${coreutils}"
"/nix/store/8w4cbiy7wqvaqsnsnb3zvabq1cp2zhyz-coreutils-8.21"

比如我们想要使用 bin/true 二进制文件：

Bash Session
1
2
nix-repl> "${coreutils}/bin/true"
"/nix/store/8w4cbiy7wqvaqsnsnb3zvabq1cp2zhyz-coreutils-8.21/bin/true"

如此就可以获取到其路径。

我们再次修改我们的 Derivation（每当 Derivation 被修改时都会创建一个新的哈希值）：

Bash Session
1
2
3
4
5
nix-repl> :l <nixpkgs>
nix-repl> d = derivation { name = "myname"; builder = "${coreutils}/bin/true"; system = builtins.currentSystem; }
nix-repl> :b d
[...]
builder for `/nix/store/qyfrcd53wmc0v22ymhhd5r6sz5xmdc8a-myname.drv' failed to produce output path `/nix/store/ly2k1vswbfmswr33hw0kf0ccilrpisnk-myname'

现在它执行了构建起（bin/true）但是并没有创建输出路径，只是以返回值 0 退出了。

现在我们再来看看这个 .drv 文件：

Bash Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
$ nix show-derivation /nix/store/qyfrcd53wmc0v22ymhhd5r6sz5xmdc8a-myname.drv
{
  "/nix/store/qyfrcd53wmc0v22ymhhd5r6sz5xmdc8a-myname.drv": {
    "outputs": {
      "out": {
        "path": "/nix/store/ly2k1vswbfmswr33hw0kf0ccilrpisnk-myname"
      }
    },
    "inputSrcs": [],
    "inputDrvs": {
      "/nix/store/hixdnzz2wp75x1jy65cysq06yl74vx7q-coreutils-8.29.drv": [
        "out"
      ]
    },
    "platform": "x86_64-linux",
    "builder": "/nix/store/qrxs7sabhqcr3j9ai0j0cp58zfnny0jz-coreutils-8.29/bin/true",
    "args": [],
    "env": {
      "builder": "/nix/store/qrxs7sabhqcr3j9ai0j0cp58zfnny0jz-coreutils-8.29/bin/true",
      "name": "myname",
      "out": "/nix/store/ly2k1vswbfmswr33hw0kf0ccilrpisnk-myname",
      "system": "x86_64-linux"
    }
  }
}

我们可以发现在 inputDrvs 中多了一个 coreutils 的 .drv。

6.6. When is the derivation built

Nix does not build derivations during evaluation of Nix expressions. In fact, that's why we have to do ":b drv" in nix repl, or use nix-store -r in the first place.

An important separation is made in Nix:

  • Instantiate/Evaluation time: the Nix expression is parsed, interpreted and finally returns a derivation set. During evaluation, you can refer to other derivations because Nix will create .drv files and we will know out paths beforehand. This is achieved with nix-instantiate.
  • Realise/Build time: the .drv from the derivation set is built, first building .drv inputs (build dependencies). This is achieved with nix-store -r.

Think of it as of compile time and link time like with C/C++ projects. You first compile all source files to object files. Then link object files in a single executable.

In Nix, first the Nix expression (usually in a .nix file) is compiled to .drv, then each .drv is built and the product is installed in the relative out paths.

6.7. Conclusion

Is it that complicated to create a package for Nix? No, it's not.

We're walking through the fundamentals of Nix derivations, to understand how they work, how they are represented. Packaging in Nix is certainly easier than that, but we're not there yet in this post. More Nix pills are needed.

With the derivation function we provide a set of information on how to build a package, and we get back the information about where the package was built. Nix converts a set to a string when there's an outPath; that's very convenient. With that, it's easy to refer to other derivations.

When Nix builds a derivation, it first creates a .drv file from a derivation expression, and uses it to build the output. It does so recursively for all the dependencies (inputs). It "executes" the .drv files like a machine. Not much magic after all.

Chapter 7. Working Derivation

这一章节，我们将尝试打包一个真实的程序：编译一个简单的 C 语言文件并为其创建一个 Derivation。

一、使用脚本作为一个构建器

我们写一个执行一系列命令的脚本 builder.sh 来构建我们的程序，并且我们希望我们的 Derivation 运行 bash builder.sh。

在 builder.sh 中我们不使用 hash bangs，因为在我们编写它的时候我们并不知道 bash 在 nix store 中的路径。

也就是说，在这个例子中 bash 就是我们的构建器，而我们要向它传递一个参数 builder.sh。

derivation 函数接受一个可选的参数 args 用于向构建器传递参数。

那么首先让我们在当前目录创建我们的 builder.sh 并输入以下内容：

Bash
1
2
declare -xp
echo foo > $out

这个脚本所做的事情如下：

  • declare -xp 列出所有导出的变量（declare 是内置的 bash 函数）

上一章中我们知道最终的 .drv 文件会包含一系列传递给构建器的环境变量，其中之一就是 $out

在 $out 中创建一个文件。

然后我们在构建的过程中使用 coreutils 中的 env 来打印环境变量，如此我们的依赖除了 bash 还有 coreutils。

Bash Session
1
2
3
4
nix-repl> :l <nixpkgs>
Added 3950 variables.
nix-repl> "${bash}"
"/nix/store/ihmkc7z2wqk3bbipfnlh0yjrlfkkgnv6-bash-4.2-p45"
Bash Session
1
2
3
4
5
6
nix-repl> d = derivation { name = "foo"; builder = "${bash}/bin/bash"; args = [ ./builder.sh ]; system = builtins.currentSystem; }
nix-repl> :b d
[1 built, 0.0 MiB DL]

this derivation produced the following outputs:
  out -> /nix/store/gczb4qrag22harvv693wwnflqy7lx5pb-foo

We did it! The contents of /nix/store/w024zci0x1hh1wj6gjq0jagkc1sgrf5r-foo is really foo. We've built our first derivation.

Note that we used ./builder.sh and not "./builder.sh". This way, it is parsed as a path, and Nix performs some magic which we will cover later. Try using the string version and you will find that it cannot find builder.sh. This is because it tries to find it relative to the temporary build directory.

二、构建环境

我们可以使用 nix-store --read-log 来查看我们的构建器产生的输出：

Bash Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
$ nix-store --read-log /nix/store/gczb4qrag22harvv693wwnflqy7lx5pb-foo
declare -x HOME="/homeless-shelter"
declare -x NIX_BUILD_CORES="4"
declare -x NIX_BUILD_TOP="/tmp/nix-build-foo.drv-0"
declare -x NIX_LOG_FD="2"
declare -x NIX_STORE="/nix/store"
declare -x OLDPWD
declare -x PATH="/path-not-set"
declare -x PWD="/tmp/nix-build-foo.drv-0"
declare -x SHLVL="1"
declare -x TEMP="/tmp/nix-build-foo.drv-0"
declare -x TEMPDIR="/tmp/nix-build-foo.drv-0"
declare -x TMP="/tmp/nix-build-foo.drv-0"
declare -x TMPDIR="/tmp/nix-build-foo.drv-0"
declare -x builder="/nix/store/q1g0rl8zfmz7r371fp5p42p4acmv297d-bash-4.4-p19/bin/bash"
declare -x name="foo"
declare -x out="/nix/store/gczb4qrag22harvv693wwnflqy7lx5pb-foo"
declare -x system="x86_64-linux"

Let's inspect those environment variables printed during the build process.

  • $HOME is not your home directory, and /homeless-shelter doesn't exist at all. We force packages not to depend on $HOME during the build process.
  • $PATH plays the same game as $HOME
  • $NIX_BUILD_CORES and $NIX_STORE are nix configuration options
  • $PWD and $TMP clearly show that nix created a temporary build directory
  • Then $builder, $name, $out, and $system are variables set due to the .drv file's contents.

And that's how we were able to use $out in our derivation and put stuff in it. It's like Nix reserved a slot in the nix store for us, and we must fill it.

In terms of autotools, $out will be the --prefix path. Yes, not the make DESTDIR, but the --prefix. That's the essence of stateless packaging. You don't install the package in a global common path under /, you install it in a local isolated path under your nix store slot.

三、.drv 的内容

We added something else to the derivation this time: the args attribute. Let's see how this changed the .drv compared to the previous pill:

Bash Session
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
$ nix show-derivation /nix/store/i76pr1cz0za3i9r6xq518bqqvd2raspw-foo.drv
{
  "/nix/store/i76pr1cz0za3i9r6xq518bqqvd2raspw-foo.drv": {
    "outputs": {
      "out": {
        "path": "/nix/store/gczb4qrag22harvv693wwnflqy7lx5pb-foo"
      }
    },
    "inputSrcs": [
      "/nix/store/lb0n38r2b20r8rl1k45a7s4pj6ny22f7-builder.sh"
    ],
    "inputDrvs": {
      "/nix/store/hcgwbx42mcxr7ksnv0i1fg7kw6jvxshb-bash-4.4-p19.drv": [
        "out"
      ]
    },
    "platform": "x86_64-linux",
    "builder": "/nix/store/q1g0rl8zfmz7r371fp5p42p4acmv297d-bash-4.4-p19/bin/bash",
    "args": [
      "/nix/store/lb0n38r2b20r8rl1k45a7s4pj6ny22f7-builder.sh"
    ],
    "env": {
      "builder": "/nix/store/q1g0rl8zfmz7r371fp5p42p4acmv297d-bash-4.4-p19/bin/bash",
      "name": "foo",
      "out": "/nix/store/gczb4qrag22harvv693wwnflqy7lx5pb-foo",
      "system": "x86_64-linux"
    }
  }
}

Much like the usual .drv, except that there's a list of arguments in there passed to the builder (bash) with builder.sh… In the nix store..? Nix automatically copies files or directories needed for the build into the store to ensure that they are not changed during the build process and that the deployment is stateless and independent of the building machine. builder.sh is not only in the arguments passed to the builder, it's also in the input derivations.

Given that builder.sh is a plain file, it has no .drv associated with it. The store path is computed based on the filename and on the hash of its contents. Store paths are covered in detail in a later pill.

四、打包一个简单的 C 语言程序

我们写一个简单的 simple.c：

C
1
2
3
void main() {
  puts("Simple!");
}

以及它的构建脚本 simple_builder.sh：

Bash
1
2
3
export PATH="$coreutils/bin:$gcc/bin"
mkdir $out
gcc -o $out/simple $src

暂时先不用担心上面的变量都是从哪来的，我们先编写 Derivation 并构建它：

Bash Session
1
2
3
4
5
6
nix-repl> :l <nixpkgs>
nix-repl> simple = derivation { name = "simple"; builder = "${bash}/bin/bash"; args = [ ./simple_builder.sh ]; gcc = gcc; coreutils = coreutils; src = ./simple.c; system = builtins.currentSystem; }
nix-repl> :b simple
this derivation produced the following outputs:

  out -> /nix/store/ni66p4jfqksbmsl616llx3fbs1d232d4-simple

Now you can run /nix/store/ni66p4jfqksbmsl616llx3fbs1d232d4-simple/simple in your shell.

我们在 derivation 添加了两个新的参数：gcc 和 coreutils。

In gcc = gcc;, the name on the left is the name in the derivation set, and the name on the right refers to the gcc derivation from nixpkgs. The same applies for coreutils.

We also added the src attribute, nothing magical — it's just a name, to which the path ./simple.c is assigned. Like simple-builder.sh, simple.c will be added to the store.

所有传入 derivation 的参数都会被转换为字符串并作为环境变量传递给构建器，这就是那一堆环境变量是怎么来的。

在 simple_builder.sh 中我们设置了 PATH 环境变量，这样后面就可以使用 mkdir 和 gcc 了。

最终我们以 $out 作为目录，将输出的二进制文件置于其中。

五、够了！在 nix repl 外进行构建！

编写一个 simple.nix：

Nix
1
2
3
4
5
6
7
8
9
with (import <nixpkgs> {});
derivation {
  name = "simple";
  builder = "${bash}/bin/bash";
  args = [ ./simple_builder.sh ];
  inherit gcc coreutils;
  src = ./simple.c;
  system = builtins.currentSystem;
}

现在我们可以使用 nix-build simple.nix 来进行构建了。这会在当前的目录下创建一个链接 result，指向输出路径。

nix-build 会做两件事：

  1. nix-instantiate ：解析并对 simple.nix 求值，在这个例子中返回对应解析的 Derivation 集合的 .drv 文件。
  2. nix-store -r : realise the .drv file, 也就是将 Derivation 构建.

Afterwards, we call the function with the empty set. We saw this already in the fifth pill. To reiterate: import <nixpkgs> {} is calling two functions, not one. Reading it as (import <nixpkgs>) {} makes this clearer.

The value returned by the nixpkgs function is a set. More specifically, it's a set of derivations. Using the with expression we bring them into scope. This is equivalent to the :l \<nixpkgs> we used in nix repl; it allows us to easily access derivations such as bash, gcc, and coreutils.

参考

  1. Derivations - Nix Reference Manual (nixos.org) ↩↩

PostgreSQL Data Defination

参考：PostgreSQL: Documentation: 15: 5.4. Constraints

二、默认值

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer,
    name text,
    price numeric DEFAULT 9.99
);

默认值也可以被设置为一个表达式，表达式会在记录被插入时求值。

一个例子就是时间戳 DEFAULT CURRENT_TIMESTAMP，还有就是自增的序列号：

PostgreSQL SQL Dialect
1
2
3
4
CREATE TABLE products (
    product_no integer DEFAULT nextval('products_product_no_seq'),
    ...
);

这个 nextval() 函数见 PostgreSQL: Documentation: 15: 9.17. Sequence Manipulation Functions

四、Constraints 约束

一、Check 约束

check 约束是最通用的约束类型，规定某一列必须满足一个布尔表达式。

比如要求产品价格 price 必须为正数：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer,
    name text,
    price numeric CHECK (price > 0)
);

可以使用 CONSTRAINT 关键字来指定约束的名字：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer,
    name text,
    price numeric CONSTRAINT positive_price CHECK (price > 0)
);

上面的是 对于某一列的约束，还可以添加 对整张表的约束：

PostgreSQL SQL Dialect
1
2
3
4
5
6
7
CREATE TABLE products (
    product_no integer,
    name text,
    price numeric CHECK (price > 0),
    discounted_price numeric CHECK (discounted_price > 0),
    CHECK (price > discounted_price)
);

额外的约束并没有紧接着写在某一列后面，而是单独出现在列的列表中。

对某一列的约束应当只引用当前列，而对整张表的约束可以引用多个列（虽然 PostgreSQL 并不强制，但是其他 SQL 可能会强制要求）。

下面是等价的一些其他写法：

PostgreSQL SQL Dialect
1
2
3
4
5
6
7
8
9
CREATE TABLE products (
    product_no integer,
    name text,
    price numeric,
    CHECK (price > 0),
    discounted_price numeric,
    CHECK (discounted_price > 0),
    CHECK (price > discounted_price)
);
PostgreSQL SQL Dialect
1
2
3
4
5
6
7
CREATE TABLE products (
    product_no integer,
    name text,
    price numeric CHECK (price > 0),
    discounted_price numeric,
    CHECK (discounted_price > 0 AND price > discounted_price)
);

同样对于表的约束也可以使用 CONSTRAINT 关键字指定约束名。

二、Not-Null 约束

要求某一列不能为空值。

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer NOT NULL,
    name text NOT NULL,
    price numeric
);

其实等价于：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer CHECK (product_no is NOT NULL),
    name text CHECK (name is NOT NULL),
    price numeric
);

多个约束条件可以用空格隔开这么写：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer NOT NULL,
    name text NOT NULL,
    price numeric NOT NULL CHECK (price > 0)
);

3. Unique 约束

要求某一列的值不重复。

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer UNIQUE,
    name text UNIQUE,
    price numeric
);

写作对表的约束可以这么写：

PostgreSQL SQL Dialect
1
2
3
4
5
6
CREATE TABLE products (
    product_no integer,
    name text,
    price numeric,
    UNIQUE (product_no, name)
);

要注意的是 NULL 被视为不相同，也就是说如果两条记录的 Unique 约束内的某一列都为 NULL，是不违反约束的。可以通过添加 NULLS NOT DISTINCT 来规定将 NULL 值视为相等：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer UNIQUE NULLS NOT DISTINCT,
    name text,
    price numeric
);

4. Primary Keys

一个主键唯一确定一条记录，也就是 UNIQUE 且 NOT NULL。

所以

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer PRIMARY KEY,
    name text,
    price numeric
);

其实等价于

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer UNIQUE NOT NULL,
    name text,
    price numeric
);

可以以一组列作为主键：

PostgreSQL SQL Dialect
1
2
3
4
5
6
CREATE TABLE example (
    a integer,
    b integer,
    c integer,
    PRIMARY KEY (a, c)
);

5. Foreign Keys

外键必须在其他表中存在，即参照完整性。

比如对于这样一张产品表 products：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no integer PRIMARY KEY,
    name text,
    price numeric
);

其中的 product_no 可能要被其他表引用，比如订单表 orders：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE orders (
    order_id integer PRIMARY KEY,
    product_no integer REFERENCES products (product_no),
    quantity integer
);

这时，如果新的记录的 product_no 在 products 表中不存在则会违反约束。

上面的命令也可以简写：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE orders (
    order_id integer PRIMARY KEY,
    product_no integer REFERENCES products,
    quantity integer
);

因为对于另一个表的引用其实默认就是以那个表的主键为引用列的。

也可以引用多个列：

PostgreSQL SQL Dialect
1
2
3
4
5
6
CREATE TABLE t1 (
  a integer PRIMARY KEY,
  b integer,
  c integer,
  FOREIGN KEY (b, c) REFERENCES other_table (c1, c2)
);

当然数量和类型必须对应。

有时候外键会是自己同一张表的主键：

PostgreSQL SQL Dialect
1
2
3
4
5
6
CREATE TABLE tree (
    node_id integer PRIMARY KEY,
    parent_id integer REFERENCES tree,
    name text,
    ...
);

这叫做 自引用外键。

还会有一个问题，就是如果引用的外键在其他表中对应记录被删除呢？此时这个记录就不合法了。

这是有几个选择：

  • 不允许删除作为外键被引用的记录 ON DELETE RESTRICT
  • 将引用了外键的记录的记录也删除掉 ON DELETE CASACDE
PostgreSQL SQL Dialect
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
CREATE TABLE products (
    product_no integer PRIMARY KEY,
    name text,
    price numeric
);

CREATE TABLE orders (
    order_id integer PRIMARY KEY,
    shipping_address text,
    ...
);

CREATE TABLE order_items (
    product_no integer REFERENCES products ON DELETE RESTRICT,
    order_id integer REFERENCES orders ON DELETE CASCADE,
    quantity integer,
    PRIMARY KEY (product_no, order_id)
);

如果 products 中的某条记录被引用，那么不允许删除 products 中的该条记录。

如果 orders 中的某条记录被删除，那么 order_items 引用了对应记录的键的记录就会被删除。

还有一些其他的：

如果什么都不写就是 NO ACTION，会抛出错误。

还有 SET NULL 和 SET DEFAULT xxx，顾名思义。

这块还有点复杂，先咕一下，后面用到了再详细整理。

6. Exclusion 约束

咕

五、修改表

1. 添加列

PostgreSQL SQL Dialect
1
ALTER TABLE products ADD COLUMN description text;

2. 删除列

PostgreSQL SQL Dialect
1
ALTER TABLE products DROP COLUMN description;

对于被引用的记录，可以使用 CASCADE 来删除依赖于此列的列：

PostgreSQL SQL Dialect
1
ALTER TABLE products DROP COLUMN description CASCADE;

3. 添加约束

PostgreSQL SQL Dialect
1
2
3
ALTER TABLE products ADD CHECK (name <> '');
ALTER TABLE products ADD CONSTRAINT some_name UNIQUE (product_no);
ALTER TABLE products ADD FOREIGN KEY (product_group_id) REFERENCES product_groups;

对于 NOT NULL 这种不能被写为表约束的约束，可以用修改列的语法来写：

PostgreSQL SQL Dialect
1
ALTER TABLE products ALTER COLUMN product_no SET NOT NULL;

4. 删除约束

PostgreSQL SQL Dialect
1
ALTER TABLE products DROP CONSTRAINT some_name;

对于 NOT NULL：

PostgreSQL SQL Dialect
1
ALTER TABLE products ALTER COLUMN product_no DROP NOT NULL;

5. 改变某一列的默认值

PostgreSQL SQL Dialect
1
ALTER TABLE products ALTER COLUMN price SET DEFAULT 7.77;

或者删除默认值：

PostgreSQL SQL Dialect
1
ALTER TABLE products ALTER COLUMN price DROP DEFAULT;

6. 改变某一列的数据类型

PostgreSQL SQL Dialect
1
ALTER TABLE products ALTER COLUMN price TYPE numeric(10,2);

7. 重命名某一列

PostgreSQL SQL Dialect
1
ALTER TABLE products RENAME COLUMN product_no TO product_number;

8. 重命名表

PostgreSQL SQL Dialect
1
ALTER TABLE products RENAME TO items;

PostgreSQL Data Manipulation

参考：PostgreSQL: Documentation: 15: Chapter 6. Data Manipulation

一、插入数据

以这张表为例：

PostgreSQL SQL Dialect
1
2
3
4
5
CREATE TABLE products (
    product_no    integer,
    name          text,
    price         numeric
);

可以通过下面的命令来插入一条记录：

PostgreSQL SQL Dialect
1
INSERT INTO products VALUES (1, 'Cheese', 9.99);

但是上面的写法要求顺序与表中列得顺序对应，也可以采取下面的写法，与表名一一对应：

PostgreSQL SQL Dialect
1
2
INSERT INTO products (product_no, name, price) VALUES (1, 'Cheese', 9.99);
INSERT INTO products (name, price, product_no) VALUES ('Cheese', 9.99, 1);

如果某一列没有值（为空）那么可以将其省略：

PostgreSQL SQL Dialect
1
2
INSERT INTO products (product_no, name) VALUES (1, 'Cheese');
INSERT INTO products VALUES (1, 'Cheese');

上面第二行是 PostgreSQL 的扩展写法，会从左到右依次为列赋值，剩余为空。

也可以显式地指定使用某一列使用默认值或全部使用默认值：

PostgreSQL SQL Dialect
1
2
INSERT INTO products (product_no, name, price) VALUES (1, 'Cheese', DEFAULT);
INSERT INTO products DEFAULT VALUES;

可以用一条命令插入多条数据：

PostgreSQL SQL Dialect
1
2
3
4
INSERT INTO products (product_no, name, price) VALUES
    (1, 'Cheese', 9.99),
    (2, 'Bread', 1.99),
    (3, 'Milk', 2.99);

还可以插入查询的结果：

PostgreSQL SQL Dialect
1
2
3
INSERT INTO products (product_no, name, price)
  SELECT product_no, name, price FROM new_products
    WHERE release_date = 'today';

PostgreSQL Views

参考：PostgreSQL: Documentation: 15: 41.2. Views and the Rule System

视图是从其他表中导出的表，是一个虚表。数据库只保存视图的定义，而不保存视图的数据（因为视图其实可以理解为对子查询的一个别名）。

而在 PostgreSQL 中的 视图 其实是使用 rule system 实现的，所以下面两个命令其实在本质上是一样的：

PostgreSQL SQL Dialect
1
CREATE VIEW myview AS SELECT * FROM mytab;
PostgreSQL SQL Dialect
1
2
3
CREATE TABLE myview (/*same column list as mytab*/);
CREATE RULE "_RETURN" AS ON SELECT TO myview DO INSTEAD
    SELECT * FROM mytab;

不过这会带来一些副作用，其中之一就是在 system catalog 中，一个 视图 的信息适合一个 表 完全一样的，所以对于解析器，它们之间没有任何区别，他们都是一个东西 —— 关系。

PostgreSQL SQL Dialect
1
2
3
4
CREATE [ OR REPLACE ] [ TEMP | TEMPORARY ] [ RECURSIVE ] VIEW /*name*/ [ ( /*column_name*/ [, ...] ) ]
    [ WITH ( /*view_option_name*/ [= /*view_option_value*/] [, ... ] ) ]
    AS /*query*/
    [ WITH [ CASCADED | LOCAL ] CHECK OPTION ]

最基本的创建视图的命令如下：

PostgreSQL SQL Dialect
1
CREATE VIEW /*name*/ AS /*query*/

如果天加上 OR REPLACE 则会在视图存在的时候将其替换。

其他的一些参数：

  • TEMP：临时的视图会在当前 session 结束时自动 drop 掉

  • RECURSIVE：创建一个递归的视图

PostgreSQL SQL Dialect
1
CREATE RECURSIVE VIEW [ schema . ] /*view_name*/ (/*column_names*/) AS SELECT ...;

其实等价于

PostgreSQL SQL Dialect
1
CREATE VIEW [ schema . ] /*view_name*/ AS WITH RECURSIVE /*view_name*/ (/*column_names*/) AS (SELECT ...) SELECT /*column_names*/ FROM /*view_name*/;
  • CHEK OPTION：控制自动更新的视图的行为

开启后，INSERT 和 UPDATE 命令会被检查确保新的行满足视图定义的条件，能够在视图中显示。

如果有视图依赖于视图的情况：

  • LOCAL：会仅检查当前视图
  • CASCADE（默认）：会递归地检查每个视图