精华内容
下载资源
问答
  • 数据库语言
    千次阅读
    2020-12-15 14:15:50

    一、DDL(data definition language)数据定义语言:

    DDL语句不用commit

    数据定义语言DDL用来创建数据库中的各种对象-----表、视图、索引、同义词、聚簇等如:
    CREATE TABLE(表)/VIEW(视图)/INDEX(索引)/SYN(同义词)/CLUSTER(簇)

    1、创建(create):create index,create tablespace……

    2、删除(drop,truncate):truncate删除整个数据,drop删除整个表(数据+表结构)两者都不用commit,也不能回滚

    3、修改(alter):alter table,alter database,alter tablespace……

    4、查看(show,desc),show parameter(查看参数的值),desc 对象-查看对象的结构

    二、DML(data Manipulation language)数据操纵语言:

    需要commit

    1、插入(insert)

    insert into table1(field1,field2) values(value1,value2)
    

    2、更新(update)

    UPDATE table1 SET field1 = value1 WHERE field2 = value2
    

    3、删除(delete):delete只删除数据,可以回滚

    delete from table1 where 范围更新:update table1 set field1=value1 where 范围
    

    三、DCL(data control language)数据控制语言:

    数据控制语言DCL用来授予或回收访问数据库的某种特权,并控制
    数据库操纵事务发生的时间及效果,对数据库实行监视等。如:

    1、授权(grant):grant create session to scott

    2、回滚(rollback)

    3、提交(commit)

    4、新建用户(create user)

    四、DQL(data query language)数据查询语言:

    数据查询语言DQL基本结构是由SELECT子句,FROM子句,WHERE子句组成的查询块:
    SELECT <字段名表> FROM <表或视图名> WHERE <查询条件>

    选择:

    select * from table1 where 范围
    

    查找:

    select * from table1 where field1 like%value1%

    排序:

    select * from table1 order by field1,field2 desc
    

    总数:

    select count(*) as totalcount from table1
    

    求和:

    select sum(field1) as sumvalue from table1
    

    平均:

    select avg(field1) as avgvalue from table1
    

    最大:

    select max(field1) as maxvalue from table1
    

    最小:

    select min(field1) as minvalue from table1
    

    说明:几个高级查询运算

    A: UNION 运算符

    UNION 运算符通过将两个结果表(例如 TABLE1 和 TABLE2)取并集后消除所有重复行而派生出一个结果表。当 ALL 随 UNION 一起使用时(即 UNION ALL),不消除重复行。两种情况下,派生表的每一行不是来自 TABLE1 就是来自 TABLE2。

    select id from my_user where id BETWEEN 10 and 15
    union
    select id from my_user where id BETWEEN 12 and 18;
    

    结果:id 10-18

    B: EXCEPT 运算符

    EXCEPT运算符通过把在 TABLE1 中但不在 TABLE2 中的行并消除所有重复行而派生出一个结果表。当 ALL 随 EXCEPT 一起使用时 (EXCEPT ALL),不消除重复行。

    select id from my_user where id BETWEEN 10 and 15
    except
    select id from my_user where id BETWEEN 12 and 18;
    

    结果:id 10-11

    C: INTERSECT 运算符

    INTERSECT运算符通过将两个结果表 TABLE1 和 TABLE2 取交集后消除所有重复行而派生出一个结果表。当 ALL随 INTERSECT 一起使用时 (INTERSECT ALL),不消除重复行。

    select id from my_user where id BETWEEN 10 and 15
    intersect
    select id from my_user where id BETWEEN 12 and 18;
    

    结果:id 12-15

    注:使用运算词的几个查询结果列必须是一致的。

    说明:使用外连接

    A、left (outer) join:

    左外连接(左连接):结果集既包括连接表的匹配行,也包括左连接表的所有行。

    SQL:

    select a.a, a.b, a.c, b.c, b.d, b.f from a LEFT OUT JOIN b ON a.a = b.c
    

    B:right (outer) join: 右外连接(右连接):结果集既包括连接表的匹配连接行,也包括右连接表的所有行。

    C:full/cross (outer) join:全外连接:不仅包括符号连接表的匹配行,还包括两个连接表中的所有记录。

    更多相关内容
  • 编程路上必定要知道的数据库语言SPL

    万次阅读 多人点赞 2022-07-08 13:59:12
    我们知道,SQL是目前数据库的主流语言。那么,用SQL做这两件事是不是很方便呢?事务类功能主要解决数据在写入和读出时要保持的一致性,实现这件事的难度并不小,但对于应用程序的接口却非常简单,用于操纵数据库读写...

    数据库语言的目标

    要说清这个目标,先要理解数据库是做什么的。

    数据库这个软件,名字中有个“库”字,会让人觉得它主要是为了存储的。其实不然,数据库实现的重要功能有两条:计算事务!也就是我们常说的OLAP和OLTP,数据库的存储都是为这两件事服务的,单纯的存储并不是数据库的目标。

    我们知道,SQL是目前数据库的主流语言。那么,用SQL做这两件事是不是很方便呢?

    事务类功能主要解决数据在写入和读出时要保持的一致性,实现这件事的难度并不小,但对于应用程序的接口却非常简单,用于操纵数据库读写的代码也很简单。如果假定目前关系数据库的逻辑存储模式是合理的(也就是用数据表和记录来存储数据,其合理性与否是另一个复杂问题,不在这里展开了),那么SQL在描述事务类功能时没什么大问题,因为并不需要描述多复杂的动作,复杂性都在数据库内部解决了。

    但计算类功能却不一样了。

    这里说的计算是个更广泛的概念,并不只是简单的加加减减,查找、关联都可以看成是某种计算。

    什么样的计算体系才算好呢?

    还是两条:写着简单跑得快

    写着简单,很好理解,就是让程序员很快能写出来代码来,这样单位时间内可以完成更多的工作;跑得快就更容易理解,我们当然希望更短时间内获得计算结果。

    其实SQL中的Q就是查询的意思,发明它的初衷主要是为了做查询(也就是计算),这才是SQL的主要目标。然而,SQL在描述计算任务时,却很难说是很胜任的。

    SQL为什么不行

    先看写着简单的问题。

    SQL写出来很象英语,有些查询可以当英语来读和写(网上多得很,就不举例了),这应当算是满足写着简单这一条了吧。

    且慢!我们在教科书上看到的SQL经常只有两三行,这些SQL确实算是写着简单的,但如果我们尝试一些稍复杂化的问题呢?

    这是一个其实还不算很复杂的例子:计算一支股票最长连续上涨了多少天?用SQL写出来是这样的:

    select max (consecutive_day)
    from (select count(*) (consecutive_day
          from (select sum(rise_mark) over(order by trade_date) days_no_gain
                from (select trade_date,
                             case when closing_price>lag(closing_price) over(order by trade_date)
                                  then 0 else 1 END rise_mark
                      from stock_price ) )
          group by days_no_gain)
    

    这个语句的工作原理就不解释了,反正有点绕,同学们可以自己尝试一下。

    这是润乾公司的招聘考题,通过率不足20%;因为太难,后来被改成另一种方式:把SQL语句写出来让应聘者解释它在算什么,通过率依然不高。

    这说明什么?说明情况稍有复杂,SQL就变得即难懂又难写!

    再看跑得快的问题,还是一个经常拿出来的简单例子:1亿条数据中取前10名。这个任务用SQL写出来并不复杂:

    SELECT TOP 10 x FROM T ORDER BY x DESC
    

    但是,这个语句对应的执行逻辑是先对所有数据进行大排序,然后再取出前10个,后面的不要了。大家知道,排序是一个很慢的动作,会多次遍历数据,如果数据量大到内存装不下,那还需要外存做缓存,性能还会进一步急剧下降。如果严格按这句SQL体现的逻辑去执行,这个运算无论如何是跑不快的。然而,很多程序员都知道这个运算并不需要大排序,也用不着外存缓存,一次遍历用一点点内存就可以完成,也就是存在更高性能的算法。可惜的是,用SQL却写不出这样的算法,只能寄希望于数据库的优化器足够聪明,能把这句SQL转换成高性能算法执行,但情况复杂时数据库的优化器也未必靠谱。

    看样子,SQL在这两方面做得都不够好。这两个并不复杂的问题都是这样,现实中数千行的SQL代码中,这种难写且跑不快的情况比比皆是。

    为什么SQL不行呢?

    要回答这个问题,我们要分析一下用程序代码实现计算到底是在干什么。

    本质上讲,编写程序的过程,就是把解决问题的思路翻译成计算机可执行的精确化形式语言的过程。举例来说,就象小学生解应用题,分析问题想出解法之后,还要列出四则运算表达式。用程序计算也是一样,不仅要想出解决问题的方法,还要把解法翻译成计算机能理解执行的动作才算完成。

    用于描述计算方法的形式语言,其核心在于所采用的代数体系。所谓代数体系,简单说就是一些数据类型和其上的运算规则,比如小学学到的算术,就是整数和加减乘除运算。有了这套东西,我们就能把想做的运算用这个代数体系约定的符号写出来,也就是代码,然后计算机就可以执行了。

    如果这个代数体系设计时考虑不周到,提供的数据类型和运算不方便,那就会导致描述算法非常困难。这时候会发生一个怪现象:翻译解法到代码的难度远远超过解决问题本身

    举个例子,我们从小学习用阿拉伯数字做日常计算,做加减乘除都很方便,所有人都天经地义认为数值运算就该是这样的。其实未必!估计很多人都知道还有一种叫做罗马数字的东西,你知道用罗马数字该怎么做加减乘除吗?古罗马人又是如何上街买菜的?

    代码难写很大程度是代数的问题

    再看跑不快的原因。

    软件没办法改变硬件的性能,CPU和硬盘该多快就是多快。不过,我们可以设计出低复杂度的算法,也就是计算量更小的算法,这样计算机执行的动作变少,自然也就会快了。但是,光想出算法还不够,还要把这个算法用某种形式语言写得出来才行,否则计算机不会执行。而且,写起来还要比较简单,都要写很长很麻烦,也没有人会去用。所以呢,对于程序来讲,跑得快和写着简单其实是同一个问题,背后还是这个形式语言采用的代数的问题。如果这个代数不好,就会导致高性能算法很难实现甚至实现不了,也就没办法跑得快了。就象上面说的,用SQL写不出我们期望的小内存单次遍历算法,能不能跑得快就只能寄希望于优化器。

    我们再做个类比:

    上过小学的同学大概都知道高斯计算1+2+3+…+100的小故事。普通人就是一步步地硬加100次,高斯小朋友很聪明,发现1+100=101、2+99=101、…、50+51=101,结果是50乘101,很快算完回家午饭了。

    听过这个故事,我们都会感慨高斯很聪明,能想到这么巧妙的办法,即简单又迅速。这没有错,但是,大家容易忽略一点:在高斯的时代,人类的算术体系(也是一个代数)中已经有了乘法!象前面所说,我们从小学习四则运算,会觉得乘法是理所当然的,然而并不是!乘法是后于加法被发明出来的。如果高斯的年代还没有乘法,即使有聪明的高斯,也没办法快速解决这个问题。

    目前主流数据库是关系数据库,之所以这么叫,是因为它的数学基础被称为关系代数,SQL也就是关系代数理论上发展出来的形式语言。

    现在我们能回答,为什么SQL在期望的两个方面做得不够好?问题出在关系代数上,关系代数就像一个只有加法还没发明乘法的算术体系,很多事做不好是必然的。

    关系代数已经发明五十年了,五十年前的应用需求以及硬件环境,和今天比的差异是很巨大了,继续延用五十年前的理论来解决今天的问题,听着就感觉太陈旧了?然而现实就是这样,由于存量用户太多,而且也还没有成熟的新技术出现,基于关系代数的SQL,今天仍然是最重要的数据库语言。虽然这几十年来也有一些改进完善,但根子并没有变,面对当代的复杂需求和硬件环境,SQL不胜任也是情理之中的事。

    而且,不幸的是,这个问题是理论上的,在工程上无论如何优化也无济于事,只能有限改善,不能根除。不过,绝大部分的数据库开发者并不会想到这一层,或者说为了照顾存量用户的兼容性,也没打算想到这一层。于是,主流数据库界一直在这个圈圈里打转转。

    SPL为什么能行

    那么该怎样让计算写着更简单、跑得更快呢?

    发明新的代数!有“乘法”的代数。在其基础上再设计新的语言。

    这就是SPL的由来。它的理论基础不再是关系代数,称为离散数据集。基于这个新代数设计的形式语言,起名为SPL(Structured Process Language)。

    SPL针对SQL的不足(更确切地说法是,离散数据集针对关系代数的各种缺陷)进行了革新。SPL重新定义了并扩展许多结构化数据中的运算,增加了离散性、强化了有序计算、实现了彻底的集合化、支持对象引用、提倡分步运算。

    把前面的问题用SPL重写一遍有个直接感受。

    一支股票最长连续上涨多少天:

    stock_price.sort(trade_date).group@i(closing_price<closing_price[-1]).max(~.len())
    

    计算思路和前面的SQL相同,但因为引入了有序性后,表达起来容易多了,不再绕了。

    1亿条数据中取前10名:

    T.groups(;top(-10,x))
    

    SPL有更丰富的集合数据类型,容易描述单次遍历上实施简单聚合的高效算法,不涉及大排序动作。

    限于篇幅,这里不能介绍SPL(离散数据集)的全貌。我们在这里列举SPL(离散数据集)针对SQL(关系代数)的部分差异化改进:

    游离记录

    离散数据集中的记录是一种基本数据类型,它可以不依赖于数据表而独立存在。数据表是记录构成的集合,而构成某个数据表的记录还可以用于构成其它数据表。比如过滤运算就是用原数据表中满足条件的记录构成新数据表,这样,无论空间占用还是运算性能都更有优势。

    关系代数没有可运算的数据类型来表示记录,单记录实际上是只有一行的数据表,不同数据表中的记录也不能共享。比如,过滤运算时会复制出新记录来构成新数据表,空间和时间成本都变大。

    特别地,因为有游离记录,离散数据集允许记录的字段取值是某个记录,这样可以更方便地实现外键连接。

    有序性

    关系代数是基于无序集合设计的,集合成员没有序号的概念,也没有提供定位计算以及相邻引用的机制。SQL实践时在工程上做了一些局部完善,使得现代SQL能方便地进行一部分有序运算。

    离散数据集中的集合是有序的,集合成员都有序号的概念,可以用序号访问成员,并定义了定位运算以返回成员在集合中的序号。离散数据集提供了符号以在集合运算中实现相邻引用,并支持针对集合中某个序号位置进行计算。

    有序运算很常见,却一直是SQL的困难问题,即使在有了窗口函数后仍然很繁琐。SPL则大大改善了这个局面,前面那个股票上涨的例子就能说明问题。

    离散性与集合化

    关系代数中定义了丰富的集合运算,即能将集合作为整体参加运算,比如聚合、分组等。这是SQL比Java等高级语言更为方便的地方。

    但关系代数的离散性非常差,没有游离记录。而Java等高级语言在这方面则没有问题。

    离散数据集则相当于将离散性和集合化结合起来了,既有集合数据类型及相关的运算,也有集合成员游离在集合之外单独运算或再组成其它集合。可以说SPL集中了SQL和Java两者的优势。

    有序运算是典型的离散性与集合化的结合场景。次序的概念只有在集合中才有意义,单个成员无所谓次序,这里体现了集合化;而有序计算又需要针对某个成员及其相邻成员进行计算,需要离散性。

    在离散性的支持下才能获得更彻底的集合化,才能解决诸如有序计算类型的问题。

    离散数据集是即有离散性又有集合化的代数体系,关系代数只有集合化。

    分组理解

    分组运算的本意是将一个大集合按某种规则拆成若干个子集合,关系代数中没有数据类型能够表示集合的集合,于是强迫在分组后做聚合运算。

    离散数据集中允许集合的集合,可以表示合理的分组运算结果,分组和分组后的聚合被拆分成相互独立的两步运算,这样可以针对分组子集再进行更复杂的运算。

    关系代数中只有一种等值分组,即按分组键值划分集合,等值分组是个完全划分。

    离散数据集认为任何拆分大集合的方法都是分组运算,除了常规的等值分组外,还提供了与有序性结合的有序分组,以及可能得到不完全划分结果的对位分组。

    聚合理解

    关系代数中没有显式的集合数据类型,聚合计算的结果都是单值,分组后的聚合运算也是这样,只有SUM、COUNT、MAX、MIN等几种。特别地,关系代数无法把TOPN运算看成是聚合,针对全集的TOPN只能在输出结果集时排序后取前N条,而针对分组子集则很难做到TOPN,需要转变思路拼出序号才能完成。

    离散数据集提倡普遍集合,聚合运算的结果不一定是单值,仍然可能是个集合。在离散数据集中,TOPN运算和SUM、COUNT这些是地位等同的,即可以针对全集也可以针对分组子集。

    SPL把TOPN理解成聚合运算后,在工程实现时还可以避免全量数据的排序,从而获得高性能。而SQL的TOPN总是伴随ORDER BY动作,理论上需要大排序才能实现,需要寄希望于数据库在工程实现时做优化。

    有序支持的高性能

    离散数据集特别强调有序集合,利用有序的特征可以实施很多高性能算法。这是基于无序集合的关系代数无能为力的,只能寄希望于工程上的优化。

    下面是部分利用有序特征后可以实施的低复杂度运算:

    1)数据表对主键有序,相当于天然有一个索引。对键字段的过滤经常可以快速定位,以减少外存遍历量。随机按键值取数时也可以用二分法定位,在同时针对多个键值取数时还能重复利用索引信息。

    2)通常的分组运算是用HASH算法实现的,如果我们确定地知道数据对分组键值有序,则可以只做相邻对比,避免计算HASH值,也不会有HASH冲突的问题,而且非常容易并行。

    3)数据表对键有序,两个大表之间对位连接可以执行更高性能的归并算法,只要对数据遍历一次,不必缓存,对内存占用很小;而传统的HASH值分堆方法不仅比较复杂度高,需要较大内存并做外部缓存,还可能因HASH函数不当而造成二次HASH再缓存。

    4)大表作为外键表的连接。事实表小时,可以利用外键表有序,快速从中取出关联键值对应的数据实现连接,不需要做HASH分堆动作。事实表也很大时,可以将外键表用分位点分成多个逻辑段,再将事实表按逻辑段进行分堆,这样只需要对一个表做分堆,而且分堆过程中不会出现HASH分堆时的可能出现的二次分堆,计算复杂度能大幅下降。

    其中3和4利用了离散数据集对连接运算的改造,如果仍然延用关系代数的定义(可能产生多对多),则很难实现这种低复杂的算法。

    除了理论上的差异, SPL还有许多工程层面的优势,比如更易于编写并行代码、大内存预关联提高外键连接性能等、特有的列存机制以支持随意分段并行等。

    这里还有更多SPL代码以体现其思路及大数据算法:

    SPL交流群

    展开全文
  • 数据库语言-SQL

    千次阅读 2022-01-14 08:36:42
    SQL语言是集DDL、DML、DCL于一体的数据库语言。 DDL语句引导词:Create(建立)、Alter(修改)、Drop(撤销)。 模式的定义和删除,包括定义Database, Table,View,Index,完整性约束条件等,也包括定义对象...

    一、概述

    SQL语言是集DDL、DML、DCL于一体的数据库语言。

    1. DDL语句引导词:Create(建立)、Alter(修改)、Drop(撤销)。
      模式的定义和删除,包括定义Database, Table,View,Index,完整性约束条件等,也包括定义对象(RowType行对象,Type列对象)

    2. DML语句引导词:Insert,Delete,Update,Select
      各种方式的更新与检索操作,如直接输入记录,从其他Table(由SubQuery建立)输入。
      各种复杂条件的检索,如连接查找,模糊查找,分组查找,嵌套查找等。
      各种聚集操作,求平均、求和、…等,分组聚集,分组过滤等。

    3. DCL语句引导词: Grant,Revoke
      安全性控制:授权和撤消授权

    二、利用SQL建立数据库

    定义数据库和表(使用DDL),向表中追加元组(使用DML)。

    1、创建Database

    简单语法形式:create database 数据库名;

    2、创建Table

    简单语法形式create table 表名(列名 数据类型[Primary key|Unique] [Not null][,列名数据类型[Not null] ,...]);

    “[]”表示其括起的内容可以省略,“|”表示其隔开的两项可取其一。

    1. Primary key:主键约束。每个表只能创建一个主键约束
    2. Unique:唯一性约束(即候选键)。可以有多个唯一性约束。
    3. Not null:非空约束。是指该列允许不允许有空值出现,如选择了Not null表明该列不允许有空值出现。

    语法中的数据类型在SQL标准中有定义

    3、追加元组

    简单语法形式insert into 表名[(列名[列名]...] values(值[,值],.….);

    values后面值的排列,须与into子句后面的列名排列一致.
    若表名后的所有列名省略,则values后的值的排列,须与该表存储中的列名排列一致.

    三、利用SQL进行简单查询

    1、单表查询

    简单语法形式Select 列名 [,列名].….] From 表名 [ Where 检索条件];
    语义:从表名所给出的表中,查询出满足检索条件的元组,并按给定的列名及顺序进行投影显示。
    Select语句中的select … , from… , where…,等被称为子句,在以上基本形式基础上会增加许多构成要素,也会增加许多新的子句,满足不同的需求。
    在这里插入图片描述

    2、检索条件之去重复记录

    结果唯一性问题:关系模型不允许出现重复元组。但现实DBMS,却允许出现重复元组,但也允许无重复元组。

    在Table中要求无重复元组是通过定义Primary key或Unique来保证的;而在检索结果中要求无重复元组,是通过DISTINCT保留字的使用来实现的。

    示例∶在选课表中,检索成绩大于80分的所有学号
    select S# From sc Where Score > 80;
    // 有重复元组出现,比如一个同学两门以上课程大于80

    Select DISTINCT S# From sc Where score > 80;
    // 重复元组被DISTINCT过滤掉,只保留一份

    3、检索结果之排序

    Select语句中结果排序是通过增加order by子句实现的:order by 列名 [asc | desc]

    意义为检索结果按指定列名进行排序,若后跟asc或省略,则为升序;若后跟desc,则为降序。

    示例:按学号由小到大的顺序显示出所有学生的学号及姓名:
    Select S#, Sname From Student Order By S# ASC ;
    示例:检索002号课大于80分的所有同学学号并按成绩由高到低顺序显示:
    Select S# From sc Where C# =‘002’and Score > 80 Order By Score DESC ;

    4、模糊查询

    含有like运算符的表达式:列名 [not] like “字符串”

    找出匹配给定字符串的字符串。其中给定字符串中可以出现%, _等匹配符.

    匹配规则:

    1. “%”:匹配零个或多个字符
    2. “_”:匹配任意单个字符
    3. “l”:转义字符,用于去掉一些特殊字符的特定含义,使其被作为普通字符看待,如用“1%”去匹配字符%,用_去匹配字符_

    示例:检索所有姓张的学生学号及姓名
    Select S#, Sname From Student Where Sname Like ‘张%’;
    示例:检索名字为张某某的所有同学姓名
    Select Sname From Student Where Sname Like ‘张_ _’;
    示例:检索名字不姓张的所有同学姓名
    Select Sname From Student Where Sname Not Like ‘张%’;

    四、利用SQL语言进行多表联合查询

    多表联合检索可以通过连接运算来完成,而连接运算又可以通过广义笛卡尔积后再进行选择运算来实现。
    Select的多表联合检索语句Select 列名 [[列名].….] From 表名1, 表名2,…. Where 检索条件;
    在这里插入图片描述
    检索条件中要包含连接条件,通过不同的连接条件可以实现等值连接、不等值连接及各种θ-连接

    1、θ-连接之等值连接

    示例:按“001”号课成绩由高到低顺序显示所有学生的姓名(二表连接)
    Select Sname From Student, sc Where Student.S# = sc.s# and sC.C# =‘001’ Order By Score DESC;

    多表连接时,如两个表的属性名相同,则需采用 表名.属性名 方式来限定该属性是属于哪一个表

    示例:按‘数据库’课成绩由高到低顺序显示所有同学姓名(三表连接)
    Select Sname From Student, sC, Course Where Student.S# = sc.s# and sC.c# = Course.C# and Cname =‘数据库’ Order By Score DESC;

    2、表更名与表别名

    连接运算涉及到重名的问题,如两个表中的属性重名,连接的两个表重名(同一表的连接)等,因此需要使用别名以便区分。
    select中采用别名的方式Select 列名 as 列别名 [[列名 as 列别名]...] From 表名1 as 表别名1, 表名2 as 表别名2, … Where 检索条件;

    上述定义中的as可以省略
    当定义了别名后,在检索条件中可以使用别名来限定属性

    3、θ-连接之不等值连接

    示例:求有薪水差额的任意两位教师
    Select T1.Tname as Teacher1,T2.Tname as Teacher2 From Teacher T1,Teacher T2 Where T1.Salary > T2.Salary;
    示例:求年龄有差异的任意两位同学的姓名
    Select S1.Sname as Stu1, S2.Sname as Stu2 From Student S1, Student s2 Where S1.Sage > s2.Sage ;

    五、利用SQL语言进行增、删、改

    1、新增操作

    元组新增 Insert 命令有两种形式

    1. 单一元组新增命令形式:插入一条指定元组值的元组:insert into 表名 列名 [,列名].….)] values (值 [,值].….);
    2. 批数据新增命令形式:插入子查询结果中的若干条元组。待插入的元组由子查询给出:insert into 表名 [列名[,列名].….)] 子查询;

    示例:单一元组新增
    Insert Into Teacher (T#,Tname, D#, Salary) Values ("005", “阮小七”, "03", “1250");

    Insert Into Teacher Values ("006”,“李小虎”,“03", “950");

    示例:批元组新增
    新建立Table: St(S#, Sname),将检索到的满足条件的同学新增到该表中:
    Insert Into st (S#, Sname) Select S#, Sname From Student Where Sname like ‘%伟’;

    lnsert Into St (s#, Sname) Select S#, Sname From Student Order By Sname;

    2、删除操作

    元组删除Delete命令:删除满足指定条件的元组:Delete From 表名 [ Where 条件表达式 ];

    如果Where条件省略,则删除所有的元组。

    示例:删除SC表中所有元组
    Delete From sc ;

    示例:删除98030101号同学所选的所有课程
    Delete From sC Where s# =‘98030101’;

    示例:删除自动控制系的所有同学
    Delete From Student Where D# in (Select D# From Dept Where Dname = ‘自动控制);

    3、更新操作

    元组更新Update命令:用指定要求的值更新指定表中满足指定条件的元组的指定列的值
    Update 表名 Set 列名 = 表达式 | (子查询) [ [,列名=表达式|(子查询)]….] Where 条件表达式];

    如果Where条件省略,则更新所有的元组。

    示例:将所有教师工资上调5%
    Update Teacher Set Salary = Salary * 1.05 ;

    示例:将所有计算机系的教师工资上调10%
    Update Teacher Set Salary = Salary * 1.1 Where D# in (Select D# From Dept Where Dname=‘计算机);

    六、利用SQL语言修正与撤销数据库

    1、修正数据库

    修正数据库的定义,主要是修正表的定义

    修正基本表的定义
    alter table tablename [add {colname datatype,…}] [drop {完整性约束名) [modify {colname datatype,.…]]
    // 增加新列 删除完整性约束 修改列定义

    示例:在学生表Student(S#,Sname,Ssex,Sage,D# ,Sclass)基础上增加二列Saddr, PID
    Alter Table Student AddSaddr char[40],PID char[18];

    示例:将上例表中Sname列的数据类型增加两个字符
    Alter Table student Modify Sname char(10) ;

    示例:删除学生姓名必须取唯一值的约束
    Alter Table student Drop Unique( Sname );

    2、撤销基本表

    撤消基本表drop table 表名

    示例:撤消学生表Student
    Drop Table Student;

    注意,SQL-delete语句只是删除表中的元组,而撤消基本表drop table的操作是撤消包含表格式、表中所有元组、由该表导出的视图等相关的所有内容。

    撤消数据库drop database 数据库名;

    示例:撤消SCT数据库
    Drop database SCT;

    指定当前数据库use 数据库名;

    关闭当前数据库close 数据库名;

    七、备注

    1. FROM子句对应的是关系代数的笛卡尔积操作。
    2. SELECT子句对应关系代数的投影操作。
    3. GROUP BY子句是分组操作。
    4. WHERE子句对应关系代数的选择操作。
    展开全文
  • 只知道SQL数据库?又一国产数据库语言诞生了

    万次阅读 多人点赞 2022-04-01 11:00:04
    只知道SQL吗?又一国产数据库诞生了!

    一、为什么学习数据库?

    学习数据库,你肯定需要先了解它,这样你才知道你为什么要学习它,数据库除了SQL还有一些别的数据库,了解它们的作用,可以在不同的场景选择最符合的一个数据库。

    1.1 什么是数据库?

    首先你的先知道数据库的作用是什么,数据库的定义:数据库是结构化信息或数据的有组织的集合,通常以电子方式存储在计算机系统中。数据库通常由数据库管理系统 (DBMS)控制。数据和 DBMS 以及与之关联的应用程序一起被称为数据库系统,通常简称为数据库。

    数据库的组件:硬件,软件,数据,程序,访问语言。
    在这里插入图片描述

    1.2 数据库有啥优点?

    列举以下几点,来说明为什么学习数据库:

    1. 数据库可以有效地存储大量记录(占用的空间很小)
    2. 海量的数据中很容易找到需要的信息,给你一万条数据你用眼睛找?
    3. 容易添加新的数据以及编辑或删除已有的数据
    4. 可以轻松搜索数据,比如有一对蔬菜的数据,你只想查找所有白菜的数据?
    5. 数据可以轻松排序,比如有一万个人注册网站,你想根据注册时间排序?也许只需要一行语句
    6. 多人可以同时访问同一个数据库,这样可以多人管理,而且每个人的全选可能不一样,一个大型数据库可以每个人负责一部分
    7. 安全性可能比纸质文件更好,比存储到本地的文档好,这是毋庸置疑的!

    1.3 数据库有啥用途?偏偏要学它

    这里我依然举例子来说明它的用途:

    1. 警方在数据库中有所有已知罪犯的详细信息,例如他们犯下的罪行
    2. 学校使用数​​据库来存储学生的详细信息,例如每个人的成绩
    3. 医院会将所有患者的详细信息存储在数据库中,例如他们的病历
    4. 政府使用数据库存储人们的所得税支付记录
    5. 如果过路费不在人工,一个数据库用于跟踪上海中心所有已支付过路费的司机,如果未支付就通过就要对他罚款。再比如无人超市?

    二、为什么不选择SQL?

    我们需要知道以下SQL的优缺点,才能知道是否选择它。这里列举SQL的缺点:

    1. 安全:无论 SQL哪个 版本,SQL 中的数据库都经常受到威胁,因为它拥有大量敏感数据。
    2. 速度:随着 SQL 数据库变得越来越大,大量表之间所需的查找和连接可能会减慢速度!
    3. 可靠性:SQL 很难实现高性能算法,大数据操作的性能只能依靠数据库的优化引擎,但在复杂情况下往往有些不可靠。
      在这里插入图片描述

    2.1 使用SQL处理亿量数据太难了!

    很多大数据计算都是用SQL实现的,跑得慢时就要去优化SQL,但常常碰到让人干瞪眼的情况。比如,存储过程中有三条大概形如这样的语句执行得很慢:

     select a,b,sum(x) from T group by a,b where ;   
     select c,d,max(y) from T group by c,d where ;  
     select a,c,avg(y),min(z) from T group by a,c where ;
    

    这里的T是个有数亿行的巨大表,要分别按三种方式分组,分组的结果集都不大。分组运算要遍历数据表,这三句SQL就要把这个大表遍历三次,对数亿行数据遍历一次的时间就不短,何况三遍。

    这种分组运算中,相对于遍历硬盘的时间,CPU计算时间几乎可以忽略。如果可以在一次遍历中把多种分组汇总都计算出来,虽然CPU计算量并没有变少,但能大幅减少硬盘读取数据量,就能成倍提速了。

    如果SQL支持类似这样的语法:

    from T --数据来自T表 
     select a,b,sum(x) group by a,b where    --遍历中的第一种分组     
     select c,d,max(y) group by c,d where    --遍历中的第二种分组     
     select a,c,avg(y),min(z) group by a,c where ; --遍历中的第三种分组
    

    能一次返回多个结果集,那就可以大幅提高性能了。

    可惜, SQL没有这种语法,写不出这样的语句!
    在这里插入图片描述

    只能用个变通的办法,就是用group a,b,c,d的写法先算出更细致的分组结果集,但要先存成一个临时表,才能进一步用SQL计算出目标结果。SQL大致如下:

     create table T\_temp as select a,b,c,d,  
         sum(case when  then x else 0 end) sumx,  
         max(case when  then y else null end) maxy,   
         sum(case when  then y else 0 end) sumy,   
         count(case when  then 1 else null end) county,  
         min(case when  then z else null end) minz 
         group by a,b,c,d;
     select a,b,sum(sumx) from T\_temp group by a,b where ;  
     select c,d,max(maxy) from T\_temp group by c,d where ;  
     select a,c,sum(sumy)/sum(county),min(minz) from T\_temp group by a,c where ; 
    

    这样只要遍历一次了,但要把不同的WHERE条件转到前面的case when里,代码复杂很多,也会加大计算量。而且,计算临时表时分组字段的个数变得很多,结果集就有可能很大,最后还对这个临时表做多次遍历,计算性能也快不了。大结果集分组计算还要硬盘缓存,本身性能也很差。

    还可以用存储过程的数据库游标把数据一条一条fetch出来计算,但这要全自己实现一遍WHERE和GROUP的动作了,写起来太繁琐不说,数据库游标遍历数据的性能只会更差!只能干瞪眼!
    在这里插入图片描述

    TopN运算同样会遇到这种无奈。举个例子,用Oracle的SQL写top5大致是这样的:

     select \* from (select x from T order by x desc) where rownum<=5
    

    表T有10亿条数据,从SQL语句来看,是将全部数据大排序后取出前5名,剩下的排序结果就没用了!大排序成本很高,数据量很大内存装不下,会出现多次硬盘数据倒换,计算性能会非常差!
    在这里插入图片描述

    避免大排序并不难,在内存中保持一个5条记录的小集合,遍历数据时,将已经计算过的数据前5名保存在这个小集合中,取到的新数据如果比当前的第5名大,则插入进去并丢掉现在的第5名,如果比当前的第5名要小,则不做动作。这样做,只要对10亿条数据遍历一次即可,而且内存占用很小,运算性能会大幅提升。

    这种算法本质上是把TopN也看作与求和、计数一样的聚合运算了,只不过返回的是集合而不是单值。SQL要是能写成这样,就能避免大排序了:

     select top(x,5) from T
    

    然而非常遗憾,SQL没有显式的集合数据类型,聚合函数只能返回单值,写不出这种语句!啊啊啊啊!
    在这里插入图片描述

    不过好在全集的TopN比较简单,虽然SQL写成那样,数据库却通常会在工程上做优化,采用上述方法而避免大排序。所以Oracle算那条SQL并不慢。但是,如果TopN的情况复杂了,用到子查询中或者和JOIN混到一起的时候,优化引擎通常就不管用了。比如要在分组后计算每组的TopN,用SQL写出来都有点困难。Oracle的SQL写出来是这样:

     select \* from (select y,x,row\_number() over (partition by y order by x desc) rn from T) where rn<=5
    

    这时候,数据库的优化引擎就晕了,不会再采用上面说的把TopN理解成聚合运算的办法。只能去做排序了,结果运算速度陡降!

    假如SQL的分组TopN能这样写:

     select y,top(x,5) from T group by y
    

    把top看成和sum一样的聚合函数,这不仅更易读,而且也很容易高速运算。可惜,不行。还是干瞪眼!只想说一句:气死

    2.2 关联计算

    关联计算也是很常见的情况。以订单和多个表关联后做过滤计算为例,SQL大体是这个样子:

    select o.oid,o.orderdate,o.amount 
    from orders o 
        left join city ci on o.cityid = ci.cityid 
        left join shipper sh on o.shid=sh.shid 
        left join employee e on o.eid=e.eid 
        left join supplier su on o.suid=su.suid 
    where ci.state='New York' 
        and e.title='manager' 
        and ... 
    

    订单表有几千万数据,城市、运货商、雇员、供应商等表数据量都不大。过滤条件字段可能会来自于这些表,而且是前端传参数到后台的,会动态变化。

    SQL一般采用HASH JOIN算法实现这些关联,要计算 HASH 值并做比较。每次只能解析一个JOIN,有N个JOIN要执行N遍动作,每次关联后都需要保持中间结果供下一轮使用,计算过程复杂,数据也会被遍历多次,计算性能不好。

    通常,这些关联的代码表都很小,可以先读入内存。如果将订单表中的各个关联字段预先做序号化处理,比如将雇员编号字段值转换为对应雇员表记录的序号。那么计算时,就可以用雇员编号字段值(也就是雇员表序号),直接取内存中雇员表对应位置的记录,性能比HASH JOIN快很多,而且只需将订单表遍历一次即可,速度提升会非常明显!

    也就是能把SQL写成下面的样子:

    select o.oid,o.orderdate,o.amount 
    from orders o 
        left join city c on o.cid = c.# --订单表的城市编号通过序号#关联城市表 
        left join shipper sh on o.shid=sh.# --订单表运货商号通过序号#关联运货商表 
        left join employee e on o.eid=e.# --订单表的雇员编号通过序号#关联雇员表 
        left join supplier su on o.suid=su.#--订单表供应商号通过序号#关联供应商表 
    where ci.state='New York' 
        and e.title='manager' 
        and ... 
    

    可惜的是,SQL 使用了无序集合概念,即使这些编号已经序号化了,数据库也无法利用这个特点,不能在对应的关联表这些无序集合上使用序号快速定位的机制,只能使用索引查找,而且数据库并不知道编号被序号化了,仍然会去计算 HASH 值和比对,性能还是很差!有好办法也实施不了,只能再次干瞪眼!

    2.3 高并发帐户查询

    高并发帐户查询,这个运算倒是很简单:

    select id,amt,tdate,from T 
    where id='10100' 
        and tdate>= to\_date('2021-01-10','yyyy-MM-dd') 
        and tdate<to_date('2021-01-25','yyyy-mm-dd') 
        and=""="" <p="">
    

    在T表的几亿条历史数据中,快速找到某个帐户的几条到几千条明细,SQL写出来并不复杂,难点是大并发时响应速度要达到秒级甚至更快。为了提高查询响应速度,一般都会对 T 表的 id 字段建索引:

    create index index_T_1 on T(id)
    

    在数据库中,用索引查找单个帐户的速度很快,但并发很多时就会明显变慢。原因还是上面提到的SQL无序理论基础,总数据量很大,无法全读入内存,而数据库不能保证同一帐户的数据在物理上是连续存放的。硬盘有最小读取单位,在读不连续数据时,会取出很多无关内容,查询就会变慢。高并发访问的每个查询都慢一点,总体性能就会很差了。在非常重视体验的当下,谁敢让用户等待十秒以上?!容易想到的办法是,把几亿数据预先按照帐户排序,保证同一帐户的数据连续存储,查询时从硬盘上读出的数据块几乎都是目标值,性能就会得到大幅提升。

    三、为什么选择SPL?

    不能再用SQL和关系数据库了,要使用别的计算引擎,那就是SPL。开源的集算器SPL基于创新的理论基础,支持更多的数据类型和运算,能够描述上述场景中的新算法。用简单便捷的SPL写代码,在短时间内能大幅提高计算性能!very good!

    3.1 解决SQL的痛!

    上面这些问题用SPL写出来的代码样例如下:

    • 一次遍历计算多种分组
    AB
    1=file(“T.ctx”).open().cursor(a,b,c,d,x,y,z
    2cursor A1=A2.select(…).groups(a,b;sum(x))
    3//定义遍历中的第一种过滤、分组
    4cursor=A4.select(…).groups(c,d;max(y))
    5//定义遍历中的第二种过滤、分组
    6cursor=A6.select(…).groupx(a,c;avg(y),min(z))
    7//定义遍历中的第三种过滤、分组
    8//定义结束,开始计算三种方式的过滤、分组
    • 用聚合的方式计算Top5

    全集Top5(多线程并行计算)

    A
    1=file(“T.ctx”).open()
    2=A1.cursor@m(x).total(top(-5,x),top(5,x))
    3//top(-5,x) 计算出 x 最大的前 5 名,top(5,x) 是 x 最小的前 5 名。

    分组Top5(多线程并行计算)

    A
    1=file(“T.ctx”).open()
    2=A1.cursor@m(x,y).groups(y;top(-5,x),top(5,x))
    • 用序号做关联的SPL代码:

    系统初始化

    A
    1>env(city,file(“city.btx”).import@b()),env(employee,file(“employee.btx”).import@b()),…
    2//系统初始化时,几个小表读入内存

    查询

    A
    1=file(“orders.ctx”).open().cursor(cid,eid,…).switch(cid,city:#;eid,employee:#;…)
    2=A1.select(cid.state==“New York” && eid.title==“manager”…)
    3//先序号关联,再引用关联表字段写过滤条件
    • 高并发帐户查询的SPL代码:

    数据预处理,有序存储

    AB
    1=file(“T-original.ctx”).open().cursor(id,tdate,amt,…)
    2=A1.sortx(id)=file(“T.ctx”)
    3=B2.create@r(#id,tdate,amt,…).append@i(A2)
    4=B2.open().index(index_id;id)
    5//将原数据排序后,另存为新表,并为帐号建立索引

    帐户查询

    A
    1=T.icursor(;id==10100 && tdate>=date(“2021-01-10”) && tdate<date(“2021-01-25”) && …,index_id).fetch()
    2//查询代码非常简单

    除了这些简单例子,SPL还能实现更多高性能算法,比如有序归并实现订单和明细之间的关联、预关联技术实现多维分析中的多层维表关联、位存储技术实现上千个标签统计、布尔集合技术实现多个枚举值过滤条件的查询提速、时序分组技术实现复杂的漏斗分析等等。

    3.2 更多关于SPL的思路和算法

    这里还有更多SPL代码以体现其思路及大数据算法:

    正在为SQL性能优化头疼的小伙伴们,可以来一起讨论:http://www.raqsoft.com.cn/wx/Query-run-batch-ad.html

    四、SPL参考

    一起支持国产数据库,点个star支持一下吧:
    在这里插入图片描述

    展开全文
  • 数据库语言

    2012-09-16 13:21:32
    数据库SQL语言学习必备! SQL(Structured Query Language,结构化查询语言)是关系数据库的标准语言;几乎所有的关系型数据库管理系统均采用SQL语言标准。
  • Sql Server数据库语言设置

    千次阅读 2019-07-16 16:20:27
    数据库-安全性-用户名属性-默认语言选择对应语言即可
  • 关系数据库语言的特点和分类

    万次阅读 2018-05-03 17:23:48
    关系数据库语言可以分为三类: (1)关系代数语言 (2)关系演算语言:元组关系演算语言和域关系演算语言 (3)SQL:具有关系代数和关系演算双重特点的语言 这些关系数据语言的共同特点是,语言具有完备的...
  • 数据库语言SQL

    千次阅读 2018-07-11 18:35:07
    数据库语言SQL SQL的发展 1974年,由Boyce和Chamberlin提出 1975~1979,IBM San Jose Research Lab的关系数据库管理系统原型System R实施了这种语言 SQL-86是第一个SQL标准 SQL-89、SQL-92(SQL2)、...
  • cache 数据库M语言

    2018-09-07 16:03:27
    详细的语法讲解欢迎大家踊跃下载,由于国内资源很少,特地拿出来分享
  • 关系数据库语言SQL

    2011-05-25 12:56:53
    关系数据库语言SQL关系数据库语言SQL关系数据库语言SQL关系数据库语言SQL关系数据库语言SQL
  • 数据库究竟有哪几种最常用语言

    千次阅读 2022-01-06 10:10:20
    我们常说的SQL语言共分为四大类: 数据查询语言DQL, 数据操纵语言DML, 数据定义语言DDL, 数据控制语言DCL。 1. 数据查询语言DQL 数据查询语言DQL基本结构是由SELECT子句,FROM子句,WHERE 子句组成的查询块:...
  • 数据库语言分类

    千次阅读 2012-04-26 11:12:50
    SQL(Structure Query Language)语言数据库的核心语言。     SQL的发展是从1974年开始的,其发展过程如下: 1974年-----由Boyce和Chamberlin提出,当时称SEQUEL。 1976年-----IBM公司的Sanjase研究所在研制...
  • 数据库操作语言种类

    千次阅读 2020-06-12 18:05:37
    结构化查询语言(Structured Query Languages)简称SQL或“S-Q-L”,是一种数据库查询、程序设计和数据库管理语言,用于存取数据、查询数据、更新数据和管理关系数据库系统;同时也是数据库脚本文件的扩展名。包括...
  • 数据库发展和展望二、使用C语言实现一个简单的数据库三、使用C语言连接数据库四、SQL语言和MySQL教程1.SQL是什么1) DDL - Data Definition Language,数据定义语言2) DML - Data Manipulation Language,数据处理...
  • 神通数据库帮助手册(SQL语言手册,数据库备份恢复,读写分离集群,数据库审计,数据库进程守护,数据库接口
  • 关系型数据库语言分类

    千次阅读 2019-12-16 18:43:53
    一、关系型数据库语言分类 1.DDL 数据定义语言:( Data Definition Language ) 用来定义数据库的对象,如数据表、视图、索引等 create drop alter truncate 2.DML 数据操纵语言:( Data Manipulation Language ...
  • 关系型数据库语言分类(DDL,DML,DCL)

    千次阅读 2011-12-01 10:31:21
    关系数据库的语言分三类,它们是(数据描述语言DDL)、(数据操纵语言DML)和(数据控制语言DCL),而SQL是(集DDL、DML、DCL为一体)的标准关系数据库语言。 DDL is Data Definition Language statements. Some ...
  • 数据库的四种语言

    千次阅读 2019-11-18 14:26:17
    SQL语言共分为四大类:数据查询语言DQL,数据操纵语言DML,数据定义语言DDL,数据控制语言DCL。 1. 数据查询语言DQL 数据查询语言DQL基本结构是由SELECT子句,FROM子句,WHERE 子句组成的查询块: SELECT <字段名...
  • 数据库的四大语言分类

    万次阅读 2018-08-04 18:15:01
    DDL (数据定义语言) 数据定义语言 - Data Definition Language 用来定义数据库的对象,如数据表、视图、索引等 create drop alter truncate DML (数据操纵语言) 数据处理语言 - Data Manipulation Language...
  • 关系型数据库由哪三部分组成 使用关系数据库 (Using The Relational Database) A relational database is used for electronic data management in computer systems and is based on the relational database model...
  • 本文关键字:DB、DBMS、SQL、图形界面工具。刚刚接触数据库的小伙伴可能会对几个名词混淆不清,一上来又是命令又是工具的,这篇文章帮大家来明确一下这几个概念之间的关系。
  • 关系数据库标准语言SQL

    千次阅读 2017-12-07 23:55:17
    结构化查询语言(SQL)是关系数据库的标准语言,也是一个通用的、功能极强的关系数据语言。其功能不仅是查询,还包括数据库模式创建、数据库数据的插入与修改、数据库安全性完整性定义与控制等一系列功能。 1、SQL的...
  • java语言数据库课程设计校园网上订餐系统源代码java语言数据库课程设计校园网上订餐系统源代码java语言数据库课程设计校园网上订餐系统源代码java语言数据库课程设计校园网上订餐系统源代码java语言数据库课程设计...
  • SELECT TOP 10 x FROM T ORDER BY x DESC
  • SELECT TOP 10 x FROM T ORDER BY x DESC

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,203,292
精华内容 481,316
关键字:

数据库语言

友情链接: PositionOfPlayers.zip