标签 Go 下的文章

通过实例理解Web应用跨域问题

本文永久链接 – https://tonybai.com/2023/11/19/understand-go-web-cross-origin-problem-by-example

在开发Web应用的过程中,我们经常会遇到所谓“跨域问题(Cross Origin Problem)”。跨域问题是由于浏览器的同源策略(Same-origin policy)导致的,它限制了不同源(Origin:域名、协议或端口)之间的资源交互。在这篇文章中,我将通过一些具体的示例来把跨域问题以及主流解决方法说清楚,供大家参考。

1. 什么是跨域问题

跨域问题指的是当一个Web应用程序在访问另一个域(Origin)的资源时,浏览器会阻止这个跨域的请求(Cross Origin Request)。这句针对跨域问题的诠释里有一个术语“域(Origin)”,它到底是什么呢?

1.1 什么是Origin

在Mozilla官方术语表中,”Origin”指的是一个Web应用/网站的标识,由协议(protocol/scheme)、域名(domain,或主机名host)和端口(port)组成。如果两个应用/网站的协议、域名和端口都相同,它们就被认为是同源的(same origin);否则,它们被视为不同源。我们看到:Origin是一个典型的三元组(protocol, domain, port),只有三元组相同的两个应用/站点才会被认为是同源的(same origin)。

下面是一些判断两个应用/站点是否同源的例子及判断理由:

知道了Origin三元组后,我们来揪出跨域问题背后的“罪魁祸首”。

1.2 同源策略 – 跨域问题的“罪魁祸首”

浏览器为了增加安全性而采取的一项重要措施,那就是“同源策略”。同源策略限制了一个网页中的脚本只能与同源(三元组:协议、域名、端口相同)的资源进行交互,而不能直接访问不同源的资源。

浏览器的这种同源策略限制主要包含以下几点:

  • Cookie、LocalStorage和IndexDB无法读取非同源的资源。
  • DOM和JS对象无法获得非同源资源。例如iframe、img等标签加载的资源,DOM无法访问;JS无法操作非同源页面的DOM。
  • AJAX请求不能发送到非同源的域名,浏览器会阻止非同源的AJAX请求。
  • 不能读取非同源网页的Cookie、LocalStorage和IndexDB。

下图(图片来自网络)展示了同源策略对恶意脚本代码对非同源数据访问的限制:

上面这张图片清晰地展示了恶意脚本代码试图访问非同源数据进行恶意登录的过程。

首先,用户通过浏览器访问正常网站domain1.com,并用用户名密码正常登录该网站,domain1.com使用cookie技术在用户浏览器中保存了与用户登录domain1.com相关的会话信息或token信息。

之后,用户又访问了恶意站点domain2.com,该站点首页的脚本代码在被下载到用户浏览器中后,试图访问浏览器cookie中有关domain1.com的cookie信息,并试图用该信息冒充用户登录domain1.com做恶意操作。

浏览器的同源策略成功禁止了恶意代码的这些恶意操作,浏览器从domain2.com下载的脚本代码只能访问与domain2.com同源的信息。

通过这个过程我们看到:浏览器同源策略的本意是防止恶意网站通过脚本窃取用户的敏感信息,比如登录凭证、个人资料等。如果同源策略不存在,恶意网站就可以自由地读取、修改甚至篡改其他网站的数据,给用户和网站带来巨大的安全风险。

不过,这种策略的存在给开发人员在开发过程带来诸多烦恼,比如:跨域数据访问限制、跨域脚本调用限制以及无法在不同域名之间共享会话信息等。为此,开发人员需要使用一些技术手段来解决这些跨域问题,这增加了开发的复杂性,并且需要额外的配置和处理,给开发人员带来了一定的麻烦。此外,不正确地处理跨域请求也可能导致安全漏洞,因此开发人员还需要对跨域请求进行合理的安全控制和验证。

1.3 获取请求中的“origin”

为了做同源检测,我们需要获取和确定请求中的origin信息。那么如何读取和确定呢?

在HTTP请求头中,”Origin”字段表示发送请求的页面或资源的源信息。该字段包含了发送请求的页面的完整URL或者仅包含协议、域名和端口的部分URL。

在同源策略下,所有的跨域请求都必须携带”Origin”请求头字段,指示请求的来源。因此,在符合同源策略的情况下,每个请求都应该携带”Origin”字段。

在服务器端,我们可以通过读取请求头中的”Origin”字段来确定请求的origin,具体的方法会根据使用的编程语言和框架而有所不同,例如在Go中可以通过r.Header.Get(“Origin”)来获取”Origin”字段的值。由于”Origin”字段是由客户端提供的,服务器端在处理请求时,需要进行验证和安全性检查,以防止伪造或恶意的请求。

然而,有些情况下,请求可能不会携带”Origin”字段。例如,非浏览器环境下的请求(如服务器间的请求、命令行工具等)可能不会包含”Origin”字段。此外,某些旧版本的浏览器可能也不会发送”Origin”字段。

在这种情况下,我们就需要通过其他方式来确定请求的来源。例如,服务端可以查看请求头中的Referer字段来获取请求的来源。Referer字段指示了请求的来源页面的URL。通过检查Referer字段,服务端可以判断请求是否来自不同的域。此外,服务器端还可以检查请求头中的Host字段,该字段指示了请求的目标主机。如果请求的目标主机与服务端所在的主机不一致,那么可以判断请求是跨域的。

不过,需要注意的是,服务端的这些方法都依赖于请求头中的信息,而请求头可以被客户端伪造或修改。因此,为了更可靠地判断请求是否跨域,服务端应该综合考虑多个因素,并进行适当的验证和安全措施。

下面我们看一个可以复现跨域问题的示例。

1.4 复现跨域问题的Go代码示例

出现跨域问题的示例的图示如下:

在这个示例中,我们有两个Web应用:server1.com:8081和server2.com:8082。根据前面对Origin的理解,这两个Web应用显然不是同源的。

server1.com和server2.com对应的Go代码分别如下:

// cross-origin-examples/reproduce/server1.com

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "text/html; charset=utf-8")

        html := `
            <!DOCTYPE html>
            <html>
            <head>
                <title>Cross-Origin Example</title>
                <script>
                    function makeCrossOriginRequest() {
                        var xhr = new XMLHttpRequest();
                        xhr.open("GET", "http://server2.com:8082/api/data", true);
                        xhr.onreadystatechange = function() {
                            if (xhr.readyState === 4 && xhr.status === 200) {
                                console.log(xhr.responseText);
                            }
                        };
                        xhr.send();
                    }
                </script>
            </head>
            <body>
                <h1>Cross-Origin Example</h1>
                <button onclick="makeCrossOriginRequest()">Make Cross-Origin Request</button>
            </body>
            </html>
        `

        fmt.Fprintf(w, html)
    })

    err := http.ListenAndServe("server1.com:8081", nil)
    if err != nil {
        panic(err)
    }
}

// cross-origin-examples/reproduce/server2.com

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
        fmt.Printf("recv request: %#v\n", *r)
        w.Write([]byte("Welcome to api/data"))
    })

    http.ListenAndServe("server2.com:8082", nil)
}

注:在编译启动上面两个程序之前,需要在/etc/hosts中将server1.com和server2.com的地址指为127.0.0.1。

从示意图来看,用户使用浏览器与两个Web应用的交互过程是这样的:

首先,用户通过浏览器访问了server1.com:8081的主页,并收到server1.com:8081返回的应答包体。该应答包体是一个html页面,如下图:

接下来,用户点击“Make Cross-Origin Request”按钮,页面内通过ajax向server2.com:8082/api/data发起GET请求。

最后,我们在(Edge/Chrome)浏览器的控制台上将看到下面错误:

通过下面server2.com的日志,我们看到ajax请求已经发到server2.com并被正确处理:

recv request: http.Request{Method:"GET", URL:(*url.URL)(0xc00010a480), Proto:"HTTP/1.1", ProtoMajor:1, ProtoMinor:1, Header:http.Header{"Accept":[]string{"*/*"}, "Accept-Encoding":[]string{"gzip, deflate"}, "Accept-Language":[]string{"zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6"}, "Connection":[]string{"keep-alive"}, "Origin":[]string{"http://server1.com:8081"}, "Referer":[]string{"http://server1.com:8081/"}, "User-Agent":[]string{"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36 Edg/116.0.1938.81"}}, Body:http.noBody{}, GetBody:(func() (io.ReadCloser, error))(nil), ContentLength:0, TransferEncoding:[]string(nil), Close:false, Host:"server2.com:8082", Form:url.Values(nil), PostForm:url.Values(nil), MultipartForm:(*multipart.Form)(nil), Trailer:http.Header(nil), RemoteAddr:"127.0.0.1:49773", RequestURI:"/api/data", TLS:(*tls.ConnectionState)(nil), Cancel:(<-chan struct {})(nil), Response:(*http.Response)(nil), ctx:(*context.cancelCtx)(0xc000106320)}

server2.com在服务端并没有主动判断是否是同源请求,但即使服务器没有进行跨域校验并返回成功的响应和数据,浏览器也会拦截脚本读取跨域响应数据的尝试,这是由浏览器的同源策略所决定的。这也是我们看到上面截图中报错的原因。

那么解决跨域问题有哪些主流的解决方法呢?我们继续看一下。

2. 跨域问题的主流解决方法

为了解决跨域问题,有下面几种常见的解决方法:

  • JSONP(JSON with Padding)

通过动态创建\<script>标签来加载跨域的JavaScript脚本,进而实现跨域数据获取。

  • CORS(跨域资源共享, CORS是Cross-Origin Resource Sharing)

通过在服务器响应头中设置CORS访问策略以允许指定的Origin访问资源。

  • 代理服务器

在同域下创建一个代理服务器,将跨域请求转发到目标服务器并返回结果。代理服务器对响应头统一增加Access-Control-Allow-Origin等CORS相关字段,表示允许跨域访问。

其中CORS是解决跨域问题时应用最为广泛的方法。CORS(跨域资源共享)主要是通过设置HTTP头来解决跨域问题的。

服务器端通过在响应(Response)的HTTP头中设置Access-Control-Allow-Origin头来设置允许的请求来源域(Origin: 三元组)。

如果设置为“*”,则表示允许任意域发起跨域请求:

Access-Control-Allow-Origin: *

也可以在响应中将Access-Control-Allow-Origin设置为只允许指定的Origin访问资源,比如:

Access-Control-Allow-Origin: http://server1.com:8081

Access-Control-Allow-Origin头的值还支持设置多个origin,多个origin用逗号分隔:

Access-Control-Allow-Origin: http://server1.com:8081,https://server2.com:8082

注:关于Access-Control-Allow-Origin的值是否要带上protocol和port的问题,我实测的情况是必须带。前面说过:Origin是三元组,只有完全相同才算是同源。

此外,域名必须具体到二级域名才能匹配成功。顶级域名如“.com”、“.org”是不允许的。

服务端响应的跨域设置还不仅Access-Control-Allow-Origin一个,我们还可以设置Access-Control-Allow-Methods、Access-Control-Allow-Headers、Access-Control-Max-Age等字段来更细粒度的进行跨域访问控制。

注:有些值Access-Control-XXX-xxx字段仅用于Preflight Request(预检请求),比如:Access-Control-Allow-Methods。CORS Preflight Request是一种CORS请求,它使用特定的方法和Header检查CORS协议是否被理解和服务器是否被感知。它是一个OPTIONS请求,使用两个或三个HTTP请求头: Access-Control-Request-Method(访问控制请求方法)、Origin(起源)和可选的 Access-Control-Request-Headers(访问控制请求头)。

3. 使用CORS解决跨域问题的示例

下面我们修改一下server2.com的代码来解决前面遇到的跨域问题:

// cross-origin-examples/solve/server2.com/main.go

func main() {
    http.HandleFunc("/api/data", func(w http.ResponseWriter, r *http.Request) {
        fmt.Printf("recv request: %#v\n", *r)
        w.Header().Set("Access-Control-Allow-Origin", "http://server1.com:8081")
        w.Write([]byte("Welcome to api/data"))
    })

    http.ListenAndServe("server2.com:8082", nil)
}

我们仅在server2.com/main.go中增加了一行代码,旨在允许来自http://server1.com:8081的跨域请求访问server2.com的资源:

w.Header().Set("Access-Control-Allow-Origin", "http://server1.com:8081")

启动新版server2.com后,再点击页面上的“Make Cross-Origin Request”按钮,我们在浏览器的控制台上就能看到应答成功被接受并显示。

4. 小结

本文介绍了日常Web应用开发过程中经常遇到的跨域问题,探讨了“域(Origin)”概念以及跨域问题的真实原因:即浏览器的同源策略限制了不同源请求资源的访问。

接下来通过Go代码示例演示了跨域问题的表现形式,并介绍了几种主要的跨域解决方案,最后对最常见的CORS解决方案做了细致说明,并用实例展示了服务端设置CORS头后跨域问题的解决。

希望本文可以帮助大家更深入的理解和掌握Web应用跨域问题以及解决方法。

本文涉及的源码可以在这里下载。

5. 参考资料


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

关系代数、SQL语句和Go语言示例

本文永久链接 – https://tonybai.com/2023/11/15/relational-algebra-and-sql-with-go-examples

近些年,数据库领域发展日新月异,除传统的关系型数据库外,还出现了许多新型的数据库,比如:以HBase、Cassandra、MongoDB为代表的NoSQL数据库,以InfluxDB、TDEngine为代表的时序数据库,以Neo4J、Dgraph为代表的图数据库,以Redis、Memcached等为代表的内存数据库,以Milvus为代表的向量数据库,以CockroachDB、TiDB为代表的HTAP融合数据库以及云原生数据库等。各类型数据库都有自己的优势,开发者可以根据应用场景选择最合适的数据库。

不过,关系型数据库依旧是当今最流行的数据库管理系统,广泛应用于企业应用,也是大多数数应用开发人员日常接触最多的一种数据库类型。关系型数据库通过关系模型和关系代数的理论基础,实现了对关系数据的高效组织和操作。但许多开发人员在使用SQL进行数据库开发时,往往感到关系代数晦涩难懂,对SQL语句的语义理解不透彻,这给数据库应用开发带来了困难。

在这篇文章中,我们就来研究一下关系模型和关系代数,探究其与SQL语句的对应关系,并用Go语言代码示例实现相关查询,期望能帮助读者增进对关系数据库的理解,减轻数据库开发痛点,提高数据库应用能力。

1. 关系模型(Relational Model)

20世纪70年代,IBM研究员E.F. Codd在“A Relational Model of Data for Large Shared Data Banks”这篇论文中提出了关系模型的概念。随后,E.F.Codd又陆续发表了多篇文章,用数学理论奠定了关系数据库的基础,为关系数据库建立了一个数据模型 —— 关系数据模型

关系模型基于谓词逻辑和集合论,有严格的数学基础,提供了高级别的数据抽象层次,并不规定数据存取的具体过程,而是交由DBMS(数据库管理系统)自己实现。

关系模型之所以成为DBMS领域的主流模型,正是由于其非常简单(相较于更早的网络模型(network model)和层次模型(hierarchical model)),下面是关系模型中定义的一些概念:

  • 关系(Relation)

E.F.Codd的论文对关系(Relation)的定义是这样的:“这里的关系是指公认的数学意义上的关系。给定集合S1, S2, … ,Sn(不一定互不相关),如果 R是由n元组(n-tuples)组成的集合,其中每个元组的第一个元素来自S1,第二个元素来自S2,以此类推,那么R就是这n个集合(S1~Sn)上的一个关系”。

不用你说,我也知道这段文字太过抽象!下面我尽力用一个图来呈现一下Relation的含义:

我们看到,关系(Relation)是一个集合,实质上是一个“二维表格结构”,把上图中不属于R中的元组去掉,看起来可能更清晰一些:

这个结构中的每一行就是1个n元组(n-tuples),列则是S1到Sn,一共n个列。n元组中的数据依次分别来自S1、S2、…Sn。

  • 元组(Tuple)

关系(Relation)这个“二维表格结构”中的每一个n元组,即每一行,被称作元组(Tuple)。

  • 属性(Attribute)

关系(Relation)这个“二维表格结构”中的每一列(Sn)被称作一个属性(Attribute)。

  • 域(Domain)

属性可能取值的范围被称为该属性的域,以图中属性S3为例,S3-e1、S3-e2一直到S3-ek都在该属性的域中,显然{S3-e1, S3-e2, …, S3-ek}这个集合是属性S3的域的一个子集。有个特殊的值null是所有域的一个成员,它一般表示值为”unknown”。

论文在定义关系模型时,还定义了一些模型的额外特征,比如:

  • 元组的顺序是不重要的;
  • 所有的元组(行)是不同的;
  • … …

有了关系模型的定义,接下来就可以在模型基础上定义以关系操作对象的运算了,这种运算的集合就构成了关系代数

2. 关系代数(Relational Algebra)

关系代数由一系列操作组成,这些操作将一个或两个关系作为输入,并产生一个新的关系作为结果。概括来说就是关系代数的运算通过输入有限数量的关系进行运算,运算结果仍为关系。

关系代数定义了一些基本关系运算和扩展关系运算,其中基本关系运算包括:

  • 选择(Selection)
  • 投影(Projection)
  • 笛卡儿积(Cartesian Product)
  • 连接(Join)
  • 除(Division)
  • 关系并(Union)
  • 关系差(Difference)

扩展运算包括:

  • 关系交(Intersection)
  • 重命名(Rename)
  • … …

注:关于关系代数的基本关系运算与扩展关系运算的定义在不同书籍里或资料里有所不同。比如在《数据库查询优化器的艺术》一书中,作者认为:关系代数(Relational Algebra)是在集合代数基础上发展起来的,其数据的操作可分为传统的集合运算和专门的关系运算两类。传统的集合运算包括并(Union)、差(Difference)、交(Intersection)和笛卡儿积(Cartesion Product),专门的关系运算包括选择(Select)、投影(Project)、连接(Join)和除(Division)。关系代数中五个基本的操作并(Union)、差(Difference)、笛卡儿积(Cartesion Product)、选择(Select)和投影(Project)组成了关系代数完备的操作集。

关系代数中的一些操作(如选择、投影和重命名操作)被称为一元操作(unary operation),因为它们只对一个关系进行操作。其他操作,如关系并、笛卡尔积和关系差,则是对一对关系进行操作,因此称为二元操作(binary operation):

到这里,我们知道了关系模型的概念定义以及基于关系的代数运算都有哪些。那么关系模型、代数运算与我们日常的关系数据库以及我们使用的SQL语句的对应关系是什么呢?接下来我们就逐一说明一下。

3. 关系模型与关系数据库实现的对应关系

讲到这里,其实大家心里或多或少都有个数了,关系模型与关系数据库实现中概念的对应关系十分明显:

  • 关系型数据库中的表(table)对应关系模型中的关系(relation);
  • 关系型数据库中的表的记录行(row)对应关系模型中的元组(triple);
  • 关系型数据库中的表的列(column)对应关系模型中的属性(attribute);
  • 关系型数据库中的表的列数据类型(column type)对应关系模型中的属性的域(domain)。

当然关系型数据库与关系模型还有一些对应关系不是本文重点,比如:

  • 关系模型中的关系完整性约束(如实体完整性、参照完整性等)对应于关系数据库中的约束(如主键约束、外键约束等)。
  • 关系模型中的范式理论(如第一范式、第二范式等)对应于关系数据库中的数据规范化过程。

我们下面要关注的一个最重要的对应就是关系模型中的关系代数运算对应于关系数据库中的查询操作,我们可以使用SQL语句来实现关系模型中的运算,这也是下面我们要重点说明的内容,通过了解SQL语句背后实现的关系代数运算的本质,将可以帮助我们更好地理解关系模型,对后续数据库设计以及数据操作的高效性都大有裨益。

4. 关系代数与SQL的对应关系

终于来到最重要的内容了,其实就是通过SQL如何实现关系代数的操作,这也是作为应用开发人员最最关心的内容。

4.1 预先定义的关系

为了便于后续的说明,这里我们预先定义一些关系(表),它们将用在后续说明各个关系运算符的示例中,这些表见下图:

这里包含一个学生表(Students)、一个课程清单表(Courses)以及两年年度的选课表:CourseSelection2022和CourseSelection2023(注:这里不讨论表设计的合理性)。

文中使用sqlite做为数据库管理系统(DBMS)的代表,主要是为了简单,SQL标准的兼容性也不错。下面的Go代码用于创建上图中的表并插入样例数据:

// relational-algebra-examples/create_database/main.go

package main

import (
    "database/sql"
    "fmt"

    _ "modernc.org/sqlite"
)

func createTable(db *sql.DB, sqlStmt string) error {
    stmt, err := db.Prepare(sqlStmt)
    if err != nil {
        fmt.Println("prepare statement error:", err)
        return err
    }

    _, err = stmt.Exec()
    if err != nil {
        fmt.Println("exec prepared statement error:", err)
        return err
    }

    return nil
}

func createTables(db *sql.DB) error {
    // 创建Students表
    err := createTable(db, `CREATE TABLE IF NOT EXISTS Students (
    Sno INTEGER PRIMARY KEY,
    Sname TEXT,
    Gender TEXT,
    Age INTEGER
  )`)
    if err != nil {
        fmt.Println("create table Students error:", err)
        return err
    }

    // 创建Courses表
    err = createTable(db, `CREATE TABLE IF NOT EXISTS Courses (
    Cno INTEGER PRIMARY KEY,
    Cname TEXT,
    Credit INTEGER
  )`)
    if err != nil {
        fmt.Println("create table Courses error:", err)
        return err
    }

    // 2022选课表
    err = createTable(db, `CREATE TABLE CourseSelection2022 (
  Sno INTEGER,
  Cno INTEGER,
  Score INTEGER,

  PRIMARY KEY (Sno, Cno),
  FOREIGN KEY (Sno) REFERENCES Students(Sno),
  FOREIGN KEY (Cno) REFERENCES Courses(Cno)
)`)
    if err != nil {
        fmt.Println("create table CourseSelection2022 error:", err)
        return err
    }

    // 2023选课表
    err = createTable(db, `CREATE TABLE CourseSelection2023 (
  Sno INTEGER,
  Cno INTEGER,
  Score INTEGER,

  PRIMARY KEY (Sno, Cno),
  FOREIGN KEY (Sno) REFERENCES Students(Sno),
  FOREIGN KEY (Cno) REFERENCES Courses(Cno)
)`)

    if err != nil {
        fmt.Println("create table CourseSelection2023 error:", err)
        return err
    }
    return nil
}

func checkErr(err error) {
    if err != nil {
        panic(err)
    }
}

func insertData(db *sql.DB) {
    // 向Students表插入数据
    stmt, err := db.Prepare("INSERT INTO Students VALUES (?, ?, ?, ?)")
    checkErr(err)

    _, err = stmt.Exec(1001, "张三", "M", 20)
    checkErr(err)
    _, err = stmt.Exec(1002, "李四", "F", 18)
    checkErr(err)
    _, err = stmt.Exec(1003, "王五", "M", 19)
    checkErr(err)

    // 向Courses表插入数据
    stmt, err = db.Prepare("INSERT INTO Courses VALUES (?, ?, ?)")
    checkErr(err)

    _, err = stmt.Exec(1, "数据库", 4)
    checkErr(err)
    _, err = stmt.Exec(2, "数学", 2)
    checkErr(err)
    _, err = stmt.Exec(3, "英语", 3)
    checkErr(err)

    // 插入2022选课数据
    stmt, _ = db.Prepare("INSERT INTO CourseSelection2022 VALUES (?, ?, ?)")
    _, err = stmt.Exec(1001, 1, 85)
    checkErr(err)
    _, err = stmt.Exec(1001, 2, 80)
    checkErr(err)
    _, err = stmt.Exec(1002, 1, 83)
    checkErr(err)
    _, err = stmt.Exec(1003, 1, 76)
    checkErr(err)
    // ...

    // 插入2023选课数据
    stmt, _ = db.Prepare("INSERT INTO CourseSelection2023 VALUES (?, ?, ?)")
    stmt.Exec(1001, 3, 75)
    checkErr(err)
    stmt.Exec(1002, 2, 81)
    checkErr(err)
    stmt.Exec(1003, 3, 86)
    checkErr(err)
}

func main() {
    db, err := sql.Open("sqlite", "../test.db")
    defer db.Close()
    if err != nil {
        fmt.Println("open test.db error:", err)
        return
    }

    err = createTables(db)
    if err != nil {
        fmt.Println("create table error:", err)
        return
    }

    insertData(db)
}

这里我们使用了cznic大神实现并开源的modernc.org/sqlite,这是一个纯Go的sqlite3数据库driver。Go社区另一个广泛使用的sqlite3的driver库为go-sqlite3,只不过go-sqlite3是使用cgo对sqlite3 C库的封装。

执行上面go代码,便可以建立一个名为test.db的sqlite数据库,我们通过sqlite官方的命令行工具(cli)也可以与该数据库文件交互(这里我们使用的是容器版cli),比如:

$docker pull  nouchka/sqlite3

// cd到test.db文件路径下

$docker run -v {test.db文件所在目录的绝对路径}:/root/db -it nouchka/sqlite3
SQLite version 3.40.1 2022-12-28 14:03:47
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database.
sqlite> .open ./test.db
sqlite> .databases
main: /root/db/test.db r/w
sqlite> .tables
CourseSelection2022  Courses
CourseSelection2023  Students
sqlite>

接下来,我们就先从关系代数运算中最容易理解的一元运算符开始说起。

4.2. 选择(Selection)

“选择”是一元关系运算,它的运算符为σ,语义如下:

R' = σ[p](R) = {t | t∈R ∩ p(t) = true } // 这里用[p]表示数学符号的下标

其中R为关系,t为元组,p是谓词(predicate)表达式的组合,可以由一个或多个谓词表达式构成。

这个语义相对好理解一些:它对R的操作结果依然是关系R’,即一个新元组集合,这个元组集合中的元组来自R,但必须满足p(t) = true的条件。说直白一些,就是选择满足给定条件的元组。下面是一个“选择”操作的示意图:

我们可以用下面最常见的SQL语句实现对单一关系(表)的选择运算:

SELECT * FROM R WHERE p(t) = true;

对应Go示例的代码片段如下:

// relational-algebra-examples/query/main.go

func doSelection(db *sql.DB) {
    rows, _ := db.Query("SELECT * FROM CourseSelection2022 where score >= 80") // p(t)为score >= 80
    var selections []CourseSelection
    for rows.Next() {
        var s CourseSelection
        rows.Scan(&s.Sno, &s.Cno, &s.Score)
        selections = append(selections, s)
    }
    fmt.Println(selections)
}

输出结果为:

[{1001 1 85} {1001 2 80} {1002 1 83}]

4.3 投影(Projection)

“投影”也是一元关系运算,它的运算符为∏,语义如下:

R' = ∏[A1,A2,...,An](R) = {t[A1,A2,...,An]| t∈R } // 这里A1,A2,...,An表示从R中取出的列名

显然和“选择”通过谓词表达式选元组不同,“投影”选择一个关系中的指定列(A1,A2,…,An),即选择需要的属性。下面是其运算过程的示意图:

“投影”对应的SQL语句也是我们最熟悉的语句:

SELECT A1, A2, ..., An FROM R;

对应Go示例的代码片段如下:

// relational-algebra-examples/query/main.go

func doProjection(db *sql.DB) {
    rows, _ := db.Query("SELECT Sno, Sname FROM Students") // A1 = Sno, A2 = Sname
    var students []Student
    for rows.Next() {
        var s Student
        rows.Scan(&s.Sno, &s.Sname)
        students = append(students, s)
    }
    fmt.Println(students)
}

输出结果为:

[{1001 张三  0} {1002 李四  0} {1003 王五  0}]

不过要注意的是:取消某些关系列后可能出现重复行,违反了关系的定义(关系是一个元组的集合),因此必须检查并去除结果关系中重复的元组。

4.4 运算符的组合(Composition)

关系运算的输入是关系,结果也是一个关系,因此我们可以将关系运算符组合成一个更复杂的关系运算符表达式来实现更复杂的运算。比如将上面的两个一元关系运算符组合在一起“先选元组,再选属性”:

R' = ∏[A1,A2,...,An](σ[p](R))

其运算过程如下图所示:

上述运算符组合对应的SQL语句如下:

SELECT A1, A2, ..., An FROM R where p(t) = true;

对应Go示例的代码片段如下:

// relational-algebra-examples/query/main.go

func doCompositionOperation(db *sql.DB) {
    rows, _ := db.Query("SELECT Sno, Sname FROM Students where age >= 20")
    var students []Student
    for rows.Next() {
        var s Student
        rows.Scan(&s.Sno, &s.Sname)
        students = append(students, s)
    }
    fmt.Println(students)
}

输出结果为:

[{1001 张三  0}]

无论是选择运算还是投影运算,亦或是组合之后的运算,理解起来都相对容易,因为只涉及一个“关系”。接下来我们就看一下涉及两个关系的二元运算符,我们先来看看集合运算

4.5 关系交(Intersection)

如果没有记错,我们是在高中学习的集合代数。那时定义两个集合的交集运算是这样的:

对于集合A和B,其交运算(Intersction)为:

A ∩ B = { x | x ∈ A且 x ∈ B}

用一个一维空间的数的集合的例子来说,就是当A = {1, 2, 3, 4, 5},B = { 3, 5, 6, 9}时,A ∩ B = {3, 5}。我们通常用维恩图来示意集合运算:

在关系模型中,元组是一维集合,关系是元组的集合,即是一个二维集合,那么基于关系的交运算就要有一个前提:那就是参与运算的两个关系的属性必须是兼容的

两个关系的属性兼容需满足以下条件:

  • 属性数量相同

两个关系中的属性数量必须相同。

  • 属性类型相同或可转换

两个关系中对应位置的属性类型必须相同或可以通过类型转换进行兼容。例如,一个关系中的属性类型是整数,而另一个关系中的属性类型是浮点数,这种情况下属性类型是兼容的,因为整数可以隐式转换为浮点数。

  • 属性名称可以不同

两个关系中对应位置的属性名称可以不同,只要它们的属性类型兼容即可。属性名称的不同不会影响属性兼容性。

在关系模型中,两个关系的属性兼容性是判断两个关系是否可以进行某些操作(包括集合操作)的重要条件之一。

回到集合运算,如果两个关系的属性不兼容,则这两个关系无法进行集合运算,比如Students表和Courses表的属性个数不同,如果对它们进行关系交运算,会导致报错:

SELECT * FROM Students INTERSECT SELECT * FROM Courses;
Parse error: SELECTs to the left and right of INTERSECT do not have the same number of result columns

介绍完集合运算的前提后,我们再来看关系交运算,其语义入下:

R' = R1 ∩ R2

即两个关系R1和R2在属性兼容的前提下进行关系交运算的结果为返回两个关系中相同的元组。

关系交运算对应的SQL语句如下:

SELECT * FROM R1 INTERSECT SELECT * FROM R2;

对应Go示例的代码片段如下:

// relational-algebra-examples/query/main.go

func doIntersection(db *sql.DB) {
    rows, _ := db.Query("SELECT * FROM CourseSelection2022 INTERSECT SELECT * FROM CourseSelection2023")
    var selections []CourseSelection
    for rows.Next() {
        var s CourseSelection
        rows.Scan(&s.Sno, &s.Cno, &s.Score)
        selections = append(selections, s)
    }
    fmt.Println(selections)
}

由于CourseSelection2022和CourseSelection2023这两个关系没有相同元组,所以上述Go程序输出的结果为空。

4.6 关系并(Union)

和关系交一样,两个关系进行关系并运算的前提也是属性兼容。关系并运算的语义如下:

R' = R1 ∪ R2

即两个关系R1和R2在属性兼容的前提下进行关系并运算的结果为返回两个关系中的所有元组,但要去除重复元组。

关系并对应的SQL语句如下:

SELECT * FROM R1 UNION SELECT * FROM R2;

对应Go示例的代码片段如下:

// relational-algebra-examples/query/main.go

func doUnion(db *sql.DB) {
    rows, _ := db.Query("SELECT * FROM CourseSelection2022 UNION SELECT * FROM CourseSelection2023")
    var selections []CourseSelection
    for rows.Next() {
        var s CourseSelection
        rows.Scan(&s.Sno, &s.Cno, &s.Score)
        selections = append(selections, s)
    }
    fmt.Println(selections)
}

CourseSelection2022和CourseSelection2023这两个关系没有重复元组,所有关系并运算后得到的结果关系中包含了这两个关系的全部元组,上述程序的输出结果为:

[{1001 1 85} {1001 2 80} {1001 3 75} {1002 1 83} {1002 2 81} {1003 1 76} {1003 3 86}]

4.7 关系差(Difference)

在集合代数中,对于集合A和B,其差运算为:

A - B = { x | x ∈ A且 x ∉ B}

即从A集合中排除掉B集合中的元素。

在关系模型中,关系差运算即是从一个关系中排除另一个关系中的元组,其语义如下:

R' = R1-R2={t|t∈R1 ∩ t∉R2} // t为关系中的元组

在SQL中,我们可以用NOT IN实现:

SELECT * FROM R1 WHERE A1 NOT IN (SELECT A1 FROM R2 WHERE 条件)

下面是对应的Go语言代码片段:

// relational-algebra-examples/query/main.go

func doDifference(db *sql.DB) {
    rows, _ := db.Query("SELECT * FROM CourseSelection2022 WHERE Cno NOT IN (SELECT Cno FROM CourseSelection2023)")
    var selections []CourseSelection
    for rows.Next() {
        var s CourseSelection
        rows.Scan(&s.Sno, &s.Cno, &s.Score)
        selections = append(selections, s)
    }
    fmt.Println(selections)
}

这段示例的含义是选出CourseSelection2022的元组,但去掉Cno值在CourseSelection2023出现过的元组。下面是运行结果:

[{1001 1 85} {1002 1 83} {1003 1 76}]

注意:关系差运算的前提也是两个关系的属性兼容。

最后看看略复杂的二元运算符:笛卡尔积和连接。

4.8 笛卡尔积(Cartesian-product)

在关系代数中,关系积,即笛卡尔积(Cartesian Product)这种运算(也被称为关系叉乘)用于取两个关系的所有可能的组合。它的数学语义可以描述为:给定关系R1和R2,它们的笛卡尔积结果是一个新的关系,其中的元组由R1中的每个元组与R2中的每个元组的组合构成。

在SQL中,笛卡尔积可以通过使用CROSS JOIN关键字来实现:

SELECT * FROM R1 CROSS JOIN R2;

也可以通过下面SQL语句来实现:

SELECT R1.*, R1.* FROM R1, R2;

对应的Go代码片段如下:

// relational-algebra-examples/query/main.go

// StudentCourse结果
type StudentCourse struct {
    Sno    int
    Sname  string
    Gender string
    Age    int
    Cno    int
    Cname  string
    Credit int
}

func doCartesianProduct(db *sql.DB) {
    rows, _ := db.Query("SELECT * FROM Students CROSS JOIN Courses")
    // rows, _ := db.Query("SELECT Students.*, Courses.* FROM Students, Courses")
    var selections []StudentCourse
    for rows.Next() {
        var s StudentCourse
        rows.Scan(&s.Sno, &s.Sname, &s.Gender, &s.Age, &s.Cno, &s.Cname, &s.Credit)
        selections = append(selections, s)
    }
    fmt.Println(len(selections))
    fmt.Println(selections)
}

示例的运行结果如下:

9
[{1001 张三 M 20 1 数据库 4} {1001 张三 M 20 2 数学 2} {1001 张三 M 20 3 英语 3} {1002 李四 F 18 1 数据库 4} {1002 李四 F 18 2 数学 2} {1002 李四 F 18 3 英语 3} {1003 王五 M 19 1 数据库 4} {1003 王五 M 19 2 数学 2} {1003 王五 M 19 3 英语 3}]

我们看到对Students和Courses两个关系(表)进行笛卡尔积运算后,结果包含了Students中的每个元组与Courses中的每个元组进行组合的结果(3×3=9个)。

需要注意的是,由于笛卡尔积可能导致非常大的结果集,因此在实际使用中应谨慎使用,并且通常需要与其他运算符和条件结合使用,以限制结果的大小和提高查询效率。通常我们会用连接来达到这些目的。

4.9 连接(Join)

连接(Join)运算(⋈)是从两个关系的笛卡儿积中选取属性间满足一定条件的元组形成一个新的关系,即将笛卡尔积和选择(selection)运算合并达到一个操作中。从这个角度来看,笛卡尔积可以视为一种无条件的连接

连接代数运算符是关系代数中很有用的关系代数运算符,也是日常经常使用的运算符,它有很多种不同的子类别,下面我们分别看看各种子类型的语义、SQL语句以及对应的Go代码示例。

4.9.1 等值连接(Equijoin)

等值连接是通过比较两个关系(表)之间的属性值是否相等来进行连接的操作。连接条件使用等号(=)来比较属性值的相等性。

我们直接看Go示例:

// relational-algebra-examples/query/main.go

func dumpOperationResult(operation string, rows *sql.Rows) {
    cols, _ := rows.Columns()

    w := tabwriter.NewWriter(os.Stdout, 0, 2, 1, ' ', 0)
    defer w.Flush()
    w.Write([]byte(strings.Join(cols, "\t")))
    w.Write([]byte("\n"))

    row := make([][]byte, len(cols))
    rowPtr := make([]any, len(cols))
    for i := range row {
        rowPtr[i] = &row[i]
    }

    fmt.Printf("\n%s operation:\n", operation)
    for rows.Next() {
        rows.Scan(rowPtr...)
        w.Write(bytes.Join(row, []byte("\t")))
        w.Write([]byte("\n"))
    }
}

func doEquijoin(db *sql.DB) {
    rows, _ := db.Query("SELECT * FROM CourseSelection2022 JOIN Students ON CourseSelection2022.Sno = Students.Sno")
    dumpOperationResult("Equijoin", rows)
}

这个示例使用等值连接将CourseSelection2022表和Students表连接起来,连接条件是CourseSelection2022.Sno = Students.Sno,即学生编号相等,返回的结果将包含CourseSelection2022和Students两个表中满足连接条件的元组。

我们看看程序运行的输出结果:

Equijoin operation:
Sno  Cno Score Sno  Sname Gender Age
1001 1   85    1001 张三    M      20
1001 2   80    1001 张三    M      20
1002 1   83    1002 李四    F      18
1003 1   76    1003 王五    M      19

在这个结果中,我们看到一个“奇怪”的情况,那就是出现了两个Sno属性。在等值连接中,如果连接的两个表中存在相同名称的属性(例如这里两个表中都有名为”Sno”的属性),那么在连接结果中会出现两个相同名称的属性。

这是因为等值连接会将两个表中具有相同连接条件的属性进行匹配,并将匹配成功的元组进行组合。由于两个表中都有名为”Sno”的属性,因此连接结果中会保留这两个属性,以显示连接操作前后的对应关系。

为了区分来自不同表的相同属性名,通常在连接结果中会使用表别名或表名作为前缀,以区分它们的来源。这样可以确保结果中的属性名称是唯一的,避免歧义。 例如,如果在等值连接中连接了名为”CourseSelection2022″的表和名为”Students”的表,并且两个表中都有名为”Sno”的属性,那么连接结果中可能会出现类似于”CourseSelection2022.Sno”和”Students.Sno”的属性名称,以明确它们的来源。

需要注意的是,数据库管理系统的具体实现和查询工具的设置可能会影响连接结果中属性的显示方式,但通常会采用类似的方式来区分相同属性名的来源。

4.9.2 自然连接(Natural Join)

自然连接是基于两个表中具有相同属性名的属性进行连接的操作,重点在于它会自动匹配具有相同属性名的属性,并根据这些属性的相等性进行连接,而无需手工指定

我们来看自然连接的Go示例:

// relational-algebra-examples/query/main.go

func doNaturaljoin(db *sql.DB) {
    rows, _ := db.Query("SELECT * FROM CourseSelection2022 NATURAL JOIN Students")
    dumpOperationResult("Naturaljoin", rows)
}

这个示例使用自然连接将CourseSelection2022表和Students表连接起来,自然连接会自动基于两个表中所有具有相同属性名的属性进行连接,返回的结果将包含CourseSelection2022和Students两个表中所有满足连接条件的元组,并自动消除重复属性,这是与等值连接的一个明显的区别。

我们看看程序运行的输出结果:

Naturaljoin operation:
Sno  Cno Score Sname Gender Age
1001 1   85    张三    M      20
1001 2   80    张三    M      20
1002 1   83    李四    F      18
1003 1   76    王五    M      19

如果两个表(比如R1和R2)有一个以上的属性名相同,比如2个(比如:A1和A2),那就会自动针对这两个属性名(一起)在两个表中进行等值连接:只有R2.A1 = R1.A1且R2.A2 = R1.A2时,才将元组连接并放入结果关系中。

4.9.3 θ连接(Theta Join)

θ连接是一种通用的连接操作,它使用比等号更一般化的连接条件进行连接。连接条件可以使用除了等号之外的比较运算符(如大于、小于、不等于等)来比较两个表之间的属性。

我们来看θ连接的Go示例:

// relational-algebra-examples/query/main.go

func doThetajoin(db *sql.DB) {
    rows, _ := db.Query(`SELECT *
FROM CourseSelection2022
JOIN Students ON CourseSelection2022.Sno > Students.Sno`)
    dumpOperationResult("Thetajoin", rows)
}

这个示例使用Join将CourseSelection2022表和Students表连接起来,连接条件是CourseSelection2022.Sno > Students.Sno,即学生编号大于学生表中的学生编号,返回的结果将包含CourseSelection2022和`Students两个表中满足连接条件的元组。

Thetajoin operation:
Sno  Cno Score Sno  Sname Gender Age
1002 1   83    1001 张三    M      20
1003 1   76    1001 张三    M      20
1003 1   76    1002 李四    F      18

这个结果的生成过程大致如下:

  • 先看CourseSelection2022表的第一个元组,其Sno为1001,该Sno不大于Students表中的任一个Sno;
  • 再看CourseSelection2022表的第二个元组,其Sno为1002,该Sno仅大于Students表中的Sno为1001的那一个元组,于是将CourseSelection2022表的第二个元组和Students表中第一个元组连接起来作为结果表中的第一个元组;
  • 最后看CourseSelection2022表的第三个元组,其Sno为1003,该Sno大于Students表中的Sno为1001和1002的元组,于是将CourseSelection2022表的第三个元组分别和Students表中第一个和第二个元组连接起来作为结果表中的第二个和第三个元组。

4.9.4 半连接(Semi Join)

半连接是一种特殊的连接操作,它返回满足连接条件的左侧关系中的元组,并且只返回右侧关系中与之匹配的属性。半连接通常用于判断两个关系中是否存在匹配的元组,而不需要返回右侧关系的详细信息。

我们来看半连接的Go示例:

// relational-algebra-examples/query/main.go

func doSemijoin(db *sql.DB) {
    rows, _ := db.Query(`SELECT *
FROM Students
WHERE EXISTS (
    SELECT *
    FROM CourseSelection2022
    WHERE Students.Sno = CourseSelection2022.Sno
)`)
    dumpOperationResult("Semijoin", rows)
}

这个示例使用半连接操作,以Students表为左侧关系,CourseSelection2022表为右侧关系。它使用子查询来判断左侧关系中是否存在满足连接条件的元组,即Students.Sno = CourseSelection2022.Sno。它返回的结果将只包含满足连接条件的Students表中的元组。

下面是程序输出的结果:

Semijoin operation:
Sno  Sname Gender Age
1001 张三    M      20
1002 李四    F      18
1003 王五    M      19

半连接返回的结果关系中只包含左关系中的行,其中每一行只返回一次,即使在右关系中有多个匹配项。

4.9.5 反连接(Anti Join)

反连接是半连接的补集操作,它返回左侧关系中不存在满足连接条件的元组。反连接通常用于查找在左侧关系中存在而在右侧关系中不存在的元组。

我们来看反连接的Go示例:

// relational-algebra-examples/query/main.go

func doAntijoin(db *sql.DB) {
    rows, _ := db.Query(`SELECT *
FROM Students
WHERE NOT EXISTS (
    SELECT *
    FROM CourseSelection2022
    WHERE Students.Sno = CourseSelection2022.Sno
)`)
    dumpOperationResult("Antijoin", rows)
}

这个示例使用反连接操作,以Students表为左侧关系,CourseSelection2022表为右侧关系,并使用NOT EXISTS子查询来判断左侧关系中不存在满足连接条件的元组,即Students.Sno = CourseSelection2022.Sno。返回的结果将只包含左侧关系Students表中不存在连接条件的元组。

Antijoin operation:
Sno Sname Gender Age

我们看到输出的元组集合为空。

4.9.6 左(外)连接(Left Outer Join)

左外连接是将左侧关系中的所有元组与满足连接条件的右侧关系中的元组进行连接,并返回所有左侧关系的元组。如果右侧关系中没有与左侧关系匹配的元组,对应的属性值将为NULL。

我们来看左(外)连接的Go示例:

// relational-algebra-examples/query/main.go

func doLeftjoin(db *sql.DB) {
    rows, _ := db.Query(`SELECT *
FROM Students
LEFT JOIN CourseSelection2022 ON Students.Sno = CourseSelection2022.Sno`)
    dumpOperationResult("Leftjoin", rows)
}

这个示例使用左外连接将Students表和CourseSelection2022表连接起来,其连接条件是Students.Sno = CourseSelection2022.Sno,即学生编号相等。示例的返回结果将包含Students表中的所有元组,并将满足连接条件的CourseSelection2022表中的元组加入结果中。如果没有匹配的元组,右侧关系中的属性值将为NULL。
`
下面是程序输出的结果:

Leftjoin operation:
Sno  Sname Gender Age Sno  Cno Score
1001 张三    M      20  1001 1   85
1001 张三    M      20  1001 2   80
1002 李四    F      18  1002 1   83
1003 王五    M      19  1003 1   76

4.9.7 右(外)连接(Right Outer Join)

右外连接是将右侧关系中的所有元组与满足连接条件的左侧关系中的元组进行连接,并返回所有右侧关系的元组。如果左侧关系中没有与右侧关系匹配的元组,对应的属性值将为NULL。

我们来看右(外)连接的Go示例:

// relational-algebra-examples/query/main.go

func doRightjoin(db *sql.DB) {
    rows, _ := db.Query(`SELECT *
FROM Students
RIGHT JOIN CourseSelection2022 ON Students.Sno = CourseSelection2022.Sno`)
    dumpOperationResult("Rightjoin", rows)
}

这个示例使用右外连接将Students表和CourseSelection2022表连接起来,它的连接条件是Students.Sno = CourseSelection2022.Sno,即学生编号相等。返回的结果将包含CourseSelection2022表中的所有元组,并将满足连接条件的Students表中的元组加入结果中。如果没有匹配的元组,左侧关系中的属性值将为NULL。

下面是程序输出的结果:

Rightjoin operation:
Sno  Sname Gender Age Sno  Cno Score
1001 张三    M      20  1001 1   85
1001 张三    M      20  1001 2   80
1002 李四    F      18  1002 1   83
1003 王五    M      19  1003 1   76

4.9.8 全连接(Full Outer Join)

全连接是将左侧关系和右侧关系中的所有元组进行连接,并返回所有满足连接条件的元组。如果左侧关系或右侧关系中没有与对方匹配的元组,对应的属性值将为NULL。

我们来看全连接的Go示例:

// relational-algebra-examples/query/main.go

func doFulljoin(db *sql.DB) {
    rows, _ := db.Query(`SELECT *
FROM Students
FULL JOIN CourseSelection2022 ON Students.Sno = CourseSelection2022.Sno`)
    dumpOperationResult("Fulljoin", rows)
}

这个示例使用全连接将Students表和CourseSelection2022表连接起来,连接条件是Students.Sno = CourseSelection2022.Sno,即学生编号相等。示例返回的结果将包含Students表和CourseSelection2022表中的所有元组,并将满足连接条件的元组进行组合。如果没有匹配的元组,对应关系中的属性值将为NULL。

下面是程序输出的结果:

Fulljoin operation:
Sno  Sname Gender Age Sno  Cno Score
1001 张三    M      20  1001 1   85
1001 张三    M      20  1001 2   80
1002 李四    F      18  1002 1   83
1003 王五    M      19  1003 1   76

以上就是本文要介绍的连接类型,这些连接类型提供了在关系数据库中操作和组合表数据的灵活性,可以根据特定的需求选择合适的连接方式来获取所需的结果。

5. 小结

本文系统地介绍和讲解了关系数据库中的关系代数运算,包括选择、投影、连接、交、并、积等,以及关系代数的SQL实现,并给出了Go语言示例。

关系模型是关系数据库的理论基础,关系代数通过对关系的运算来表达查询,因此关系代数也构成了SQL查询语言的理论基础。理解关系代数与SQL的对应关系,可以更好地使用SQL语言操作关系型数据库。

本文算是关系数据库的入门文章,既能让数据库初学者快速掌握关系代数,也能让有基础的读者回顾并深入理解概念内涵。通过阅读学习,能帮助读者把关系代数运用到实际数据库应用中,解决查询优化等问题。

本文涉及的源码可以在这里下载。

注:由于环境所限,本文所有示例均是在sqlite3上进行的。

6. 参考资料


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻) – https://gopherdaily.tonybai.com

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite
  • Gopher Daily归档 – https://github.com/bigwhite/gopherdaily

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats