Postgresql alias是一种把表名作为别名的方法，它可以让你更好的理解表的含义。

Postgresql - TABLE ALIAS


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型。它返回左表中的所有行和右表中的所有行，包括在 ON 子句中不匹配的行。FULL OUTER JOIN 在想要在最终结果集中包含两个表中不匹配的行时非常有用。

以下查询使用`INNER JOIN`表连接到自身的查询

```sql
SELECT select_list
FROM table_name t1
INNER JOIN table_name t2 ON join_predicate;
```

此外还可以使用`LEFT JOIN`或`RIGHT JOIN`将表连接到自身：

```sql
SELECT select_list
FROM table_name t1
LEFT JOIN table_name t2 ON join_predicate;
```

## 示例

### 查询分层数据

假设有以下组织结构

![x9yBXT](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/x9yBXT.jpg)

创建`employee`表并将一些数据插入表中

```sql
CREATE TABLE employee (
	employee_id INT PRIMARY KEY,
	first_name VARCHAR (255) NOT NULL,
	last_name VARCHAR (255) NOT NULL,
	manager_id INT,
	FOREIGN KEY (manager_id)
	REFERENCES employee (employee_id)
	ON DELETE CASCADE
);
INSERT INTO employee (
	employee_id,
	first_name,
	last_name,
	manager_id
)
VALUES
	(1, 'Windy', 'Hays', NULL),
	(2, 'Ava', 'Christensen', 1),
	(3, 'Hassan', 'Conner', 1),
	(4, 'Anna', 'Reeves', 2),
	(5, 'Sau', 'Norman', 2),
	(6, 'Kelsie', 'Hays', 3),
	(7, 'Tory', 'Goff', 3),
	(8, 'Salley', 'Lester', 3);
```

使用自连接查询谁向谁报告

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
INNER JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

![1zBzNp](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/1zBzNp.jpg)

以上查询两次引用`employee`表，一次作为雇员，另一次作为经理，通过匹配`employee_id`和`manager_id`查找雇员/经理对

使用`LEFT JOIN`instead of`INNER JOIN`查询结果集中包含最高管理者

```sql
SELECT
    e.first_name || ' ' || e.last_name employee,
    m .first_name || ' ' || m .last_name manager
FROM
    employee e
LEFT JOIN employee m ON m .employee_id = e.manager_id
ORDER BY manager;
```

![7eG9pZ](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/7eG9pZ.jpg)

### 比较同表的行

![GRiyfG](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/GRiyfG.jpg)

查询所有长度相同的电影

```sql
SELECT
    f1.title,
    f2.title,
    f1.length
FROM
    film f1
INNER JOIN film f2
    ON f1.film_id <> f2.film_id AND
       f1.length = f2.length;
```

![AFkjme](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/AFkjme.jpg)


在 Postgresql 中，FULL OUTER JOIN 是一种结合左外连接和右外连接结果的连接类型

Postgresql - FULL OUTER JOIN


CSS 的继承是指某个元素的某个样式属性可以被它的后代元素继承。具体来说，如果一个元素的某个样式属性没有被显式地设置，那么这个属性就会从它的父元素继承。如果父元素也没有设置这个属性，那么这个属性就会继续向上寻找，直到找到有设置这个属性的元素或者到达根元素为止。

CSS 的继承是一种很方便的样式控制方式，它可以让页面的样式表更加简洁，同时也可以减少代码量，提高开发效率。下面是一些常见的继承属性：

- 字体属性：字体大小、字体样式、字体粗细、字体颜色等属性都是可以被继承的。
- 文本属性：文本对齐方式、文本缩进、行高、文字间距等属性也是可以被继承的。
- 列表属性：列表项的标志、列表项的编号等属性也可以被继承。
- 表格属性：表格的边框、单元格的边框、单元格的背景颜色等属性也可以被继承。

但是并不是所有的样式属性都可以被继承，例如定位、背景图像、边框样式等属性就不能被继承。此外，如果一个元素的某个样式属性被显式地设置了，那么它的后代元素就不会继承这个属性。

需要注意的是，虽然继承可以让样式表更加简洁，但是过度使用继承也可能会造成样式的混乱，特别是当嵌套层级比较深的时候。因此，在使用继承时需要注意权衡利弊，避免过度使用。

## 案例

1. 字体样式继承

```css
body {
  font-size: 16px;
  font-family: Arial, sans-serif;
  color: #333;
}

h1 {
  font-size: 24px; /* h1 标签继承了 body 的字体样式 */
  font-weight: bold; /* h1 标签自己设置了字体粗细 */
  color: red; /* h1 标签自己设置了颜色 */
}
```

2. 列表样式继承

```css
ul {
  list-style-type: disc;
  color: #333;
}

ul li {
  font-size: 14px;
  color: inherit; /* li 标签继承了 ul 的颜色 */
}
```

3. 表格样式继承

```css
table {
  border-collapse: collapse;
}

th {
  background-color: #ccc;
  font-weight: bold;
  text-align: center;
}

td {
  padding: 5px;
  border: 1px solid #ccc;
  text-align: center;
}
```

4. 表单样式继承

```css
label {
  font-weight: bold;
  color: #333;
}

input {
  border: 1px solid #ccc;
  padding: 5px;
  font-size: 14px;
}

input[type='submit'] {
  background-color: #333;
  color: #fff;
}
```


css - Inheritance


![tc1TS8](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/tc1TS8.jpg)

## 异步处理历史

- 异步 callbacks：callbacks 即是将函数作为参数传递，当同步代码运行结束，就调用函数参数继续运行。
- Promise：
- Generator：
- async/await：

优缺点对比：

| 发展史        | 优点                                       | 缺点                                                                                                  |
| ------------- | ------------------------------------------ | ----------------------------------------------------------------------------------------------------- |
| Callback      | 解决了同步问题                             | 回调地狱、可读性差、无法 try / catch 、无法 return                                                    |
| Promise       | 一定程度上解决了回调地狱的可读性           | 无法取消、任务多时，同样存在语义不清晰                                                                |
| Generator     | 可以控制函数的执行，可以配合 co 函数库使用 | 流程管理却不方便（即何时执行第一阶段、何时执行第二阶段                                                |
| async / await | 语义更清晰、简洁，内置执行器               | 认知不清晰可能会造成大量 await 阻塞（程序并不会等在原地，而是继续事件循环，等到响应后继续往下走）情况 |

## Promise

```js
let promise = new Promise(function (resolve, reject) {
  // code
})
promise
  .then(() => {
    // then
  })
  .catch((error) => {
    // console.log(error)
  })
  .finally((_) => {
    // finally
  })
```

`code`处是用于执行的代码，当`new Promise`创建时，自动执行。

`then`是定义在`Promise.prototype`上的用来处理状态改变时的回调函数。

参数`resolve`和`reject`是 JavaScript 自身提供的回调函数。当`code`呗执行后应该调用`resolve`或`reject`

- `resolve` 任务成功返回 value
- `reject` 任务失败返回`error`

当`promise`被`reject`的时候或者运行代码抛出错误异常如：`throw new Error('Whoops!')`，`catch`负责处理错误

`finaylly`是`promise`结束时，无论结果是`fulfilled`还是`rejected`都会执行的回调函数

内部属性：

- `state` 初始值`pending`，`resolve`的时候为`fullfilled`，`reject`的时候为`rejected`
- `result` 初始值`undefined`，`resolve`的时候为`value`，`reject`的时候为`error`对象

![ZBHm59](https://cdn.jsdelivr.net/gh/manonicu/pics@master/uPic/ZBHm59.png)

### Promise.all

执行多个 promise，并等待所有 promise 准备就绪，任意一个 promise 被 reject，都会立即出发 Promise.all 的 reject 并且返回该 promise 的 error

```js
let promise = Promise.all([
  /*promises*/
])

// 例子
let urls = [
  'https://api.github.com/users/iliakan',
  'https://api.github.com/users/remy',
  'https://api.github.com/users/jeresig'
]

// 将每个 url 映射（map）到 fetch 的 promise 中
let requests = urls.map((url) => fetch(url))

// Promise.all 等待所有任务都 resolved
Promise.all(requests).then((responses) =>
  responses.forEach((response) => alert(`${response.url}: ${response.status}`))
)
```

### Promise.allSettled

与 Promise.all 不同的是，Promise.allSettled 会等待所有 promise 完成，无论成功失败。

- `{status:"fulfilled", value:result}` 对于成功的响应
- `{status:"rejected", reason:error}` 对于 error。

### Promise.race

只要有一个准备就绪就返回其结果或者错误

```js
Promise.race([
  new Promise((resolve, reject) => setTimeout(() => resolve(1), 1000)),
  new Promise((resolve, reject) =>
    setTimeout(() => reject(new Error('Whoops!')), 2000)
  ),
  new Promise((resolve, reject) => setTimeout(() => resolve(3), 3000))
]).then(alert) // 1
```

### Promise.any

与 Promise.race 类似，Promise.any 等待的是第一个`fulfilled`，如果都`rejected`，则返回一个 error 数组

## async/await

Async/await 是以更舒适的方式使用 promise 的一种特殊语法，同时它也非常易于理解和使用。

async 会将其后面的函数的返回值封装成一个`Promise`对象，而 await 会等待这个`Promise`完成，并将其结果返回。

```js
async function hello() {
  return (greeting = await Promise.resolve('Hello'))
}

hello().then(alert)
```

错误处理

1. 使用`try...catch`捕获 async/await 运行程序中抛出的错误
2. **[await-to-js](https://www.npmjs.com/package/await-to-js)**，使用类 go 语言的方式处理（属于 1 的封装）


Async & Promise


## 语法

```sql
table_name AS alias_name
```

## 作用

假如在查询中，你想要查询一个表的所有数据，但是又不想要表的名字，可以使用别名。

```sql
a_very_long_table_name.column_name

a_very_long_table_name AS alias_name

alias.column_name
```

在`JOIN`语句中使用别名，可以避免重复的表名。

```sql
SELECT
	c.customer_id,
	first_name,
	amount,
	payment_date
FROM
	customer c
INNER JOIN payment p
    ON p.customer_id = c.customer_id
ORDER BY
   payment_date DESC;
```

在`self-join`中使用别名，可以避免重复的表名。

```sql
SELECT
    e.first_name employee,
    m .first_name manager
FROM
    employee e
INNER JOIN employee m
    ON m.employee_id = e.manager_id
ORDER BY manager;
```



## Go 介绍

Go 也称为 Golang，是 Google 开发的一种开源，编译和静态类型的编程语言。Go 创作背后的关键人物是 Rob Pike， Ken Thompson 和 Robert Griesemer。Go 于 2009 年 11 月公开发布。

Go 是一种通用的编程语言，具有简单的语法，并具有强大的标准库作为后盾。Go 大放异彩的关键领域之一是创建高可用性和可伸缩性的 Web 应用程序。Go 还可以用于创建命令行应用程序，桌面应用程序甚至移动应用程序。

## Go 优点

当大量其他语言（例如 python，ruby，nodejs ...）执行相同的工作时，为什么选择 Go 作为服务器端编程语言。

这是我选择 Go 时发现的一些优点。

### 简单语法

语法简单明了，并且该语言不会因不必要的功能而肿。这使得编写可读性和可维护性的代码变得容易。

### 易于编写并发程序

并发是语言的固有部分。结果，编写多线程程序简直是小菜一碟。这是通过 Goroutines 和渠道实现的，我们将在接下来的教程中对其进行讨论。

### 编译语言

Go 是一种编译语言。源代码被编译为本地二进制文件。解释语言（例如，nodejs 中使用的 JavaScript）缺少此功能。

### 快速编译

Go 编译器非常神奇，并且从一开始就被设计为快速的。

### 静态链接

Go 编译器支持静态链接。整个 Go 项目可以静态链接到一个大的二进制文件中，并且可以轻松部署在云服务器中，而不必担心依赖关系。

### Go 工具

工具在 Go 中值得特别提及。Go 附带了功能强大的工具，可帮助开发人员编写更好的代码。很少有常用的工具是

- gofmt- gofmt 用于自动格式化 go 源代码。它使用制表符进行缩进，并使用空格进行对齐。
- vet- vet 分析 go 源代码并报告可能的可疑代码。vet 报告的所有内容都不是真正的问题，但是具有捕获编译器未报告的错误的能力，例如使用 Printf 时格式不正确的说明符。
- golint- golint 用于识别代码中的样式问题。

### 垃圾收集

Go 使用垃圾回收，因此内存管理几乎会自动执行，开发人员无需担心内存管理问题。这也有助于轻松地编写并发程序。

### 简单语言规范

语言规范非常简单。在整个规范在页面千篇一律，你甚至可以用它来写你自己的编译器:)

### 开源的

最后但并非最不重要的一点是，Go 是一个开源项目。您可以参与 Go 项目并为该项目做出贡献。

## 使用 Go 构建的热门产品

以下是一些使用 Go 构建的流行产品。

- Google 使用 Go 开发了 Kubernetes。
- Docker 是世界著名的容器化平台，是使用 Go 开发的。
- Dropbox 已将其性能关键组件从 Python 迁移到 Go。
- Infoblox 的下一代网络产品是使用 Go 开发的。

## 安装

Go 可以安装在 Mac，Windows 和 Linux 这三个平台上。您可以从https://golang.org/dl/下载对应平台的二进制文件

### Mac

从https://golang.org/dl/下载Mac OS 安装程序。双击开始安装。按照提示进行操作，这会将 Golang 安装在/usr/local/go 中，并且还将文件夹/usr/local/go/bin 添加到 PATH 环境变量中。

```bash
# if you don't have git install it like so:
brew install git

# then install go
brew install go

# add GOBIN path to your PATH in ~/.bash_profile
export PATH=${HOME}/go/bin:$PATH
```

### Windows

从https://golang.org/dl/下载MSI安装程序。双击开始安装，然后按照提示进行操作。这会将Go安装在位置c:\Go，还将目录c:\Go\ bin 添加到您的路径环境变量中。

### Linux

从https://golang.org/dl/下载tar文件并将其解压缩到/usr/local。

将/usr/local/go/bin 添加到 PATH 环境变量中。

## 验证安装

要验证 Go 安装是否成功，请 go version 在终端中键入命令，它将输出已安装的 Go 版本。这是我终端的输出。

```bash
$ go version
go version go1.13.6 darwin/amd64
```


Go - 简介



混合模式（Blend modes）是一种在图形设计和图像编辑中常用的技术，可以通过将两个或多个图层的像素颜色混合在一起来创建不同的视觉效果。

在混合模式中，每个像素都由两个或多个图层的对应像素的颜色值组成。通过将这些颜色值进行数学计算，可以创建出一系列不同的效果。混合模式的计算基于所选混合模式的算法，以及每个像素的透明度值。不同的混合模式可以产生不同的视觉效果，如颜色叠加、柔光、变暗等。

以下是一些常见的混合模式：

- 正常（Normal）：两个图层的像素颜色直接叠加。
- 变暗（Darken）：将两个图层的像素颜色的较暗的颜色作为输出结果。
- 变亮（Lighten）：将两个图层的像素颜色的较亮的颜色作为输出结果。
- 滤色（Screen）：将两个图层的像素颜色取反，并相乘再取反。
- 叠加（Overlay）：根据底层像素的颜色强度来调整顶层像素的颜色值，产生更加复杂的视觉效果。
- 柔光（Soft light）：根据底层像素的颜色值来调整顶层像素的亮度和饱和度，产生柔和的光照效果。
- 差值（Difference）：将两个图层的像素颜色的差值作为输出结果。

混合模式通常用于图像处理和图形设计中，例如调整图片的颜色和对比度、创建复杂的图形效果、以及制作特殊效果。在 CSS 中，混合模式也可以用于控制背景图像和元素之间的混合效果。
