oracle 学习

1.勤能补拙
2. undo和 redo
Redo：重做日志文件，用于前滚数据恢复数据
Undo：恢复事务，取消一条或一组语句
通常对undo有一个误解，认为undo用于数据库物理地恢复到执行语句或事务之前的样子，但实际上并非如此。数据库只是逻辑地恢复到原来的样子，所有修改都被逻辑地取消，但是数据结构以及数据库块本身在回滚后可能大不相同。（比如一个插入操作，新分配了一些数据块。后来事务失败，插入操作全部回滚，新分配的一些数据块还是存在的）
例如，假设我们的事务执行了一个INSERT语句，这条语句导致分配一个新区段（也就是说，导致表的空间增大）。通过执行这个INSET，我们将得到一个新的块，格式化这个块以便使用，并在其中放上一些数据。此时，可能出现另外某个事务，它也向这个块中插入数据。如果要回滚我们的事务，显然不能取消对这个块的格式化和空间分配。因此，Oracle回滚时，它实际上会做与先前逻辑上相反的工作。对于每个INSERT，Oracle会完成一个DELETE。对于每个DELETE，Oracle会执行一个INSERT。对于每个UPDATE，Oracle则会执行一个“反UPDATE“，或者执行另一个UPDATE将修改前的行放回去。
所以有一种异常情况就很容易解释了，一个表明明只有1000行左右的数据，一条select * from table 语句可能需要耗时1,2分钟。这张表应该是经常进行新增删除操作的表，比如我新增了1000万行数据，然后又将这些数据删除。对这个表进行全表扫描的时候，仍然会去扫描这1000万行以前所占用的那些数据块，看看里面是否包含数据。也就是oracle里面所说的高水平线（HWM），这些数据块都增加到了高水平线下面，oracle会扫描所有高水平线下的数据块。

3.sql拼接闪回锁表解锁kill进程
SELECT ‘DROP TABLE ‘||TABLE_NAME||’;’ FROM USER_TABLES WHERE TABLE_NAME LIKE ‘NEDW%’; ----sql拼接

FLASHBACK TABLE a TO BEFORE DROP; --闪回删除表

select * from 表名 as of timestamp(sysdate-5/1440); —闪回到5分钟前

select * from DBA_OBJECTS T where T.OBJECT_TYPE LIKE ‘%PACKGE’ —查看数据库的包和包体

select * from sys.v_$version —查看oracle版本

SELECT * from v $locked_object i ,All_Objects o,v$ session s WHERE i.OBJECT_ID=o.OBJECT_ID AND i.SESSION_ID=s.SID;

alter system kill session ‘1293,12637’ immediate;

SELECT spid,osuser,s.PROgram from v $session s,v$ process p WHERE s.PADDR=p.ADDR AND s.SID=‘37’;

pl/sqldeveloper试用期到期无法使用解决方法
1）鹏威给的激活工具双击输入（网盘）

2）当 PL/SQL 免费使用 30 天后，打开时会提示“Your trial period for PL/SQL Developer is over.”这表明试用期已到，需要用序列号激活后才能用，但有时候手头没有序列号，又无法上网去查，则可以用另一种办法来解决无法使用的问题，那就是修改注册表。

第一步，开始菜单的“搜索程序和文件”中，输入指令“regedit”回车，打开注册表。

第二步，按 HKEY_CURRENT_USER\Software\Allround Automations\PL/SQL Developer 这个路径找到“PL/SQL Developer”，然后删除它。

第三步，再找到“HKEY_CURRENT_USER\Software\Microsoft\Security”，删除“Security”。

第四步，关闭注册表，重新登陆 PL/SQL Developer，这时候就可以重新用30天了
这种方法只能用 30 天，所以紧急事情解决后，还是赶紧找注册码吧，一劳永逸；当然也可以 30 天到期后，再次这样解决，再用 30 天，循环下去。

5（同义词）使用户不能修改表结构只能增删改查数据
同义词—（操作同义词数据同步原表）
1）.先在A用户创建表
CREATE TABLE EMP3 AS SELECT * from EMP;
2）.把增删该查赋权给B用户
GRANT SELECT ,UPDATE,DELETE ,INSERT TO CESHI;
3）.给B用户赋权（创建同义词权限）
GRANT CREATE SYNONYM TO CESHI;
4）.在B用户创建A用户表的同义词
CREATE SYNONYM test_lxx FOR scott.test_lxx;
6．查询正在使用的用户（删除用户时）
SELECT username,SID,serial# from v$session WHERE username=‘BBSP’;

ALTER SYSTEM KILL SESSION ‘69,1660’;
注意：【Oracle】想查询相关的v $视图，但是提示表或视图不存在解决办法原因是使用的用户没有相关的查询权限导致解决办法：grant select any dictionary to 用户; --这个权限比较大这个权限是最低的要求，但是可以访问到v$ 相关视：图grant select_catalog_role to 用户;
收回权限 revoke select_catalog_role from user;

7.连接数据库cmd (执行sql都需要分号结束)
Sqlplus bbsp7/bbsp7@bems_49
Sqlplus as /sysdba
conn lxx

8.数据仓库学习
OLTP系统：联机事务处理系统银行储蓄系统
OLAP：联机事务分析系统面向主体的跨部门的
建模：
概念模型（自上而下）：圈定系统边界，什么不做，划清楚，沟通的基础（一定的商业语言），逻辑模型的输入，交付品用一页纸描绘整个模型，
逻辑模型：占项目的70%，客户，商品，订单~~实体，属性，约束使用术语表的先规范化在逆规范化（优化），不可一步到位，使用CASE工具做逻辑模型（建模），重关联关系需要强制建立，与概念模型保持一致，注意模型的版本管理，要像一本书而非一页纸，严格遵循命名规则
物理模型：（用CASE工具自动由逻辑模型自动生成）选择数据库，生成DDL，改动也是改逻辑模型，保证一致，表空间索引分区物化视图数据归档在物理层，DBA需要深度介入，需要DBA评审，物理层一般DBA维护，ddl注意注释的生成，
关系型数据库的基本概念
实体（表）：概念模型确定，逻辑模型完善，重在沟通（5w1H）
实体分类：按照含义分类
按照patern分类
属性（列）和域：
属性的分类：按内容
关系：
键KEY：候选键，主键，
候选键：主键和可选键
主键：单键和复合键，代理件和自然键，唯一性，强制不为空，不可改变，最小集合（能用2个不用三个），外键可以为空
单键：主键一个属性
复合键：多个主键
代理键
自然键：已经真实存在的键，可以是单键和复合键，例如身份证车牌号
代理键：都是单键没哟复合键，完全没有商业含义
约束（constraint）
唯一标识，例如主键约束，非空约束，获取当前日期，default，check（条件），RI（Referential Integrity）参照完整性，
null值有坑需注意：

默认值要统一，比如时间截止时间默认9999-12-13，项目结束后再统一改回去，不能很多值，不好管理
数据质量要求高，默认均为not null

XREF----多表关联中间表
数据库规范化：1NF~2NF-3NF-BCNF-4NF-5NF
先规范化后逆规范化
第一范式：原子性，没有重复列，列不可再分，
保证同一列是表达一个含义，同一列是同一个数据类型
去掉多值属性，例如：省份区地址拆开写、多个电话就拆开两个字段
去掉重复组，建子表
第二范式：
非主键属性只依赖一个属性，就拆出来（避免数据冗余）
第三范式：
如果非主属性依赖另一个非主属性就拆出来这两个字段单独建表

大数据系列相关学习
开源组件介绍：大数据介绍4V（volume、variety、velocity、value）
hadoop分布式存储分布式计算（hdfs mapreduce（批量计算引擎））
Spark（计算引擎）内存计算实时计算一站式框架支持R语言
Habase（列式数据库）也是存储在hdfs上面查询速度快有些公司用hbase做实时查询
Zookeeper（管理员）做协调
Nutch（数据采集）hadoop的先驱，
Storm（计算引擎）流式计算
R语言（数据分析数据挖掘用到的多）
Hive（交互式查询）类sql 底层计算引擎mapreduce 交互式速度不令人满意，延迟要求不是很高可以用
Impala（交互式查询）跟hive作用一致，比hive快，搜索引擎是自己的
麒麟（hadoop hive hbase）olap多维分析
Sqoop、kafka、flume（数据接入）是一个用来将hadoop中hdfs和关系型数据库中的数据相互迁移的工具，sqoop的底层实现是mapreduce，所以sqoop依赖于hadoop，数据并行导入。
Yarn（资源统一管理）

Sqoop：导入导出 oracle mysql sqlserver 等
Sqoop(发音:skup)是一款开源的工具，主要用于在HADOOP(Hive)与传统的数据库(mysql、postgresql…)间进行数据的传递，可以将一个关系型数据库(例如 : MySQL ,Oracle ,Postgres等)中的数据导进到Hadoop的HDFS中，也可以将HDFS的数据导进到关系型数据库中。
将关系型数据库导成文件形式放入hdfs或者相反，并行读取-m,hdfs默认分隔符是‘，’可以修改分隔符，导入全表目录不能存在，每次需要删除一下hadoop的文件目录
hdfs dfs –rm –R /~路径
可以检查导入导出情况（sqoop-list-database、sqoop-list-tables、sqoop-eval）
命令行执行或者把所有命令放到文件里面 .txt(文件里需要每个参数一换行)
支持增量导入导出（表结构和数据），也可以导出HDFS文件，也可以导出hive 和hbase
Sqoop Import命令：sqoop import –connect jdbc:mysql://centos:3306/sqooptestname –username root –password 123456 –table bigdata
默认端口：Mysql 3306 、oracle 1521
Sqoop连接关系型数据库密码有三种方式-P推荐
支持导入部分数据（增量导入），加条件

Hive ：大数据领域的数据仓库把sql转化为mapreduce的作业

开源，Apache Hive ，直接建立于hadoop之上，一种工具，可以通过sql访问数据，可以完成ETL 报表分析，数据访问hdfs文件和hbase，查询方式是一种类sql—HiveQL
Hive的查询引擎：hive转换mr，2.0版本支持存储过程HPL/SQL
Hive的架构：1用户接口（命令行接口，jdbc、odbc，webui）、
单机Derby是hive的源数据存储，多用户模式的话是通过网络连接到关系型数据库，远程模式

单用户模式：只能一个终端打开session
Hive和pig都只是把脚本和sql语言丢给mapreduce解析
Hive和Impala组件比较
Hive和Impala（实时交互的sql查询工具）比较：
Impala比hive快
Hive适合延迟的数据分析，Impala适合实时的
Hive和Impala可以结合一起用，先hive后Impala
Hive和Spark SQL比较：
Hive默认是基于mapreduce的计算引擎Hive On Spark—hive用spark的计算引擎
Hive环境搭建：要有一个linux系统，hadoop，mysql
Hive CLI:Hive shell
设置reduce数量reduce任务数
Hive –hiveconf mapred.Reduce.task=10
查数据
hive –e “select * from t2 where userid>4” –database hello
****每个hql文件里语句都要一个分号；来结束
Hive –f
Hive add
Hive> list file;
Hive delete
!pwd
hadoop> hdfs dfs –ls /
Hive>dfs ~
Query

Beeline: 是hiveserver2的CLI，一种jdbc客户端，和hive交互的，hiveserver2的CLI只能做一下查询，交互不如beeline好。
Beeline需要结合hiveserver2，首先配置文件配置beeline，配置完文件需要重启hadoop集群，如何启动，问题如何解决。
Hive基本数据类型：
数值型：tinyint 1字节，smallint 2，int/integer 4(10亿),bigint 8,float 例 1.0 ，double 例 1.0，decimal
日期时间：timestamp 年月日时分秒，date 年月日
字符型：string ，varchar ，char
复杂数据类型：数组 array，映射 map，结构体 struct，联合体 uniontype
SerDe----系列化和反序列化
Hive分区表：partitioned by指定分区字段 Clustered By 指定分区字段+可以排序（Sort By）
Distributed By 无序的+划分不同的输出粗粒度划分静态分区和动态分区默认静态分区
分区字段是伪字段，不能与表字段重合
桶表（Bucketed sorted Tables）：细粒度划分提高表的效率和普通标建表语句一样但是有Clustered By 分区
倾斜表（SkewedTables）：知道有些字段null值情况
临时表：只存在当前会话中的表，关闭再打开就没有了，若和已存在的表同名，查询的都是临时表，临时表不支持分区和索引，
查看表语句：show tables /desc formated tables;
删除表：drop table [if exists] table_name[purge] 删除索引被引用的表，索引失效，purge删的干干净净，不移动到垃圾箱
Hive可以创建索引和视图，修改索引，修改视图，修改表
简称的全拼学习：Ddl（Data Definition Language）SQL(Structure Query Language)
Show和desc命令学习：
Show database/schemas like ‘~’;
Show tables;
Show views;(版本不同2.2后有view)
Show tblproperties tblname;
Show create table t;
Show columns in t;
Show formatted t;
Show locks tablename 😭)

Desc database、schema、tablename;
Hive 的导入导出：
导入 —load （文件或者目录）filepath目录不能包含子目录
Load data 【local】inpath ‘filepath’【overwrite】into table tablename 【partition】
filepath目录不能包含子目录，加载的数据是压缩文件（数据）效率低
— insert

ETL工程师知识点
由于笔者很荣幸的参与了目前所在公司的登月计划，整个登月计划过程中收获也颇丰，在此之前，完全没有和数据打交道的经验，所以一些基本问题需要总结出来，以供自己日后参考；
1、作为一名开发人员，我们不仅要懂得技术的实现要点，也需要懂得自己所处工作组的业务逻辑；
2、作为处理数据的工程师，不仅要懂得写基本的SQL，还需要懂得怎么去用日常的许多基本工具；
3、作为数据开发和同步人员，我们往往有必要懂得如何分析基本的数据；
正文
1、同步数据的过程中，有sa层数据、sda层数据、rda层数据，那么这三种数据层的差异在哪里？
首先，简单说明一下数据来源，sa层的数据来源于sqoop直接抽取mysql数据库的数据，属于一个全量的非实时的数据；
sda层数据则是结合了sa层数据+binlog操作日志，组合成为了一个全量的t-1的实时数据；
binlog数据来源，通过阿里的开源框架canal，模仿mysql slave的交互协议，伪装自己为mysql slave，向mysql master发送dump协议，从而收集binary log给slave，得到binlog的字节流日志；
目前同步方式为binlog->Kafka->Spark Streaming->hdfs->Impala刷新；
rda层数据=sda的t-1数据+binlog的t数据，组合成为一个全量的实时数据，保证业务方使用到的数据都是实时的；
2、为什么会有这么多层数据产生，sda层相对于sa层解决了什么，rda层相对于sda层的优点又在哪里？
（1）sda层数据的出现，主要是因为通过sqoop抽取的sa数据，可能会因为sqoop进程启动的时候晚了10分钟，导致最终sa的数据，可能是t-2的数据加上多余10分钟的数据；
为了解决这多处10分钟的数据问题，我们加上binlog的t-1的数据，由于binlog只取最新的数据，所以即使sa有多余10分钟的数据，也最终会被binlog最新的数据给替换，所以组成全新的完整的没有多余数据的t-1数据；
（2）rda层相对于sda层数据的优点在于它是一个实时（t）的数据，同样用sda层数据+binlog数据，是为了避免多余10分钟数据的情况出现，由sda+binlog的数据，又能保证数据是实时的数据；
3、hue平台的使用总结，我们在很多时候会通过hue添加一些大数据组件，其中就有hive和impala，那么两者的区别和各自优势？
在底层表结构和数据变更的时候，hive的实时响应比impala要快很多，所以如果刚刚同步完一张表，如果没有进行refresh或者INVALIDATE METADATA的话，那么hive可能很快能查得到这张表的表结构和同步数据，而impala需要几分钟以后才能开始使用这张表；
impala的查数速度快于hive，这是因为hive的底层查数使用缓慢的MapReduce批处理，而impala直接从HDFS或HBase中用SELECT、JOIN和统计函数查询数据，大大降低了延迟；
4、表结构变更和表数据刷新：refresh table、INVALIDATE METADATA；
5、在删除表的时候出现外健级联的时候，无法drop table之后：
SET foreign_key_checks = 0; // 先设置外键约束检查关闭
drop table table1; // 删除表，如果要删除视图，也是如此
SET foreign_key_checks = 1; // 开启外键约束检查，以保持表结构完整性
6、union all的用法：
select count() from test.table where etl_tx_dt=20181226 union all
select count() from test.table1 where etl_tx_dt=20181226 union all
select count() from test.table2 where etl_tx_dt=20181226 union all
…
7、删除表分区、显示表所有分区：
alter table test.table drop partition (etl_tx_dt=‘2019-02-27’)；
show partitions test.table1；
8、sql验数的经验分析：
（1）计算字段的时候，int、bigint、decimal类型的字段用sum，string、timestamp类型的用count；
（2）当某张表出现数据条数不对的时候，首先要检查基础表数据条数对不对；
（3）当总条数对上，字段条数对上以后，需要去底层分析哪一个字段出现不对，有可能是因为不同的平台，同步数据的方式不同，假设a平台的数据默认null和’‘为空，都计算为一个字段，而b平台同步完以后，只计算null的条数，而不计算’‘的条数，这就会导致某一个字段同步完以后，条数对应不上；
解决办法：case when xxx=’’ then null end as xxx ；
（4）当null也对的上的时候，就需要去定位id，逐步缩小数据失误的范围，最终找到某条id的数据，如：
?
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 按照截断分区查数据：
select floor(id/10000) sa_id,
count(),min(id),max(id)
from test.table
where etl_tx_dt=20190314
GROUP BY floor(id/10000)
order by sa_id
desc

select floor(id/10000) sda_id,
count(*),min(id),max(id)
from test.table
where etl_tx_dt=20190314
GROUP BY floor(id/10000)
order by sda_id
desc
用excel比较出两者的id区别在哪里，然后比较找出相差的区间id;

查找相差区间的最大id和最小id，查最大数和最小数据两条数据：
select * from test.table
where etl_tx_dt=20190314
and id in(26510000,26517670)

查找相差区间的最大id和最小id，查区间数据：
select * from test.table
where etl_tx_dt=20190314
and id>=26510000 and id <=26517670
9、较验数据时候，核对字段的统计策略：
（1）数值类型的都用sum，如：int、bigint、decimal(38,4)；
（2）非数值类型的用count，如：string；

oracle表分区整理
表空间：是一个或多个数据文件的集合，所有的数据对象都存放在指定的表空间中，但主要存放的是表，所以称作表空间。
分区表：当表中的数据量不断增大，查询数据的速度就会变慢，应用程序的性能就会下降，这时就应该考虑对表进行分区。表进行分区后，逻辑上表仍然是一张完整的表，只是将表中的数据在物理上存放到多个表空间(物理文件上)，这样查询数据时，不至于每次都扫描整张表。
什么时候使用分区表？
表的大小超过2GB。
表中包含历史数据，新的数据被增加都新的分区中。

查看分区
select * from liusheng_part partition (liusheng_part_1999_1);
表分区的优缺点
表分区有以下优点：
改善查询性能：对分区对象的查询可以仅搜索自己关心的分区，提高检索速度。
增强可用性：如果表的某个分区出现故障，表在其他分区的数据仍然可用；
维护方便：如果表的某个分区出现故障，需要修复数据，只修复该分区即可；
均衡I/O：可以把不同的分区映射到磁盘以平衡I/O，改善整个系统性能。
缺点：
已经存在的表没有方法可以直接转化为分区表。但是有几种方式可以间接完成这个操作，
分区划分：
按时间
按条数

树操作

1)、查找树中的所有顶级父节点（辈份最长的人）。假设这个树是个目录结构，那么第一个操作总是找出所有的顶级节点，再根据该节点找到其下属节点。
1 select * from tb_menu m where m.parent is null;
2)、查找一个节点的直属子节点（所有儿子）。如果查找的是直属子类节点，也是不用用到树型查询的。
1 select * from tb_menu m where m.parent=1;
3)、查找一个节点的所有直属子节点（所有后代）。
1 select * from tb_menu m start with m.id=1 connect by m.parent=prior m.id;
这个查找的是id为1的节点下的所有直属子类节点，包括子辈的和孙子辈的所有直属节点。
4)、查找一个节点的直属父节点（父亲）。如果查找的是节点的直属父节点，也是不用用到树型查询的。
1
2
3
4 --c–>child, p->parent
select c.id, c.title, p.id parent_id, p.title parent_title
from tb_menu c, tb_menu p
where c.parent=p.id and c.id=6
5)、查找一个节点的所有直属父节点（祖宗）。
1 select * from tb_menu m start with m.id=38 connect by prior m.parent=m.id;
这里查找的就是id为1的所有直属父节点，打个比方就是找到一个人的父亲、祖父等。但是值得注意的是这个查询出来的结果的顺序是先列出子类节点再列出父类节点，姑且认为是个倒序吧。
上面列出两个树型查询方式，第3条语句和第5条语句，这两条语句之间的区别在于prior关键字的位置不同，所以决定了查询的方式不同。当parent = prior id时，数据库会根据当前的id迭代出parent与该id相同的记录，所以查询的结果是迭代出了所有的子类记录；而prior parent = id时，数据库会跟据当前的parent来迭代出与当前的parent相同的id的记录，所以查询出来的结果就是所有的父类结果。
以下是一系列针对树结构的更深层次的查询，这里的查询不一定是最优的查询方式，或许只是其中的一种实现而已。
6)、查询一个节点的兄弟节点（亲兄弟）。
1
2
3 --m.parent=m2.parent–>同一个父亲
select * from tb_menu m
where exists (select * from tb_menu m2 where m.parent=m2.parent and m2.id=6)
7)、查询与一个节点同级的节点（族兄弟）。如果在表中设置了级别的字段，那么在做这类查询时会很轻松，同一级别的就是与那个节点同级的，在这里列出不使用该字段时的实现!
1
2
3
4
5
6
7
8 with tmp as(
select a., level leaf
from tb_menu a
start with a.parent is null
connect by a.parent = prior a.id)
select *
from tmp
where leaf = (select leaf from tmp where id = 50);
这里使用两个技巧，一个是使用了level来标识每个节点在表中的级别，还有就是使用with语法模拟出了一张带有级别的临时表。
8)、查询一个节点的父节点的的兄弟节点（伯父与叔父）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 with tmp as(
select tb_menu., level lev
from tb_menu
start with parent is null
connect by parent = prior id)

select b.*
from tmp b,(select *
from tmp
where id = 21 and lev = 2) a
where b.lev = 1

union all

select *
from tmp
where parent = (select distinct x.id
from tmp x, --祖父
tmp y, --父亲
(select *
from tmp
where id = 21 and lev > 2) z --儿子
where y.id = z.parent and x.id = y.parent);
这里查询分成以下几步。
首先，将第7个一样，将全表都使用临时表加上级别；
其次，根据级别来判断有几种类型，以上文中举的例子来说，有三种情况：
（1）当前节点为顶级节点，即查询出来的lev值为1，那么它没有上级节点，不予考虑。
（2）当前节点为2级节点，查询出来的lev值为2，那么就只要保证lev级别为1的就是其上级节点的兄弟节点。
（3）其它情况就是3以及以上级别，那么就要选查询出来其上级的上级节点（祖父），再来判断祖父的下级节点都是属于该节点的上级节点的兄弟节点。
最后，就是使用union将查询出来的结果进行结合起来，形成结果集。
9)、查询一个节点的父节点的同级节点（族叔）。
这个其实跟第7种情况是相同的。
1
2
3
4
5
6
7
8 with tmp as(
select a., level leaf
from tb_menu a
start with a.parent is null
connect by a.parent = prior a.id)
select *
from tmp
where leaf = (select leaf from tmp where id = 6) - 1;
基本上，常见的查询在里面了，不常见的也有部分了。其中，查询的内容都是节点的基本信息，都是数据表中的基本字段，但是在树查询中还有些特殊需求，是对查询数据进行了处理的，常见的包括列出树路径等。
补充一个概念，对于数据库来说，根节点并不一定是在数据库中设计的顶级节点，对于数据库来说，根节点就是start with开始的地方。
下面列出的是一些与树相关的特殊需求。
10)、名称要列出名称全部路径。
这里常见的有两种情况，一种是从顶级列出，直到当前节点的名称（或者其它属性）；一种是从当前节点列出，直到顶级节点的名称（或其它属性）。举地址为例：国内的习惯是从省开始、到市、到县、到居委会的，而国外的习惯正好相反（老师说的，还没接过国外的邮件，谁能寄个瞅瞅）。
从顶部开始：
1
2
3
4
5 select sys_connect_by_path (title, ‘/’)
from tb_menu
where id = 50
start with parent is null
connect by parent = prior id;
从当前节点开始：
1
2
3
4 select sys_connect_by_path (title, ‘/’)
from tb_menu
start with id = 50
connect by prior parent = id;
在这里我又不得不放个牢骚了。oracle只提供了一个sys_connect_by_path函数，却忘了字符串的连接的顺序。在上面的例子中，第一个sql是从根节点开始遍历，而第二个sql是直接找到当前节点，从效率上来说已经是千差万别，更关键的是第一个sql只能选择一个节点，而第二个sql却是遍历出了一颗树来。再次ps一下。
sys_connect_by_path函数就是从start with开始的地方开始遍历，并记下其遍历到的节点，start with开始的地方被视为根节点，将遍历到的路径根据函数中的分隔符，组成一个新的字符串，这个功能还是很强大的。
11)、列出当前节点的根节点。
在前面说过，根节点就是start with开始的地方。
1
2
3
4 select connect_by_root title, tb_menu.
from tb_menu
start with id = 50
connect by prior parent = id;
connect_by_root函数用来列的前面，记录的是当前节点的根节点的内容。
12)、列出当前节点是否为叶子。
这个比较常见，尤其在动态目录中，在查出的内容是否还有下级节点时，这个函数是很适用的。
1
2
3
4 select connect_by_isleaf, tb_menu.*
from tb_menu
start with parent is null
connect by parent = prior id;

13.excel vlookup 比较两列的名相应后两列的值（D列和H2到H75列有相同的则把对应的E列打印出来）
=COUNTIF(Sheet1!A:A,A7)-----------统计A列的a7出现的次数
=VLOOKUP(A2,B:B,1,FALSE) ------------vlookup查询第一列中的值是否存在在第二列
=VLOOKUP($H $2:$ H $75,$ D $1:$ E$95,2,0)

==VLOOKUP($A $1:$ A $51,$ B $1:$ B$51,1,0)
VLOOKUP(第二列中存在第一列的值显示)

14.分区合分表的区别
什么是分表，从表面意思上看呢，就是把一张表分成N多个小表
什么是分区，分区呢就是把一张表的数据分成N多个区块，这些区块可以在同一个磁盘上，也可以在不同的磁盘上
为什么要分库分表？
数据库中的数据量不一定是可控的，在未进行分库分表的情况下，随着时间和业务的发展，库中的表会越来越多，表中的数据量也会越来越大，相应地，数据操作，增删改查的开销也会越来越大；另外，一台服务器的资源（CPU、磁盘、内存、IO等）是有限的，最终数据库所能承载的数据量、数据处理能力都将遭遇瓶颈。

15.查看星期几
select to_char(to_date(‘2017-01-01’, ‘yyyy-mm-dd’) ,‘DY’) from dual

16.查看年初到年末一共有几个星期一、二。。。。。
select xq ,count(*) from (select rq,to_char(rq, ‘DY’) xq from (select nc + (level - 1) as rq from (select to_date(‘2017-01-01’, ‘yyyy-mm-dd’) as nc from dual) connect by level <= (select add_months(to_date(‘2017-01-01’,‘yyyy-mm-dd’),12) -to_date(‘2017-01-01’, ‘yyyy-mm-dd’) as nm from dual))) group by xq

17.数据库导入导出备份恢复
–查看数据泵地址
select * from all_directories;
–创建数据泵地址
create directory cs_lx as ‘/backup/lxx’;
–授予用户读写权限
grant read,write on directory cs_lx to bbsp;
–导出表只倒表结构加（rows=n）,不打印日志加上参数(nologfile=y)
Expdp lxx/lxx directory=cs_lx dumpfile=lxx.dmp tables= CPPM_AUTHLIST_DATA,CPPM_BANK_DATA rows=n
exp bbsp2/bbsp2@BEMS_49 file=E:\pzw\dmp\move_data_20171102.dmp tables=(ACCEPTIMPAWN,ACCEPTPLEDGE)
导入表
imp bbsp8/bbsp8@BEMS_49 fromuser=bbsp2 touser=bbsp8 ignore=y file=e:\init_data_20171102.dmp full=y
impdp bbsp7/bbsp7 directory=cs_lx dumpfile=lxx.dmp parallel=4 remap_schema=bbsp2:bbsp7

–当前用户导出导入
expdp bbsp7/bbsp7 directory=cs_lx dumpfile=bbsp7_20171122_%U.dmp parallel=4
impdp bbsp7/bbsp7 directory=cs_lx dumpfile=bbsp7_20171122_%U.dmp parallel=4
–全库导出 --不打印日志加上参数nologfile=y
expdp bbsp7/bbsp7 directory=cs_lx dumpfile=bbsp77_20171122_%U.dmp parallel=4 job_name=bbsp_export

18…dat文件入库 sqlload
E:\pzw\sql
1.先把.dat文件移过来
2.修改.ctl
.dat文件和数据库字段对应
.dat文件名
APPEND 还是 TRUNCATE
3…bat 修改.ctl文件名
问题收集
1时间问题 to_date()时间写死
2字符集查看数据库表字符集
2.1SELECT * from Nls_Database_Parameters;
2.2SELECT * FROM v$nls_parameters;
2.3SELECT USERENV(‘language’) FROM dual;

oracle sql 语句字段加双引号，是为了区分大小写

20.查看入职日期的月初
select hiredate,trunc(‘2017-12-12’,‘mm’) from aa_lxx ;

21.查询年月日时分秒月初年初周初月末下月初年初周几月份
select to_number(to_char(hiredate,‘hh24’)) as 时,
to_number(to_char(hiredate,‘mi’)) as 分,
to_number(to_char(hiredate,‘ss’)) as 秒,
to_number(to_char(hiredate,‘dd’)) as 日,
to_number(to_char(hiredate,‘mm’)) as 月,
to_number(to_char(hiredate,‘yyyy’)) as 年,
to_number(to_char(hiredate,‘ddd’)) as 年内第几天,
trunc(hiredate,‘dd’) as 一天之始,
trunc(hiredate,‘day’) as 周初,
trunc(hiredate,‘mm’) as 月初,
last_day(hiredate) as 月末,
add_months(trunc(hiredate,‘mm’),1) as 下月初,
trunc(hiredate,‘yy’) as 年初,
to_char(hiredate,‘day’) as 周几,
to_char(hiredate,‘month’) as 月份
from (select hiredate + 30 / 24 / 60 / 60 + 20 / 24 / 60 + 5 / 24 as hiredate
from aa_lxx
where rownum = ‘1’)

22.计算该年是否为闰年
select hiredate,to_char(last_day(add_months(trunc(hiredate, ‘yy’), 1)), ‘DD’) from aa_lxx
23.一年中的所有星期五
select dy, to_char(dy, ‘day’)
from (select trunc(sysdate, ‘Y’) + (level - 1) dy
from dual connect by level <= add_months(trunc(sysdate, ‘y’), 12) - trunc(sysdate, ‘y’))
where to_char(dy, ‘d’) = 6

24.当月内第一个星期一与最后一个星期一
select next_day(trunc(hiredate,‘mm’)-1,2), next_day(last_day(trunc(hiredate,‘mm’))-7,2) from aa_lxx

25.指定月份的日历
select max(case 周几 when 2 then 日期 end) 周一,
max(case 周几 when 3 then 日期 end) 周二,
max(case 周几 when 4 then 日期 end) 周三,
max(case 周几 when 5 then 日期 end) 周四,
max(case 周几 when 6 then 日期 end) 周五,
max(case 周几 when 7 then 日期 end) 周六,
max(case 周几 when 8 then 日期 end) 周日
from (select to_char(t,‘iw’) 所在周,to_char(t,‘dd’) 日期,to_number(to_char(t,‘d’)) 周几 from (select yc + (level - 1) t
from (select trunc(to_date(‘2017-12-15’, ‘yyyy-mm-dd’), ‘mm’) yc,
add_months(trunc(to_date(‘2017-12-15’, ‘yyyy-mm-dd’), ‘mm’),1) xyc from dual)
connect by level <= (xyc - yc)))
group by 所在周 order by 所在周

26.全年日历

select case when lag(所在月份) over(order by 所在周) = 所在月份 then
null else 所在月份 end as 月份, 所在周,
max(case 周几 when 2 then 日期 end) 周一,
max(case 周几 when 3 then 日期 end) 周二,
max(case 周几 when 4 then 日期 end) 周三,
max(case 周几 when 5 then 日期 end) 周四,
max(case 周几 when 6 then 日期 end) 周五,
max(case 周几 when 7 then 日期 end) 周六,
max(case 周几 when 8 then 日期 end) 周日
from (select 日期, 所在月份, case when 所在月份 = ‘12’ and 所在周 = ‘01’ then
‘53’ else 所在周 end as 所在周, to_number(to_char(日期, ‘d’)) 周几
from (select 日期,to_char(日期, ‘mm’) as 所在月份, to_char(日期, ‘iw’) as 所在周
from (select 本年初 + (level - 1) as 日期 from (select trunc(to_date(年份, ‘yyyy’)) as 本年初,
add_months(trunc(to_date(年份, ‘yyyy’)),12) as 下年初 from (select 2013 as 年份 from dual))
connect by level <= 下年初 - 本年初))) group by 所在月份,所在周 order by 2

27.删除重复数据
1.rowid(建单列索引name) 最高效的删除重复记录方法（因为使用了rowid）
delete from a c where c.rowid < (select max(cc.rowid) from a cc where c.id = cc.id);
DELETE FROM EMP E
WHERE E.ROWID > (SELECT MIN(X.ROWID) FROM EMP X WHERE X.EMPNO = E.EMPNO);

2.临时表
1)、execute immediate ‘create table cust_info_tp as select max(id) as id, cust_no from CUST_INFO_TEMP cc group by cust_no having count(cust_no) > 1’;
2)、 execute immediate ‘delete from CUST_INFO_TEMP c where c.id < (select id from cust_info_tp cc where c.cust_no = cc.cust_no)’;
3.根据name相同id不同的方式来判断(利用这种方式需要建组合索引)
Delete from emp a where exists (select null from emp b where b.name=a.name and b.id>a.id);

4.通过分析函数根据name分组生成序号，然后删除序号大于1的数据。
DELETE FROM EMP
WHERE ROWID IN (SELECT RID
FROM (SELECT ROWID AS RID,
ROW_NUMBER() OVER(PARTITION BY ENAME ORDER BY empno) AS SEQ
FROM EMP)
WHERE SEQ > 1)；

28.查询重复数据（拼接出所有表的查重语句）
SELECT ‘select count(’ || COLUMN_NAME || ‘),’ || COLUMN_NAME || ’ from ’ || TABLE_NAME || ’ group by ’ || COLUMN_NAME || ’ having count(’ || COLUMN_NAME || ‘) > 1;’ FROM USER_TAB_COLUMNS WHERE TABLE_NAME LIKE ‘NEDW%’ AND COLUMN_ID=1；
select count(BILL_ID),BILL_ID from NEDW_DAILY_BALANCE group by BILL_ID having count(BILL_ID) > 1;
29.oracle 语句提高查询效率的方法
1.用EXISTS替代IN，用NOT EXISTS替代NOT IN
2.避免使用HAVING字句，用WHERE替代
3.表内数据量小的表放最后
4.过滤掉最大数量记录的条件写在where子句的末尾
5.避免使用*
6．使用decode函数来减少处理时间
7.truncate替代delete
8.多使用commit
9.count（）比count（1）快
10.使用表的别名，别名.列
11.用表连接替换exists
12.用exists替换distinct
13．在sqlplus，sqlforms和proc中重新设置arraysize参数
14.sql语句用大写
15.在Java代码中尽量少用“+”连接
16.避免在索引列上使用not
17.避免在索引列上使用计算
18.用>=代替>
19.用union代替or
20.用in替换or
21．避免在索引列上使用is nul 和 not null
22.总是使用索引的第一列
23.用union all代替union
24.“！=”，“||”，“+”将不使用索引
25.表分区
26.频繁查询的sql建立临时表

30.数据泵

drop user bbsp cascade;
create user bems4 identified by bems4 default tablespace dbs;
grant connect,resource,dba to bems4;
–查看数据泵地址
select * from all_directories;
–创建数据泵地址
create directory imp_dir as ‘/backup’;
–授予用户读写权限
grant read,write on directory imp_dir to bbsp;

/* 数据泵导出导入 */

–导出单表或多个表
expdp bbsp/bbsp directory=IMP_DIR dumpfile=rgct_bill_hist.dmp tables=rgct_bill_hist,rgct_bill_info
–导入单表或多个表
impdp bbsp/bbsp directory=IMP_DIR dumpfile=rgct_bill_hist.dmp tables=rgct_bill_hist,rgct_bill_info

总结：导入别的库不用加表名

–全库导出 --不打印日志加上参数nologfile=y
expdp bbsp/bbsp directory=IMP_DIR dumpfile=bbsp_20180606_%U.dmp parallel=4 job_name=bbsp_export ----
–当前用户导出导入
impdp bbsp4/bbsp4 directory=DATADUMP dumpfile=bbsp_20180606_%U.dmp parallel=4 remap_schema=bbsp:bbsp4 ----
–非当前用户导出导入
impdp bems4/bems4 directory=DATADUMP dumpfile=bbsp_20180605_%U.dmp parallel=4 remap_schema=bbsp:bems4

/* 常用导入 */
–bbsp>bbsp4
impdp bbsp/bbsp directory=DMP_DIR dumpfile=bsp6_20180601_%U.dmp parallel=4 remap_schema=bbsp6:bbsp9 table_exists_action=skip include=index,constraint,comment
–bems>bems4
impdp bems4/bems4 directory=IMP_DIR dumpfile=bbsp_20170824_%U.dmp parallel=4 remap_schema=bems:bems4

、
31.复制表
CREATE TABLE aa_lxxx AS SELECT * from aa_lxx
32.复制表结构
CREATE TABLE aa_lxxxx AS SELECT * from AA_LXX WHERE 1=2
33.两张关联表，删除主表中已经在副表中没有的信息
DELETE FROM aa_lxx a WHERE NOT exists (SELECT * from aa_lxxx b WHERE a.ID=b.ID);
34. 吴陈达：修改一张表的一个字段，按照状态为1的数据一半一半修改-----rownum
UPDATE PAY_SIGN_RECIVER PA
SET PA.HOST_IP = ‘10.1.88.51’
WHERE PA.ID IN (SELECT PS.ID
FROM PAY_SIGN_RECIVER PS
WHERE PS.OPER_STATS = ‘1’
AND ROWNUM <= (SELECT COUNT(*) / 2
FROM PAY_SIGN_RECIVER PS
WHERE PS.OPER_STATS = ‘1’));
35.Case when then 写法
SELECT empno,CASE WHEN sal<=1000 THEN ‘低工资人群’ WHEN sal BETWEEN 1000 AND 3000 THEN ‘中等’ END from emp;

36.查询第几条数据前十条数据分页查询：
–写一个分页查询
SELECT *
FROM (SELECT E., ROWNUM RN FROM EMP E WHERE ROWNUM <= 10) EM
WHERE RN > 5;
SELECT * from ( SELECT row_number() OVER(ORDER BY ROWID) row_number, a. from aa_lxx a )WHERE row_number<=10;
1.SELECT * from emp WHERE ROWNUM <=2 ORDER BY sal
2.SELECT * from (SELECT e.* , ROWNUM rn from emp e WHERE ROWNUM <=8 ORDER BY sal ) WHERE rn>2

试图
用视图view 建立视图不包含不修改的那几列 —阻止对某几列的插入
***单一表试图可以插入操作，多个表插入可能会报错
视图(VIEW)也被称作虚表，即虚拟的表，是一组数据的逻辑表示,其本质是对应于一条SELECT语句，结果集被赋予一个名字，即视图名字。
视图本身并不包含任何数据，它只包含映射到基表的一个查询语句，当基表数据发生变化，视图数据也随之变化。
38.给数据重排房间号
MERGE INTO HOTEL A
USING (SELECT ROWID AS RID,
(FLOOR_NBR * 100) + ROW_NUMBER() OVER(PARTITION BY FLOOR_NBR ORDER BY ROWID) AS ROOM_NBR
FROM HOTEL) B
ON (A.ROWID = B.ROWID)
WHEN MATCHED THEN UPDATE SET A.ROOM_NBR = B.ROOM_NBR;
原数据样式 11223 100 100 100 100 100

39.查询存储过程跑批时间
SELECT task_name, TABLE_NAME ,ROUND((MAX(END_TIME)-MIN(START_TIME))2460,4) from SYS_LOGRECORD GROUP BY ROLLUP (TABLE_NAME,task_name) ORDER BY TABLE_name;

SELECT TASK_NAME,
ROUND((MAX(END_TIME) - MIN(START_TIME)) * 24 * 60, 4) AS ff
FROM SYS_LOGRECORD
GROUP BY TASK_NAME
ORDER BY ff DESC;

******rollup 分组函数：group by rollup(a,b,c): rollup(ab)(ac)(bc)(abc)…….
40.为什么用存储过程，为什么用plsql而不是sql
答：SQL是结构化查询语言，比较接近自然语言，使用SQL，只需要说干什么，不需要说怎么干。由数据定义语言、数据操纵语言、数据控制语言构成，它不面向过程，即前一条语句与后一条语句无关。SQL是标准的语。
PL/SQL，Oracle对SQL标准的扩充，增加了面向过程的功能，所以可以用来编写存储过程、存储函数、触发器等等。 PL/SQL是结构化SQL，就是在标准SQL中加入了IF…ELSE… For…等控制过程的SQL。
PLSQL是什么
是专用于Oracle服务器，在SQL基础之上，添加了一些过程化控制语句，叫PLSQL
过程化包括有：类型定义，判断，循环，游标，异常或例外处理。。。
PLSQL强调过程
为什么要用PLSQL
因为SQL是第四代命令式语言，无法显示处理过程化的业务，所以得用一个过程化程序设计语言来弥补SQL的不足之处，
SQL和PLSQL不是替代关系，是弥补关系
41.比较两个数据库差异
打开较多的库bbsp9—tools—compare_user_objects—选择要对比的数据库（target_session）—开始对比（compare）

42.如何使用oracle的游标

oracle中的游标分为显示游标和隐式游标
显示游标是用cunsor_is命令定义的游标，它可以对查询语句（select）返回的多条记录进行处理；隐式游标是在执行插入、删除、修改和返回单挑记录的查询语句时由pl/sql自动定义的。
显示游标的操作：打开游标、操作游标、关闭游标；pl/sql隐式地打开sql游标，并在它内部处理sql语句，然后关闭它。
43.游标学习
–2.使用游标和loop循环来显示所有部门的名称

–游标声明
CURSOR c_dept
IS
–select语句
SELECT dname FROM dept;
–指定行指针，这句话应该是指定和c_dept行类型相同的变量
row_dept c_dept%ROWTYPE;
BEGIN
–fou循环
FOR row_dept IN c_dept LOOP

dbms_output.put_line('部门名称：'||row_dept.dname);
END LOOP;

END;
–3.使用while打印和游标循环所有部门的地理位置（loc）
CURSOR csr_testwhile
IS
SELECT loc FROM dept;
row_loc csr_testwhile%ROWTYPE;
BEGIN
OPEN csr_testwhile;
FETCH csr_testwhile INTO row_loc;
WHILE csr_testwhile%FOUND LOOP
dbms_output.put_line(‘部门地点：’||row_loc.loc);
FETCH csr_testwhile INTO row_loc;
END LOOP;
CLOSE csr_testwhile;
–4.接收用户输入的部门编号，用for循环和游标，打印出此部门的所有雇员的所有信息（使用循环游标）
CURSOR c_dept(p_deptno NUMBER)
IS
SELECT * FROM emp WHERE
emp.deptno=p_deptno;
r_emp c_dept%ROWTYPE;
BEGIN
FOR r_emp IN c_dept(v_lvg) LOOP

dbms_output.put_line('员工号：'||r_emp.empno||'员工名'||r_emp.ename||'工资'||r_emp.sal);
END LOOP;

–5.向游标传递一个工种，显示此工种的所有雇员的所有信息（使用参数游标）
–游标声明
CURSOR c_job(p_job nvarchar2)
IS
–select语句
SELECT * FROM emp WHERE job=p_job;
–指定行指针，这句话应该是指定和c_dept行类型相同的变量
r_job emp%ROWTYPE;
BEGIN
–fou循环
FOR r_job IN c_job(‘CLERK’) LOOP

dbms_output.put_line('员工号：'||r_job.empno||' '||'员工姓名'||r_job.ename);
END LOOP;

END;
–6．用更新游标来为雇员加佣金；（用if实现，创建一个与emp表一模一样的emp1表，对emp1表进行修改操作），并将更新前后的数据输出出来

CURSOR CRS_UPDATE IS
–select语句
SELECT * FROM EMP1 FOR UPDATE OF SAL;
–指定行指针，这句话应该是指定和c_dept行类型相同的变量
EMPINFO CRS_UPDATE%ROWTYPE;
SALINFO EMP1.SAL%TYPE;
BEGIN
–fou循环
FOR EMPINFO IN CRS_UPDATE LOOP
IF EMPINFO.sal < 1500 THEN
SALINFO := EMPINFO.SAL * 1.2;
ELSIF EMPINFO.sal< 2000 THEN
SALINFO := EMPINFO.SAL * 1.5;
ELSIF EMPINFO.sal < 3000 THEN
SALINFO := EMPINFO.SAL * 2;

END IF;
UPDATE EMP1 SET SAL = SALINFO WHERE CURRENT OF CRS_UPDATE;

END LOOP;
COMMIT;
END;
–7.编写一个pl/sql程序块，对名字以‘A’或‘S’开始的所有雇员按他们的基本薪水（sal）的10%给他们加薪（对emp1表进行修改操作）
CURSOR CRS_ADDSAL IS
–select语句
SELECT *
FROM EMP1
WHERE ENAME LIKE ‘A%’
OR ENAME LIKE ‘S%’
FOR UPDATE OF SAL;
–指定行指针，这句话应该是指定和c_dept行类型相同的变量
R_ADDSAL CRS_ADDSAL%ROWTYPE;
SALEINFO EMP1.SAL%TYPE;
BEGIN
–fou循环
FOR R_ADDSAL IN CRS_ADDSAL LOOP
DBMS_OUTPUT.PUT_LINE(R_ADDSAL.ENAME || ‘原来的工资：’|| R_ADDSAL.SAL);
SALEINFO :=R_ADDSAL.Sal*1.1;
UPDATE EMP1 SET SAL = SALEINFO WHERE CURRENT OF CRS_ADDSAL;

END LOOP;
COMMIT;
END;

–8．编写一个pl/sql程序块，对所有的salesman增加佣金（comm）500
CURSOR csr_addcomm(P_job nvarchar2) IS
–select语句
SELECT *
FROM EMP1
WHERE job=p_job
FOR UPDATE OF comm;
–指定行指针，这句话应该是指定和c_dept行类型相同的变量
R_ADDcomm csr_addcomm%ROWTYPE;
comminfo EMP1.SAL%TYPE;
BEGIN
–fou循环
FOR R_ADDcomm IN csr_addcomm(‘saleman’) LOOP
comminfo :=R_ADDcomm.Comm+500;
UPDATE EMP1 SET comm = comminfo WHERE CURRENT OF csr_addcomm;

END LOOP;
COMMIT;
END;
–9.编写一个pl/sql程序块，以提升2个资质最老的职员为manager（工作时间越长，资质越老）
–（提示：可以定义一个变量作为计数器控制游标只提取两条数据；也可以在声明游标的时候把雇员中资质最老的两个人查出来放到游标中。）
CURSOR CSR_TESTCOMPUT IS
–select语句
SELECT * FROM EMP1 ORDER BY HIREDATE ASC;
–计数器
TOP_TWO NUMBER := 2;
R_TESTCOMPUT CSR_TESTCOMPUT%ROWTYPE;
BEGIN
OPEN CSR_TESTCOMPUT;
FETCH CSR_TESTCOMPUT
INTO R_TESTCOMPUT;
WHILE TOP_TWO > 0 LOOP

DBMS_OUTPUT.PUT_LINE('员工姓名：' || R_TESTCOMPUT.ENAME || '工作时间' ||R_TESTCOMPUT.HIREDATE);
--计数器减--
TOP_TWO := TOP_TWO - 1;
FETCH CSR_TESTCOMPUTINTO R_TESTCOMPUT;

END LOOP;
CLOSE CSR_TESTCOMPUT;
END;

–10.编写一个pl/sql程序块，对所有雇员按他们的基本薪水（sal）的20%为他们加薪，
–如果增加的薪水大于300就取消加薪（对emp1表进行修改操作，并将更新前后的数据输出出来）
CURSOR CRS_UPDATESAL IS
–select语句
SELECT * FROM EMP1 FOR UPDATE OF SAL;

R_UPDATESAL CRS_UPDATESAL%ROWTYPE;
SALINFO EMP1.SAL%TYPE;
SALADD EMP1.SAL%TYPE;
BEGIN
FOR R_UPDATESAL IN CRS_UPDATESAL LOOP
SALADD := R_UPDATESAL.Sal * 0.2;
IF SALADD > 300 THEN
SALINFO := R_UPDATESAL.SAL;
DBMS_OUTPUT.PUT_LINE(R_UPDATESAL.ENAME || ‘加薪失败’ || ‘a薪水维持在：’ ||
R_UPDATESAL.SAL);
ELSE
SALINFO := R_UPDATESAL.Sal + SALADD;
DBMS_OUTPUT.PUT_LINE(R_UPDATESAL.ENAME || ‘加薪成功’ || ‘a薪水变为：’ ||
SALINFO);
END IF;
UPDATE EMP1 SET SAL = SALINFO WHERE CURRENT OF CRS_UPDATESAL;
END LOOP;
END;
–11.将每位员工工作了多少年零多少月零多少天输出出来
–近似
CURSOR CRS_WORKDAY IS
–select语句
SELECT ENAME,
HIREDATE,
TRUNC(MONTHS_BETWEEN(SYSDATE, HIREDATE) / 12) AS SPANDYEARS,
TRUNC(MOD(MONTHS_BETWEEN(SYSDATE, HIREDATE), 12)) AS MONTHS,
TRUNC(MOD(MOD(SYSDATE - HIREDATE, 365), 12)) AS DAYS
FROM EMP1;

R_WORKDAY CRS_WORKDAY%ROWTYPE;
BEGIN

FOR R_WORKDAY IN CRS_WORKDAY LOOP

DBMS_OUTPUT.PUT_LINE(R_WORKDAY.ENAME || '已经工作了' ||R_WORKDAY.SPANDYEARS || '年零' || '工作时间' ||R_WORKDAY.MONTHS || '月零' || R_WORKDAY.DAYS || '天');

END LOOP;

END;
–12.输入部门编号，按照下列加薪比例执行（用case实现，创建一个emp1表，修改emp1的数据），并将更新前后的数据输出出来
–deptno raise(%)
–10 5%
–20 10%
–30 15%
–40 20%
–加薪比例以现有的sal为标准
–游标声明

CURSOR CRS_CASETEST IS
–select语句
SELECT * FROM EMP1 FOR UPDATE OF sal;
–指定行指针，这句话应该是指定和c_dept行类型相同的变量
R_CASETEST CRS_CASETEST%ROWTYPE;
SALINFO EMP1.SAL%TYPE;
BEGIN
–fou循环
FOR R_CASETEST IN CRS_CASETEST LOOP
IF
R_CASETEST.DEPTNO = 10 THEN
SALINFO := R_CASETEST.SAL * 1.05;
ELSIF R_CASETEST.DEPTNO = 20 THEN
SALINFO := R_CASETEST.SAL * 1.1;
ELSIF R_CASETEST.DEPTNO = 30 THEN
SALINFO := R_CASETEST.SAL * 1.15;
ELSIF R_CASETEST.DEPTNO = 40 THEN
SALINFO := R_CASETEST.SAL * 1.2;
END IF;
UPDATE EMP1 SET SAL = SALINFO WHERE CURRENT OF CRS_CASETEST;

END LOOP;
COMMIT;
END;
–13.对每位员工的薪水进行判断，如果该员工薪水高于其所在部门的平均薪水，则将其薪水减50元，
–输出更新前后的薪水，员工姓名，所在部门编号。
CURSOR CRS_TESTAVG IS
–select语句
SELECT ENAME,
EMPNO,
JOB,
SAL,
DEPTNO,
AVG(SAL) OVER(PARTITION BY DEPTNO) AS DEP_AVG
FROM EMP1
FOR UPDATE OF SAL;

R_TESTAVG CRS_TESTAVG%ROWTYPE;
SALINFO EMP1.SAL%TYPE;
BEGIN

FOR R_TESTAVG IN CRS_TESTAVG LOOP
IF R_TESTAVG.SAL > R_TESTAVG.DEP_AVG THEN
SALINFO := R_TESTAVG.SAL - 50;
END IF;
UPDATE EMP1 SET SAL = SALINFO WHERE CURRENT OF CRS_TESTAVG;
END LOOP;
COMMIT;
END;

44.同一key的value值拼接
SELECT KEY, LTRIM(SYS_CONNECT_BY_PATH(KEY, ‘+’), ‘+’)
FROM (SELECT KEY,
VALUE,
ROW_NUMBER() OVER(PARTITION BY KEY ORDER BY VALUE) RN,
COUNT(1) OVER(PARTITION BY KEY) CNT
FROM A) A
WHERE LEVEL = CNT
START WITH RN = 1
CONNECT BY PRIOR KEY = KEY
AND PRIOR RN = RN - 1
45.事物的概念：锁的概念：视图：游标
事务：事物就是被绑在一起作为一个逻辑工作单元的sql语句分组，如果任何一个语句操作失败那么整个操作就失败，以后操作就会回滚到操作之前状态，或者是上一个节点。为了确保要么执行，要么不执行，就可以使用事务。要将有组语句作为事务考虑，就需要通过acid测试，即原子性，一致性，隔离性和持久性。
锁：在所以的dbms中，锁是实现事务的关键，锁可以保证事务的完整性和并发性。与现实生活中的锁一样，它可以使某些数据的拥有者，在某段时间内不能使用某些数据或数据结构。当然锁还分级别的。
视图：是一种虚拟的表，具有和物理表相同的功能。可以对视图进行增，改，查，操作，视图通常是有一个表或者多个表的行或列的子集。对视图的修改不影响基本表。它使得我们获取数据更容易，相比多表查询。
游标：是对查询出来的结果集作为一个单元来有效的处理。游标可以定在该单元中的特定行，从结果集的当前行检索一行或多行。可以对结果集的当前行做修改。一般不使用游标，但是需要逐条处理数据的时候，游标显得十分重要。

46.使用存储过程访问数据库比直接用sql语句访问有哪些优点
存储过程是预编译过的，执行时无须编译，执行速度更快；存储过程封装了一批sql语句，便于维护数据的完整性与一致性；可以实现代码的复用。
47.Trunkate和delete的区别
1.truncate在各种表上无论是大的还是小的都非常快。如果有rollbake命令delete将被撤销，而truncate则不会被撤销。
2.truncate是一个ddl语言而delete是dml语句，向其他所有的ddl语言一样，他将被隐式提交，不能对truncate使用rollback命令。
3.truncate将重新设置高水位线和所有的索引。在对整个表和索引进行完全浏览时，经过truncate操作后的表比delete操作后的表要快得多。
4.truncate不能触发触发器，delete会触发触发器。
5.不能授予任何人清空他人的表的权限。
6.当表被清空后表和表的索引将重新设置成初始大小，而delete不能。
7.不能清空副表。
48.谈谈索引的用法及原理
索引是若干数据行的关键字的列表，查询数据时，通过索引中的关键字可以快速定位到要访问的记录所在的数据块，从而大大减少读取数据块的i/o次数，因此可以显著提高性能。
49.oracle索引分为几类，说出唯一索引和位图索引的概念
Oracle索引有B树索引，位图索引，函数索引，簇索引等。
唯一索引也是B树索引的一种，它要求被索引的字段值不可以重复。在创建的时候使用B树算法创建。
位图索引并不是采用像唯一索引那样存储（引字段值，记录rowid）来创建索引段的，而是为每一个唯一索引的字段值创建一个位图，位图中使用位元来对应一个记录的rowid。位元到rowid是通过映射得到的。
50.使用索引的理由
快速访问表中的data block
51. 数据库多线程

alter session enable parallel dml;
alter table RGCT_BILL_INFO nologging;

insert /*+ APPEND PARALLEL(dailylink,6) / into RGCT_BILL_INFO dailylink select /+ parallel(daily,6) */ * from RGCT_BILL_INFO_B daily;
commit;

alter table RGCT_BILL_INFO logging;
alter session disable parallel dml;
commit;
52.怎样把这样一个表，查成这样一个结果

SELECT YEAR,
(SELECT amount FROM AAA m WHERE MONTH=1 AND m.year=aaa.year) AS M1,
(SELECT amount FROM AAA m WHERE MONTH=2 AND m.year=aaa.year) AS M2,
(SELECT amount FROM AAA m WHERE MONTH=3 AND m.year=aaa.year) AS M3,
(SELECT amount FROM AAA m WHERE MONTH=4 AND m.year=aaa.year) AS M4
FROM AAA
GROUP BY YEAR;

53．区块链
比特币去中心化的账本区块存储组织数据链的形式存储可编程的智能合约代码片段可触发的可追溯
验证的指纹存储（照片指纹 MD5）记录无上限看本地磁盘（以太坊比特币）是一个平台 case by case 定制平台
共识算法（全量数据一样的，） kafka 时间有序的
智能合约：不可篡改不可被调用在链上代码上链可信发比单位驱动代码（不可篡改）区块链网络里执行的
上链的一瞬间是可信的上链前是不可信的
联盟区块链：规定节点（节点是一个程序）
公有区块链：可信的没有条件节点
私有区块链：规定节点存储很少的数据量

众筹 --互联网金融领域的应用
比特币–最成功的的应用（可信的） UTxO：记账模式交易过程这前3来源和2去向可回溯不可篡改
spv：移动设备的钱包比特币的买卖
区块链加：区块链手机存储钱包地址（记一大堆私钥记住密匙）七笔交易地址收敛追随每笔钱的来源
区块链：不擅长海量数据存储

区块链状态

54．触发器的作用
触发器是一种特殊的存储过程，主要是通过事件来触发而被执行的。它可以强化约束，来维护数据的完整性和一致性，可以跟踪数据库内操作从而不允许未经许可的更新和变化。可以联级运算。如，某表上的触发器上包含对另一个表的数据操作，而该操作又会导致该表触发器被触发。

强化约束
联级运算
55．什么是内存泄露
一般我们所说的内存泄露指的是堆内存的泄露。堆内存是程序从堆中为其分配的，大小任意的，使用完后要显示释放内存。当应用程序关键字new等创建对象时，就从堆中为它分配一块内存，使用完后程序调用free或者delete释放该内存，否则就说该内存就不能被使用，我们就说该内存被泄露了。

56．行转列动态出转换的列 pivo

–建表
–drop table SalesList;
create table SalesList(
keHu varchar2(20), --客户
shangPinId number(8), --商品Id
shangPin varchar2(20), --商品名称
salesNum number(8) --销售数量
);

–插入数据
declare
–谈几个客户
cursor lr_kh is
select regexp_substr(‘张三、李四、王五、赵六’,’[^、]+’,1, level) keHu from dual
connect by level <= 4;
–进点货
cursor lr_sp is
select level shangPinId, regexp_substr(‘上衣、裤子、袜子、帽子’,’[^、]+’,1, level) shangPin from dual
connect by level <= 4;
begin
–循环插入
for v_kh in lr_kh loop
for v_sp in lr_sp loop
insert into SalesList
select v_kh.keHu, v_sp.shangPinId, v_sp.shangPin, floor(dbms_random.value(10,50)) from dual;
end loop;
end loop;
commit;
end;
/

–看下源数据
select * from salesList a;

–固定行转列
select *
from (select kehu, shangPin, salesNum from salesList) pivot(
max(salesNum) for shangPin in (
‘上衣’ as 上衣,
‘裤子’ as 裤子,
‘袜子’ as 袜子,
‘帽子’ as 帽子
)
);

–动态行转列
call p_RowsToCols(‘select keHu, shangPin, salesNum from salesList’,
‘select distinct shangPinId, shangPin cols from salesList order by shangPinId’,
‘max(salesNum)’,
‘shangPin’,
‘sales_RowsToCols’);

select * from sales_RowsToCols;

57．表空间问题
DROP TABLESPACE DBS_IDX INCLUDING CONTENTS AND DATAFILES;–删除表空间

查询使用表空间(DBS_IDX)的表
SELECT 'alter table ’ ||OWNER|| ‘.’ ||TABLE_NAME|| ’ drop constraint ’ ||CONSTRAINT_NAME|| ‘;’
FROM DBA_CONSTRAINTS
WHERE CONSTRAINT_TYPE IN (‘U’, ‘P’)
AND (INDEX_OWNER, INDEX_NAME) IN
(SELECT owner,segment_name FROM DBA_SEGMENTS WHERE TABLESPACE_NAME = ‘DBS_IDX’);

查看表空间使用情况
SELECT A.TABLESPACE_NAME “表空间名”,
TOTAL “表空间大小”,
FREE “表空间剩余大小”,
(TOTAL - FREE) “表空间使用大小”,
TOTAL / (1024 * 1024 * 1024) “表空间大小(G)”,
FREE / (1024 * 1024 * 1024) “表空间剩余大小(G)”,
(TOTAL - FREE) / (1024 * 1024 * 1024) “表空间使用大小”,
ROUND((TOTAL - FREE) / TOTAL, 4) * 100 “使用率%”
FROM (SELECT TABLESPACE_NAME, SUM(BYTES) free
FROM DBA_FREE_SPACE
GROUP BY TABLESPACE_NAME) A,
(SELECT TABLESPACE_NAME, SUM(BYTES) TOTAL
FROM Dba_Data_Files
GROUP BY TABLESPACE_NAME) B
WHERE A.TABLESPACE_NAME = B.TABLESPACE_NAME;

查看（临时）表空间使用情况
SELECT D.TABLESPACE_NAME,
SPACE “sum_space(M)”,
BLOCKS sum_blocks,
USER_SPACE “USER_SPACE(M)”,
ROUND(NVL(USEr_SPACE, 0) / SPACE * 100, 2) “used_rate(%)”,
NVL(FREE_SPACE, 0) “free_space(M)”
FROM (SELECT TABLESPACE_NAME,
ROUND(SUM(BYTES) / (1024 * 1024), 2) SPACE,
SUM(BLOCKS) BLOCKS
FROM DBA_TEMP_FILES
GROUP BY TABLESPACE_NAME) D,
(SELECT TABLESPACE_NAME,
ROUND(SUM(BYTES_USED) / (1024 * 1024), 2) USER_SPACE,
ROUND(SUM(BYTES_FREE) / (1024 * 1024), 2) FREE_SPACE
FROM V$TEMP_SPACE_HEADER
GROUP BY TABLESPACE_NAME) F
WHERE D.TABLESPACE_NAME = F.TABLESPACE_NAME(+)

Ora-01652 索引表空间不足（自动）修改临时表空间
SELECT * from Dba_Data_Files;
ALTER DATABASE DATAFILE ‘/oradata/DBS_IDX_1.dbf’ RESIZE 12000m; 扩容 ****临时表空间也是一样的扩容笨蛋
SELECT Tablespace_name,file_name,bytes/1024/1024 file_size,Autoextensible from dba_temp_files;-- 查看临时表空间大小

临时表空间扩容
ALTER DATABASE TEMPFILE ‘/oradata/BEMS/datafile/temp.dbf’ RESIZE 5000M
SELECT * from Database_Properties WHERE property_name=‘DEFAULT_TEMP_TABLESPACE’;

SELECT Tablespace_name,file_name,bytes/102/4/1024 file_size,Autoextensible from Dba_Temp_Files;

查看表空间使用情况（修改自动扩展）
SELECT * from dba_data_files;
ALTER DATABASE DATAFILE ‘D:\DBS_IDX.ORA’ AUTOEXTEND ON;
58．查询一个表的某两个列都大于两条的数据
SELECT BILL_NO, rgct_id
FROM DISC_BILL_INFO B2
WHERE EXISTS (SELECT BILL_NO, rgct_id
FROM DISC_BILL_INFO B1
WHERE B1.rgct_id = B2.rgct_id
AND B1.BILL_NO = B2.BILL_NO
GROUP BY BILL_NO, rgct_id
HAVING COUNT(*) >= 2);
59．Sql基础学习
–表空间
CREATE TABLESPACE temptablespace_lxx datafile ‘D:\temptablespace_lxx.ora’ SIZE 1000m;
SELECT * FROM User_Tablespaces;
SELECT * from user_users;
SELECT A.TABLESPACE_NAME, (1 - (A.TOTAL) / B.TOTAL) * 100 USED_PERCENT
FROM (SELECT TABLESPACE_NAME, SUM(BYTES) TOTAL
FROM DBA_FREE_SPACE
GROUP BY TABLESPACE_NAME) A,
(SELECT TABLESPACE_NAME, SUM(BYTES) TOTAL
FROM DBA_DATA_FILES
GROUP BY TABLESPACE_NAME) B
WHERE A.TABLESPACE_NAME = B.TABLESPACE_NAME;–查看表空间的增张情况
SELECT tablespace_name,segment_space_management from dba_tablespaces; --查看表空间是否手动管理
SELECT * from dba_ts_quotas; --查询配额

–用户
CREATE USER bbsp6 IDENTIFIED BY lxx1 DEFAULT TABLESPACE tablespace_lxx QUOTA 500m ON USERS TEMPORARY TABLESPACE temptablespace_lxx;
DROP USER lxxx CASCADE;–删除用户(如果用户下有对象，用cascade，可删除用户所有的对象，然后再删除用户)
ALTER USER lxx IDENTIFIED BY lxxx;–修改用户密码
ALTER USER lxx ACCOUNT LOCK; --用户锁定
ALTER USER lxx ACCOUNT UNLOCK;–用户解锁
SELECT * from dba_sys_privs;–查看用户系统权限
SELECT * from user_sys_privs;–查看当前用户系统权限
SELECT * from Session_Privs;–查看当前会话系统权限
SELECT * from USER_TABLES;–查看用户下的所有表
SELECT * from User_Objects WHERE instr(object_name,‘DE’)>0; --查看用户下的所有表
SELECT SUM(BYTES) / (1024 * 1024) AS “size(M)”
FROM USER_SEGMENTS
WHERE SEGMENT_NAME = UPPER(’&table_name’);–查看某表的大小
DROP USER APEX_030200 CASCADE; --删除用户
ALTER TABLE test_lxx RENAME TO aa_lxx;–修改表名
ALTER TABLE aa_lxx ADD age VARCHAR2(3);–增加字段
ALTER TABLE TEST_lxx Modify age VARCHAR2(4);–修改字段属性
ALTER TABLE test_lxx DROP COLUMN age;–删除字段
ALTER TABLE TEST_lxx RENAME COLUMN age TO lxx_age;–修改字段名
CONNECT:ALTER SESSION、CREATE CLUSTER,CREATE databaselink,CREATE sequence,CREATE SESSION,CREATE synonym,CREATE TABLE,CREATE triggr
resource:CREATE cluster,CREATE PROCEDURE,CREATE sequence,CREATE TABLE,CREATE triggr
SELECT * from dba_USERS; --用户状态

–角色
CREATE ROLE student;–创建角色
GRANT SELECT ON CLASS TO student;–给角色赋权
DROP ROLE student;–删除角色s
GRANT ALL PRIVILEGES TO lxx;–赋权
GRANT CONNECT ,resource,DBA TO lxx;–赋权
GRANT SELECT ANY TABLE TO TEST;–赋权给test表select权限
GRANT UPDATE(job) ON emp1 TO TEST;–把表的某一列操作权限赋权给其他用户
SELECT * from User_Tab_Privs_Made;–查看都把哪些表什么权限赋予了其他用户
GRANT ALL TO USER;–赋权
GRANT CREATE SESSION,SELECT ANY TABLE,DBA TO USER;–赋权
GRANT CREATE SESSION,CREATE TABLE,SELECT ANY TABLE,DBA TO ceshi WITH ADMIN OPTION;–(admin option 使该用户具有转授系统权限的权限)
REVOKE CREATE TABLE FROM lxx;–收回系统权限
REVOKE CREATE SESSION FROM lxx;–收回系统权限
SELECT * from Session_Roles;–查询当前用户的所有有效角色
SELECT * from User_Role_Privs;–查询当前用户的所有有效角色
SELECT * from User_Sys_Privs;–查看当前用户的系统权限/表级权限
SELECT * from User_Tab_Privs;–查看当前用户的系统权限/表级权限
SELECT * from dba_sys_privs;–查看当前用户的系统权限/表级权限

–数据库连接db_link(需要dba权限)
drop PUBLIC database link LINK_BBSP;
SELECT * from dba_objects WHERE object_type=‘DATABASE LINK’;
SELECT * from DBA_DB_LINKS;
create database link LINK_abc
connect to bems IDENTIFIED by bems
using ‘(DESCRIPTION =
(ADDRESS_LIST =
(ADDRESS = (PROTOCOL = TCP)(HOST = 10.200.44.86)(PORT = 1521))
)
(CONNECT_DATA =
(SERVICE_NAME = bems)
)
)’;
SELECT * from Dba_Db_Links; --查看所有的db_link

–同义词 Create the synonym
create or replace synonym EMP3 for SCOTT.EMP3;
create or replace synonym EMP3 FOR bank@link_bbsp;

–存储过程
SELECT * from user_objects WHERE object_type = ‘PROCEDURE’;
SELECT TASK_NAME,
ROUND((MAX(END_TIME) - MIN(START_TIME)) * 24 * 60, 4) AS ff
FROM SYS_LOGRECORD
GROUP BY TASK_NAME
ORDER BY ff DESC;–查看存储过程跑批时间

–数据字典
SELECT * from user_segments;–查看表和索引的段，区，…数据字典
SELECT * from System_Privilege_Map;–查看所有系统权限
SELECT * from Dba_Ts_Quotas;–查看数据库用户使用情况
select userenv(‘language’) from dual; --查看数据库表字符集
SELECT * from Nls_Database_Parameters;–查看数据库表字符集
SELECT * FROM v$nls_parameters; --查看数据库表字符集

–索引
SELECT * from user_indexes;–查看索引
create INDEX index_emp_deptno ON emp (deptno) TABLESPACE temptablespace_lxx;–创建索引
DROP INDEX index_emp_deptno;–删除索引
SELECT * from User_Ind_Columns;–查看索引被索引的字段
SELECT SUM(BYTES) / (1024 * 1024) AS “size(M)”
FROM USER_SEGMENTS
WHERE SEGMENT_NAME = UPPER(’&index_name’);–查看某索引的大小

–序列
SELECT * FROM user_sequences;–查看序列号

–视图
SELECT * from USER_VIEWS; --查看视图的名称

–约束
SELECT * FROM user_constraints; --查看约束条件
ALTER TABLE test_lxx ADD CONSTRAINT pk_test PRIMARY KEY (NAME);–建主键
alter table EMP add constraint FK_TEST foreign key (DEPTNO) references DEPT (DEPTNO) on delete cascade;–建外键
ALTER TABLE test_lxx DROP CONSTRAINT pk_test;–删主键

–数据库
SELECT * FROM product_component_version;–查看数据库版本/信息
SELECT * FROM v $version;--查看数据库版本/信息 SELECT NAME,created,log_mode from v$ database;–查看数据库版本/信息
select * from 表名 as of timestamp(sysdate-5/1440);–还原到五分钟之前
SELECT USERENV(‘language’) FROM dual; --查看数据库编码
select * from sys.v_$version ; --查看oracle版本

–删除重复记录
DELETE FROM EMP_LXX LX
WHERE ROWID < (SELECT MAX(ROWID)
FROM EMP_LXX LXX
WHERE LXX.EMPNO = LX.EMPNO
GROUP BY ENAME
HAVING COUNT(*) > 0);

–函数
SELECT ABS(COMM) from EMP;–取绝对值
SELECT POWER(3,2) FROM dual;–乘方
SELECT SQRT(4) from DUAL;–平方根
SELECT CEIL(4.4) from DUAL;–大于或等于取整数
SELECT FLOOR(4.4) from DUAL;–小于或等于取整数
SELECT MOD(4,3) from DUAL;–取余数
SELECT ROUND(4.3) from DUAL;–按m的位数取四舍五入值如果round(日期): 中午12以后将是明天的日期. round(sysdate,‘Y’)是年的第一天
SELECT ROUND(SYSDATE) from DUAL;–按m的位数取四舍五入值如果round(日期): 中午12以后将是明天的日期. round(sysdate,‘Y’)是年的第一天
SELECT ROUND(SYSDATE,‘Y’) from DUAL;–按m的位数取四舍五入值如果round(日期): 中午12以后将是明天的日期. round(sysdate,‘Y’)是年的第一天
SELECT CHR(4) from DUAL;–CHR 按数据库的字符集由数字返回字符
SELECT concat(4,3) from DUAL;–CONCAT(c1,c2) 把两个字符c1,c2组合成一个字符, 和 || 相同
SELECT replace(234345345,4,1) from DUAL;–REPLACE(c,s,r) 把字符c里出现s的字符替换成r, 返回新字符
SELECT SUBSTR(134345,3,5) from DUAL;–SUBSTR(c,m,n) m大于0,字符c从前面m处开始取n位字符,m等于0和1一样, m小与0,字符c从后面m处开始取n位字符
SELECT SUBSTR(134345,-3,5) from DUAL;–SUBSTR(c,m,n) m大于0,字符c从前面m处开始取n位字符,m等于0和1一样, m小与0,字符c从后面m处开始取n位字符
SELECT TRANSLATE(134345,3,5) from DUAL;–TRANSLATE(c,f1,t1) 字符c按f1到t1的规则转换成新的字符串
SELECT INITCAP(‘sdfvfvsdfv’) from DUAL;–INITCAP 字符首字母大写,其它字符小写
SELECT LOWER(‘DFGDFGR’) from DUAL;–LOWER 字符全部小写
SELECT UPPER(‘DSdfdfv’) from DUAL;–UPPER 字符全部大写
SELECT LTRIM(‘ssssdcsdc’,‘s’) from dual;–LTRIM(c1,c2) 去掉字符c1左边出现的字符c2
SELECT RTRIM(‘ssssdcsdcsss’,‘s’) from dual;–RTRIM(c1,c2) 去掉字符c1右边出现的字符c2
SELECT TRIM(BOTH ‘’ FROM ‘llllllll’) from dual;
SELECT TRIM(LEADING '’ FROM ‘llllllll’) from dual;
SELECT TRIM(TRAILING ‘*’ FROM ‘llllllll’) from dual;
SELECT length(TRIM(’ 23v ')) from dual;—TRIM(c1,c2) 去左右空格
SELECT LPAD(‘sdvsd’,‘9’,‘c’) from dual;–LPAD(c1,n,c2) 字符c1按指定的位数n显示，不足的位数用c2字符串替换左边的空位
SELECT rPAD(‘sdvsd’,‘9’,‘c’) from dual;–RPAD(c1,n,c2) 字符c1按指定的位数n显示，不足的位数用c2字符串替换右边的空位
SELECT add_months(to_date(‘2012-12-12’,‘yyyy-mm-dd’) ,‘3’) from dual;–ADD_MONTHS(d,n) 日期值加n月
SELECT last_day(to_date(‘2012-12-12’,‘yyyy-mm-dd’) ) FROM dual;–LAST_DAY(d) 返回当月的最后一天的日期
SELECT MONTHS_BETWEEN(TO_DATE(‘2012-12-2’, ‘yyyy-mm-dd’), SYSDATE) FROM DUAL; --MONTHS_BETWEEN(d1,d2) 两个日期值间的月份
SELECT NEXT_DAY(SYSDATE,2) from dual;–NEXT_DAY(d) 返回日期值下一天的日期
SELECT NVL(comm,‘444444’) from emp;–NVL(EXPR1, EXPR2)当EXPR1为空用EXPR2替代
SELECT DECODE(deptno,‘20’,‘22’,‘30’,‘33’) from emp;–DECODE(EXPR﹐V1﹐R1﹐V2﹐R2…)EXPR后条件和返回值成对出现，最后一个单值是不在条件中的返回值，如果没有单值，不满足条件的返回NULL。
SELECT to_CHAR(SYSDATE, ‘MM’) FROM dual;–TO_CHAR(HIREDATE, ‘MM’)取时间月份
SELECT * from EMP_BONUS WHERE COalesce(DE,0)<‘12’;–把de列的空值也参与比较（返回其参数中第一个非空表达式）

–0.排序求5-10条数据
SELECT *
FROM (SELECT ROW_NUMBER() OVER(ORDER BY SAL) AS RN, A.*
FROM EMP A
WHERE SAL IS NOT NULL)
WHERE RN BETWEEN 6 AND 10;

SELECT *
FROM (SELECT ROW_NUMBER() OVER(ORDER BY ROWID) ROW_NUMBER, A.*
FROM AA_LXX A)
WHERE ROW_NUMBER <= 10; --前十条数据

SELECT * FROM EMP WHERE ROWNUM <= 2 ORDER BY SAL
SELECT *
FROM (SELECT E.*, ROWNUM RN FROM EMP E WHERE ROWNUM <= 8 ORDER BY SAL)
WHERE RN > 2 --排序求2-8条数据

SELECT *
FROM EMP
WHERE ROWNUM < 10
MINUS
SELECT * FROM EMP WHERE ROWNUM < 5; --返回第5-9条记录

–1.查询课程1比课程2成绩高的所有学生的学号
SELECT A.S#, A.SCORE, B.SCORE
FROM (SELECT * FROM SC WHERE C# = ‘2’) A,
(SELECT * FROM SC WHERE C# = ‘1’) B
WHERE A.SCORE < B.SCORE
AND A.S# = B.S#;

–2.查询平均成绩大于60分的同学的学号和平均成绩
SELECT S#, AVG(SCORE) FROM SC GROUP BY S# HAVING AVG(SCORE) > ‘60’;

–3.查询所有同学的学号、姓名、选课数、总成绩
SELECT S.S#, S.SNAME, COUNT(SC.C#), SUM(SC.SCORE)
FROM SC SC, STUDENT S
WHERE SC.S# = S.S#
GROUP BY S.S#, S.SNAME;

–4.查询姓江的老师的个数
SELECT COUNT(DISTINCT(T#)) FROM TEACHER WHERE TNAME LIKE ‘江%’;

–5.查询没学过江老师课的同学的学号、姓名
SELECT S#, SNAME
FROM STUDENT
WHERE S# NOT IN (SELECT SC.S#
FROM TEACHER T, SC SC, COURSE C
WHERE SC.C# = C.C#
AND C.T# = T.T#
AND TNAME = ‘江老师’);

–6.查询学过1课并且也学过2课的同学的学号、姓名
SELECT S.S#, SNAME
FROM STUDENT S, SC SC
WHERE SC.S# = S.S#
AND SC.C# = ‘1’
AND EXISTS (SELECT *
FROM SC SC_2
WHERE SC_2.S# = SC.S#
AND SC_2.C# = ‘2’);

–7.查询学过江老师所交的所有课的同学的学号、姓名
SELECT S#, SNAME
FROM STUDENT WHERE S# IN (SELECT SC.S#
FROM SC SC, COURSE C, TEACHER T
WHERE T.T# = C.T#
AND SC.C# = C.C#
AND TNAME = ‘江老师’
GROUP BY S#
HAVING COUNT(c.c#) =(SELECT COUNT(c#)
FROM COURSE C, TEACHER T
WHERE T.T# = C.T#
AND TNAME = ‘江老师’));

–8、查询所有课程成绩小于60分的同学的学号、姓名
SELECT S#, SNAME
FROM STUDENT
WHERE S# NOT IN (SELECT S.S#
FROM STUDENT S, SC SC
WHERE SC.S# = S.S#
AND SCORE > 60);

–9.查询没有学全所有课的同学的学号、姓名
SELECT S.S#, SNAME
FROM SC SC, STUDENT S
WHERE SC.S# = S.S#
GROUP BY S.S#, S.SNAME
HAVING COUNT(C#) < (SELECT COUNT(C#) FROM COURSE);

–10、查询至少有一门课与学号为012512的同学所学相同的同学的学号和姓名
SELECT S.S#, SNAME
FROM SC SC, STUDENT S
WHERE SC.S# = S.S#
AND C# IN (SELECT C# FROM SC WHERE S# = ‘012512’)
GROUP BY S.S#, SNAME;

–11、删除学习江老师课的sc表记录
DELETE sc WHERE c# IN (SELECT DISTINCT SC.C#
FROM SC SC, TEACHER T, COURSE C
WHERE T.T# = C.T#
AND C.C# = SC.C#
AND TNAME = ‘江老师’);

–12.查询各科成绩最高和最低的分；以如下形式显示:课程id，最高分，最低分；
SELECT C#, MAX(SCORE), MIN(SCORE) FROM SC GROUP BY C#;

–13、查询学生平均成绩及其名次
SELECT 1 + (SELECT COUNT(DISTINCT 平均成绩)
FROM (SELECT S#, AVG(SCORE) 平均成绩 FROM SC GROUP BY S#) T1
WHERE 平均成绩 > T2.平均成绩) 名次,
S# 学生学号,平均成绩
FROM (SELECT S#, AVG(SCORE) 平均成绩 FROM SC GROUP BY S#) T2
ORDER BY 平均成绩 DESC;

SELECT SS.* ,ROWNUM from (SELECT SC.s#, AVG(SCORE) AS AVG
FROM SC SC, STUDENT S
WHERE SC.S# = S.S#
GROUP BY SC.s# ORDER BY AVG DESC ) SS;

–14.查询各科成绩前三名的记录；（不考虑成绩并列的情况）
SELECT *
FROM (SELECT C#,
ROW_NUMBER() OVER(PARTITION BY C# ORDER BY SCORE DESC) RN,
S.S#,
S.SNAME,
SC.SCORE
FROM SC SC, STUDENT S
WHERE SC.S# = S.S#) A
WHERE RN < 4;

–15.查询每门功课成绩最好的第2.3名
SELECT *
FROM (SELECT C#,
ROW_NUMBER() OVER(PARTITION BY C# ORDER BY SCORE DESC) RN,
S.S#,
S.SNAME,
SC.SCORE
FROM SC SC, STUDENT S
WHERE SC.S# = S.S#) A
WHERE RN < 4 AND rn>1;

–16.表中有abc三列，用sql语句实现：当A列大于B列时选A列否则选择B列，当B列大于C列时选择B列否则选择C列
SELECT A,
B,
C,
(CASE
WHEN TO_NUMBER(A) > TO_NUMBER(B) THEN
A
ELSE
B
END),
(CASE
WHEN TO_NUMBER(B) > TO_NUMBER© THEN
B
ELSE
C
END)
FROM SC;

–17.有一张表有abc三列分别语文数学英语，70,80,58分，写：大于或等于80表示优秀，大于或等于60表示及格，小于60分表示不及格，
/显示格式：语文数学英语
及格优秀不及格/
SELECT A,
B,
C,
(CASE
WHEN A >= 80 THEN
‘优秀’
WHEN A < 60 THEN
‘不及格’
ELSE
‘及格’
END) AS 语文,
(CASE
WHEN B >= 80 THEN
‘优秀’
WHEN B < 60 THEN
‘不及格’
ELSE
‘及格’
END) AS 数学,
(CASE
WHEN C >= 80 THEN
‘优秀’
WHEN C < 60 THEN
‘不及格’
ELSE
‘及格’
END) AS 英语
FROM SC;

–18.查询出dept表中哪个部门下没有员工
SELECT DEPTNO FROM DEPT
MINUS
SELECT DISTINCT DEPTNO FROM EMP;

–19.查询出Emp表中比任意一个销售员(“SALESMAN”)工资低的员工姓名、工作、工资。
SELECT * from emp WHERE sal< ANY(SELECT sal from emp WHERE job=‘SALESMAN’);

–20.查询出比所有销售员的工资都高的员工姓名，工作，工资。
SELECT ENAME, JOB, SAL
FROM EMP
WHERE SAL > ALL (SELECT SAL FROM EMP WHERE JOB = ‘SALESMAN’);

–21.查询出工资最高的前5名员工的姓名、工资和工资。
SELECT ROWNUM ,sc.c# from (SELECT * from sc ORDER BY score) sc WHERE ROWNUM<6;

–22.对EMP表中工资为2000元以下的员工，如果没有奖金，则奖金为200元，如果有奖金，则在原来的奖金基础上加100元。
SELECT ENAME,JOB,SAL,NVL2(COMM,comm+100,200) “comm” FROM EMP WHERE SAL<2000;

–23.用一条sql语句查询出每门课都大于80分的学生姓名
SELECT * FROM SC SC WHERE S# NOT IN (SELECT S# FROM SC WHERE SCORE < 80);
SELECT S# FROM SC GROUP BY S# HAVING MIN(SCORE) > 80;

–24.最高效的去除重复记录方法（因为使用了rowid）去重
DELETE FROM EMP E
WHERE E.ROWID > (SELECT MIN(X.ROWID) FROM EMP X WHERE X.EMPNO = E.EMPNO);

–25.一个叫team的表，里面只有一个字段name,一共有四条记录，abcd四个球队，四个球队比赛，有多少种组合
SELECT A.NAME, B.NAME FROM TEAM A, TEAM B WHERE A.NAME < B.NAME;

–26.有两个表A,B 均有key和value两个字段，如果B的key在A中也有，就把B的value换为A中对应的value
UPDATE B
SET B.VALUE =
(SELECT A.VALUE FROM A WHERE A.KEY = B.KEY)
WHERE B.ID IN (SELECT B.ID FROM B, A WHERE B.KEY = A.KEY)

–27.有一个表a有两个字段key value，字段都非空，写一个sql列出该表中一个key对应多个不同的value的记录
SELECT A.KEY || ‘a’ || A.VALUE
FROM A, A B
WHERE A.KEY = B.KEY
AND A.VALUE <> B.VALUE;

SELECT *
FROM A
WHERE KEY IN
(SELECT KEY FROM A GROUP BY KEY HAVING(COUNT(DISTINCT(VALUE)) >= 2));

–28.计算工资>999年龄<35的人数，工资>999年龄>35的人数，工资<999年龄<35的人数，工资<999年龄>35的人数
SELECT SUM(CASE WHEN (sal>999 AND age<35) THEN 1 ELSE 0 END ) ,
SUM(CASE WHEN (sal>999 AND age<35) THEN 1 ELSE 0 END ) ,
SUM(CASE WHEN (sal<999 AND age>35) THEN 1 ELSE 0 END ) ,
SUM(CASE WHEN (sal<999 AND age>35) THEN 1 ELSE 0 END )
from emp1 ;

–29.查询月份，当月收入，上月收入，下月收入
SELECT MONTHS AS “月份”,
MAX(INCOMES) AS “收入”,
MAX(PREV_MONTHS) AS “上月收入”,
MAX(NEXT_MONTHS) AS “下月收入”
FROM (SELECT MONTHS,
INCOMES,
DECODE(LAG(MONTHS) OVER(ORDER BY MONTHS),
TO_CHAR(ADD_MONTHS(TO_DATE(MONTHS, ‘yyyymm’), -1),
‘yyyymm’),
LAG(INCOMES) OVER(ORDER BY MONTHS),
0) AS PREV_MONTHS,
DECODE(LEAD(MONTHS) OVER(ORDER BY MONTHS),
TO_CHAR(ADD_MONTHS(TO_DATE(MONTHS, ‘yyyymm’), 1),
‘yyyymm’),
LEAD(INCOMES) OVER(ORDER BY MONTHS),
0) AS NEXT_MONTHS
FROM (SELECT MONTHS, SUM(SAL) AS INCOMES FROM EMP1 GROUP BY MONTHS) AA) AAA
GROUP BY MONTHS;

–30.表b 要求如下格式展示
/c1 c2 * 2005-01-01 4
2005-01-01 1 * 2005-01-02 5
2005-01-01 3 * 合计 9
2005-01-02 5/

SELECT NVL(TO_CHAR(C1, ‘yyyy-mm-dd’), ‘合计’), SUM(C2)
FROM B
GROUP BY ROLLUP(C1);

–31.

–32.查询数据库有多少张表有多少条数
SELECT table_name,num_rows FROM user_tables;

–33.把表和index都收集一下
ANALYZE TABLE emp COMPUTE STATISTICS;
ANALYZE index xxx COMPUTE STATISTICS;
–34.有两个表A,B 均有key和value两个字段，如果B的key在A中也有，就把B的value换为A中对应的value
UPDATE B
SET B.VALUE =
(SELECT A.VALUE FROM A WHERE A.KEY = B.KEY)
WHERE B.ID IN (SELECT B.ID FROM B, A WHERE B.KEY = A.KEY)

–35.随机取数
SELECT * from (SELECT * from EMP ORDER BY dbms_random.value()) WHERE ROWNUM <=3;

60．Pgsql导入TXT文本文档

copy “lx_test” from ‘d:\data\BP_MASTER_1.txt’ USING DELIMITERS ’ ';

61．数仓数据库连接：
connection name DataWarehouse_prd
ip：10.96.234.172
port:5432
DB gpmpdb
user gpmpuser
pwd gpmpuser123

ODH测试环境的链接信息如下：
IP: 10.120.24.160
Port:5432
DB:odhdb ,public Schema
data_migration，密码Initial0.

lixue13@lenovo.com KPgS-5606
luxuec Lx5142541
编号 6787
62．Outlook和lync连接不上究其原因：连错了网应该连接联想内部网
Jdk:jdk安装完不能javac java –version 原因是前一个jdk没卸载
63．练习sql
create table student(
sno varchar2(10) primary key,
sname varchar2(20),
sage number(2),
ssex varchar2(5)
);
create table teacher(
tno varchar2(10) primary key,
tname varchar2(20)
);
create table course(
cno varchar2(10),
cname varchar2(20),
tno varchar2(20),
constraint pk_course primary key (cno,tno)
);
create table sc(
sno varchar2(10),
cno varchar2(10),
score number(4,2),
constraint pk_sc primary key (sno,cno)
);
/初始化学生表的数据/
insert into student values (‘s001’,‘张三’,23,‘男’);
insert into student values (‘s002’,‘李四’,23,‘男’);
insert into student values (‘s003’,‘吴鹏’,25,‘男’);
insert into student values (‘s004’,‘琴沁’,20,‘女’);
insert into student values (‘s005’,‘王丽’,20,‘女’);
insert into student values (‘s006’,‘李波’,21,‘男’);
insert into student values (‘s007’,‘刘玉’,21,‘男’);
insert into student values (‘s008’,‘萧蓉’,21,‘女’);
insert into student values (‘s009’,‘陈萧晓’,23,‘女’);
insert into student values (‘s010’,‘陈美’,22,‘女’);
commit;
/初始化教师表****/
insert into teacher values (‘t001’, ‘刘阳’);
insert into teacher values (‘t002’, ‘谌燕’);
insert into teacher values (‘t003’, ‘胡明星’);
commit;
/初始化课程表*************/
insert into course values (‘c001’,‘J2SE’,‘t002’);
insert into course values (‘c002’,‘Java Web’,‘t002’);
insert into course values (‘c003’,‘SSH’,‘t001’);
insert into course values (‘c004’,‘Oracle’,‘t001’);
insert into course values (‘c005’,‘SQL SERVER 2005’,‘t003’);
insert into course values (‘c006’,‘C#’,‘t003’);
insert into course values (‘c007’,‘JavaScript’,‘t002’);
insert into course values (‘c008’,‘DIV+CSS’,‘t001’);
insert into course values (‘c009’,‘PHP’,‘t003’);
insert into course values (‘c010’,‘EJB3.0’,‘t002’);
commit;
/初始化成绩表********/
insert into sc values (‘s001’,‘c001’,78.9);
insert into sc values (‘s002’,‘c001’,80.9);
insert into sc values (‘s003’,‘c001’,81.9);
insert into sc values (‘s004’,‘c001’,60.9);
insert into sc values (‘s001’,‘c002’,82.9);
insert into sc values (‘s002’,‘c002’,72.9);
insert into sc values (‘s003’,‘c002’,81.9);
insert into sc values (‘s001’,‘c003’,59);

#注意：以下练习中的数据是根据初始化到数据库中的数据来写的SQL 语句，请大家务必注意。

#1、查询“c001”课程比“c002”课程成绩高的所有学生的学号；
select * from sc a, sc b where a.sno=b.sno and a.cno=‘c001’ and b.cno=‘c002’ and a.score>b.score;
#2、查询平均成绩大于60 分的同学的学号和平均成绩；
select st.sname,ss.sco from student st,(select sno,avg(score)sco from sc group by sno)ss where st.sno=ss.sno and sco>=60;
#3、查询所有同学的学号、姓名、选课数、总成绩；
select st.sname,ss.* from student st,(select sno,count(score)sco,sum(score) from sc group by sno)ss where st.sno=ss.sno;
#4、查询姓“刘”的老师的个数；
select count() from teacher where tname like ‘%刘%’;
#5、查询没学过“谌燕”老师课的同学的学号、姓名；
select sc.sno,acno. from sc sc,(select co.cno from course co,(select tno from teacher where tname=‘谌燕’)tn where co.tno<>tn.tno)acno where acno.cno=sc.cno;
#6、查询学过“c001”并且也学过编号“c002”课程的同学的学号、姓名；
select sa.sname,sc.sno from sc sc,(select st.sname,s.* from student st,(select sno,cno from sc where cno in(‘c001’))s where st.sno=s.sno)sa where sc.sno=sa.sno and sc.cno=‘c002’;
#7、查询学过“谌燕”老师所教的所有课的同学的学号、姓名；
select distinct st.sname from student st,sc sc join (select cno from teacher te join course co on(te.tno=co.tno) where te.tname=‘谌燕’)aca on(sc.cno=aca.cno) where st.sno=sc.sno;
#9、查询所有课程成绩小于60 分的同学的学号、姓名；
select st.sname,sc.sno from student st join sc sc on(st.sno=sc.sno)where sc.score<60;
#10、查询没有学全所有课的同学的学号、姓名；
select sname,st.sno,scn.cn from student st join (select distinct sno,count()cn from sc group by sc.sno)scn on(st.sno=scn.sno) where scn.cn=(select distinct count(cno) from course);
select st.sname,st.sno from student st join (select sc.sno sn,count(sc.cno) cou from sc group by sc.sno) scs on st.sno=scs.sn where scs.cou <(select count(cno) from course);
#11、查询至少有一门课与学号为“s001”的同学所学相同的同学的学号和姓名；
select distinct st.sno, sname
from student st
join sc sc on (st.sno = sc.sno)
where sc.cno in (select cno from sc where sno = ‘s001’) and sc.sno<>‘s001’;
[sql] view plain copy print?
#13、把“SC”表中“谌燕”老师教的课的成绩都更改为此课程的平均成绩；
#update sc sc set sc.score=update sc sc set sc.score=(select tc.cno,round(avg(sc.score),2)av from (select * from teacher te join course co on(te.tno=co.tno) where te.tname=‘谌燕’)tc join sc sc on(tc.cno=sc.cno) group by tc.cno)cnn.score where sc.cno=cnn.av;
select tc.cno,round(avg(sc.score),2) from (select * from teacher te join course co on(te.tno=co.tno) where te.tname=‘谌燕’)tc join sc sc on(tc.cno=sc.cno) group by tc.cno;
#14、查询和“s001”号的同学学习的课程完全相同的其他同学学号和姓名；
select cno from sc where sno=‘s001’;
#15、删除学习“谌燕”老师课的SC 表记录；
delete from sc where sc.cno in(select cno from teacher te join course co on(te.tno=co.tno) where te.tname=‘谌燕’)
#17、查询各科成绩最高和最低的分：以如下形式显示：课程ID，最高分，最低分
select cno,max(score),min(score) from sc group by cno;
#18、按各科平均成绩从低到高和及格率的百分数从高到低顺序
#select count(score) from sc where score>=60 group by cno ;
select cno,avg(score)acs,savg.cnu,(count(score)-savg.cnu)/count(score)100 from sc,
(select count(score)cnu,avg(score)acs2 from sc where score<60 order by acs2 desc)savg
group by savg.cnu,cno order by acs desc;
#21、查询各科成绩前三名的记录:(不考虑成绩并列情况)
select * from (select S.,rownum rn from (select * from sc order by score desc)S where rownum<=3)where rn>=1;
#22、查询每门课程被选修的学生数
select cno,count(cno) from sc group by cno;
#23、查询出只选修了一门课程的全部学生的学号和姓名
select st.sname,st.sno from student st join
(select distinct sc. from sc sc join (select sno,count(cno)cnum from sc group by sno)ss on(sc.sno=ss.sno) where ss.cnum=1)ssb
on(st.sno=ssb.sno);
#24、查询男生、女生人数
select ssex,count(ssex) from student st group by ssex;
#25、查询姓“张”的学生名单
select sname from student where sname like ‘%张%’;
#26、查询同名同性学生名单，并统计同名人数
select st.* from student st join (select sname,count(sname)cnum from student group by sname)scomm on(st.sname=scomm.sname) where scomm.cnum>1;
#27、1981 年出生的学生名单(注：Student 表中Sage 列的类型是number)
select * from student where to_char(sysdate,‘yyyy’)-sage =‘1981’;
#28、查询每门课程的平均成绩，结果按平均成绩升序排列，平均成绩相同时，按课程号降序排列
select cno,avg(score)lim from sc group by cno order by lim asc;
#29、查询平均成绩大于85 的所有学生的学号、姓名和平均成绩
select st.sname,st.sno,savg.lim from student st join (select sno,avg(score)lim from sc group by sno)savg on(st.sno=savg.sno) where savg.lim>85;
#30、查询课程名称为“数据库”，且分数低于60 的学生姓名和分数
select distinct st.sname,cs.score from student st join (select * from course co join sc sc on(co.cno=sc.cno))cs on(st.sno=cs.sno)where cs.score<60 and cs.cname=‘数据库’;
#31、查询所有学生的选课情况；
select distinct st.sname,cs.cname from student st join (select * from course co join sc sc on(co.cno=sc.cno))cs on(st.sno=cs.sno);
#32、查询任何一门课程成绩在70 分以上的姓名、课程名称和分数；
select distinct st.sname,cs.score,cs.cname from student st join (select * from course co join sc sc on(co.cno=sc.cno))cs on(st.sno=cs.sno)where cs.score>70;
#33、查询不及格的课程，并按课程号从大到小排列
select * from sc where score<60 order by sno desc;
#34、查询课程编号为c001 且课程成绩在80 分以上的学生的学号和姓名；
select st.sname,st.sno from student st join (select * from sc where cno=‘c001’ and score>80)snum on(st.sno=snum.sno);
#35、求选了课程的学生人数
select count(ss.sno) from (select distinct sno from sc)ss;
#36、查询选修“谌燕”老师所授课程的学生中，成绩最高的学生姓名及其成绩
select st.sname,cnum.score from student st join
(select distinct * from sc sc where cno in(select distinct cno from course co join
(select tno from teacher where tname=‘谌燕’)ten on(co.tno=ten.tno)) order by score desc)cnum on(st.sno=cnum.sno) where rownum=1;
#37、查询各个课程及相应的选修人数
#(select cno,count(cno) from sc group by cno);
select co.cname,cns.cnum from course co join (select cno,count(cno)cnum from sc group by cno)cns on(co.cno=cns.cno);
#39、查询每门功课成绩最好的前两名
select cno from sc order by score desc group by cno;
#40、统计每门课程的学生选修人数（超过10 人的课程才统计）。要求输出课程号和选修人数，查询结果按人数降序排列，若人数相同，按课程号升序排列
#41、检索至少选修两门课程的学生学号
select sno from (select sno,count(cno)cnum from sc group by sno) where cnum>=2;
#42、查询全部学生都选修的课程的课程号和课程名
#select count() from (select distinct sno from sc);
#select cno,count(cno)cns from sc group by cno;
#select cno from (select count()num from (select distinct sno from sc))cs1,(select cno,count(cno)cns from sc group by cno)cs2 where cs2.cns=cs1.num;
select cname,scs.cno from course co join
(select cno from (select count(*)num from (select distinct sno from sc))cs1,
(select cno,count(cno)cns from sc group by cno)cs2 where cs2.cns=cs1.num)scs on(co.cno=scs.cno);
#43、查询没学过“谌燕”老师讲授的任一门课程的学生姓名
#select co.cno from course co join (select tno from teacher where tname=‘谌燕’)tn on(co.tno=tn.tno);
select sname from student where sno not in
(select distinct sno from sc where cno in(select co.cno from course co join
(select tno from teacher where tname=‘谌燕’)tn on(co.tno=tn.tno)));
#44、查询两门以上不及格课程的同学的学号及其平均成绩
#select sno,count(sno),avg(score) from sc where score < 60 group by sno;
select * from (select sno,count(sno)cnum,avg(score) from sc where score < 60 group by sno)avs where avs.cnum>1;
#45、检索“c004”课程分数小于60，按分数降序排列的同学学号
select sno from sc where cno=‘c004’ and score<60 order by score desc;
#46、删除“s002”同学的“c001”课程的成绩
delete from sc where sno=‘s002’ and cno=‘c001’;

#13、把“SC”表中“谌燕”老师教的课的成绩都更改为此课程的平均成绩；
#update sc sc set sc.score=update sc sc set sc.score=(select tc.cno,round(avg(sc.score),2)av from (select * from teacher te join course co on(te.tno=co.tno) where te.tname=‘谌燕’)tc join sc sc on(tc.cno=sc.cno) group by tc.cno)cnn.score where sc.cno=cnn.av;
select tc.cno,round(avg(sc.score),2) from (select * from teacher te join course co on(te.tno=co.tno) where te.tname=‘谌燕’)tc join sc sc on(tc.cno=sc.cno) group by tc.cno;
#14、查询和“s001”号的同学学习的课程完全相同的其他同学学号和姓名；
select cno from sc where sno=‘s001’;
#15、删除学习“谌燕”老师课的SC 表记录；
delete from sc where sc.cno in(select cno from teacher te join course co on(te.tno=co.tno) where te.tname=‘谌燕’)
#17、查询各科成绩最高和最低的分：以如下形式显示：课程ID，最高分，最低分
select cno,max(score),min(score) from sc group by cno;
#18、按各科平均成绩从低到高和及格率的百分数从高到低顺序
#select count(score) from sc where score>=60 group by cno ;
select cno,avg(score)acs,savg.cnu,(count(score)-savg.cnu)/count(score)100 from sc,
(select count(score)cnu,avg(score)acs2 from sc where score<60 order by acs2 desc)savg
group by savg.cnu,cno order by acs desc;
#21、查询各科成绩前三名的记录:(不考虑成绩并列情况)
select * from (select S.,rownum rn from (select * from sc order by score desc)S where rownum<=3)where rn>=1;
#22、查询每门课程被选修的学生数
select cno,count(cno) from sc group by cno;
#23、查询出只选修了一门课程的全部学生的学号和姓名
select st.sname,st.sno from student st join
(select distinct sc.* from sc sc join (select sno,count(cno)cnum from sc group by sno)ss on(sc.sno=ss.sno) where ss.cnum=1)ssb
on(st.sno=ssb.sno);
#24、查询男生、女生人数
select ssex,count(ssex) from student st group by ssex;
#25、查询姓“张”的学生名单
select sname from student where sname like ‘%张%’;
#26、查询同名同性学生名单，并统计同名人数
select st.* from student st join (select sname,count(sname)cnum from student group by sname)scomm on(st.sname=scomm.sname) where scomm.cnum>1;
#27、1981 年出生的学生名单(注：Student 表中Sage 列的类型是number)
select * from student where to_char(sysdate,‘yyyy’)-sage =‘1981’;
#28、查询每门课程的平均成绩，结果按平均成绩升序排列，平均成绩相同时，按课程号降序排列
select cno,avg(score)lim from sc group by cno order by lim asc;
#29、查询平均成绩大于85 的所有学生的学号、姓名和平均成绩
select st.sname,st.sno,savg.lim from student st join (select sno,avg(score)lim from sc group by sno)savg on(st.sno=savg.sno) where savg.lim>85;
#30、查询课程名称为“数据库”，且分数低于60 的学生姓名和分数
select distinct st.sname,cs.score from student st join (select * from course co join sc sc on(co.cno=sc.cno))cs on(st.sno=cs.sno)where cs.score<60 and cs.cname=‘数据库’;
#31、查询所有学生的选课情况；
select distinct st.sname,cs.cname from student st join (select * from course co join sc sc on(co.cno=sc.cno))cs on(st.sno=cs.sno);
#32、查询任何一门课程成绩在70 分以上的姓名、课程名称和分数；
select distinct st.sname,cs.score,cs.cname from student st join (select * from course co join sc sc on(co.cno=sc.cno))cs on(st.sno=cs.sno)where cs.score>70;
#33、查询不及格的课程，并按课程号从大到小排列
select * from sc where score<60 order by sno desc;
#34、查询课程编号为c001 且课程成绩在80 分以上的学生的学号和姓名；
select st.sname,st.sno from student st join (select * from sc where cno=‘c001’ and score>80)snum on(st.sno=snum.sno);
#35、求选了课程的学生人数
select count(ss.sno) from (select distinct sno from sc)ss;
#36、查询选修“谌燕”老师所授课程的学生中，成绩最高的学生姓名及其成绩
select st.sname,cnum.score from student st join
(select distinct * from sc sc where cno in(select distinct cno from course co join
(select tno from teacher where tname=‘谌燕’)ten on(co.tno=ten.tno)) order by score desc)cnum on(st.sno=cnum.sno) where rownum=1;
#37、查询各个课程及相应的选修人数
#(select cno,count(cno) from sc group by cno);
select co.cname,cns.cnum from course co join (select cno,count(cno)cnum from sc group by cno)cns on(co.cno=cns.cno);
#39、查询每门功课成绩最好的前两名
select cno from sc order by score desc group by cno;
#40、统计每门课程的学生选修人数（超过10 人的课程才统计）。要求输出课程号和选修人数，查询结果按人数降序排列，若人数相同，按课程号升序排列
#41、检索至少选修两门课程的学生学号
select sno from (select sno,count(cno)cnum from sc group by sno) where cnum>=2;
#42、查询全部学生都选修的课程的课程号和课程名
#select count() from (select distinct sno from sc);
#select cno,count(cno)cns from sc group by cno;
#select cno from (select count()num from (select distinct sno from sc))cs1,(select cno,count(cno)cns from sc group by cno)cs2 where cs2.cns=cs1.num;
select cname,scs.cno from course co join
(select cno from (select count(*)num from (select distinct sno from sc))cs1,
(select cno,count(cno)cns from sc group by cno)cs2 where cs2.cns=cs1.num)scs on(co.cno=scs.cno);
#43、查询没学过“谌燕”老师讲授的任一门课程的学生姓名
#select co.cno from course co join (select tno from teacher where tname=‘谌燕’)tn on(co.tno=tn.tno);
select sname from student where sno not in
(select distinct sno from sc where cno in(select co.cno from course co join
(select tno from teacher where tname=‘谌燕’)tn on(co.tno=tn.tno)));
#44、查询两门以上不及格课程的同学的学号及其平均成绩
#select sno,count(sno),avg(score) from sc where score < 60 group by sno;
select * from (select sno,count(sno)cnum,avg(score) from sc where score < 60 group by sno)avs where avs.cnum>1;
#45、检索“c004”课程分数小于60，按分数降序排列的同学学号
select sno from sc where cno=‘c004’ and score<60 order by score desc;
#46、删除“s002”同学的“c001”课程的成绩
delete from sc where sno=‘s002’ and cno=‘c001’;

问题：
1、查询“001”课程比“002”课程成绩高的所有学生的学号；
select a.S#
from (select s#,score from SC where C#=’001′) a,
(select s#,score from SC where C#=’002′) b
where a.score>b.score and a.s#=b.s#;

2、查询平均成绩大于60分的同学的学号和平均成绩；
select S#,avg(score)
from sc
group by S# having avg(score) >60;

3、查询所有同学的学号、姓名、选课数、总成绩；
select Student.S#,Student.Sname,count(SC.C#),sum(score)
from Student left Outer join SC on Student.S#=SC.S#
group by Student.S#,Sname

4、查询姓“李”的老师的个数；
select count(distinct(Tname))
from Teacher
where Tname like ‘李%’;

5、查询没学过“叶平”老师课的同学的学号、姓名；
select Student.S#,Student.Sname
from Student
where S# not in (select distinct( SC.S#) from SC,Course,Teacher where SC.C#=Course.C# and Teacher.T#=Course.T# and Teacher.Tname=’叶平’);

6、查询学过“001”并且也学过编号“002”课程的同学的学号、姓名；
select Student.S#,Student.Sname
from Student,SC
where Student.S#=SC.S# and SC.C#=’001′and exists( Select * from SC as SC_2 where SC_2.S#=SC.S# and SC_2.C#=’002′);
7、查询学过“叶平”老师所教的所有课的同学的学号、姓名；
select S#,Sname
from Student
where S# in
(select S#
from SC ,Course ,Teacher
where SC.C#=Course.C# and Teacher.T#=Course.T# and Teacher.Tname=’叶平’ group by S# having count(SC.C#)=(select count(C#) from Course,Teacher where Teacher.T#=Course.T# and Tname=’叶平’));

8、查询所有课程成绩小于60分的同学的学号、姓名；
select S#,Sname
from Student
where S# not in (select Student.S# from Student,SC where S.S#=SC.S# and score>60);

9、查询没有学全所有课的同学的学号、姓名；
select Student.S#,Student.Sname
from Student,SC
where Student.S#=SC.S#
group by Student.S#,Student.Sname having count(C#) <(select count(C#) from Course);

10、查询至少有一门课与学号为“1001”的同学所学相同的同学的学号和姓名；
select S#,Sname
from Student,SC
where Student.S#=SC.S# and C# in （select C# from SC where S#=‘1001’）;

11、删除学习“叶平”老师课的SC表记录；
Delect SC
from course ,Teacher
where Course.C#=SC.C# and Course.T#= Teacher.T# and Tname=‘叶平’;

12、查询各科成绩最高和最低的分：以如下形式显示：课程ID，最高分，最低分
SELECT L.C# 课程ID,L.score 最高分,R.score 最低分
FROM SC L ,SC R
WHERE L.C# = R.C#
and
L.score = (SELECT MAX(IL.score)
FROM SC IL,Student IM
WHERE IL.C# = L.C# and IM.S#=IL.S#
GROUP BY IL.C#)
and
R.Score = (SELECT MIN(IR.score)
FROM SC IR
WHERE IR.C# = R.C#
GROUP BY IR.C# );

13、查询学生平均成绩及其名次
SELECT 1+(SELECT COUNT( distinct 平均成绩)
FROM (SELECT S#,AVG(score) 平均成绩
FROM SC
GROUP BY S# ) T1
WHERE 平均成绩 > T2.平均成绩) 名次, S# 学生学号,平均成绩
FROM (SELECT S#,AVG(score) 平均成绩 FROM SC GROUP BY S# ) T2
ORDER BY 平均成绩 desc;

14、查询各科成绩前三名的记录:(不考虑成绩并列情况)
SELECT t1.S# as 学生ID,t1.C# as 课程ID,Score as 分数
FROM SC t1
WHERE score IN (SELECT TOP 3 score
FROM SC
WHERE t1.C#= C#
ORDER BY score DESC)
ORDER BY t1.C#;

15、查询每门功成绩最好的前两名
SELECT t1.S# as 学生ID,t1.C# as 课程ID,Score as 分数
FROM SC t1
WHERE score IN (SELECT TOP 2 score
FROM SC
WHERE t1.C#= C#
ORDER BY score DESC )
ORDER BY t1.C#;

补充：
已经知道原表
year salary
——————
2000 1000
2001 2000
2002 3000
2003 4000

解：
select b.year,sum(a.salary)
from salary a,salary b
where a.year<=b.year
group by b.year
order by b.year;

在面试过程中多次碰到一道SQL查询的题目，查询A(ID,Name)表中第31至40条记录，ID作为主键可能是不是连续增长的列，完整的查询语句如下：
方法一：
select top 10 *
from A
where ID >(select max(ID) from (select top 30 ID from A order by ID ) T) order by ID
方法二：
select top 10 *
from A
where ID not In (select top 30 ID from A order by ID)
order by ID
数据库面试题 1

在一个查询中，使用哪一个关键字能够除去重复列值?
答案：使用distinct关键字
什么是快照?它的作用是什么?
答案：快照Snapshot是一个文件系统在特定时间里的镜像，对于在线实时数据备份非常有用。快照对于拥有不能停止的应用或具有常打开文件的文件系统的备份非常重要。对于只能提供一个非常短的备份时间而言，快照能保证系统的完整性。
解释存储过程和触发器
答案：
存储过程是一组Transact-SQL语句，在一次编译后可以执行多次。因为不必重新编译Transact-SQL语句，所以执行存储过程可以提高性能。
触发器是一种特殊类型的存储过程，不由用户直接调用。创建触发器时会对其进行定义，以便在对特定表或列作特定类型的数据修改时执行。
SQL Server是否支持行级锁，有什么好处?
答案：支持动态行级锁定
SQL Server 2000动态地将查询所引用的每一个表的锁定粒度调整到合适的级别。当查询所引用的少数几行分散在一个大型表中时，优化数据并行访问的最佳办法是使用粒度锁，如行锁。但是，如果查询引用的是一个表中的大多数行或所有行，优化数据并行访问的最佳办法可以是锁定整个表，以尽量减少锁定开销并尽快完成查询。
SQL Serve 2000通过为每个查询中的每个表选择适当的锁定级别，在总体上优化了数据并发访问。对于一个查询，如果只引用一个大型表中的几行，则数据库引擎可以使用行级锁定；如果引用一个大型表的几页中的多行，则使用页级锁定；如果引用一个小型表中的所有行，则使用表级锁定。
数据库日志干什么用，数据库日志满的时候再查询数据库时会出现什么情况。
答案：每个数据库都有事务日志，用以记录所有事务和每个事务对数据库所做的修改。
存储过程和函数的区别?
答案：存储过程是用户定义的一系列SQL语句的集合，涉及特定表或其它对象的任务，用户可以调用存储过程，而函数通常是数据库已定义的方法，它接收参数并返回某种类型的值并且不涉及特定用户表
事务是什么?
答案：事务是作为一个逻辑单元执行的一系列操作，一个逻辑工作单元必须有四个属性，称为 ACID（原子性、一致性、隔离性和持久性）属性，只有这样才能成为一个事务：
(1)原子性
事务必须是原子工作单元；对于其数据修改，要么全都执行，要么全都不执行。
(2) 一致性
事务在完成时，必须使所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。事务结束时，所有的内部数据结构（如 B 树索引或双向链表）都必须是正确的。
(3) 隔离性
由并发事务所作的修改必须与任何其它并发事务所作的修改隔离。事务查看数据时数据所处的状态，要么是另一并发事务修改它之前的状态，要么是另一事务修改它之后的状态，事务不会查看中间状态的数据。这称为可串行性，因为它能够重新装载起始数据，并且重播一系列事务，以使数据结束时的状态与原始事务执行的状态相同。
(4) 持久性
事务完成之后，它对于系统的影响是永久性的。该修改即使出现系统故障也将一直保持。
游标的作用?如何知道游标已经到了最后?
答案：游标用于定位结果集的行，通过判断全局变量@@FETCH_STATUS可以判断是否到了最后，通常此变量不等于0表示出错或到了最后。
触发器分为事前触发和事后触发，这两种触发有何区别?语句级触发和行级触发有何区别?
答案：
事前触发器运行于触发事件发生之前，而事后触发器运行于触发事件发生之后。通常事前触发器可以获取事件之前和新的字段值。
语句级触发器可以在语句执行前或后执行，而行级触发在触发器所影响的每一行触发一次。
解决死锁的方法有哪些?
答案：
解决手段一：SQL Server自动检测和消除死锁
解决手段二：设置死锁优先级
解决手段三：设置锁定超时
解决手段四：使用更新锁避免死锁
提高数据库运行效率的办法有哪些?
答案：在给定的系统硬件和系统软件条件下，提高数据库系统的运行效率的办法是：
(1) 在数据库物理设计时，降低范式，增加冗余, 少用触发器, 多用存储过程。
(2) 当计算非常复杂、而且记录条数非常巨大时(例如一千万条)，复杂计算要先在数据库外面，以文件系统方式用C++语言计算处理完成之后，最后才入库追加到表中去。这是电信计费系统设计的经验。
(3) 发现某个表的记录太多，例如超过一千万条，则要对该表进行水平分割。水平分割的做法是，以该表主键PK的某个值为界线，将该表的记录水平分割为两个表。若发现某个表的字段太多，例如超过八十个，则垂直分割该表，将原来的一个表分解为两个表。
(4) 对数据库管理系统DBMS进行系统优化，即优化各种系统参数，如缓冲区个数。
(5) 在使用面向数据的SQL语言进行程序设计时，尽量采取优化算法。总之，要提高数据库的运行效率，必须从数据库系统级优化、数据库设计级优化、程序实现级优化，这三个层次上同时下功夫。
通俗地理解三个范式
答案：通俗地理解三个范式，对于数据库设计大有好处。在数据库设计中，为了更好地应用三个范式，就必须通俗地理解三个范式(通俗地理解是够用的理解，并不是最科学最准确的理解)：
第一范式：1NF是对属性的原子性约束，要求属性具有原子性，不可再分解；第二范式：2NF是对记录的惟一性约束，要求记录有惟一标识，即实体的惟
一性；
第三范式：3NF是对字段冗余性的约束，即任何字段不能由其他字段派生出来，它要求字段没有冗余。没有冗余的数据库设计可以做到。但是，没有冗余的数据库未必是最好的数据库，有时为了提高运行效率，就必须降低范式标准，适当保留冗余数据。具体做法是：在概念数据模型设计时遵守第三范式，降低范式标准的工作放到物理数据模型设计时考虑。降低范式就是增加字段，允许冗余。
简述存储过程的优缺点
优点：
更快的执行速度：存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度；
与事务的结合，提供更好的解决方案：当对数据库进行复杂操作时(如对多个表进行Update、Insert、Query和Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用；
支持代码重用：存储过程可以重复使用,可减少数据库开发人员的工作量；4. 安全性高：可设定只有某此用户才具有对指定存储过程的使用权。

缺点：

如果更改范围大到需要对输入存储过程的参数进行更改，或者要更改由其返回的数据，则您仍需要更新程序集中的代码以添加参数、更新 GetValue() 调用，等等，这时候估计比较繁琐了。
可移植性差由于存储过程将应用程序绑定到 SQL Server，因此使用存储过程封装业务逻辑将限制应用程序的可移植性。如果应用程序的可移植性在您的环境中非常重要，则将业务逻辑封装在不特定于 RDBMS 的中间层中可能是一个更佳的选择。
主键和唯一索引有什么区别?
答案：
相同点:它们都属于实体完整性约束。
不同点:
(1) 唯一性约束所在的列允许空值，但是主键约束所在的列不允许空值。
(2) 可以把唯一性约束放在一个或者多个列上，这些列或列的组合必须有唯一的。但是，唯一性约束所在的列并不是表的主键列。
(3) 唯一性约束强制在指定的列上创建一个唯一性索引。在默认情况下，创建唯一性的非聚簇索引，但是，也可以指定所创建的索引是聚簇索引。
(4) 建立主键的目的是让外键来引用。
(5) 一个表最多只有一个主键，但可以有很多唯一键。
简述索引存取的方法的作用和建立索引的原则
作用：加快查询速度。
原则：
(1) 如果某属性或属性组经常出现在查询条件中，考虑为该属性或属性组建立索引；
(2) 如果某个属性常作为最大值和最小值等聚集函数的参数，考虑为该属性建立索引；
(3) 如果某属性经常出现在连接操作的连接条件中，考虑为该属性或属性组建立索引；
简述数据库的设计过程
数据库设计分为五个阶段：
需求分析：主要是准确收集用户信息需求和处理需求，并对收集的结果进行整理和分析，形成需求说明。
概念结构设计：对用户需求进行综合、归纳、抽象，形成一个与与具体的DBMS无关概念模型（一般为ER模型）。
逻辑结构设计：将概念结构设计的概念模型转化为某个特定的DBMS所支持的数据模型，建立数据库逻辑模式，并对其进行优化，同时为各种用户和应用设计外模式。
物理结构设计：为设计好的逻辑模型选择物理结构，包括存储结构和存取方法等，建立数据库物理模式。
实施和维护：实施就是使用DLL语言建立数据库模式，将实际数据载入数据库，建立真正的数据库。维护阶段是对运行中的数据库进行评价、调整和修改。

oracle性能优化之表设计
数据库优化的目标无非是避免磁盘I/O瓶颈、减少CPU利用率和减少资源竞争。为了便于读者阅读和理解，笔者参阅了Sybase、Informix和Oracle等大型数据库系统参考资料，基于多年的工程实践经验，从基本表设计、扩展设计和数据库表对象放置等角度进行讨论，着重讨论了如何避免磁盘I/O瓶颈和减少资源竞争，相信读者会一目了然。
基于第三范式的基本表设计
在基于表驱动的信息管理系统（MIS）中，基本表的设计规范是第三范式（3NF）。第三范式的基本特征是非主键属性只依赖于主键属性。基于第三范式的数据库表设计具有很多优点：一是消除了冗余数据，节省了磁盘存储空间；二是有良好的数据完整性限制，即基于主外键的参照完整限制和基于主键的实体完整性限制，这使得数据容易维护，也容易移植和更新；三是数据的可逆性好，在做连接（Join）查询或者合并表时不遗漏、也不重复；四是因消除了冗余数据（冗余列），在查询（Select）时每个数据页存的数据行就多，这样就有效地减少了逻辑I/O，每个Cash存的页面就多，也减少物理I/O；五是对大多数事务(Transaction)而言，运行性能好；六是物理设计(Physical Design)的机动性较大，能满足日益增长的用户需求。
在基本表设计中，表的主键、外键、索引设计占有非常重要的地位，但系统设计人员往往只注重于满足用户要求，而没有从系统优化的高度来认识和重视它们。实际上，它们与系统的运行性能密切相关。现在从系统数据库优化角度讨论这些基本概念及其重要意义：
（1）主键(Primary Key)：主键被用于复杂的SQL语句时，频繁地在数据访问中被用到。一个表只有一个主键。主键应该有固定值（不能为Null或缺省值，要有相对稳定性），不含代码信息，易访问。把常用（众所周知）的列作为主键才有意义。短主键最佳（小于25bytes），主键的长短影响索引的大小，索引的大小影响索引页的大小，从而影响磁盘I/O。主键分为自然主键和人为主键。自然主键由实体的属性构成，自然主键可以是复合性的，在形成复合主键时，主键列不能太多，复合主键使得Join作复杂化、也增加了外键表的大小。人为主键是，在没有合适的自然属性键、或自然属性复杂或灵敏度高时，人为形成的。人为主键一般是整型值（满足最小化要求），没有实际意义，也略微增加了表的大小；但减少了把它作为外键的表的大小。
（2）外键（Foreign Key）：外键的作用是建立关系型数据库中表之间的关系（参照完整性），主键只能从独立的实体迁移到非独立的实体，成为后者的一个属性，被称为外键。
（3）索引(Index)：利用索引优化系统性能是显而易见的，对所有常用于查询中的Where子句的列和所有用于排序的列创建索引，可以避免整表扫描或访问，在不改变表的物理结构的情况下，直接访问特定的数据列，这样减少数据存取时间；利用索引可以优化或排除耗时的分类作；把数据分散到不同的页面上，就分散了插入的数据；主键自动建立了唯一索引，因此唯一索引也能确保数据的唯一性（即实体完整性）；索引码越小，定位就越直接；新建的索引效能最好，因此定期更新索引非常必要。索引也有代价：有空间开销，建立它也要花费时间，在进行Insert、Delete和Update作时，也有维护代价。索引有两种：聚族索引和非聚族索引。一个表只能有一个聚族索引，可有多个非聚族索引。使用聚族索引查询数据要比使用非聚族索引快。在建索引前，应利用数据库系统函数估算索引的大小。
① 聚族索引（Clustered Index）：聚族索引的数据页按物理有序储存，占用空间小。选择策略是，被用于Where子句的列：包括范围查询、模糊查询或高度重复的列（连续磁盘扫描）；被用于连接Join作的列；被用于Order by和Group by子句的列。聚族索引不利于插入作，另外没有必要用主键建聚族索引。
② 非聚族索引（Nonclustered Index）：与聚族索引相比，占用空间大，而且效率低。选择策略是，被用于Where子句的列：包括范围查询、模糊查询（在没有聚族索引时）、主键或外键列、点（指针类）或小范围（返回的结果域小于整表数据的20%）查询；被用于连接Join作的列、主键列（范围查询）；被用于Order by和Group by子句的列；需要被覆盖的列。对只读表建多个非聚族索引有利。索引也有其弊端，一是创建索引要耗费时间，二是索引要占有大量磁盘空间，三是增加了维护代价（在修改带索引的数据列时索引会减缓修改速度）。那么，在哪种情况下不建索引呢？对于小表（数据小于5页）、小到中表（不直接访问单行数据或结果集不用排序）、单值域（返回值密集）、索引列值太长（大于20bitys）、容易变化的列、高度重复的列、Null值列，对没有被用于Where子语句和Join查询的列都不能建索引。另外，对主要用于数据录入的，尽可能少建索引。当然，也要防止建立无效索引，当Where语句中多于5个条件时，维护索引的开销大于索引的效益，这时，建立临时表存储有关数据更有效。
批量导入数据时的注意事项：在实际应用中，大批量的计算（如电信话单计费）用C语言程序做，这种基于主外键关系数据计算而得的批量数据（文本文件），可利用系统的自身功能函数（如Sybase的BCP命令）快速批量导入，在导入数据库表时，可先删除相应库表的索引，这有利于加快导入速度，减少导入时间。在导入后再重建索引以便优化查询。
（4）锁：锁是并行处理的重要机制，能保持数据并发的一致性，即按事务进行处理；系统利用锁，保证数据完整性。因此，我们避免不了死锁，但在设计时可以充分考虑如何避免长事务，减少排它锁时间，减少在事务中与用户的交互，杜绝让用户控制事务的长短；要避免批量数据同时执行，尤其是耗时并用到相同的数据表。锁的征用：一个表同时只能有一个排它锁，一个用户用时，其它用户在等待。若用户数增加，则Server的性能下降，出现“假死”现象。如何避免死锁呢？从页级锁到行级锁，减少了锁征用；给小表增加无效记录，从页级锁到行级锁没有影响，若在同一页内竞争有影响，可选择合适的聚族索引把数据分配到不同的页面；创建冗余表；保持事务简短；同一批处理应该没有网络交互。
（5）查询优化规则：在访问数据库表的数据(Access Data)时，要尽可能避免排序（Sort）、连接(Join)和相关子查询作。经验告诉我们，在优化查询时，必须做到：
① 尽可能少的行；
② 避免排序或为尽可能少的行排序，若要做大量数据排序，最好将相关数据放在临时表中作；用简单的键（列）排序，如整型或短字符串排序；
③ 避免表内的相关子查询；
④ 避免在Where子句中使用复杂的表达式或非起始的子字符串、用长字符串连接；
⑤ 在Where子句中多使用“与”（And）连接，少使用“或”(Or)连接；
⑥ 利用临时数据库。在查询多表、有多个连接、查询复杂、数据要过滤时，可以建临时表（索引）以减少I/O。但缺点是增加了空间开销。
除非每个列都有索引支持，否则在有连接的查询时分别找出两个动态索引，放在工作表中重新排序。
3 基本表扩展设计
基于第三范式设计的库表虽然有其优越性（见本文第一部分），然而在实际应用中有时不利于系统运行性能的优化：如需要部分数据时而要扫描整表，许多过程同时竞争同一数据，反复用相同行计算相同的结果，过程从多表获取数据时引发大量的连接作，当数据来源于多表时的连接作；这都消耗了磁盘I/O和CPU时间。
尤其在遇到下列情形时，我们要对基本表进行扩展设计：许多过程要频繁访问一个表、子集数据访问、重复计算和冗余数据，有时用户要求一些过程优先或低的响应时间。
如何避免这些不利因素呢？根据访问的频繁程度对相关表进行分割处理、存储冗余数据、存储衍生列、合并相关表处理，这些都是克服这些不利因素和优化系统运行的有效途径。
3.1 分割表或储存冗余数据
分割表分为水平分割表和垂直分割表两种。分割表增加了维护数据完整性的代价。
水平分割表：一种是当多个过程频繁访问数据表的不同行时，水平分割表，并消除新表中的冗余数据列；若个别过程要访问整个数据，则要用连接作，这也无妨分割表；典型案例是电信话单按月分割存放。另一种是当主要过程要重复访问部分行时，最好将被重复访问的这些行单独形成子集表（冗余储存），这在不考虑磁盘空间开销时显得十分重要；但在分割表以后，增加了维护难度，要用触发器立即更新、或存储过程或应用代码批量更新，这也会增加额外的磁盘I/O开销。
垂直分割表（不破坏第三范式），一种是当多个过程频繁访问表的不同列时，可将表垂直分成几个表，减少磁盘I/O（每行的数据列少，每页存的数据行就多，相应占用的页就少），更新时不必考虑锁，没有冗余数据。缺点是要在插入或删除数据时要考虑数据的完整性，用存储过程维护。另一种是当主要过程反复访问部分列时，最好将这部分被频繁访问的列数据单独存为一个子集表（冗余储存），这在不考虑磁盘空间开销时显得十分重要；但这增加了重叠列的维护难度，要用触发器立即更新、或存储过程或应用代码批量更新，这也会增加额外的磁盘I/O开销。垂直分割表可以达到最大化利用Cache的目的。
总之，为主要过程分割表的方法适用于：各个过程需要表的不联结的子集，各个过程需要表的子集，访问频率高的主要过程不需要整表。在主要的、频繁访问的主表需要表的子集而其它主要频繁访问的过程需要整表时则产生冗余子集表。
注意，在分割表以后，要考虑重新建立索引。
3.2 存储衍生数据
对一些要做大量重复性计算的过程而言，若重复计算过程得到的结果相同（源列数据稳定，因此计算结果也不变），或计算牵扯多行数据需额外的磁盘I/O开销，或计算复杂需要大量的CPU时间，就考虑存储计算结果（冗余储存）。现予以分类说明：
若在一行内重复计算，就在表内增加列存储结果。但若参与计算的列被更新时，必须要用触发器更新这个新列。
若对表按类进行重复计算，就增加新表（一般而言，存放类和结果两列就可以了）存储相关结果。但若参与计算的列被更新时，就必须要用触发器立即更新、或存储过程或应用代码批量更新这个新表。
若对多行进行重复性计算（如排名次），就在表内增加列存储结果。但若参与计算的列被更新时，必须要用触发器或存储过程更新这个新列。
总之，存储冗余数据有利于加快访问速度；但违反了第三范式，这会增加维护数据完整性的代价，必须用触发器立即更新、或存储过程或应用代码批量更新，以维护数据的完整性。
3.3 消除昂贵结合
对于频繁同时访问多表的一些主要过程，考虑在主表内存储冗余数据，即存储冗余列或衍生列（它不依赖于主键），但破坏了第三范式，也增加了维护难度。在源表的相关列发生变化时，必须要用触发器或存储过程更新这个冗余列。当主要过程总同时访问两个表时可以合并表，这样可以减少磁盘I/O作，但破坏了第三范式，也增加了维护难度。对父子表和1：1关系表合并方法不同：合并父子表后，产生冗余表；合并1：1关系表后，在表内产生冗余数据。
4 数据库对象的放置策略
数据库对象的放置策略是均匀地把数据分布在系统的磁盘中，平衡I/O访问，避免I/O瓶颈。
⑴ 访问分散到不同的磁盘，即使用户数据尽可能跨越多个设备，多个I/O运转，避免I/O竞争，克服访问瓶颈；分别放置随机访问和连续访问数据。
⑵ 分离系统数据库I/O和应用数据库I/O。把系统审计表和临时库表放在不忙的磁盘上。
⑶ 把事务日志放在单独的磁盘上，减少磁盘I/O开销，这还有利于在障碍后恢复，提高了系统的安全性。
⑷ 把频繁访问的“活性”表放在不同的磁盘上；把频繁用的表、频繁做Join*作的表分别放在单独的磁盘上，甚至把把频繁访问的表的字段放在不同的磁盘上，把访问分散到不同的磁盘上，避免I/O争夺；
⑸ 利用段分离频繁访问的表及其索引（非聚族的）、分离文本和图像数据。段的目的是平衡I/O，避免瓶颈，增加吞吐量，实现并行扫描，提高并发度，最大化磁盘的吞吐量。利用逻辑段功能，分别放置“活性”表及其非聚族索引以平衡I/O。当然最好利用系统的默认段。另外，利用段可以使备份和恢复数据更加灵活，使系统授权更加灵活

什么是内存泄漏?
答案：一般我们所说的内存泄漏指的是堆内存的泄漏。堆内存是程序从堆中为其分配的，大小任意的，使用完后要显示释放内存。当应用程序用关键字new等创建对象时，就从堆中为它分配一块内存，使用完后程序调用free或者delete释放该内存，否则就说该内存就不能被使用，我们就说该内存被泄漏了。
什么是基本表?什么是视图?
答案：基本表是本身独立存在的表，在 SQL 中一个关系就对应一个表。
视图是从一个或几个基本表导出的表。视图本身不独立存储在数据库中，是一个虚表
试述视图的优点
(1) 视图能够简化用户的操作
(2) 视图使用户能以多种角度看待同一数据；
(3) 视图为数据库提供了一定程度的逻辑独立性；
(4) 视图能够对机密数据提供安全保护。
所有的视图是否都可以更新?为什么?
答案：不是。
视图是不实际存储数据的虚表，因此对视图的更新，最终要转换为对基本表的更新。
因为有些视图的更新不能惟一有意义地转换成对相应基本表的更新，所以，并不是所有的视图都是可更新的。
哪类视图是可以更新的?哪类视图是不可更新的?各举一例说明。
答案：基本表的行列子集视图一般是可更新的。若视图的属性来自集函数、表达式，则该视图肯定是不可以更新的。
维护数据库的完整性、一致性、你喜欢用触发器还是自写业务逻辑?为什么?
答案：尽可能用约束（包括CHECK、主键、唯一键、外键、非空字段）实现，这种方式的效率最好；其次用触发器，这种方式可以保证无论何种业务系统访问数据库都能维持数据库的完整性、一致性；最后再考虑用自写业务逻辑实现，但这种方式效率最低、编程最复杂，当为下下之策。
在为视图创建索引前，视图本身必须满足哪些条件?
(1) 视图以及视图中引用的所有表都必须在同一数据库中，并具有同一个所有者
(2) 索引视图无需包含要供优化器使用的查询中引用的所有表。
(3) 必须先为视图创建唯一群集索引，然后才可以创建其它索引。
(4) 创建基表、视图和索引以及修改基表和视图中的数据时，必须正确设置某些 SET 选项（在本文档的后文中讨论）。另外，如果这些 SET 选项正确，查询优化器将不考虑索引视图。
(5) 视图必须使用架构绑定创建，视图中引用的任何用户定义的函数必须使用 SCHEMABINDING 选项创建。
(6) 另外，还要求有一定的磁盘空间来存放由索引视图定义的数据。
什么是SQL Server的确定性函数和不确定性函数?
答案：只要使用特定的输入值集并且数据库具有相同的状态，不管何时调用，始终都能范围相同结果的函数叫确定性函数。几十访问的数据库的状态不变，每次书用特定的输入值都可能范围不同结果的函数叫非确定性函数。

数据库面试题 4

第一章：
1）E-R模型的组成包括以下的元素，除了（C）。（选择一项）
a)实体
b)属性
c)记录
d)关系

你为公司开发了一个逻辑模型：公司有10个部门，每个部门有6-7个员工，但每个员工可能会不止一个部门工作。下面所给的模型正确的是（B）。（选择一项）
a)部门和员工之间是一种确定的一对多的关系
b)建立一个关联表，从该关联表到员工建立一个一对多的关系，然后再从该关
联表到部门表建立一个一对多的关系
c)建立一个关联表，从员工表到该关联表建立一个一对多的关系，然后再从部
门表到该关联表建立一个一对多的关系
d)这种情况不能建立正常的数据库模型
下面©不是数据库规范化要达到的效果.(选择一项)
a)改善数据库的设计
b)实现最小的数据冗余
c)可以用一个表来存储所有数据,使设计及存储更加简化
d)防止更新,插入及删除的时候,产生数据丢失
(A)是个人能看到的相关数据库部分的数据库视图。（选择一项）
a)外部级别
b)逻辑级别
c)用户级别
d)物理级别
在某ERD里有“客户”和“订单”两个实体，他们的关系是“客户”发出“订单”，在“订单”这个实体里又有“订购数量”、“产品代码”等属性，“产品”与“产品代码”之间的关系应该是（B）。（选择一项）
a)一对一
b)一对多
c)多对多
d)循环对应
在ACCESS数据库表设计的时候，某用户在设计视图的有效性规则中设置为[get score]>[average score],则此用户用的是（C）类型的检查约束。（选择一项）
a)字段值
b)记录级
c)表级
d)平均值

第二章：T-SQ程序设计

使用T-SQL定义两个局部变量AA和BB,正确的语句是(A).(选择一项)
a) DECLARE@AA,@BB
b) PIRVTE@AA;@BB
c) PUBLIC@AA;@BB
d) DECLARE@AA;@BB

第三章:事务和锁

四个并发连接各自同时在select,insert,update和delete操作，有时当选择的行数超 10，000时再做update/delete操作时会停止，你该（C）去修复。（选择一项）
a)在Selesct会话中，设置低优先级的Deadlock
b)在Update/Delete会话中，设置低优先级的Deadlock
c)在Select会话中，设置末提交读隔离低级别
d）设置查询等待选项为50，0000

第四章：用户和安全管理

在sql server 2000的查询分析器中执行以下的t-sql:
exec sp_grantdbacces’workarea\remotelongin’,’dblocalh’
下列理解正确的是（B）（一项）
a)允许windows nt 域 workarea的所有远程登陆的用户都具有访问数据库dblocalh的权限
b)在当前数据库中为windows nt 用户workarea\remotelogin添加帐户，并取名为dblocalh
c)把windows nt 用户workarea\remotelogin赋予已经存在的角色dblocalh的全部权限
d)限制windows nt windows nt 用户workarea\remotelogin只能访问数据库dblocalh

2）在SQL server 2000的安全模型中，提供了“服务器”和（B）两种类型的角色。（选择一项）
a)客户端
b)数据库
c)操作系统
d)数据对象

在SQL Server2000的查询分析器中，执行以下的: EXEC sp_droplogin’DBLocalHost’ 正确的为
a)若存在数据库DBLocalHost,将删除该数据库及其所有相关的对象
b)若存在角色DBLocalHost,将删除该角色并从所有的相关的用户回收该角色所具有的权限
c)若存在登录名DBLocalHost,将删除该登录.并阻止使用登录名访问
d)若存在数据库用户DBLocalHost,将删除该用户

4）在SQL Server2000数据库中Pubic角色是一类特殊的角色，并且具有以下的特性，除了（D）。
a)它不能被删除。
b)每个数据库用户都属于Public角色，甚至包括sa帐户。
c)它包含在每个数据库中。
d)不能为Public角色分配其他更加高级的权限。

5）在SQL Server数据库中，以下对象都可以通过Drop关键字进行删除，除了（D）。（选择一项）
A）表
B）触发器
C）视图
D）角色

在SQL Server 2000的查询分析器中运行以下的T-SQL:
USE PubsGo
GRANT INSERT,UPDATE,DELETE ON authors TO MaryYa
Go将©.(选择一项)
a)禁止用户MaryYa操作数据库pubs中除了authors之外所有的表
b)把数据库pubs中表authors中的数据全部转移到数据库MaryYa中
c)赋予用户MaryYa操作数据库pubs中表authors插入更新和删除数据的权利
d)代码运行将失败，提示GRANT操作无效

第五章：高级查询
1）在SQL Server数据库中，你想得到在products表中最贵的产品的产品名称和产品价格应该使用的查询是（A）。（选择一项）
a)SELECT TOP 1 Productnamem ,Price FROM Products ORDER BY Price desc
b)SELECECT Productname,MAX(price)FROM Products
c)SELECTCT Productname

2）以下分别是sql server 2000中两个数据表的结构描述和已经有的数据项，除Anumber字段为数字类型外，其他字段数据类型都是长度为32的字符：
在查询分析器内执行以下的T-SQL（C）。（选择一项）
SELECT Acount_No,Aname FROM Saving_Accounts
UNION SELECT Account_No,Bname FROM Current_Accounts
Account NoAnameAnumber
S001James1
S002Rita2
S003Mary3
S004Valentina4
Saving_Accounts 表
Acceout NoBname
C001Micheel
C002Rodin
Current_Accouns 表
a).查询错误，因为使用UNION查询的时候，两个字段结构必须保持一致
b). 查询错误，因为使用UNION查询的时候，查询输出的列名必须保持一致
c).正确得到联合查询的结果集，并且输出的列名名称为Account_No 和 Aname
d)正确得到联合查询的结果集，并且输出三列六行数据

该发年终奖了，你想找出销售量最高的前5名销售，在sql server中，你会使用下面（B）查询语句。
a)select top 5 orderamount,salesmanid form orders
b)select top 5 orderamount,salesmanid form orders order by orderamount desc
c)select top 5 with orderamount,salesmanid form orders order by salesmanid desc
d)slesect top5 with orderamount,salesmanid from orders order by orderamount

4）在microsoft access 的sql视图里有：
select distinctrow 产品.产品名称，产品.产品单价 from产品 where （（（产品.单价）>（select avg([单价]) from 产品）））order by 产品.单价 desc; 下面说法错误的是（B）。（选择一项）
a)”select avg([单价] from 产品)” 是子查询
b)“order by 产品.单价 desc”是指按单价从低到高顺序排列
c)查询结果显示的是单价大于平均价格的记录
d)这次查询显示的字段只有“产品名称”和“单价”

以下的T-SQL代码：
UPDATE titles
SET t.ytd_sales=t.ytd_sales+s.qty FROM titles t,sales s
WHERE t.title_id=s.title_id AND s.ord_date=(SELECT MAX(sales.ord_date)FROM sales)
该代码在查询分析器执行后，将（B）。（选择一项）
a)不能执行数据更新，因为Update子句中，不能使用FROM
b)不能执行数据更新，因为set T.YTD_sales=t.ytd_sales+s.qty行中不能使用表的别名t
c)不能执行数据更新，因为s.ord_date=(SELECT MAX(sales.ord_date)FROM sales)不符合逻辑，一个字段的值不允许等于一个子查询的输出
d)正确执行数据更新

第六章：索引
1）在SQL Sever数据库一个班级表里只记录了100位同学的情况，那么对该表建立索引文件的说法正确的是（B）。（选择一项）
a)一定要，因为索引有助于加快搜索记录的错误
b)不适宜，因为对少量记录的表进行索引实际上会产生不利的影响
c)一定要，因为索引对于任何数据库都是必要的
d)没有必要，因为建立索引对任何数据库的性能没有影响

关于全文索引，以下说法正确的是（A）。（选择一项）
a)全文索引被存储在文件系统中。
b)表允许有多个全文本索引。
c)可以用Transact-SQL语句来创建、管理和丢弃全文本索引。
d)全文索引与表的聚集、非聚集索引无关，可以只建立全问索引而不需要聚集
或者非聚集索引。

第七章：视图和游标

以下SQL Server是支持的三种游标类型,除了(A).(选择一项)
a)幻想游标
b)Transact-SQL游标
c)API服务器游标
d)客户端游标
以下是SQL Server中使用游标变量并进行赋值的T-SQL：
DECLARE @CurV CURSOR
DECLARE OBJCurV CURSOR FOR SELECT LastName FROM Employees—(1)此处填写正确的游标赋值语句，则（1）处应填写的正确的代码为（A）。（选择一项）
a)Set @Curv = ObjCurV
b)B）@Curv = ObjCurV
c)SET Curv =ObjCurV
d)Curv =ObjCurV
在sql server中，以下对象可以通过create语句来创建，除了（B）。（选择一项）
a)视图
b)游标
c)存储过程
d)触发器
在SQL Server数据库中，（B）可以看成为虚拟的表。（选择一项）
a)游标
b)视图
c)全文索引
d)存储过程

第八章：存储]过程

以下的T-SQL代码：
Create procedure price_proc
(@count int output,@avg_price money output,@type char(12)=’business’)
as
Selec@Count=Count(),@avg_price=Avg(price)from titles where type=@type
以下说法正确的是（B）。（选择一项）
a)建立一个存储过程price_proc，所有参数都有是输出参数
b)建立一个存储过程price_proc，返回的是用户指定类图书的数量及平均价格
c)c)@count=count()也可以用@count=count()代替
d)创建存储过程失败，因为select语句中用了聚合函,因此必须使用Group By进行分组
考虑下面SQL Server的存储过程
CREATE procedure lookup(@a int)As
If@a is null
Begin
Print ‘You forgot to pass in a parameter’
Return End
Select * from sysobjects where id = @a
retunrn
如果这个存储过程不带参数运行会发生（C）。（选择一项）
a)该存储过程会打印”You forgot to pass in a parameter“
b)该存储过程会基于无参数情况做一个查找，返回表中的所有行
c)该存储过程有语法错误
d)服务器会打印一条消息，提示该存储过程需要提供一个参数
用sp_recompile系统存储过程可以强制存储过程在下一次启动时进行重新编译,其语法为:其中的可以是以下某个对象名称,除了©.(选择一项)
a)存储过程名称
b)触发气名称
c)约束对象名称
d)试图名称
在SQL Server 2000中，系统存储过程（A）。（选择一项）
a)存储在Master数据库中
b)可以在查询分析器中修改
c)一些名称以”sp_”开头，一些名称以”sys_”开头
d)用来代替用户自定义的存储过程

第九章：触发器

在SQL Server 2000的查询分析器中运行以下T-SQL（C）:
use pubs go
create table my_table(a int NULL,b int NULL)go
create trigger my_trig on my_table for in sert as
if update(b) begin Create database AAA print’OK…’end go
insert my_table values(3,4)go
update my_table set a=5 where b=4 go(选择一项)
a)正确创建数据库AAA，并且打印OK…
b)第一次正确创建数据库AAA，打印OK…,在第二次触发的时候报告错误信息，数据库AAA已经存在
c)报告错误信息，提示不能在触发器中使用CREATE DATABASE语句
d)该触发器不会被触发，代码运行完毕后，不创建数据库，也不会打印任何输出信息
在SQL SERVER 中，以下都是触发器的特性，除了（B）。（选择一项）
a)强化约束
b)可级联运行
c)跟踪变化
b）查询优化

3）在sql server 2000中的查询分析器中运行以下的T_sql;
use pubs
create table my_table (a int null,b int null)
go
create trigger My_trig on my_table for insert
as
if update（b）
print “更新….”
Go
Insert My_table values(3,4)
Go
Update My_table set a=5 where b=4
Go
将打印输出（A）。（选择一项）
a)更新….
b)更新….
更新……
c)不打印任何信息
d)以上代码将出现运行错误而中断

4）在查询分析器中你运行下面的语句：
CREATE TABLE numbers(
N1 INT,
N2 NUMERIC(5,0),
N3 NUMERIC(4,2)
GO
INSERT numbers VALUES(1.7,1.6,1.4)
SELECT *FROM numbers
)
得到的结果是（C）。（选择一项）
a)2.2，1.50
b)1.7，1.6，1.4
c)1，2，1.40
d)CREATE TABLE 命令不会执行，因为无法为列N2设置精度为0。

5）假设两张表建立“主键-外键”的引用关系，则（B、C）
A.主表数据必须在子表中有对应
B.主表数据可以比子表中的数据多
C.子表外键列可以包含空值
D.外键不能是列的组合，即一个外键不能包含多列
E.与外键对应的主键不能是列的组合，即不能是组合键

1.关于数据规范化，下列说法正确的有（ABCD）：
A.数据规范化的目的是为了除去关系型数据库表中冗余的数据
B.通常第三范式被认为是大多数应用程序所需的最高等级
C.从性能上考虑，应该将关系数据规范化到最高等级
D.有时候为了提高整体性能，可以增加冗余――即将数据非规范化

2.如果一个表定义了主键，不包含重复的列，且只包含依赖于主键的列，则我们称该表满足（C）。
A.第一范式
B.第二范式
C.第三范式
D.第四范式

3.用于表示数据库实体之间关系的图是（B）。
A.数据模型图
B.实体关系图
C.实体分类图
D.以上都不是

4.下列那条语句可以用来从T-SQL的WHILE语句中退出?(D)
A.CLOSE
B.BREAK
C.EXIT
D.以上都是

5.关于T-SQL中变量的使用，下列说法正确的有（C）?
A.局部变量以@为前缀，全部变量以@@为前缀
B.局部变量可以不用声明而直接使用
C.全局变量@@ROWCOUNT用于返回最近打开的游标中的行数
D.SET语句是给局部变量赋值的唯一方法

6.语句select datediff(mm,’01/01/1999′,’09/30/1999′)的返回值为（C）。
A.272
B.0
C.8
D.23500800

7.事务所具有的特性有（ABCD）。
A.原子性
B.一致性
C.隔离性
D.持久性

8.事务可以分为哪几种类型?(AB)
A.显式事务
B.隐式事务
C.自动提交事务
D.延迟事务

9.下列哪条语句用于清除自最近的事务语句以来所有的修改?(B)
A.Commit Transaction
B.Rollback Transaction
C.Begin Transaction
D.Save Transaction

10.SQL Server认可的登录身份验证机制包括（A）。
A.SQL Server身份验证
B.混和模式身份验证
C.明文身份验证
D.密码身份验证

11.SQL Server使用__________、____________和___________命令来管理权限（A）
A.GRANT、DENY、REVOKE
B.ALLOW、DENY、REVOKE
C.ALLOW、DISALLOW、PERMIT
D.PERMIT、DENY、REVOKE

12.下面的SQL语句用于在SQL Server的PUBS数据库中查找所有住在California，并且收到的某本书的版税低于30%的第二作者的姓名，与之返回结果相等的SQL语句是（B）。
SELECT au_lname, au_fname FROM authors WHERE state=’CA’ AND au_id IN (SELECT au_id FROM titleauthor WHERE royaltyper<30 AND au_ord=2)
A.SELECT au_lname, au_fname FROM authors INNER JOIN titleauthor ON authors.au_id= titleauthor.au_id WHERE state=’CA’ AND royaltyper<30 AND au_ord=2
B.SELECT au_lname, au_fname FROM authors UNION titleauthor ON authors.au_id= titleauthor.au_id WHERE state=’CA’ AND royaltyper<30 AND au_ord=2
C.SELECT au_lname, au_fname FROM authors OUTTER JOIN titleauthor ON authors.au_id= titleauthor.au_id WHERE state=’CA’ AND royaltyper<30 AND au_ord=2
D.SELECT au_lname, au_fname FROM authors CROSS JOIN titleauthor ON authors.au_id= titleauthor.au_id WHERE state=’CA’ AND royaltyper<30 AND au_ord=2

13.关于用UNION操作符联接多个数据表中的行，下列说法正确的有（ABCD）?
A.UNION操作符可以将两个或多个SELECT语句的结果合并为一个结果集，每个SELECT语句都必须具有相同的结果：兼容的列类型和相同的列数
B.在UNION后如果包括ALL子句，则所有的行都包括在结果集中，并且不会删除重复的行
C.默认情况下，UNION操作符从结果集中删除重复的行
D.通过 UNION 生成的表中的列名来自 UNION 语句中的第一个单独的查询。若要用新名称引用结果集中的某列（例如在 ORDER BY 子句中），必须按第一个 SELECT 语句中的方式引用该列

14.______________子句为聚合函数生成汇总值，该汇总值作为一个附加的行显示在结果集中（BD）
A.COMPUTE
B.EXISTS
C.UNION
D.DISTINCT

15.SELECT INTO子句可用来基于现存的表创建一个新的表，下列说法正确的有（AD）
A.创建的新表具有与现存表相同的结构
B.创建的新表是一个临时表，相当于一个游标，数据库关闭的时候会自动释放
C.创建的新表是只读的，不能向里面添加数据
D.创建的新表可以执行添加、删除数据的操作

16.关于SQL Server的索引，下列说法正确的有（B）
A.索引分为聚集索引和非聚集索引两种类型
B.聚集索引确定表中数据的物理顺序，非聚集索引确定表中数据的逻辑顺序
C.一个表中可以只能包含一个聚集索引，但是可以包括多个非聚集索引
D.对于频繁更改的列，最好使用聚集索引

17.下列关于视图的说法，正确的有：（CD）
A.视图可以防止未经许可的用户访问敏感数据
B.创建视图时，可以将列名改为有意义的名称，使用户更容易理解列所代表的内容
C.定义的视图中可以包含ORDER BY子句
D.不能为视图建立索引

18.在不再需要使用某个游标时，可以使用哪个语句将该游标的引用释放删除（A）
A.CLOSE
B.FETCH
C.NOTHING
D.DEALLOCATE

19.下列关于存储过程的说法正确的有：（A）
A.存储过程的编写体现了模块化程序设计的思想
B.使用存储过程在某种意义上将降低了网络流量
C.在C/S结构中使用存储过程，保证了数据的安全性
D.存储过程比大量的T-SQL批代码执行要快

20.关于存储过程的两种类别，下列说法正确的有（B）
A.系统存储过程位于master数据库中
B.用户只能通过系统存储过程访问和更新系统表
C.创建用户自定义存储过程可以通过企业管理器或查询分析器完成
D.系统存储过程sp_helptext可以显示加密的存储过程的原始文本

21.在SQL Server2000中通过存储过程返回数据的方法包括（BCD）
A.输入参数
B.输出参数
C.返回代码
D.SELECT语句的结果集

22.通过存储过程中处理错误信息的方法包括（AB）
A.返回代码
B.使用RAISEERROR语句
C.使用ON ERROR GOTO 语句
D.使用 ON ERROR RESUME语句

23.在创建存储过程中指定WITH RECOMPILE会产生什么效果?（C）
A.下次执行时重新编译该过程
B.下次启动SQL Server以及执行过程时会重新编译该过程
C.每次执行过程时都重新编译过程
D.每次在引用表上创建索引时都重新编译该过程

24.SQL Server提供的几种重新编译存储过程的方法为（ABC）
A.使用系统存储过程sp_recompile
B.在创建存储过程使指定with recompile
C.在使用execute时指定with recompile
D.在SQL Server启动时候强制重新编译

25.关于触发器，下列说法正确的有?（ABC）
A.触发器主要通过事件进行触发
B.触发器的主要作用是能够实现主键和外键所不能保证的复杂的参照完整性和数据一致性
C.同存储过程和约束一样，触发器也是一个在数据库服务器端实现或执行业务规则的有效方法
D.触发器可以嵌套任意层

26.下列关于实体完整性的说法正确的有：（B）
A.实体完整性是数据完整性约束条件的一种，其规则规定基表主键的任何部分都不可以接受空值
B.实体完整性将行定义为特定表的唯一实体
C.实体完整性牵制表的标识符列或主键的完整性
D.可以通过主键约束、标识列、外键约束等实现实体完整性

27.以下哪几项是主键约束和唯一约束的区别（BD）
A.一个表可以有多个唯一约束，但是只能有一个主键约束
B.主键约束列不能为空，而唯一约束可以为空
C.主键约束只能包含一列，而唯一约束可以包含多列
D.主键约束实现实体完整性，而唯一约束实现引用完整性

28.关于数据库的主要数据文件和次要数据文件，下列哪一项说法是正确的（B）
A.数据库可以有多个主要数据文件和多个次要数据文件
B.数据库只能有一个主要数据文件，并且可以没有次要数据文件
C.数据库只能有一个次要数据文件，但是可以有多个主要数据文件
D.数据库可以没有主要数据文件，也可以没有次要数据文件

29.唯一标识表中的记录的一个或者一组列被称为（B）
A.外键
B.主键
C.关系
D.度

30.SQL Server中数据库文件类型有如下几种（ABC）
A.主要数据文件
B.次要数据文件
C.日志文件
D.备份文件

关于Access和SQL Server数据库的比较，以下那些说法是正确的（B、E）
A.他们都将数据保存在一个物理文件中
B.他们使用相同的SQL语言
C.他们采取类似的备份方式
D.他们都具有数据文件和日志文件
E.在打开Access数据库或者SQL Server正在运行时，数据库对应的物理文件不能被删除

32.在SQL Server的系统数据库中，（A）数据库用于保存数据库的配置信息
A.Master
B.Model
C.MSDB
D.SysDB
E.System

33.使用IDENTITY来标识特定的行时，下列写法符和要求的有（A、E）
A.CREATE TABLE ABC(Id_Num int IDENTITY(1,3),fname varchar(20))
B.CREATE TABLE ABC(Id_Num IDENTITY(5),fname varchar(20))
C.CREATE TABLE ABC(Id_Num IDENTITY(5,1),fname varchar(20))
D.CREATE TABLE ABC(Id_Num varChar IDENTITY,fname varchar(20))
E.CREATE TABLE ABC(Id_Num int IDENTITY,fname varchar(20))

34.假设有T-SQL为：ALTER TABLE ABC ADD CONSTRAINT PRIMARYKEYS CHECK(CH>300),则它的执行结果是（B）
A.为表ABC添加主键约束，并且字段CH的值必须大于300
B.为表ABC添加检查约束，约束名为PRIMARYKEYS
C.为表ABC添加约束，规定字段CH为主键
D.为表ABC添加一个字段CH，并且字段CH的值必须大于300
E.检查CH，如果CH大于300，则为表ABC添加一个字段CH，并设为主键

35.在表STUD中有一列为SNAME，执行查询语句“DELETE FROM STUD WHERE SNAME LIKE ‘_[ae]%’”时，下列STUD中哪些数据行可能被删除（B）
A.Whyte
B.Carson
C.Annet
D.Hunyer
E.都不会被删除

36.假设ABC表中的A列存储电话号码信息，则查询不是以7开头的所有电话号码，正确的查询语句是（C）
A.SELECT A FROM ABC WHERE A IS NOT ’7%’
B.SELECT A FROM ABC WHERE A LIKE ‘%7%’
C.SELECT A FROM ABC WHERE A NOT LIKE ’7%’
D.SELECT A FROM ABC WHERE A LIKE ‘[1-6]%’
E.SELECT A FROM ABC WHERE A NOT IN(’7%’)

下面的SQL试题将使用到如下一个银行基本数据库，基本表结构如下：
表名列名
Branch
(分支机构)branch-name
branch-city
assets
表名列名
Customer
(客户)customer-name
customer-street
customer-city

表名列名
Loan
(贷款)loan-number
branch-name
amount
表名列名
Borrower
(贷款人)customer-name
loan-number

表名列名
Account
(账户)account-number
branch-name
balance

表名列名
Depositor
(存款人)customer-name
account-number

37.如果在同一个查询中同时存在Where子句和Having子句，那么首先应用Where子句。满足Where子句的条件的记录可以通过group by子句形成分组。Having子句若存在，就将在用于每一分组。不符合having子句条件的分组将被抛弃，剩余的分组被Select子句用来产生查询结果记录集。
我们利用上面信息来完成如下操作：“找出住在Harrison且在银行中至少有三个账户的客户的平均余额”：
A.Select depositor. customer-name, avg(balance)From depositor, account, customer
Where depositor.account-number = account.account-number And
account.account-number = customer.customer-nameAnd
customer-city = ‘Harrison’group by account.customer-name
having count (distinct depositor.account-number)>=3
B.Select depositor. customer-name, avg(balance)From depositor, account, customer
Where depositor.account-number = account.account-number And
depositor.account-number = customer.customer-nameAnd
customer-city = ‘Harrison’group by depositor.customer-name
having count (depositor.account-number)>=3
C.Select depositor. customer-name, avg(balance)From depositor, account, customer
Where depositor.account-number = account.account-number And
depositor.account-number = customer.customer-nameAnd
customer-city = ‘Harrison’group by depositor.customer-name
having count (distinct depositor.account-number)>=3
D.Select depositor. customer-name, avg(balance)From depositor, account, customerWhere depositor.account-number = account.account-number And
depositor.account-number = customer.customer-nameAnd
customer-city = ‘Harrison’group by account.customer-name
having count (depositor.account-number)>=3

38.“找出在银行中有贷款的客户的名字，并且他的名字既不是Smith 也不是 Jones”：©
A.select distinct customer-name from borrowerwhere customer-name not is (‘Smith’,’Jones’)
B.select customer-name from borrowerwhere customer-name not is (‘Smith’,’Jones’)
C.select distinct customer-name from borrowerwhere customer-name not in (‘Smith’,’Jones’)
D.select distinct customer-name from borrowerwhere customer-name in (‘Smith’,’Jones’)

39.“找出那些总资产至少比位于Brooklyn某一家支行要多的支行的名称”：©
A.Select distinct T.branch-name From branch as T
Where T.assets > T.assets and T.branch-city = ‘Brooklyn’
B.Select distinct T.branch-name From branch as T, branch as S
Where T.assets < S.assets and S.branch-city = ‘Brooklyn’
C.Select distinct T.branch-name From branch as T, branch as S
Where T.assets > S.assets and S.branch-city = ‘Brooklyn’
D.Select distinct T.branch-name From branch as T, branch as S
Where T.assets > S.assets and T.branch-city = ‘Brooklyn’

40.“找出所有在Perryridge支行中只有一个账户的客户”：(B)
A.Select T.customer-name From depositor as TWhere (select R.customer-name
From account, depositor as RWhere T.customer=R.customer-name and
R.account-number=account.account-number and Account.branch-name=’Perryridge’)
B.Select T.customer-name From depositor as TWhere unique (select R.customer-name
From account, depositor as RWhere T.customer=R.customer-name and
R.account-number=account.account-number and Account.branch-name=’Perryridge’)
C.Select T.customer-name From depositorWhere unique (select R.customer-name
From account, depositor as RWhere T.customer=R.customer-name and
R.account-number=account.account-number and Account.branch-name=’Perryridge’)
D.Select T.customer-name From depositor as TWhere not unique (select R.customer-name
From account, depositor as RWhere T.customer=R.customer-name and R.account-number=account.account-number andAccount.branch-name=’Perryridge’)

41.找出loan表中amount为空值的贷款号：(B)
A.Select loan-number From loanWhere amount in (null)
B.Select loan-number From loanWhere amount is null
C.Select loan-number From loanWhere amount is ’null’
D.Select loan-number From loanWhere amount = null

42.“找出每个支行储户数”：©
A.Select branch-name, count(customer-name)From depositor, account
Where depositor.account-number = account.account-numberGroup by branch-name
B.Select branch-name, count(distinct customer-name)From depositor, account
Where depositor.account-number = account.account-number
C.Select branch-name, count(distinct customer-name)From depositor, account
Where depositor.account-number = account.account-numberGroup by branch-name
D.Select branch-name, count(customer-name)From depositor, account
Group by branch-name

43.“找出账户平均余额大于1200元的支行”：©
A.Select branch-name, avg(balance) From account
Where balance > 1200Group by branch-name
B.Select branch-name, avg(balance) From account
Group by branch-nameHaving balance > 1200
C.Select branch-name, avg(balance) From account
Group by branch-nameHaving avg(balance) > 1200
D.Select branch-name, avg(balance) From accountWhere balance>avg(balance)
Group by branch-nameHaving balance > 1200

44.“找出街道地址中包含子串Main的所有客户的姓名”：©
A.Select customer-name From customerWhere customer-street like ‘Main’
B.Select customer-name From customerWhere customer-street like ‘Main%’
C.Select customer-name From customerWhere customer-street like ‘%Main%’
D.Select customer-nameFrom customerWhere customer-street like ‘%Main%’

1)数据库设计的任务是（c）。

a)选择一个符合项目需求的数据库
b)根据需求建立几个表来存贮数据
c)规划和结构化数据库中的数据对象以及这些对象之间的关系
d)能使程序同时访问多个或多种数据库

2)（a）图被用来表示数据库实体之间的关系。

a)实体关系
b)数据模型
c)实体分类
d)以上都不是

3)用户程序使用 SQL批处理技术的好处是（bcd）（多选）。

a)没有好处，和每次传递一条SQL语句一样
b)可以减少网络流量
c)简化数据库的管理
d)提高效率

4)在sql server的存储过程中，有几个语句用于为局部变量赋值（b）。

a)1个
b)2个
c)3个
d)不需要语句，等号即可

5)在用户程序中，如果没有设置显示或隐式事务模式，那么SQL server（b）。

a)不进行任何事务处理
b)使用自动提交模式
c)就处理不了数据的更新
d)选择默认的隐式事务模式

6)当我们的程序使用了select * from table时，sql server会为我们建立（c）锁。

a)意向
b)排他
c)共享
d)构架

7)如果某公司有10个部门，每个部门有6－7个员工，但每个员工可能会为不止一个部门工作。下面所给的模型合理的是（ c）。

a)部门和员工之间是一种确定的一对多的关系
b)建立一个关联表，从该关联表到员工表建立一个一对多的关系，然后再从该关连表到部门表建立一个一对多的关系
c)建立一个关联表，从员工表到该关联表建立一个一对多的关系，然后从部门表到该关联表建立一个一对多的关系
d)这种情况，不能建立正常的数据库模型

8)有一张销售表orders，含有地区编号（regionID）、销售额（orderamount）两列，现希望统计出各地区的销售总额以及所有销售额总和，下面（ c）语句可以实现。

a)SELECT SUM (orderamount) FROM orders GROUP BY salepersonID, regionID
b)SELECT regionID, SUM (orderamount) FROM orders ORDER BY regionID
COMPUTE SUM (orderamount)
c)SELECT regionID, orderamount FROM orders ORDER BY regionID
COMPUTE SUM (orderamount) BY regionID COMPUTE SUM (orderamount)
d)SELECT regionID, orderamount FROM orders
GROUP BY regionID, orderamount COMPUTE SUM (orderamount)

9)你想删除在t表中5年以前的数据，可以使用以下（a）的T-SQL

a)Delete from t Where OrderDate < DATEADD(YYYY,-5,GETDATE())
b)Delete from t Where OrderDate < DATEADD(YYYY,5,GETDATE())
c)Delete from t Where OrderDate < GETDATE(), -5
d)Delete from t Where OrderDate < GETDATE(), +5

10)一存储过程：
CREATE PROCEDURE pr_getstudent @age Int As
select name,age from Students where Age = @age
假如你要在Students表中查找年龄是18岁的学生，（ b）可以正确的调用这个存储过程。

a)EXEC pr_getstudent @ age =‘18’
b)EXEC pr_getstudent @ age =18
c)EXEC pr_getstudent age =‘18’
d)EXEC pr_getstudent age =18

11)在SQL Server 2000的查询分析器中运行以下T-SQL：
USE PUBS GO sp_recompile Authors
下面说法正确的是：C
a)报告语法错误，因为执行存储过程需要EXEC关键字
b)执行成功，并且Authors表中的数据行被重新排列
c)执行成功，并且Authors表中的存储过程在下次运行时将重新编译
d)执行成功，并且Authors表中的触发器将被暂时禁止使用，直到下次运行本命令

12)在SQL Server的视图里有:
SELECT DISTINCT productName, price FROM
product WHERE (price>(SELECT AVG(price) FROM product))
ORDER BY price DESC;
下面说法错误的是(B ).
a)”SELECT AVG（price） FROM product ”是子查询
b)”ORDER BY price DESC”是指按price从低到高顺序排列
c)查询结果显示的是大于平均价格的产品记录
d)此查询显示的字段只有”productName”和”price”

13)以下是SQL Server表autos的定义：
Create table autos
(
make varchar(20) not null,
model varchar(20) not null,
acquisition_cost money null,
acquisition_date datetime null
)go
创建该表后再执行以下的语句：
Truncate table autos
Begin tran
Insert autos (make,model) values (‘Tucker’,'Torpedo’)
If exists (select * from autos)
Rollback tran
Else
Commit tran
go
以下说法正确的是（B）
a)该批处理将失败，因为begin tran……commit tran 没有正确嵌套
b)该批处理结束后，表内没有数据行
c)该批处理结束后，表内有一行数据
d)插入数据行的语句将失败，并且提示错误信息

14)下列哪些答案最好地表达了下面建表命令的执行结果? (AC)
Create table MyTable (id int not null, price smallmoney not null, markup numeric (5,2) not null, msrp as price *(1+(markup/100)))
a)SQL Sever存储了一张4列的表
b)SQL Server存储了一张看上去像4列实际上是3列的表
c)建立了一张表，只允许msrp字段为null
d)Markup字段是7位数字宽度

15)关于IDENTITY属性的描述，错误的说法是? C
a)一个表只能有一个列具有IDENTITY属性。
b)你不能对定义了IDENTITY属性的列加上 default约束。
c)附加了IDENTITY属性的列可以是任意数据类
d)你不能直接更新一个定义了IDENTITY属性的列。

16)Create table Sale(SaleId numeric identity,
CustomerId numeric(10),
SaleNote varchar(2000) default ‘NONE’,
SaleDate datetime) 你不想将SaleNote再存储到表中，为了从表中删除SaleNote，下面所列的做法中最好的是D
a)将sale表从数据库中以块的方式拷贝了来，删除该表，然后建立一个新的sale表，并将数据库块拷贝到的Sale表中，但忽略SaleNote列。
b)通过删除SaleNote列来改变Sale表。
c)先将Sale表改名，然后建立一个新的Sale表，用DTS将数据转移到新的Sale表中，但忽略SaleNote列。最后删除原始的sale表。
d)先删除SaleNote列的缺省对象（包括索引和约束等），然后再删除该SaleNote列。

17)对于下列建表语句：描述正确的是（A）。
Create table MyTable(id int not null,price smallmoney not null,markup numeric(5,2) not null,msrp as price*(1+(markup/100)))
a)在数据库中建立了表MyTable
b)表中所有字段都可以为null
c)除了字段msrp，表中所有其它字段都可以为null
d)不会建立表MyTable

18)考虑下列实例，设计一个数据库跟踪系里的课程负载情况：
PROFESSORS表包含每一个教授的信息。
COURSES 表包含所有的课程的信息。
每门课程被分配给一个指定的教授，而每一个教授可以教授几门课程。
只有在PROFESSORS 表中注册过的教授才能够教授课程，而这个教授也只能教授那些在COURSES表中登记过的课程。
有关约束方面，下列说法正确的是（B）?
a)在PROFESSORS表中建立一个主键，引用COURSES表。
b)在COURSES表中创建一个外键，引用 PROFESSORS表。
c)在PROFESSORS表中创建一个外键，引用COURSES表。
d)在COURSES表中建立一个主键，引用PROFESSORS表。

19)有关下列T-SQL语句，说法正确的是（BC）。
ALTER TABLE MyTable
ADD AddDate smalldatetime NULL
CONSTRAINT AddDateDflt
DEFAULT getdate( ) WITH VALUES
a)修改表MyTable，添加一个约束“AddDate”，要求数据必须为日期格式，默认值为当前日期
b)修改表MyTable，添加一列“AddDate”，数据类型为日期
c)修改表MyTable，添加一列“AddDate”，允许为空，默认值为当前日期
d)WITH VALUES选项表示用当前日期填充现有行的AddDate列数据。

20)有关下列T-SQL语句，说法正确的是（BC）。
CREATE DATABASE mytest GO
a)创建数据库需要日志文件和数据文件，所以上述语句错误。
b)上述语句创建数据库mytest，并创建相应的主文件和事务日志文件，保存在默认的位置。
c)上述语句创建数据库mytest，主数据库文件的大小为 model 数据库主文件的大小。
d)上述语句创建数据库mytest，日志文件的大小为master 数据库事务日志文件的大小。
64．聚数宝_联通自然人项目
Wiki账号：http://10.0.245.129:7081/projects/five/wiki/NP层 lix/Lx```
VPN：https://noc.chinaunicom.cn lix#contextpool.com/password
跳转机46 / Mio@2019DeUser*46
VPN密码：LiXue/j#Ex4dt@mS
35环境：10.162.158.35 、22
50 ----- 10.162.158.6 Ui23jksd@
20 ----- 10.124.128.65 Ui23jksd@
./MIOapp\ Platform\ Manager &
./MIOapp_Platform_Manager_v14 &
frank_5layer_check Lx
/data/nfsshare/supw/tool/miocase/chongqing-out源数据校验
/data/nfsshare/frank/shengfen/shengfen —数据全
/data/MIOdb/sdc/data/Frank/report 报表
加载顺序：配置文件产品、部门索引其他
119个表 31个省一省3个partition cb24个接口1个新疆4个partition

西安环境 10.172.32.53\Fj29ruvn@Yz@
廊坊环境生产10.191.17.95 96 miouser/ Fj29ruvn@Yz@
静态文件 10.191.17.215：/data/MIOdb/sdb/InitialData
/data/MIOdb/sdb/MIOedge
账号邮箱前缀，密码LxLxLxLx@123

非生产 miouser/Miosoft2017
导出一个adapter是导出一个formate：formate右键

加密 aben 解密 abde

刷数（单独字段map2映射刷数）
添加remege映射+ self modifySwitch: true. self userId = ‘700’

北六：黑龙江、河南、辽宁、山东、北京和河北

查询数据来源（静态文件还是流文件）：消息层record-recordTrack【s】和streamTrack【s】
用户归集条件
^(self removeTag in: #(0 1 3 91 92 93 94)) and: [self netTypeCode notIn: #(5 7) ].

查询是不是好自然人方法：

System.Search –find NP by pspt
空白处—右键—Explore context—右键—Inspect vertex—草稿图标
添加条件
self setNaturalPersonByPsptRealId: ‘023ba60f55fcfd7e0e7960828db7907b’ psptEffectiveTypeCode: ‘1’.
self naturalPersons

实名标识：

REAL_NAME_CODE 实名类型
0:双实名
1：实名-二代，
2：实名-公安（国政通），
3：实名-系统（符合实名制八大项校验），
4：非实名

Bundle建立：
首先先在config里建bnd文件
Miocon.System.Initial genloadFromFile:‘10slices_50machine’

接口：
选中接口方法，右键，reference

Cut数据：
| stats input inputWCF output outputWCF|

input :=‘D:\Work\ChinaUnicom\NewMessageCenter\out\zrr_08_0.webcapture’.
output := ‘D:\Work\ChinaUnicom\NewMessageCenter\out\zrr_09_0.webcapture’.
“outputWCF := Miosoft.WebCaptureFile openFileNamed: output toWrite: true.”
outputWCF := Miosoft.WebCaptureFile newFileNamed: output.

stats := Dictionary new.

inputWCF := Miosoft.WebCaptureFile openFileNamed: input toWrite: false.

stats at: ‘input recordCount’ put: inputWCF recordCount.
stats at: ‘K records’ put: 0.

1 to: ( inputWCF recordCount min: 100 ) do:
[:i |
| record |

record := inputWCF recordAt: i.
outputWCF addRecord: record.
outputWCF commit.

stats at: ‘output recordCount’ put: outputWCF recordCount.
inputWCF close.
outputWCF commit;close.

^stats

65．解析def文件的format
D:\frank\defFileParser-trimblank(1).format

66．导出数据时候WM_contact() 把里面的字符串给排序了，后来设了一个ID（rownum）
select table_name, max(to_char(rr)) rrr from ( select table_name,wm_concat(column_name) over (partition by table_name order by id) rr from (select table_name,column_name,rownum as id from all_tab_columns ) rr)group by table_name;

要主键的表结构
select TO_CHAR( SUBSTR(t1.table_name||’’||t1.rrr||’’||t2.coname||’**’||t2.position||’~~~~’,1,3999)) from (select table_name,max(to_char(SUBSTR(rr,1,3800))) rrr from ( select table_name,wm_concat(column_name) over (partition by table_name order by id) rr from (select table_name,column_name,rownum as id from all_tab_columns ) )group by table_name) t1 left join (select col.table_name ctname,wm_concat(col.column_name) coname,wm_concat(col.position) position from all_constraints con, all_cons_columns col where con.constraint_name = col.constraint_name and con.constraint_type=‘P’ group by col.table_name )t2 on t1.table_name=t2.ctname;

查询三个月得表接入
SELECT T.SYSTEM, T.TABLENAME, nvl(SUM(W.CNT),0)
FROM INITSTATISTICS_USE T
LEFT JOIN WCSTATISTICS W
ON T.SYSTEM = W.TOPIC
AND T.TABLENAME = W.TABLENAME AND w.month IN(‘2018-12’,‘2018-11’,‘2018-10’)
GROUP BY T.SYSTEM, T.TABLENAME
67． Linux shell
解压jar包
jar -xvf xxx.jar
打jar包，不生成清单文件，不压缩
jar -cvfM0 xxx.jar BOOT-INF/ META-INF/ org/或者jar -cvfM0 xxx.jar *
grep：文本搜索
grep ‘w[ea]ll’ file_name
在file_name文件中找到wall 或者是well 所在的所有行并显示
grep ‘w[^e]ll’ file_name
在file_name文件中找到”非well” 所在的所有行并显示
grep ‘^The’ file_name
在file_name文件中找到以The开头的所有行并显示（请与上一条命令进行区别）

sed：数据的替换，删除，增加，选取（以行为单位）
sed ‘2,4d’ file_name
删除file_name文件的2到4行

awk：以字段为单位进行处理(其实是把一行的数据分割，然后进行处理)切分文件
1.切分
awk -F “\t” ‘{print $1}’ 20190130.txt |sort|uniq|awk ‘{cmd=“grep “$1” 20190130.txt>”$1".txt";system(cmd)}’

2.只留后两个字段：
awk -F “\t” ‘{print $2"\t"$3}’ anhui.txt > anhui-new.txt

0代表一整行的数据 0代表一整行的数据 1 代表第一个字段，用人的话来说就是第一列的数据
NR 目前处理的是第几行的数据
命令格式：awk ‘条件{命令1} 条件{命令2}…’ file_name
注：print 默认带有换行符，printf 没有
awk ‘NR<6{print 1"\t" 1"\t" 2 }’ file_name
把file_name 文件中的前五行的第一列，第二列的数据列出来（以[tab]或空格键分隔）

总结
• 三个命令的运用形式
grep ‘字符’ 文件
sed ‘命令’ 文件
awk ‘条件{命令}’ 文件

68．分库分表
表多而数据多—适合垂直切分
表少每张表数据多—-适合水平切分

69．52连接miovantage：
/data/MIOdb/sdb/MIOedge14
./MIOapp_Platform_Manager_14 &
10.172.32.8 miouser/3edc$RFV

70．Mio语句
Self custid in #(‘’ ‘’ ‘’)
self custId isNotNil —查询custid不为空
self custId ~= ‘’ ----查询custid=？
self records any: [:t1 | (t1 columns at: 2) in: #(‘8616032066760543’ ‘1014121127080905’ ‘1115031635641791’)]

(self system = ‘cbss’ and:[self systemInstance = ‘UCR_CRM1’]) and:[self tableName in: #(‘TF_F_USER_ITEM’ ’ TF_F_USER ']

self modificationSwitch: true. self systemInstance = ‘TF_F_USER-USE’

(self tableName = ‘PM_PRODUCT_T’ )and:[ self system = ‘shanxi_b’]

((self tableName in: #(‘BB_SERVICE_RELATION_T’ ‘PM_PRODUCT_T’ ) ) not )and:[ self system = ‘shanxi_b’]

self recordStates: (self recordStates collect: [:each | each modificationSwitch: true]). self recordStates any: [:t1 | (t1 record columns at:1) = ‘1114060166553904’]

self tableName = ‘’

根据手机号查询 userID
|x|
x := Miocon.BO.User_byPhone scanPredicate: ‘serialNumber=“13007627787”’.
x ifNotNil: [
^ (x userId),’|’,(x system)
].

Miovantage使用：
1.登陆输入lincens号

创建engine：

资源片创建：两个零两个100

导出报表

先设置一下分隔符
导出不亮是没选路径

71．GP数据库与Oracle数据库有什么区别？
oracle是传统关系型数据库，gp是分布式数据库。
gp的查询可以很快，数据量可以很大。有数据过期机制等。
以前数据都是接入到oracle和mysql等关系型数据库里，但存入多了查询就变慢了，可以使用gp作为解决方案。
72．为什么要用ETL工具？
▶ 当数据来自不同的物理主机，这时候如使用SQL语句去处理的话，就显得比较吃力且开销也更大。
▶ 数据来源可以是各种不同的数据库或者文件，这时候需要先把他们整理成统一的格式后才可以进行数据的处理，这一过程用代码实现显然有些麻烦。
▶ 在数据库中我们当然可以使用存储过程去处理数据，但是处理海量数据的时候存储过程显然比较吃力，而且会占用较多数据库的资源，这可能会导致数据资源不足，进而影响数据库的性能。
上面所说的问题，我们用ETL工具就可以解决。它的优点有：
● 支持多种异构数据源的连接。（部分）
● 图形化的界面操作十分方便。
● 处理海量数据速度快、流程更清晰等。
73．CMD突然不能连接sqlplus
原因：环境变量没有了
解决办法：
添加环境变量
添加ORACLE_HOME=C:\soft\product\11.2.0\dbhome_1，
编辑Path=%ORACLE_HOME%\BIN

56．Oracle一次插入多条记录（ORA-00933）
向Oracle数据库插入多条记录时，开始使用如下的SQL语句
insert into test (id,name) values(1,’zengzeyi’),(2,’zengluoqiu’);
总是提示错误：ORA-00933：SQL command not properly ended
经分析，出现错误是因为Oracle不支持上述语法一次插入多条记录
而应使用如下语法

insert into test (id,name)
select * from(
select 1,‘zengzeyi’ from dual union all
select 2,‘zengluoqiu’ from dual union all
select 3,‘zengshuangqiu’ from dual
)

74．两个表取差异数据（相同system取差异表）
SELECT j.system,j.table_name from JOINSTRUCTION j
Minus
SELECT s.system,s.table_name FROM SCN s
延伸：

union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复
union all与limit不能一同使用；
Intersect：对两个结果集进行交集操作，不包括重复行，同时进行默认规则的排序；
Minus：对两个结果集进行差操作，不包括重复行，同时进行默认规则的排序

75．Oracle设置常用的快捷键
最近在开发过程中，遇到一些麻烦，就是开发效率问题，有时候其他同事使用PLSQL 编程效率明显高于自己，观察了好久，才发现他使用PLSQL 已经很长时间了而且，他自己也在其中添加了好多快捷方式
1、登录后默认自动选中My Objects
默认情况下，PLSQL Developer登录后，Brower里会选择All objects，如果你登录的用户是dba，要展开tables目录，正常情况都需要Wait几秒钟，而选择My Objects后响应速率则是以毫秒计算的。
设置方法：
Tools菜单 --> Brower Filters，会打开Brower Folders的定单窗口，把“My Objects”设为默认即可。
Tools菜单－－Brower Folders，中把你经常点的几个目录（比如：Tables Views Seq Functions Procedures）移得靠上一点，并加上颜色区分，这样你的平均寻表时间会大大缩短，试试看。

2、记住密码
这是个有争议的功能，因为记住密码会给带来数据安全的问题。但假如是开发用的库，密码甚至可以和用户名相同，每次输入密码实在没什么意义，可以考虑让PLSQL Developer记住密码。
设置方法：菜单Tools --> Preferences --> Oracle --> Logon History --> Store With Password

3、双击即显示表数据
鼠标双击表或者视图时的默认响应实在让我感到失望，因为我最关心的是表结构和数据，但是双击后这两件事情都没有发生，也许默认响应是高手们需要的，但对我来说查看数据和表结构是最主要的，其他的我不关心。不过好的是这是可以设置的，你可以给鼠标双击和拖放绑定需要的事件，比如：双击编辑数据，拖放显示表结构，Yeah！
设置方法：菜单Tools --> Preferences --> Browser，在右侧，为不同的Object Type绑定双击和拖放操作。

4、SQL语句字符全部大写
自认为这是个好习惯，信息系统的核心是数据库，系统出问题时最先要查的就是SQL语句，怎样在浩瀚的日志中快速找到那条SQL语句是件比较痛苦的事情。 SQL语句全部大写并不能彻底解决这一问题，但在一堆代码中间找一行全部大写的字符相对容易些，你的眼睛会感谢你。

设置方法：菜单Tools --> Preferences --> Editor --> Keyword Case --> Uppercase

5、特殊Copy
在SQL Window里写好的SQL语句通常需要放到Java或者别的语言内，就需要转成字符串并上加上相应的连字符，这一个事不需要再重复做了，在写好的SQL上点右键，使用特殊Copy即OK！
设置方法：鼠标右键 --> Special Copy

6、自定义快捷键
PLSQL Developer里预留了很多键让用户自定义，这是件很Hight的事情。不像霸道的Word，基本上所有的键都已预定义了功能，修改起来很是头疼。通常情况下，打开PLSQL Developer后，最经常干的事就是打开SQL Window和Command Window，就给这两个操作定义了快捷键，ALT+S和ALT+ C，这样拿鼠标点三下的事情只需要按一下键。
设置方法：菜单Tools --> Preferences --> Key Configuration

7、SQL Window中根据光标位置自动选择语句
设置方法：Preferences --> Window Types --> SQL Window，将AutoSelect statement选中即可。注意，每条语句后面要加分号。

8、自动替换
快捷输入SQL语句，例如输入s，按下空格，自动替换成SELECT；再例如，输入sf，按下空格，自动替换成SELECT * FROM，非常方便，节省了大量的时间去编写重复的SQL语句。
设置方法：菜单Tools --> Preferences --> Editor --> AutoReplace. --> Edit
下面定义了一些规则作为参考
s=SELECT
f=FROM
w=WHERE
o=ORDER BY
d=DELETE
sf=SELECT * FROM
df=DELETE FROM
sc=SELECT COUNT(*) FROM
另外
1）在editor中输入．后,plsql会执行自动完成.有时候觉得自动提示不舒服.速度慢.那可以自己设置提示键.
先关闭代码自动完成：
Tools->Preferences->User Interface->Code Assistant->Automatically activated ，取消选择。

设置手动调用自动完成的快捷键：
Tools->Preferences->User Interface->Key Configuration。
找到Tools/Code Assistant，修改为自己常用的快捷键，Plsql developer8默认是F6。

还可以:
Edit table 设置成ctrl+shift+E
Edit data，设置成ctrl+shift+D
Edit spec & body，设置 ctrl+shift+B

2）自定义提示

Tools->Preferences->Edit->AutoReplace
Edit保存。

如：s=SELECT * FROM
Edit里，我输入s然后按一下空格,内容就会自动变成SELECT * FROM,这样在做常规查询的时候就不用每次都输入select 这长串字符了.

Tools->Preferences->Edit->Syntax Highlighting
顺便把Keyword case改成Uppercase。

自动保存数据库密码

Tools->Preferences->Oracle->Logon History->Definition
选择Store with password。

字体设置

Tools->Preferences->Fonts
我习惯都用宋体9号。

Tools->Preferences->Edit->Syntax Highlighting
我习惯把Comment的Italic去掉，斜体看不清啊。

5）F8自动执行当前行Sql

Tools->Preferences->Window Types->SQL Window
把AutoSelect statement选上吧。

Tools->Preferences->Edit->Other
顺便把Highlight edit line也加上吧。

1.用户界面-编辑器
i=INSERT
U=UPDATE
S=SELECT
f=FROM
w=WHERE
d=DELETE
df=DELETE FROM
sf=SELECT * FROM
sc=SELECT COUNT(*) FROM
sfu=SELECT * FROM FOR UPDATE
cor=CREATE OR REPLACE
p=PROCEDURE
fn=FUNCTION
t=TIGGER
v=VIEW
sso=SET SERVEROUTPUT ON
tc=to_char(calc_dt,‘yyyymmdd’)
td=to_date(data_date,‘yyyymmdd’)
56．Oracle数据库类型和约束
char 表示定长，固定长度，比如char(5)表示可以储存的字符长度不能超过5 如果实际只有3个，剩余的2个会用空格填补，查询效率比较高。
varchar()表示可变长度，比如varchar(10) 如果实际只有3个字符，只存放3个字符，查询效率比char低。
varchar2()表示可变长度，和varchar()的用法一至。为了向上向下兼容而设计出来的类型。
varchar和varchar2的区别
varchar是标准sql里面的。 varchar2是oracle提供的独有的数据类型。
varchar对于汉字占两个字节，对于英文是一个字节，占的内存小，varchar2都是占两个字节。
varchar对空串不处理，varchar2将空串当做null来处理。
varchar存放固定长度的字符串，最大长度是2000，varchar2是存放可变长度的字符串，最大长度是4000.
如果是要更换不同的数据库，例如mysql，那么就用varchar，如果就用oracle，那么用varchar2比较好一点。

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

livy 原理启动阶段以及用户交互阶段流程分析
文章目录背景启动阶段livyServer [livy-server模块]webserver小服务分类interactiveSessionServletbatchSessionServlet其他servlet用户交互阶段背景由于livy官方文档并不是很全，工作又要用到，所以，需要对livy进行源码剖析，并解决工作用遇到的一些问题所要做的本人对其进…...
2024/3/29 10:29:10
ExoPlayer简单使用
ExoPlayer Library 概述ExoPlayer是运行在YouTube app Android版本上的视频播放器ExoPlayer是构建在Android低水平媒体API之上的一个应用层媒体播放器。和Android内置的媒体播放器相比，ExoPlayer有许多优点。ExoPlayer支持内置的媒体播放器支持的所有格式外加自适应格式DASH和…...
2024/4/9 13:36:07
python生成Windows可执行的exe文件
python生成Windows可执行的exe文件在Windows下生成可执行文件的好处1.不需要在Windows下安装对应的IDE；2.将应用闭源；3.用户可以方便、快捷的直接双击使用即可打包工具pyinstaller 安装pyinstaller1.pip install 安装pyinstaller2.python setup.py install xxx.tar.gz注意：…...
2024/4/13 13:45:16
感性认识和理性认识与理性因素和非理性因素区别
感性认识：人们在实践过程中，通过自己的肉体感官（眼、耳、鼻、舌、身）直接接触客观外界，引起许多感觉，在头脑中有了许多印象，对各种事物的表面有了初步认识，这就是感性认识。理性认识：理性认识是认识过程的重要阶段，以事物的本质规律为认识对象，是对事物的内在联系的…...
2024/3/29 10:29:07
Scala 2.8馆藏图书馆是“历史上最长的遗书”吗？ [关闭]
我刚刚开始研究即将发布的2.8版本中的Scala集合库重新实现。熟悉2.7中的库的人会注意到，从使用角度来看，库几乎没有变化。例如... > List("Paris", "London").map(_.length) res0: List[Int] List(5, 6)......适用于任何一个版本。图书馆非常实…...
2024/4/16 0:06:55
一统江湖的大前端React.js-从开发者到工程师
《一统江湖的大前端》系列是自己的前端学习笔记，旨在介绍javascript在非网页开发领域的应用案例和发现各类好玩的js库，不定期更新。如果你对前端的理解还是写写页面绑绑事件，那你真的是有点OUT了，前端能做的事情已经太多了, 手机app开发 , 桌面应用开发 , 用于神经网络人工…...
2024/4/18 17:14:19
ubuntu安装Beyond Compare,无限试用
1、官网下载安装官网链接 ubuntu选择Linux下的Debian，32还是64位根据自己的系统下载。2、安装可以参考官方安装教程. sudo dpkg -i 安装包名.deb3、破解 1，在本地创建一个自动清除bcompare使用日志的脚本 cd /usr/local/binsudo vi clear_bc_reg.sh将下面的内容复制进去 #!…...
2024/4/17 12:20:24
请说一下你是如何理解互联网思维的？
一、互联网思维，是人对全生态重新审视的思考方式，就是在（移动）互联网+、大数据、云计算等科技不断发展的背景下，对市场、用户、产品、企业价值链乃至对整个商业生态进行重新审视的思考方式。二、这里的互联网指的是泛互联网，因为未来的网络形态一定是跨越各种终端设备的…...
2024/4/15 23:19:28
阿里云杨敬宇：四层技术构建基于城市场景的边缘计算
12月11日，阿里云边缘计算技术负责人杨敬宇在2019亚太内容分发大会上表示：在未来，边缘计算主要是以地市、区县为单位开展，面向城市服务的交通、医疗、健康、教育、新零售等场景提供算力基础。阿里云认为边缘计算就是城市计算，我们将围绕城市场景去建设边缘计算基础设施和灵…...
2024/3/29 10:29:02
Android学习（ListView）
自定义BaseAdapter，然后绑定ListView的最简单例子Animal.java: public class Animal {private String aName;private String aSpeak;private int aIcon;public Animal() {}public Animal(String aName, String aSpeak, int aIcon) {this.aName = aName;this.aSpeak = aSpeak;t…...
2024/4/18 5:02:22
7000 字读懂互联网公司的架构演变历程
前言我们以javaweb为例，来搭建一个简单的电商系统，看看这个系统可以如何一步步演变。该系统具备的功能：用户模块：用户注册和管理商品模块：商品展示和管理交易模块：创建交易和管理阶段一、单机构建网站网站的初期，我们经常会在单机上跑我们所有的程序和软件。此时我们使用…...
2024/3/29 10:29:00
图神经网络(GNN)
新智元报道来源：towardsdatascience作者：黃功詳 Steeve Huang 编辑：肖琴【新智元导读】图神经网络(GNN)在各个领域越来越受欢迎，本文介绍了图神经网络的基本知识，以及两种更高级的算法：DeepWalk和GraphSage。最近，图神经网络 (GNN) 在各个领域越来越受到欢迎，包括社交…...
2024/3/28 18:13:57
C#学生管理系统
环境：SqlServer+VS2015在公众号已经写了一遍教程，不懂得小伙伴可以在公众号中一步一步的看哦！！！C#成绩管理系统地址：https://blog.csdn.net/robot_sh/article/details/1035377291 需求分析随着社会的不断发展，社会各行各业对人才的需求不断增加，培养人才的高等学校为满…...
2024/3/29 10:08:47
java中的继承
1.继承 class 子类 extends 父类{} 1.首先子类不能通过多继承的方法去继承父类，因为多继承存在安全隐患，但是可以通过单继承的多层次去继承父类 2.继承的层次不要过多 2. 覆写覆写相当于手机的更新，例如诺基亚手机具有打电话发短信的功能，新的智能手机需要在此基础之上增加…...
2024/3/29 21:04:34
吉林大学数据结构教材刘大有第二版学习重点！
吉林大学数据结构教材刘大有第二版学习重点！这本书数据结构教材是考吉林大学必考的一科目！本科不管你学的那个教材，现在考研最好还是看这个书吧，然后辅助性的看王道上的知识点，王道是考408必看的书籍，和严蔚敏老师教材配套的，408难度比较大，吉大是自主命题，相…...
2024/3/29 10:08:44
CentOS7.6安装RabbitMQ教程
1. 下载erlang 和 rabbitMQ , 用网址提供的下载网址很慢，点击进入下载或者用博主提供的下载链接百度网盘下载，提取码: y1ky下载后的文件:2. 安装erlangyum -y install erlang-19.0.4-1.el6.x86_64.rpm3. 把erlang的运行目录添加进系统环境中（用户环境和系统环境都行)我这里…...
2024/3/29 10:29:01
微服务之 02 Docker 篇
在写完上一章微服务介绍之后，我考虑了很久第二章写什么，是开始写Linux的Docker等和部署环境相关的技术，还是写像Spring Cloud等和后端相关的技术。最终决定了还是写Docker，因为分布式开发的核心技术是Docker，先把整个项目的环境搭起来，后端代码才有个更好的全局观。再不济…...
2024/3/29 10:28:58
产品设计九步法
(转载） “很多PM都有一个梦想，用自己设计的产品改变世界，同时挣个盆满钵满，可十年没变的入门级薪水，却让人触摸到现实是骨感的。 1产品满足用户的哪一个核心需求? 产品设计的关键在于搞清楚产品的核心价值是哪一个，满足用户什么核心需求。实践中，70%的PM经常忘记了这一…...
2024/4/2 20:13:53
最短路径算法
到底是贪心还是动态规划？ Dijkstra算法抽象问题，选择合适的数据结构抽象问题权重图，本质求两节点最小权重值从起点开始遍历所有的临接节点，将节点权重维护到最小堆中每次以最小堆对应的顶点为起点再次遍历临接节点： 0) 默认到最小节点的距离都是MAX INT，用数组存储，…...
2024/4/7 1:46:28
EARFCN
1. EARFCN: 缩写: E-UTRA Absolute Radio Frequency Channel Number, 取值范围: 0 – 65535EARFCN：LTE的载波频点号，FDD的EARFCN从0~35999， TDD的EARFCN从36000~65531。计算公式：37750+(使用频率-2570)/0.1TD-LTE的频点编号从36000开始，F_c代表载波中心频率（…...
2024/4/9 11:08:02

oracle 学习

相关文章

最新文章