SQL基础操作_sql的乘方

基础

详解

表结构操作（建表、删表）

建表

create table 表名
(
	字段名1         VARCHAR2(50) ,
	字段名2         NUMBER(4),
	字段名3  	   DATE,
	字段名4         CHAR(3)
)
1
2
3
4
5
6
7

删除表

drop table 表名
1

建表可用的字段类型
下表列出了几种常用数据类型。要注意，不同的关系数据库管理系统中支持的数据类型不完全相同

字段

--新增字段
--新增字段名之后跟新增字段的类型
alter table 表名 add(新增字段名 varchar2(4))

--修改字段类型
--修改字段名之后跟修改为的参数类型和长度
alter table 表名 modify(修改字段名 NUMBER(8,2));
--修改字段名
alter table 表名 rename column 旧字段名 to 修改后的新字段名;

--删除字段
alter table 表名 drop column 删除字段名
1
2
3
4
5
6
7
8
9
10
11
12

关键字约束
关键字约束类型分为三种
primary——主键约束
unique——唯一约束
foreign——外键约束
语句内容
constraint——约束

--新增单个主键约束
alter table 表名 add constraint 添加的关键字名称 primary key(对应的主键列);
--新增组合主键约束
alter table 表名 add constraint 添加的关键字名称 primary key(对应的主键列1,对应的主键列2);

--新增单个唯一性约束
alter table 表名 add constraint 添加的唯一性约束名 unique(对应的字段列);
--新增组合唯一性约束
alter table 表名 add constraint 添加的唯一性约束名 unique(对应的字段列1,对应的字段列2);

--新增外键约束
--与外键关联的主表的字段必须设置为主键
--要求从表不能是临时表，主从表的字段具备相同的数据类型、字符长度和约束。
alter table 表名 add constraint 外键约束名 foreign key(表名对应的字段) references 外键约束对应的表名(外键约束对应的字段名);

--删除关键字约束
alter table 表名 drop constraint 删除的关键字名称;

--禁用关键字约束
alter table 表名 disable constraint 关键字约束名;
--启用关键字约束
alter table 表名 enable constraint 关键字约束名;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

检查约束

--添加检查约束
--只能输入限定的值
alter table 表名 add constraint 检查约束名称 check(检查字段 in ('检查值1','检查值2'));
--只能输入限制范围的值
alter table 表名 add constraint 检查约束名称 check(检查字段>0 and 检查字段<=100);

--删除检查
ALTER TABLE 表名 DROP constraint 检查约束名称
1
2
3
4
5
6
7
8

修改字段默认值

--修改字段默认值
--主要此修改不会影响到存量数据，之后影响之后的增量数据
alter table 表名 modify 字段 default 默认值;
1
2
3

限制返回条数

like-模糊查询

一般形式为：列名 [NOT ] LIKE
匹配串中可包含如下四种通配符：
_：匹配任意一个字符；
%：匹配0个或多个字符；
[ ]：匹配[ ]中的任意一个字符(若要比较的字符是连续的，则可以用连字符“-”表 达 )；
[^ ]：不匹配[ ]中的任意一个字符。

#查询学生表中姓‘张’的学生的详细信息。
SELECT * FROM 学生表 WHERE 姓名 LIKE '张%'

#查询姓“张”且名字是3个字的学生姓名。
SELECT * FROM 学生表 WHERE 姓名 LIKE '张__'

#如果把姓名列的类型改为nchar(20)，在SQL Server 2012中执行没有结果。原因是姓名列的类型是char(20)，当姓名少于20个汉字时，系统在存储这些数据时自动在后边补空格，空格作为一个字符，也参加LIKE的比较。可以用rtrim()去掉右空格。
SELECT * FROM 学生表 WHERE rtrim(姓名) LIKE '张__'

#查询学生表中姓‘张’、姓‘李’和姓‘刘’的学生的情况。
SELECT * FROM 学生表 WHERE 姓名 LIKE '[张李刘]%'

#查询学生表表中名字的第2个字为“小”或“大”的学生的姓名和学号。
SELECT 姓名,学号 FROM 学生表 WHERE 姓名 LIKE '_[小大]%'

#查询学生表中所有不姓“刘”的学生。
SELECT 姓名 FROM 学生 WHERE 姓名 NOT LIKE '刘%'

#从学生表表中查询学号的最后一位不是2、3、5的学生信息。
SELECT * FROM 学生表 WHERE 学号 LIKE '%[^235]'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

substr-截取对应长度的字段

使用方式：substr(字段名,数字1,数字2)
截取对应字段，从数字1开始到数字2的内容

使用场景：substr可以和in组合，实现批量匹配模糊查询的效果

#正常的like模糊查询
select * from 表名 where col like 123%

#实现类似in的批量匹配的模糊查询
#先使用substr截取字段需要匹配的范围
#然后使用对应长度的字段进行in匹配
select * from 表名 where substr(字段名,0,3) in ('123','132');
1
2
3
4
5
6
7

group by-分组汇总

group by 的意思为分组汇总。
使用了group by 后，要求Select出的结果字段都是可汇总的，否则就会出错。

group by 有一个原则,就是 select 后面的所有列中,没有使用聚合函数的列,必须出现在 group by 后面。

比如，有：{学号，姓名，性别，年龄，成绩}字段
这样写就是错的，因为 “姓名、性别、年龄”未被汇总，且不一定是单一。

SELECT 学号，姓名，性别，年龄，sum(成绩)
FROM 学生表
GROUP BY 学号
1
2
3

这样写是对的，汇总出每一同学号学生的总成绩。注意的是，只要学号相同，别的如果有不同，取它们值最大的一条作为显示输出。

SELECT MAX(学号)，MAX(姓名)，MAX(性别)，MAX(年龄)，sum(成绩)
FROM 学生表
GROUP BY 学号
1
2
3

这样写也是对的，但注意的是，学号，姓名，性别，年龄中，只要有一个不同，就会当成另一条记录来汇总。

SELECT 学号，姓名，性别，年龄，sum(成绩)
FROM 学生表
GROUP BY 学号，姓名，性别，年龄
1
2
3

count-取条数

执行效率
count(*) ≈ count(1) > count(id) > count(字段)

含义：
1、count() ：统计所有的行数，包括为null的行（COUNT()不单会进行全表扫描，也会对表的每个字段进行扫描。而COUNT(‘x’)或者COUNT(COLUMN)或者COUNT(0)等则只进行一个字段的全表扫描）。

2、count(1)：计算一共有多少符合条件的行，不会忽略null值（其实就可以想成表中有这么一个字段,这个字段就是固定值1,count(1),就是计算一共有多少个1…同理,count(2),也可以,得到的值完全一样,count(‘x’),count(‘y’)都是可以的。count(*),执行时会把星号翻译成字段的具体名字,效果也是一样的,不过多了一个翻译的动作,比固定值的方式效率稍微低一些。）

3、count(列名)：查询列名那一列的，字段为null不统计（这里的空不是只空字符串或者0，而是表示null）的计数，即某个字段值为NULL时，不统计。

执行效果：
1、count(*)包括了所有的列，相当于行数，在统计结果的时候，不会忽略列值为NULL。

2、count(1)包括了忽略所有列，用1代表代码行，在统计结果的时候，不会忽略列值为NULL。

3、count(列名)只包括列名那一列，在统计结果的时候，会忽略列值为空。

执行效率：

列名为主键，count(列名)会比count(1)快
列名不为主键，count(1)会比count(列名)快
如果表多个列并且没有主键，则 count（1） 的执行效率优于 count（*'
如果有主键，则 select count（主键）的执行效率是最优的
如果表只有一个字段，则count(*)最优
1
2
3
4
5

order by-排序

order by 升序
order by asc 升序
order by DESC 降序

两个字段排序，都降序必须写两个desc，因为排序不写默认asc

1.先按照a升序，再按照b降序
select  a,b,c,d,e  from  table_name  order  by a,b desc;
--也可以写为(因为默认升序，可以不写)：
select  a,b,c,d,e  from  table_name  order  by  a asc,b desc;

2.先按照a升序，再按照b升序
select  a,b,c,d,e  from  table_name  order by a,b;
--也可以写为：
select  a,b,c,d,e  from  table_name  order by  a asc,b asc;

3.先按照a降序，再按照b升序
select  a,b,c,d,e  from  table_name  order by  a desc,b;
--也可以写为：
select  a,b,c,d,e  from  table_name  order  by  a desc,b asc;

4.先按照a降序，再按照b降序
select  a,b,c,d,e  from  table_name  order by  a desc,b desc;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

round-保留位数

语法：round(value,n)

#查询语句
select [column(s),]
round(value,n) as another_name
from table
1
2
3
4

参数说明
value：数值。可为储存数值的字段。
n：小数点位数，为自然数。

说明：
1、用法与excel的round函数相似。
2、数值四舍五入，不够用0来凑。
1
2
3
4
5
6
7

用法1：对某个数值（字段）保留指定小数位数（四舍五入）。

#保留2301.15476的两位小数。
#结果为=》2301.15
select round(2301.15476,2) 
 
#保留13.36666的一位小数点。
#结果为=》13.4
select round(13.36666,2) 
 
#保留1345.0335的整数。
#结果为=》1345
select round(1345.0335,2) 
 
#保留1365的两位小数。
#结果为=》1365.00
select round(1345.0335,2) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

用法2：对字段进行指定小数点位数。
现有一张产品信息表product，其中，产品名name，平台platform，包名package，收入revenue。

#获取所有产品信息，并保留收益后两位小数。
select name,id,platform,package,
round(revenue,2) as rev
from product

#按产品名分组获取求和收益并保留两位小数点，按收益降序排序。
select name,
round(sum(revenue),2) as rev
from product
group by name
order by rev desc
1
2
3
4
5
6
7
8
9
10
11

having-聚合筛选

也是条件筛选语句，是放在group by 分组的后面
HAVING是在 GROUP BY分组之后进行条件筛选的，后面可以跟聚合函数

使用要求：
1、如果过滤条件中使用了聚合函数，则必须使用HAVING来替换WHERE，否则报错。
2、HAVING必须使用在 GROUP BY 的后面。
3、HAVING不能单独使用，要和GROUP BY一起使用。

特殊的使用场景

1.按照分隔符号分段查询

模板

SELECT
    SUBSTRING_INDEX(字段名, '分隔符号', 1) AS 新字段名1,
    SUBSTRING_INDEX( SUBSTRING_INDEX(字段名, '分隔符号', 2) ,'分隔符号',- 1) AS 新字段名2,
    SUBSTRING_INDEX(字段名, '分隔符号' ,- 1) AS 新字段名3
FROM
表名
1
2
3
4
5
6

样例

数据：

查询结果：

2.判断字段显示不同的数据

模板

SELECT
    CASE 需要判断的字段名
WHEN '判断数据1' THEN
        "显示数据1"
WHEN '判断数据2' THEN
        "显示数据2"
ELSE
        '非判断数据显示'
END 查询结果的字段名
FROM
表名
1
2
3
4
5
6
7
8
9
10
11

样例
数据：

查询结果：

3.查询去除空格

模板

SELECT
      rtrim(字段名)   AS  新字段名
FROM
    表名
1
2
3
4

样例

数据：字段录入时错误在后方录入了多余的空格

查询结果：去除了空格，不论几个

4.查询去除字段后几位

模板

SELECT
    LEFT (
        字段名,
        CHAR_LENGTH(字段名) - 去几位
    ) as 新字段名
FROM
    表名
1
2
3
4
5
6
7

样例

数据：录入时后方多了空格和不需要的内容

查询结果：去除了后四位的空格或者字符

​Oracle

1.查询当前系统时间

select sysdate from dual

select to_char(sysdate,'yyyy/mm/dd hh24:mi:ss') from dual
1
2
3

2.锁表解决

使用select for update，或者直接使用update语句的时候可能会出现很长时间没反应的情况，这种情况可能是事务锁了，现查看有没有锁的表，然后杀死进程解锁

--查看锁表的 sid , serial #
select c.object_name as 表名,
 	b.sid,
 	b.serial#,
 	logon_time,
 	b.username
from v$locked_object a,V$session b,dba _ objects c
where a.session_id = b.sid
and c.object_id = a.object_id 
order by b.logon_time

--杀死进程， sid , serial #
alter system kill session '493,913'
1
2
3
4
5
6
7
8
9
10
11
12
13

3.查询表结构

SELECT * FROM USER_TAB_COLS WHERE TABLE_NAME='表名'
1

4.显示CLOB类型

字符串很长的情况下，我们可以使用CLOB类型存放。
正常的select 语句查询出来显示为CLOB
可以使用如下语句显示CLOB类型

select dbms_lob.substr(t.字段名) AS 字段别名 FROM 表名 t
1

5.查询触发器

1.对于主体在表和视图的触发器
可以在Insert、Update、Delete时触发
2.对于主体在数据库和服务器的触发器
可以在CREATE、ALTER、DROP、GRANT、DENY、REVOKE、UPDATE时触发

select * from user_objects where object_type='TRIGGER'
1

6.nvl-空值转换

NVL函数的功能是实现空值的转换，根据第一个表达式的值是否为空值来返回相应的列名或表达式，主要用于对数据列上的空值进行处理，语法格式如：NVL( string1, replace_with)。

主要用于查询某个字段会有空值的情况

示例

--如果姓名name字段为空，则转换为张三
NVL(name, 张三)

--状态STS有三种情况：空，0，1
--需要查询不为0的数据
--错误情况STS !='0'，此方法会遗漏为空的情况，即只能查询出状态为1的数据，因为为空需要专门使用is null查询
--正确语句，将空转换为其他任意值
where NVL(STS,'任意值')!='0'

--或者
--使用下面的也可以筛选不为0
where STS ！='0'
AND STS IS NULL 
1
2
3
4
5
6
7
8
9
10
11
12
13

7.＜＞不等于

不要将其视为一对尖括号，而是将其视为一个大于符号和一个小于符号即可。于是‘<>’就成了’小于大于’，即是选择大于或小于右侧数字的值。可以大于，可以小于，就是不能等于。

所以实际上<>就是不等于。

那么‘<>’与’!='有什么区别呢？
答案是没什么区别，除了适用性。
无论哪种版本的SQL使用‘<>’都可以表示“不等于”的意思，不会有任何语法错误。而在SQL2000中，使用!=会产生语法错误。

8.REGEXP_LIKE正则表达式函数

主要作用是正则表达式筛选

REGEXP_LIKE(x,pattern)函数的功能类似于like运算符， 用于判断源字符串是否匹配或包含指定模式的子串。 x指定源字符串，pattern是正则表达式字符串。该函数只可用在where子句中。

--基本用法，是否包含某字符串 =like %36%
select * from k_micfo where  regexp_like(loginid,'36');
 
if regexp_like(str,'^[0-9\.]+$')  --只包含数字0-9，,小数点.
 
--oracle判断字段是否是纯数字 (四种写法结果一样）
select * from k_micfo where regexp_like(loginid,'^[0-9]+[0-9]$');
select * from k_micfo where regexp_like(loginid,'^[0-9]+$');   --'+' 匹配前面的子表达式一次或多次。
select * from k_micfo where regexp_like(loginid,'^[[:digit:]]+$');
select * from k_micfo where  not regexp_like(loginid,'[^0-9]');  --^表示排除
 
--不是0-9纯数字 （二种写法结果一样）
select * from k_micfo where  regexp_like(loginid,'[^0-9]');  --^表示排除
select * from k_micfo where not regexp_like(loginid,'^[[:digit:]]+$');
 
--判断字段中是否只包含0-9，-字符（二种写法结果一样）
select * from k_micfo where regexp_like(APPLICATION,'^[0-9]|[-]$');  --'|' 指明两项之间的一个选择。相当于or 例子'^([a-z]+|[0-9]+)$'表示所有小写字母或数字组合成的字符串。
select * from k_micfo where  regexp_like(APPLICATION,'[0-9-]');
 
--判断字段中是否只包含0-9，-字符, 或者空格 （五种写法结果一样）
select * from k_micfo where regexp_like(APPLICATION,'^[0-9]|[-]$') or regexp_like(APPLICATION,'^[ ]$');
select * from k_micfo where regexp_like(APPLICATION,'^[0-9]|[-]$|^[ ]$');  
select * from k_micfo where regexp_like(APPLICATION,'(^[0-9]|[-]$)|(^[ ]$)'); --'( )' 标记一个子表达式的开始和结束位置
select * from k_micfo where regexp_like(APPLICATION,'^[0-9]|[-]|[ ]$');
select * from k_micfo where  regexp_like(APPLICATION,'[0-9- ]'); 

--查询某个字段中不含字母的数据
SELECT *
  FROM 表名
 WHERE REGEXP_LIKE(字段名, '^[^a-zA-Z]+$') 
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
28
29
30

9.时间计算

加法

select sysdate,add_months(sysdate,12) from dual;         --加1年
select sysdate,add_months(sysdate,1) from dual;         --加1月
select sysdate,to_char(sysdate+7,'yyyy-mm-dd HH24:MI:SS') from dual;    --加1星期
select sysdate,to_char(sysdate+1,'yyyy-mm-dd HH24:MI:SS') from dual;    --加1天
select sysdate,to_char(sysdate+1/24,'yyyy-mm-dd HH24:MI:SS') from dual;   --加1小时
select sysdate,to_char(sysdate+1/24/60,'yyyy-mm-dd HH24:MI:SS') from dual;   --加1分钟
select sysdate,to_char(sysdate+1/24/60/60,'yyyy-mm-dd HH24:MI:SS') from dual; --加1秒
1
2
3
4
5
6
7

减法

select sysdate,add_months(sysdate,-12) from dual;         --减1年
select sysdate,add_months(sysdate,-1) from dual;         --减1月
select sysdate,to_char(sysdate-7,'yyyy-mm-dd HH24:MI:SS') from dual;    --减1星期
select sysdate,to_char(sysdate-1,'yyyy-mm-dd HH24:MI:SS') from dual;    --减1天
select sysdate,to_char(sysdate-1/24,'yyyy-mm-dd HH24:MI:SS') from dual;   --减1小时
select sysdate,to_char(sysdate-1/24/60,'yyyy-mm-dd HH24:MI:SS') from dual;   --减1分钟
select sysdate,to_char(sysdate-1/24/60/60,'yyyy-mm-dd HH24:MI:SS') from dual; --减1秒
1
2
3
4
5
6
7

对于部分比较的使用，还会涉及格式转换的问题，例如数据库中存储分钟的字段是VARCHAR2类型，就不能直接进行比较

--减1分钟
SELECT *
  FROM 表名
 WHERE 比较的字符型时间字段 >= TO_CHAR(SYSDATE - 1 / 24 / 60, 'HH24:MI:SS')
1
2
3
4

10.TO_CHAR、TO_DATE字符串日期格式转换

TO_CHAR日期转换为字符串

SELECT SYSDATE,
       TO_CHAR(SYSDATE, 'yyyy-mm-dd hh:mm:ss') AS "12小时制",
       TO_CHAR(SYSDATE, 'yyyy-mm-dd hh24:mi:ss') AS "24小时制"
  FROM dual
1
2
3
4

SYSDATE，取固定日期格式

SELECT
  TO_CHAR(SYSDATE , 'yyyy') AS 年份 ,
  TO_CHAR(to_date('2022-07-01', 'yyyy-mm-dd'), 'q') AS 季度 ,
  TO_CHAR(SYSDATE , 'mm') AS 月份 ,
  TO_CHAR(SYSDATE  , 'dd') AS 日, -- 每月的第几天
  TO_CHAR(SYSDATE  , 'd') AS "日（周）", -- 每周第几天（第一天是周日）
  TO_CHAR(SYSDATE  , 'ddd') AS "日（年）" , -- 每年的第几天
  TO_CHAR(SYSDATE  , 'ww') AS "周（年）", -- 每年的第几周
  TO_CHAR(to_date('2022-01-08', 'yyyy-mm-dd')  , 'ww') AS "周（年）" -- 每年的第几周
FROM
  dual ;
1
2
3
4
5
6
7
8
9
10
11

TO_DATE字符串转换为日期

SELECT
	TO_DATE('2022-06-20 17:08:06' , 'yyyy-mm-dd hh24:mi:ss') AS "date"
FROM
	dual ;
1
2
3
4

11.日期加减计算

INTERVAL

--当前时间加一年
SELECT SYSDATE, SYSDATE + INTERVAL '1' YEAR FROM dual;

--当前时间减一年
SELECT SYSDATE, SYSDATE - INTERVAL '1' YEAR FROM dual;

--间隔一天
SELECT SYSDATE, SYSDATE + INTERVAL '1' DAY FROM dual;

--间隔一小时
SELECT SYSDATE, SYSDATE + INTERVAL '1' HOUR FROM dual;

间隔一分钟
SELECT SYSDATE, SYSDATE + INTERVAL '1' MINUTE FROM dual;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

NUMTODSINTERVAL

--间隔一天
SELECT SYSDATE, SYSDATE + NUMTODSINTERVAL(1, 'DAY') FROM dual;

--间隔一小时
SELECT SYSDATE, SYSDATE + NUMTODSINTERVAL(1, 'HOUR') FROM dual;

--间隔一分钟
SELECT SYSDATE, SYSDATE + NUMTODSINTERVAL(1, 'MINUTE') FROM dual;
1
2
3
4
5
6
7
8

NUMTODSINTERVAL 函数对于 YEAR、MONTH 参数不支持，返回函数的参数非法，如下图所示

12.索引

查询现有的索引

SELECT c.table_name      AS 表名,
       i.index_name      AS 索引名,
       i.index_type      AS 索引类型,
       c.column_name     AS 索引列名称,
       c.column_position AS 列的位置
  FROM user_ind_columns c
  JOIN user_indexes i
    ON c.index_name = i.index_name
 WHERE c.table_name = '表名';
1
2
3
4
5
6
7
8
9

Oracle 中的索引类型及其含义为：

B树索引：普通 B 树索引。B树索引是Oracle默认的索引类型，它以B树结构组织并存储索引数据，不懂什么是B树的可以百度一下，你就知道。B树索引中的数据是以升序方式排序的，B树索引由根块、分支块和叶块组成，其中主要数据都集中在叶子节点上。Oracle采用这种方式的索引，可以确保无论索引条目在何处，只需要花费相同的I/O即可获取它，所以它被称为B（Balanced）树索引。如果在Where子句中要经常引用某列或某几列，应该基于这些列建立B树索引

位图索引：位图索引是一种高度压缩的索引类型，适用于在大型表中包含少量不同值的列上。位图索引适用于等值搜索，并且可以更快地处理多个位图索引之间的逻辑运算。位图索引不适用于频繁的插入、更新和删除操作。
对于不同值多少的划分，采用Oracel基数划分，比如一个表有10000行数据，其中的某一字段只有100种取值，基数则为1%，Oracle推荐，当一个字段基数小于1%时，适合建立位图索引

函数索引：函数索引是基于表达式的索引，可以用于在非直接存储在列中的值上进行搜索，例如，将字符串转换为大写字母。函数索引可以帮助您避免在查询中使用昂贵的函数操作，但是创建和维护函数索引可能会增加查询的成本。

散列索引：散列索引使用散列函数将索引键转换为散列值，从而提高索引搜索性能。散列索引适用于等值搜索，但不适用于范围搜索或排序操作。散列索引在写入高并发表时性能通常很好，但是当表的大小增长时，它们可能会变得不稳定。

反向键索引：Oracle会自动为表的主键创建B树索引，通常主键会是一个递增的序列编号，如果使用默认的B树索引，当数据量巨大时会导致索引数据分布不均，叶子节点可能会偏向某一个方向，这时就需要另一个索引机制，反向键索引，它可以将添加的数据随机（全部数据都会进行反向）分散到索引中，它在顺序递增列上建立索引时非常有用。反向键索引的工作原理非常简单，在存储结构方面它与常规的B树索引相同。然而，如果用户使用序列在表中输入记录，则反向键索引首先指向每个列键值的字节，然后在反向后的新数据上进行索引。例如，如果用户输入的索引列为2011,则反向转换后为1102; 9527 反向转换后为7259。需要注意的是，刚才提及的两个序列编号是递增的，但是当进行反向键索引时却是非递增的。这意味着，如果将其添加到子叶节点中，则可能会在任意的子叶节点中进行。这样就使得新数据在值的范围上的分布通常比原来的有序数更均匀。

函数索引：基于函数的索引是常规的B树索引，但它存储的数据是由表中的数据应用函数后所得到的，而不是直接存储表中的数据本身。

--例如有函数索引
SUBSTR(字段名,1,1)

--则只能触发
SELECT * FROM 表名 WHERE SUBSTR(字段名,1,1)=''

--下面的这种方式也不能触发
SELECT * FROM 表名 WHERE SUBSTR(字段名,1,2)=''
1
2
3
4
5
6
7
8

其它

1.视图

是一个虚表。数据库中仅存视图定义，不存对应的数据 。

--创建视图
creat view 视图名 as 查询语句
1
2

2.CASE WHEN查询判断内容改变输出

case when可用于=，>=，<，<=，<>，is null，is not null 等的判断

CASE WHEN 字段=值1 THEN 改变输出值1 WHEN 字段=值2 THEN 改变输出值2 ELSE 其它输出值 END
1

示例

--年龄AGE为18时输出十八岁，大于20时输出大于二十岁，否则输出其它年龄
SELECT (CASE
         WHEN A.AGE = '18' THEN
          '十八岁'
         WHEN A.AGE > '20' THEN
          '大于二十岁'
         ELSE
          '其它年龄'
       END) 年龄
  FROM STUDENT A
1
2
3
4
5
6
7
8
9
10

3.DECODE

decode只能用做相等判断，但是可以配合sign函数进行大于，小于，等于的判断

--第一种用法
--当条件等于值1时返回值1，等于值2时返回值2，......等于值3时返回值3，等于其他情况时都返回最后的缺省值。
DECODE(条件,值1,返回值1,值2,返回值2,…值n,返回值n,缺省值)

--第二种用法
--字段或字段的运算等于值1时，返回值2，否则，都返回值3。
decode(字段或字段的运算，值1，值2，值3）
1
2
3
4
5
6
7