SQL为什么动不动就百行以K记?

发明SQL的初衷之一显然是为了降低人们实施数据查询计算的难度。SQL中用了不少类英语的词汇和语法,这是希望非技术人员也能掌握。确实,简单的SQL可以当作英语阅读,即使没有程序设计经验的人也能运用。

然而,面对稍稍复杂的查询计算需求,SQL就会显得力不从心,经常写出几百行有多层嵌套的语句。这种SQL,不要说非技术人员难以完成,即使对于专业程序员也不是件容易的事,常常成为很多软件企业应聘考试的重头戏。三行五行的SQL仅存在教科书和培训班,现实中用于报表查询的SQL通常是以“K”计的。

SQL困难的分析探讨

这是为什么呢?我们通过一个很简单的例子来考察SQL在计算方面的缺点。

设有一个由三个字段构成的销售业绩表(为了简化问题,省去日期信息):

sales_amount销售业绩表
sales销售员姓名,假定无重名
product销售的产品
amount该销售员在该产品上的销售额

现在我们想知道出空调和电视销售额都在前10名的销售员名单。

这个问题并不难,人们会很自然地设计出如下计算过程:

1. 按空调销售额排序,找出前10名;

2. 按电视销售额排序,找出前10名;

3. 对1、2的结果取交集,得到答案;

我们现在来用SQL做。

1. 找出空调销售额前10名,还算简单:

select top 10 sales from sales_amount where product='AC' order by amount desc

2. 找出电视销售额前10名。动作一样:

select top 10 sales from sales_amount where product='TV' order by amount desc

3. 求1、2的交集。这有点麻烦,SQL不支持步骤化,上两步的计算结果无法保存,只能再重抄一遍了:

select * from( select top 10 sales from sales_amount where product='AC' order by amount desc )
intersect( select top 10 sales from sales_amount where product='TV' order by amount desc )

一个只三步的简单计算用SQL要写成这样,而日常计算中多达十几步的比比皆是,这显然超出来许多人的可接受能力。

我们知道了SQL的第一个重要缺点:不支持步骤化。把复杂的计算分步可以在很大程度地降低问题的难度,反过来,把多步计算汇成一步则很大程度地提高了问题的难度。

可以想象,如果老师要求小学生做应用题时只能列一个算式完成,小朋友们会多么苦恼(当然,不乏一些聪明孩子搞得定)。

SQL查询不能分步,但用SQL写出的存储过程可以分步,那么用存储过程是否可以方便地解决这个问题呢?

暂先不管使用存储过程的技术环境有多麻烦和数据库的差异性造成的不兼容,我们只从理论上来看用分步SQL是否能让这个计算更简单捷些。

1. 计算空调销售额前10名。语句还是那样,但我们需要把结果存起来供第3步用,而SQL中只能用表存储集合数据,这样我们要建一个临时表:

create temporary table x1 asselect top 10 sales from sales_amount where product='AC' order by amount desc

2. 计算电视销售额前10名。类似地

create temporary table x2 asselect top 10 sales from sales_amount where product='TV' order by amount desc

3. 求交集,前面麻烦了,这步就简单些

select * from x1 intersect x2

分步后思路变清晰了,但临时表的使用仍然繁琐。在批量结构化数据计算中,作为中间结果的临时集合是相当普遍的,如果都建立临时表来存储,运算效率低,代码也不直观。

而且,SQL不允许某个字段取值是集合(即临时表),这样,有些计算即使容忍了繁琐也做不到。

如果我们把问题改为计算所有产品销售额都在前10名的销售员,试想一下应当如何计算,延用上述的思路很容易想到:

1. 将数据按产品分组,将每组排序,取出前10名;

2. 将所有的前10名取交集;

由于我们事先不知道会有多个产品,这样需要把分组结果也存储在一个临时表中,而这个表有个字段要存储对应的分组成员,这是SQL不支持的,办法就行不通了。

如果有窗口函数的支持,可以转换思路,按产品分组后,计算每个销售员在所有分组的前10名中出现的次数,若与产品总数相同,则表示该销售员在所有产品销售额中均在前10名内。

select sales
from ( select sales,from ( select sales,rank() over (partition by product order by amount desc ) rankingfrom sales_amount)where ranking <=10 )
group by sales
having count(*)=(select count(distinct product) from sales_amount)

这样的SQL,有多少人会写呢?

况且,窗口函数在有些数据库中还不支持。那么,就只能用存储过程写循环依次计算每个产品的前10名,与上一次结果做交集。这个过程比用高级语言编写程序并不简单多少,而且仍然要面对临时表的繁琐。

现在,我们知道了SQL的第二个重要缺点:集合化不彻底。虽然SQL有集合概念,但并未把集合作为一种基础数据类型提供,这使得大量集合运算在思维和书写时都需要绕路。

我们在上面的计算中使用了关键字top,事实上关系代数理论中没有这个东西(它可以被别的计算组合出来),这不是SQL的标准写法。

我们来看一下没有top时找前10名会有多困难?

大体思路是这样:找出比自己大的成员个数作为是名次,然后取出名次不超过10的成员,写出的SQL如下:

select sales
from ( select A.sales sales, A.product product,(select count(*)+1 from sales_amountwhere A.product=product AND A.amount<=amount) rankingfrom sales_amount A )
where product='AC' AND ranking<=10

select sales
from ( select A.sales sales, A.product product, count(*)+1 rankingfrom sales_amount A, sales_amount Bwhere A.sales=B.sales and A.product=B.product AND A.amount<=B.amountgroup by A.sales,A.product )
where product='AC' AND ranking<=10

这样的SQL语句,专业程序员写出来也未必容易吧!而仅仅是计算了一个前10名。

退一步讲,即使有top,那也只是使取出前一部分轻松了。如果我们把问题改成取第6至10名,或者找比下一名销售额超过10%的销售员,困难仍然存在。

造成这个现象的原因就是SQL的第三个重要缺点:缺乏有序支持。SQL继承了数学上的无序集合,这直接导致与次序有关的计算相当困难,而可想而知,与次序有关的计算会有多么普遍(诸如比上月、比去年同期、前20%、排名等)。

SQL2003标准中增加的窗口函数提供了一些与次序有关的计算能力,这使得上述某些问题可以有较简单的解法,在一定程度上缓解SQL的这个问题。但窗口函数的使用经常伴随着子查询,而不能让用户直接使用次序访问集合成员,还是会有许多有序运算难以解决。

我们现在想关注一下上面计算出来的“好”销售员的性别比例,即男女各有多少。一般情况下,销售员的性别信息会记在花名册上而不是业绩表上,简化如下:

employee员工表
name员工姓名,假定无重名
gender员工性别

我们已经计算出“好”销售员的名单,比较自然的想法,是用名单到花名册时找出其性别,再计一下数。但在SQL中要跨表获得信息需要用表间连接,这样,接着最初的结果,SQL就会写成:

select employee.gender,count(*)
from employee,( ( select top 10 sales from sales_amount where product='AC' order by amount desc )intersect( select top 10 sales from sales_amount where product='TV' order by amount desc ) ) A
where A.sales=employee.name
group by employee.gender

仅仅多了一个关联表就会导致如此繁琐,而现实中信息跨表存储的情况相当多,且经常有多层。比如销售员有所在部门,部门有经理,现在我们想知道“好”销售员归哪些经理管,那就要有三个表连接了,想把这个计算中的where和group写清楚实在不是个轻松的活儿了。

这就是我们要说的SQL的第四个重要困难:缺乏对象引用机制,关系代数中对象之间的关系完全靠相同的外键值来维持,这不仅在寻找时效率很低,而且无法将外键指向的记录成员直接当作本记录的属性对待,试想,上面的句子可否被写成这样:

select sales.gender,count(*)
from () // …是前面计算“好”销售员的SQL
group by sales.gender

显然,这个句子不仅更清晰,同时计算效率也会更高(没有连接计算)。

我们通过一个简单的例子分析了SQL的四个重要困难,这也是SQL难写或要写得很长的主要原因。基于一种计算体系解决业务问题的过程,也就是将业务问题的解法翻译成形式化计算语法的过程(类似小学生解应用题,将题目翻译成形式化的四则运算)。SQL的上述困难会造成问题解法翻译的极大障碍,极端情况就会发生这样一种怪现象:将问题解法形式化成计算语法的难度要远远大于解决问题本身

再打个程序员易于理解的比方,用SQL做数据计算,类似于用汇编语言完成四则运算。我们很容易写出3+5*7这样的算式,但如果用汇编语言(以X86为例),就要写成

    mov ax,3mov bx,5mul bx,7add ax,bx

这样的代码无论书写还是阅读都远不如3+5*7了(要是碰到小数就更要命了)。虽然对于熟练的程序员也算不了太大的麻烦,但对于大多数人而言,这种写法还是过于晦涩难懂了,从这个意义上讲,FORTRAN确实是个伟大的发明。

为了理解方便,我们举的例子还是非常简单的任务。现实中的任务要远远比这些例子复杂,过程中会面临诸多大大小小的困难。这个问题多写几行,那个问题多写几行,一个稍复杂的任务写出几百行多层嵌套的SQL也就不奇怪了。而且这个几百行常常是一个语句,由于工程上的原因,SQL又很难调试,这又进一步加剧了复杂查询分析的难度。

更多例子

我们再举几个例子来分别说明这几个方面的问题。

为了让例子中的SQL尽量简捷,这里大量使用了窗口函数,故而采用了对窗口函数支持较好的ORACLE数据库语法,采用其它数据库的语法编写这些SQL一般将会更复杂。
这些问题本身应该也算不上很复杂,都是在日常数据分析中经常会出现的,但已经很难为SQL了。

计算不分步

把复杂的计算分步可以在很大程度地降低问题的难度,反过来,把多步计算汇成一步完成则会提高问题的复杂度。

任务1 销售部的人数,其中北京籍人数,再其中女员工人数?

销售部的人数

select count(*) from employee where department='sales'

其中北京籍的人数

select count(*) from employee where department='sales' and native_place='Beijing'

再其中的女员工人数

select count (*) from employee
where department='sales' and native_place='Beijing' and gender='female'

常规想法:选出销售部人员计数,再在其中找出其中北京籍人员计数,然后再递进地找出女员工计数。每次查询都基于上次已有的结果,不仅书写简单而且效率更高。

但是,SQL的计算不分步,回答下一个问题时无法引用前面的成果,只能把相应的查询条件再抄一遍。

任务2 每个部门挑选一对男女员工组成游戏小组

with A as(select name, department,row_number() over (partition by department order by 1) seqfrom employee where gender=‘male’)B as(select name, department,row_number() over(partition by department order by 1) seqfrom employee where gender=‘female’)
select name, department from A
where department in ( select distinct department from B ) and seq=1
union all
select name, department from B
where department in (select distinct department from A ) and seq=1

计算不分步有时不仅造成书写麻烦和计算低效,甚至可能导致思路严重变形。

这个任务的直观想法:针对每个部门循环,如果该部门有男女员工则各取一名添进结果集中。但SQL不支持这种逐步完成结果集的写法(要用存储过程才能实现此方案),这时必须转变思路为:从每个部门中选出男员工,从每个部门选出女员工,对两个结果集分别选出部门出现在另一个结果集的成员,最后再做并集。

好在还有with子句和窗口函数,否则这个SQL语句简直无法看了。

集合无序

有序计算在批量数据计算中非常普遍(取前3名/第3名、比上期等),但SQL延用了数学上的无序集合概念,有序计算无法直接进行,只能调整思路变换方法。

任务3 公司中年龄居中的员工

select name, birthday
from (select name, birthday, row_number() over (order by birthday) rankingfrom employee )
where ranking=(select floor((count(*)+1)/2) from employee)

中位数是个常见的计算,本来只要很简单地在排序后的集合中取出位置居中的成员。但SQL的无序集合机制不提供直接用位置访问成员的机制,必须人为造出一个序号字段,再用条件查询方法将其选出,导致必须采用子查询才能完成。

任务4 某支股票最长连续涨了多少交易日

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

无序的集合也会导致思路变形。

常规的计算连涨日数思路:设定一初始为0的临时变量记录连涨日期,然后和上一日比较,如果未涨则将其清0,涨了再加1,循环结束看该值出现的最大值。

使用SQL时无法描述此过程,需要转换思路,计算从初始日期到当日的累计不涨日数,不涨日数相同者即是连续上涨的交易日,针对其分组即可拆出连续上涨的区间,再求其最大计数。这句SQL读懂已经不易,写出来则更困难了。

集合化不彻底

毫无疑问,集合是批量数据计算的基础。SQL虽然有集合概念,但只限于描述简单的结果集,没有将集合作为一种基本的数据类型以扩大其应用范围。

任务5 公司中与其他人生日相同的员工

select * from employee
where to_char (birthday, ‘MMDD’) in( select to_char(birthday, 'MMDD') from employeegroup by to_char(birthday, 'MMDD')having count(*)>1 )

分组的本意是将源集合分拆成的多个子集合,其返回值也应当是这些子集。但SQL无法表示这种“由集合构成的集合”,因而强迫进行下一步针对这些子集的汇总计算而形成常规的结果集。

但有时我们想得到的并非针对子集的汇总值而是子集本身。这时就必须从源集合中使用分组得到的条件再次查询,子查询又不可避免地出现。

任务6 找出各科成绩都在前10名的学生

select name
from (select namefrom (select name,rank() over(partition by subject order by score DESC) rankingfrom score_table)where ranking<=10)
group by name
having count(*)=(select count(distinct subject) from score_table)

用集合化的思路,针对科目分组后的子集进行排序和过滤选出各个科目的前10名,然后再将这些子集做交集即可完成任务。但SQL无法表达“集合的集合”,也没有针对不定数量集合的交运算,这时需要改变思路,利用窗口函数找出各科目前10名后再按学生分组找出出现次数等于科目数量的学生,造成理解困难。

缺乏对象引用

在SQL中,数据表之间的引用关系依靠同值外键来维系,无法将外键指向的记录直接用作本记录的属性,在查询时需要借助多表连接或子查询才能完成,不仅书写繁琐而且运算效率低下。

任务7 女经理的男员工们

用多表连接

select A.*
from employee A, department B, employee C
where A.department=B.department and B.manager=C.name andA.gender='male' and C.gender='female'

用子查询

select * from employee
where gender='male' and department in(select department from departmentwhere manager in(select name from employee where gender='female'))

如果员工表中的部门字段是指向部门表中的记录,而部门表中的经理字段是指向员工表的记录,那么这个查询条件只要简单地写成这种直观高效的形式:

where gender='male' and department.manager.gender='female'

但在SQL中则只能使用多表连接或子查询,写出上面那两种明显晦涩的语句。

任务8 员工的首份工作公司

用多表连接

select name, company, first_company
from (select employee.name name, resume.company company,row_number() over(partition by resume. nameorder by resume.start_date) work_seqfrom employee, resume where employee.name = resume.name)
where work_seq=1

用子查询

select name,(select company from resumewhere name=A.name andstart date=(select min(start_date) from resumewhere name=A.name)) first_company
from employee A

没有对象引用机制和彻底集合化的SQL,也不能将子表作主表的属性(字段值)处理。针对子表的查询要么使用多表连接,增加语句的复杂度,还要将结果集用过滤或分组转成与主表记录一一对应的情况(连接后的记录与子表一一对应);要么采用子查询,每次临时计算出与主表记录相关的子表记录子集,增加整体计算量(子查询不能用with子句了)和书写繁琐度。

SPL的引入

问题说完,该说解决方案了。

其实在分析问题时也就一定程度地指明了解决方案,重新设计计算语言,克服掉SQL的这几个难点,问题也就解决了。

这就是发明SPL的初衷!

SPL是个开源的程序语言,其全名是Structured Process Language,和SQL只差一个词。目的在于更好的解决结构化数据的运算。SPL中强调了步骤化、支持有序集合和对象引用机制、从而得到彻底的集合化,这些都会大幅降低前面说的“解法翻译”难度。

这里的篇幅不合适详细介绍SPL了,我们只把上一节中的8个例子的SPL代码罗列出来感受一下:

任务1

AB
1=employee.select(department==“sales”)=A1.len()
2=A1.select(native_place==“Beijing”)=A2.len()
3=A2.select(gender==“female”)=A3.len()

SPL可以保持记录集合用作中间变量,可逐步执行递进查询。

任务2

ABC
1for employee.group(department)=A1.group@1(gender)
2>if B1.len()>1=@|B1

有步骤和程序逻辑支持的SPL能很自然地逐步完成结果。

任务3

A
1=employee.sort(birthday)
2=A1((A1.len()+1)/2)

对于以有序集合为基础的SPL来说,按位置取值是个很简单的任务。

任务4

A
1=stock_price.sort(trade_date)
2=0
3=A1.max(A2=if(close_price>close_price[-1],A2+1,0))

SPL按自然的思路过程编写计算代码即可。

任务5

A
1=employee.group(month(birthday),day(birthday))
2=A1.select(~.len()>1).conj()

SPL可以保存分组结果集,继续处理就和常规集合一样。

任务6

A
1=score_table.group(subject)
2=A1.(~.rank(score).pselect@a(~<=10))
3=A1.(~(A2(#)).(name)).isect()

使用SPL只要按思路过程写出计算代码即可。

任务7

A
1=employee.select(gender==“male” && department.manager.gender==“female”)

支持对象引用的SPL可以简单地将外键指向记录的字段当作自己的属性访问。

任务8

A
1=employee.new(name,resume.minp(start_date).company:first_company)

SPL支持将子表集合作为主表字段,就如同访问其它字段一样,子表无需重复计算。

SPL有直观的IDE,提供了方便的调试功能,可以单步跟踪代码,进一步降低代码的编写复杂度。

imagepng

对于应用程序中的计算,SPL提供了标准的JDBC驱动,可以像SQL一样集成到Java应用程序中:

…
Class.forName("com.esproc.jdbc.InternalDriver");
Connection conn =DriverManager.getConnection("jdbc:esproc:local://");
Statement st = connection.();
CallableStatement st = conn.prepareCall("{call xxxx(?,?)}");
st.setObject(1, 3000);
st.setObject(2, 5000);
ResultSet result=st.execute();
...

SPL资料

  • SPL官网
  • SPL下载
  • SPL源代码

SPL交流群

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/438326.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

深入理解happens-before和as-if-serial语义

本文大部分整理自《Java并发编程的艺术》&#xff0c;温故而知新&#xff0c;加深对基础的理解程度。下面可以和小编来一起学习下 概述 本文大部分整理自《Java并发编程的艺术》&#xff0c;温故而知新&#xff0c;加深对基础的理解程度。 指令序列的重排序 我们在编写代码…

开源SPL重新定义OLAP Server

OLAP&#xff08;Online Analytical Processing&#xff09;是指在线联机分析&#xff0c;基于数据查询计算并实时获得返回结果。日常业务中的报表、数据查询、多维分析等一切需要即时返回结果的数据查询任务都属于OLAP的范畴。对应的&#xff0c;行业内也有相应产品来满足这类…

平层、错层、跃层、复式、loft的区别是什么?

平层正如字面上的理解&#xff0c;是所有功能厅都在同一个水平面上。平时我们所见的户型&#xff0c;都是平层。错层室内各功能用房在不同的平面上&#xff0c;用2-4个台阶进行隔断。跃层是两层的住宅&#xff0c;在室内会设计一条楼梯连接上下两层&#xff0c;功能区会分开。复…

C#集合类型总结和性能分析

C#集合类型概述 集合是.NET FCL(Framework Class Library)中很重要的一部分。所有的集合类都继承自IEnumerable。集合类总体可分为一下几类&#xff1a;关联/非关联型集合&#xff0c;顺序/随机访问集合&#xff0c;顺序/无序集合&#xff0c;泛型/非泛型集合&#xff0c;线程…

Spring AOP(通知、连接点、切点、切面)

一、AOP术语 通知&#xff08;Advice&#xff09;   切面的工作被称为通知。通知定义了切面是什么以及何时使用。除了描述切面要完成的工作&#xff0c;通知还解决了何时执行这个工作的问题。 5种通知类型&#xff1a;前置通知&#xff08;Before&#xff09;&#xff1a;在…

C#中几种常用的集合的用法

集合:将一推数据类型相同的数据放入到一个容器内&#xff0c;该容器就是数组&#xff1a;内存中开辟的一连串空间。 非泛型集合 ArrayList集合&#xff1a; ArrayList是基于数组实现的&#xff0c;是一个动态数组&#xff0c;其容量能自动 增长 ArrayList的命名空间System.…

C#使用Redis的基本操作

一&#xff0c;引入dll 1.ServiceStack.Common.dll 2.ServiceStack.Interfaces.dll 3.ServiceStack.Redis.dll 4.ServiceStack.Text.dll 二&#xff0c;修改配置文件 在你的配置文件中加入如下的代码&#xff1a; <appSettings><add key"RedisPath" value…

Navicat将mysql表结构导成oracle表结构

1&#xff0c;选中对应的表右键逆向表到模型 2.点击右上角文件转换模型为 3.模型选择物理&#xff0c;数据库oracle&#xff0c;选择对应的版本 4.新弹出的模型点击右上角文件&#xff0c;导出sql 5.选择路径导出sql

程序员们的三高:高并发、高性能、高可用

你们知道淘宝&#xff0c;京东这些购物商场吗&#xff1f;他们到了双11&#xff0c;双12为什么能支持全国14亿人口同时购物下单呢&#xff0c;因为他们的程序做到了高并发、高性能、高可用。那么你对程序员的三高了解多少呢&#xff1f; 高并发 一. 高并发 高并发是现在互联…

char 和 varchar 的区别,数据库索引B+树

char 和 varchar 的区别 char(n) &#xff1a;固定长度&#xff0c;效率高&#xff1b;缺点&#xff1a;占用空间&#xff1b;存储固定长度的&#xff0c;使用 char 非常合适。 varchar(n) &#xff1a;可变长度&#xff0c;存储的值是每个值占用的字节再加上一个用来记录其长…

C#基础操作符详解

本节内容&#xff1a; 1.操作符概览&#xff1b; 2.操作符的本质&#xff1b; 3.操作符与运算顺序 4.操作符详解。 1.操作符概览&#xff1a; 操作符&#xff08;Operator&#xff09;也译为”运算符” 操作符是用来操作数据的&#xff0c;被操作符操作的数据称为操作数&a…

C# 有什么惊艳到你的地方?

作者&#xff1a;皮皮关 链接&#xff1a;https://www.zhihu.com/question/335137780/answer/786853293 来源&#xff1a;知乎 著作权归作者所有。商业转载请联系作者获得授权&#xff0c;非商业转载请注明出处。 很多游戏开发者都是由于Unity而“被迫”使用C#的。但用过一段…

SqlServer学习之存储过程

前言&#xff1a;对于存储过程一直有一种抵触的心理&#xff0c;因为毕业至今所在的公司开发组都不是很规范&#xff0c;对于开发的一些注意事项并没有很多的规定&#xff0c;只是在知乎上查找相关知识的时候&#xff0c;看到很多人对于在程序里使用存储过程的不好之处都有很多…

中间件之RPC

一、RPC的定义 1、RPC(Romote Procedure Call)&#xff1a;远程过程调用&#xff0c;允许一台计算机程序远程调用另外一台计算机的子程序&#xff0c;不用关心底层网络通信 2、应用&#xff1a;分布式网络通信 3、在Socket的基础上实现&#xff0c;比socket需要更多资源 4、…

需求分析之UML用例图学习

用例图常用的三种关系浅析&#xff1a; &#xff08;一&#xff09;泛化(Inheritance) 通常理解的继承关系 &#xff08;二&#xff09;包含&#xff08;include&#xff09; 分解功能&#xff0c;一定包含的功能 &#xff08;三&#xff09;拓展(extend) 附加功能&#xff0c…

UML之用例图(use case)箭头方向

1、Association&#xff0c;无箭头&#xff0c;Actor连接UseCase即可&#xff1b; 2、DirectedAssocition&#xff0c;Actor连接UseCase&#xff0c;箭头由Actor指向UseCase&#xff08;角色指向用例&#xff09;&#xff1b; 3、Generalization&#xff0c;继承&#xff0c;…

UML-记忆技巧

箭头方向 UML箭头方向&#xff1a;从子类指向父类&#xff0c;读作继承自定义子类时需要通过extend关键字指定父类子类一定时知道父类定义的&#xff0c;但父类并不知道子类的定义 只有知道对方信息时才能指向对方 image.png 实现-继承|虚线-实现 空心三角箭头&#xff1…

国密算法SM2,SM3,SM4-java实现

SM2是国家密码管理局于2010年12月17日发布的椭圆曲线公钥密码算法&#xff0c;基于ECC。其签名速度与秘钥生成速度都快于RSA&#xff0c;非对称加密&#xff0c;该算法已公开 SM3是中华人民共和国政府采用的一种密码散列函数标准&#xff0c;由国家密码管理局于2010年12月17日…

数据库事务隔离级别-- 脏读、幻读、不可重复读(清晰解释)

一、数据库事务隔离级别 数据库事务的隔离级别有4个&#xff0c;由低到高依次为Read uncommitted 、Read committed 、Repeatable read 、Serializable &#xff0c;这四个级别可以逐个解决脏读 、不可重复读 、幻读 这几类问题。 √: 可能出现 : 不会出现 脏读不可重复读幻…

原子性和一致性的区别是什么?

注&#xff1a; 重度参考了&#xff1a;https://www.zhihu.com/question/30272728/answer/72476703&#xff08;讲的非常好&#xff0c;逻辑清晰&#xff09; 轻度参考了&#xff1a;https://www.cnblogs.com/fjdingsd/p/5273008.html&#xff08;概念也比较清晰&#xff0c;…