这两年学会了跑sql，当时有很多同学帮助我精进了这个技能，现在也写成一个小教程，反馈给大家。
适用对象：工作中能接触到sql查询平台的业务同学(例如有数据查询权限的产品与运营同学)
适用场景：查询hive&mysql上的数据
文档优势：比起各类从零起步的教程教材，理解门槛低，有效信息密度大，可以覆盖高频业务场景。
文末有一些常见的小技巧，希望帮助同学们提升工作效率。
SQL的基础结构：
做一个类比，我们用的“表”，就像是一个账本，每天就是一个“分区”，“字段”就是日记上记的不同的事情，例如支出、收入、物品和价格等；
一般来讲sql有如下结构，意思是从表α.table里面，获取某一天的abc三个字段，后面的讲解都是在这个基础上展开的：
select                             a,b,c         //select后面输入需要查询的字段fromα.table        //from后面输入需要查询的表名wheredate='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据
多个条件同时生效-and和or
and的用法//表示多条件同时生效
select                             a,b,c         //select后面输入需要查询的字段fromα.table       //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           //表示要看date='yymmdd' 且id='XXX'id=XXX
or的用法//表示有一个条件生效即可
select                             a,b,c         //select后面输入需要查询的字段fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor d_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或d_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，d_id是xxx的数据
对指标进行加和//sum
学习到本节时，我们需要明白维度和指标的区别，维度是表示属性的，指标是表示量级的，例如全中国有56个民族，全中国就是一个维度，民族数量就是一个指标
select        //select后面输入需要查询的字段a,b,sum(c)    //需要加和的c字段(指标)括起来加sum即可，有点像excel那种fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor sp_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或sp_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，sp_id是xxx的数据group by a,b  //没有被处理的字段(维度)，需要在尾部group by 一下
为字段重新命名//as
select        //select后面输入需要查询的字段a,b as b1,sum(c) as c1   //需要加和的c字段括起来加sum即可，有点像excel那种；这里用as把b重新命名成了b1，把c重新命名成了c1fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor sp_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或sp_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，sp_id是xxx的数据group by a,b  //没有被处理的字段，需要在尾部group by 一下；被重新命名的维度字段，group by时仍用as前面的内容
查数据条数，或查询维度的数量//count和distinct
select        //select后面输入需要查询的字段a,b,sum(c),   //需要加和的c字段括起来加sum即可，有点像excel那种count(distinct d)//去重查询在a,b枚举下,d有几个,例如查ka,la(a)的客户id(b)下,总共有几个广告主(d);不加distinct查询的是所有的广告主(d)总共出现了几次fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor sp_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或sp_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，sp_id是xxx的数据group by a,b  //没有被处理的字段，需要在尾部group by 一下
对一份数据做多次处理//嵌套结构
如下sql查询了每个人在当天的页面访问频次。3到7行先查询出每个用户id的页面访问频次，然后使用3到7行的结果，查询每个访问频次下，有几个id：SELECT cnt,count(id)FROM(select id,count(*) as cnt  //-'*'可以用来查询行数from α.tablewhere date ='20190928' and label='show'group by id) a                          //-这里写一个'a',用来给3到7行的结果命名,这样外层的sql才能识别括号里面的内容group by cnt
对多份数据做关联处理//join
最常用的场景：假设表A上有门店id是a，收入是b，表B上有门店id是a，门店名称c，如果需要获取门店id，收入，门店名称的关系，可以这么写：
SELECT a,b,cFROM(select a,sum (b)  from A group by a) cost                //-为3到6行的sql命名为costleft join (           //-这里使用左连接select a,cfrom B group by a,c )text    //-为8到10行的sql命名为texton cost.a=text.a      //-这里需要写清连接两段sql的字段
放下这张图,形象的表达了各种join方法，获取的数据范围。想获取对应数据时，替换上边第7行就可以用：
(图片来源于网络，侵删)
条件判断，对同一个字段做区分计算//if 和case when
判断一次是否//if
select a,sum (b),if (label = 'show_over', duration, 0) //这一句的意思是，当这一行数据的label是show_over的时候，取duration这个字段里的值，label不是show_over的时候，取0from A group by a
判断一次或多次是否//case when
多加判断的方式见4和5两行：
select a,sum (b),case when label = 'pv' then durationwhenlabel='play' then mockdurationelse 0end,                        //2到4行的意思是，当这一行数据的label是pv的时候，取duration这个字段里的值，如果label是play的时候，取duration这个字段里的值，如果还没有，就取0from A group by a
除法取整//floor
select a,floor (X/100)  //-把X按100分档，0档表示X在[0,100)之间，1档表示X在[100,200)之间，以此类推from A group by a
筛选字段为空/不为空的方法//null
select a,sum (b)from A where type is not null //找出type 不是null的情况，不加"not",就是找出type 是null的情况group by a
各种常见类型字段、指定值的查询方法：
string：加单引号即可，例如一个字段type是string，就可以写：
select a,sum (b)from A where type='1'   //-string加单引号group by a
bigint：后面加一个L，例如一个字段type是bigint，就可以写：
select a,sum (b)from A where type=1L    //- bigint后加Lgroup by a
array：XXX代表数组内的字段类型，需要根据此类型的方式取数，假设model字段的类型是array：
select a,sum (b)from A where array_contains(model,123L)group by a
json：json经常会出现字段包字段的情况，例如常用的data是个json字段，里面会有a字段，a字段里面还会有b字段，如果想取出b，我们应该这么写：
select get_json_object(data,'$.a.b') from A
扩展阅读
一些提升效率的方法
时间分区有多种存储方式，查询where条件的时候需要注意：有的表是‘yymmdd’，有的表是‘yy-mm-dd’；字段名也不固定，有的表是p_date，有的表是date，但是对于单个表，分区字段一般是固定的，例如你经常查a.bcde这个表，上次他的时间分区格式是date=‘yymmdd’，下次查的时候它还会是date=‘yymmdd’；
有时表中的时间戳不是常见的yymmdd，而是一串数字，如果where条件里需要卡时间戳，却不知道日期对应的一串数字是什么，可使用时间戳转换器转换：https://tool.lu/timestamp/
sql没数、跑错怎么办：有时解析功能没有发现问题，但是数据直观感觉不对，可以用如下方式自查：
检查相关表的分区，和你取的分区一致不一致，例如日期有多种格式，例如yymmdd，yy-mm-dd，yy-mm-dd 00:00:00等等；
如果sql包含多个部分，比如有join，可以把其他部分的sql注释掉，分别看每个部分的sql哪里有问题；(注释方式：代码前加“//” 例如 //select ...)
需要研究单个json字段的逻辑：可以用这个网址整理json字段，方便阅读：https://www.json.cn/
同时编辑多行，可以按住shift+alt/option，鼠标点击起始行和结束行，就能同时编辑多行了，例如批量
常用概念的解释
全量表和增量表
增量表：每天存下来的数据，是当天产生的所有数据，例如日记，每日走路的步数，银行每天的收支信息等；
全量表：每天存下来的数据，是从有表开始所有的数据，相当于每天抄一份历史上所有的日记，再写今天的日记，例如银行账户的余额；
不同数据库的区别
mysql等实时查询的数据库：一般没有分区概念，存储的数据比较少，但是响应快；
hive等离线查询数据库：有分区概念，可以较低成本的存储海量数据，支持各种复杂处理，查询速度一般比mysql慢。

list列表
可以类比于其它语言(如，C语言)的数组，其起始下标为也为0。
1.列表的索引访问
1)通过list_name[index]来访问，每个列表的起始下标为0。
例子：
1 demolist = [1,2,3,4] #列表的定义
2 print type(demolist) #打印类型
3 print demolist[0] #输出第一个元素
4 print demolist[1] #输出第二个元素
输出：
1
2
2)可以通过del list_name[index]来删除列表的下标是index的数据。
例子：
1 demolist = [1,2,3,4] #列表的定义
2 del demolist[2] #删除第三个元素
3 print demolist #输出整个列表
输出：
[1, 2, 4]
2.列表的切片访问
1)想访问列表里一段连续的元素(或规则间隔的元素)可以指定列表的起止位置和终止位置、间隔的步长(可省，默认为1)。语法格式list_name(start:end[:step])表示访问下标为start至end-1的元素，step可省略，可以简记为前闭后开。
例子：
1 demolist = [1,2,3,4,5,6,7,8,9] #列表的定义
2 print demolist[0:5]  #访问第1-5的元素
3 print demolist[0:8:2] #访问第1-8的元素，步长为2
输出：
1 [1, 2, 3, 4, 5]2 [1, 3, 5, 7]
2)同样也可以使用del list_name(start:end[:step])来删除对应的元素。
例子：
1 demolist = [1,2,3,4,5,6,7,8,9] #列表的定义
2 del demolist[0:8:2]  #删除下标为0到7的元素
3 print demolist  #输出整个列表
输出：
1 [2, 4, 6, 8, 9]
3.列表的基本运算
1)列表的加法：列表可以同字符串一样相加。
例子：
1 demolist = [1,2,3,4] #列表的定义
2 print demolist+[5,6,7,8,9]
输出：
1 [1, 2, 3, 4, 5, 6, 7, 8, 9]
2)列表的乘法：相当于字符串的乘法，一个列表乘(*)以N次，表示这个列表相加了N次。
例子：
1 demolist = ["y","y","c"] #列表的定义
2 print  demolist* 3   #列表可以做乘法
输出：
1 ['y', 'y', 'c', 'y', 'y', 'c', 'y', 'y', 'c']
3)列表的in和not in运算：用于判断某个元素是否在(不在)列表中。在返回True,不在返回False。
例子：
1 demolist = [1,2,3,4] #列表的定义
2 print 2 in demolist #判断元素是否在列表中
3 print 21 in demolist
输出：
1 True2 False
4)列表的遍历：可以通过像字符串那样使用for循环来遍历列表。
例子：
1 demolist = [1,2,3,4] #列表的定义
2 i =03 for value indemolist:4     print 'demolist[%d]:'%(i),value5     i += 1
输出：
1 demolist[0]:  1
2 demolist[1]:  2
3 demolist[2]:  3
4 demolist[3]:  4
5)列表的解析：可以方便的对列表中的元素进行运算，语法格式：[val_expr for val in list_name]，val_expr是一个关于val的运算表达式，val用于存储for每次从列表中取出的元素，然后通过val_expr的运算形成一个新的列表项，for循环结束则生成一个新的列表。
例子：计算1-9每个数本身的次方，如2**2 = 4
1 demolist = range(1,10) #列表的定义:生成一个[1,10)的列表
2 printdemolist3 new_list = [x**x for x indemolist]4 print new_list
输出：
1 [1, 2, 3, 4, 5, 6, 7, 8, 9]2 [1, 4, 27, 256, 3125, 46656, 823543, 16777216, 387420489]
4.列表相关函数
TIPS--->列表的函数很多，这里有个小技巧：遇到这种很多函数又记不住，可以通过help 函数查看该类型拥有的所有方法，例如：
1 demolist = [1,2,3,4] #列表的定义
2 print help(demolist) #通过help函数查看该类型所有的函数方法
输出：太多，已折叠代码
1 Help on list object:2
3 classlist(object)4  |  list() ->new empty list5  |  list(iterable) -> new list initialized from iterable's items
6  |
7  |Methods defined here:8  |
9  |  __add__(...)10  |      x.__add__(y) <==> x+y11  |
12  |  __contains__(...)13  |      x.__contains__(y) <==> y inx14  |
15  |  __delitem__(...)16  |      x.__delitem__(y) <==> delx[y]17  |
18  |  __delslice__(...)19  |      x.__delslice__(i, j) <==> delx[i:j]20  |
21  |      Use of negative indices is notsupported.22  |
23  |  __eq__(...)24  |      x.__eq__(y) <==> x==y25  |
26  |  __ge__(...)27  |      x.__ge__(y) <==> x>=y28  |
29  |  __getattribute__(...)30  |      x.__getattribute__('name') <==>x.name31  |
32  |  __getitem__(...)33  |      x.__getitem__(y) <==>x[y]34  |
35  |  __getslice__(...)36  |      x.__getslice__(i, j) <==>x[i:j]37  |
38  |      Use of negative indices is notsupported.39  |
40  |  __gt__(...)41  |      x.__gt__(y) <==> x>y42  |
43  |  __iadd__(...)44  |      x.__iadd__(y) <==> x+=y45  |
46  |  __imul__(...)47  |      x.__imul__(y) <==> x*=y48  |
49  |  __init__(...)50  |      x.__init__(...) initializes x; see help(type(x)) forsignature51  |
52  |  __iter__(...)53  |      x.__iter__() <==>iter(x)54  |
55  |  __le__(...)56  |      x.__le__(y) <==> x<=y57  |
58  |  __len__(...)59  |      x.__len__() <==>len(x)60  |
61  |  __lt__(...)62  |      x.__lt__(y) <==> x
64  |  __mul__(...)65  |      x.__mul__(n) <==> x*n66  |
67  |  __ne__(...)68  |      x.__ne__(y) <==> x!=y69  |
70  |  __repr__(...)71  |      x.__repr__() <==>repr(x)72  |
73  |  __reversed__(...)74  |      L.__reversed__() -- returna reverse iterator over the list75  |
76  |  __rmul__(...)77  |      x.__rmul__(n) <==> n*x78  |
79  |  __setitem__(...)80  |      x.__setitem__(i, y) <==> x[i]=y81  |
82  |  __setslice__(...)83  |      x.__setslice__(i, j, y) <==> x[i:j]=y84  |
85  |      Use  of negative indices is notsupported.86  |
87  |  __sizeof__(...)88  |      L.__sizeof__() -- size of L in memory, inbytes89  |
90  |append(...)91  |      L.append(object) --append object to end92  |
93  |count(...)94  |      L.count(value) -> integer -- returnnumber of occurrences of value95  |
96  |extend(...)97  |      L.extend(iterable) -- extend list by appending elements fromthe iterable98  |
99  |index(...)100  |      L.index(value, [start, [stop]]) -> integer -- returnfirst index of value.101  |      Raises ValueError if the value is notpresent.102  |
103  |insert(...)104  |      L.insert(index, object) --insert object before index105  |
106  |pop(...)107  |      L.pop([index]) -> item -- remove and returnitem at index (default last).108  |      Raises IndexError if list is empty or index isout of range.109  |
110  |remove(...)111  |      L.remove(value) --remove first occurrence of value.112  |      Raises ValueError if the value is notpresent.113  |
114  |reverse(...)115  |      L.reverse() -- reverse *IN PLACE*
116  |
117  |sort(...)118  |      L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;119  |      cmp(x, y) -> -1, 0, 1
120  |
121  |  ----------------------------------------------------------------------
122  |  Data andother attributes defined here:123  |
124  |  __hash__ =None125  |
126  |  __new__ = 
127  |      T.__new__(S, ...) ->a new object with type S, a subtype of T128
129 None
通过help查看的list相关函数
如果只记得方法名不知道参数怎么传了，可以用help(变量名.方法名)，例如：
1 demolist = [1,2,3,4] #列表的定义
2 print help(demolist.insert) #通过help函数查看具体某方法的用法
输出：
1 Help on built-infunction insert:2
3 insert(...)4     L.insert(index, object) --insert object before index5
6 None
1) 所以呢，列表的方法太多了，下面列举几个常用的函数：
1 demolist = [1,2,3,4] #列表的定义
2 demolist.pop() #1出桟，删除最后一个元素
3 printdemolist4
5 demolist.pop(1) #2出桟，删除下标为1的元素
6 printdemolist7
8 demolist.append(20) #3追加一个数
9 printdemolist10
11 demolist.append('hello') #4还可以追加一个字符串、实型等任何类型
12 printdemolist13
14 demolist.append(['a','b',"c",20]) #5甚至还可以追加一个列表，(注：python中字符用单引号双引号都一样)
15 printdemolist16
17 print len(demolist) #6列表长度
18
19 demolist.insert(2, [8,9,10]) #7在列表的指定位置插入元素(可以时任意对象，如这里就是插入的一个列表)
20 printdemolist21
22 print demolist.count(20) #8统计某个值在列表中出现的次数
23
24 demolist.extend([20,100,200,300]) #9将指定的列表以个体的方式追加到列表的末尾
25 printdemolist26
27 demolist.remove(20) #10删除列表中第一次出现的指定元素
28 print demolist
输出：
1 [1, 2, 3]2 [1, 3]3 [1, 3, 20]4 [1, 3, 20, 'hello']5 [1, 3, 20, 'hello', ['a', 'b', 'c', 20]]6 5
7 [1, 3, [8, 9, 10], 20, 'hello', ['a', 'b', 'c', 20]]8 1
9 [1, 3, [8, 9, 10], 20, 'hello', ['a', 'b', 'c', 20], 20, 100, 200, 300]10 [1, 3, [8, 9, 10], 'hello', ['a', 'b', 'c', 20], 20, 100, 200, 300]

这两年学会了跑sql，当时有很多同学帮助我精进了这个技能，现在也写成一个小教程，反馈给大家。
适用对象：工作中能接触到sql查询平台的业务同学(例如有数据查询权限的产品与运营同学)
适用场景：查询hive&mysql上的数据
文档优势：比起各类从零起步的教程教材，理解门槛低，有效信息密度大，可以覆盖高频业务场景。
文末有一些常见的小技巧，希望帮助同学们提升工作效率。
SQL的基础结构：
做一个类比，我们用的“表”，就像是一个账本，每天就是一个“分区”，“字段”就是日记上记的不同的事情，例如支出、收入、物品和价格等；
一般来讲sql有如下结构，意思是从表α.table里面，获取某一天的abc三个字段，后面的讲解都是在这个基础上展开的：
select                             a,b,c         //select后面输入需要查询的字段fromα.table        //from后面输入需要查询的表名wheredate='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据
多个条件同时生效-and和or
and的用法//表示多条件同时生效
select                             a,b,c         //select后面输入需要查询的字段fromα.table       //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           //表示要看date='yymmdd' 且id='XXX'id=XXX
or的用法//表示有一个条件生效即可
select                             a,b,c         //select后面输入需要查询的字段fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor d_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或d_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，d_id是xxx的数据
对指标进行加和//sum
学习到本节时，我们需要明白维度和指标的区别，维度是表示属性的，指标是表示量级的，例如全中国有56个民族，全中国就是一个维度，民族数量就是一个指标
select        //select后面输入需要查询的字段a,b,sum(c)    //需要加和的c字段(指标)括起来加sum即可，有点像excel那种fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor sp_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或sp_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，sp_id是xxx的数据group by a,b  //没有被处理的字段(维度)，需要在尾部group by 一下
为字段重新命名//as
select        //select后面输入需要查询的字段a,b as b1,sum(c) as c1   //需要加和的c字段括起来加sum即可，有点像excel那种；这里用as把b重新命名成了b1，把c重新命名成了c1fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor sp_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或sp_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，sp_id是xxx的数据group by a,b  //没有被处理的字段，需要在尾部group by 一下；被重新命名的维度字段，group by时仍用as前面的内容
查数据条数，或查询维度的数量//count和distinct
select        //select后面输入需要查询的字段a,b,sum(c),   //需要加和的c字段括起来加sum即可，有点像excel那种count(distinct d)//去重查询在a,b枚举下,d有几个,例如查ka,la(a)的客户id(b)下,总共有几个广告主(d);不加distinct查询的是所有的广告主(d)总共出现了几次fromα.table        //from后面输入需要查询的表名where         date='yymmdd' //where后面输入需要卡的条件，例如只看哪天的数据and           (id=XXXor sp_id=XXX)   //表示要看date='yymmdd' ，且id是xxx或sp_id是xxx的数据。如果没有这个括号，表示的是要看date是yymmdd且id是xxx，或者不分日期，sp_id是xxx的数据group by a,b  //没有被处理的字段，需要在尾部group by 一下
对一份数据做多次处理//嵌套结构
如下sql查询了每个人在当天的页面访问频次。3到7行先查询出每个用户id的页面访问频次，然后使用3到7行的结果，查询每个访问频次下，有几个id：SELECT cnt,count(id)FROM(select id,count(*) as cnt  //-'*'可以用来查询行数from α.tablewhere date ='20190928' and label='show'group by id) a                          //-这里写一个'a',用来给3到7行的结果命名,这样外层的sql才能识别括号里面的内容group by cnt
对多份数据做关联处理//join
最常用的场景：假设表A上有门店id是a，收入是b，表B上有门店id是a，门店名称c，如果需要获取门店id，收入，门店名称的关系，可以这么写：
SELECT a,b,cFROM(select a,sum (b)  from A group by a) cost                //-为3到6行的sql命名为costleft join (           //-这里使用左连接select a,cfrom B group by a,c )text    //-为8到10行的sql命名为texton cost.a=text.a      //-这里需要写清连接两段sql的字段
放下这张图,形象的表达了各种join方法，获取的数据范围。想获取对应数据时，替换上边第7行就可以用：
(图片来源于网络，侵删)
条件判断，对同一个字段做区分计算//if 和case when
判断一次是否//if
select a,sum (b),if (label = 'show_over', duration, 0) //这一句的意思是，当这一行数据的label是show_over的时候，取duration这个字段里的值，label不是show_over的时候，取0from A group by a
判断一次或多次是否//case when
多加判断的方式见4和5两行：
select a,sum (b),case when label = 'pv' then durationwhenlabel='play' then mockdurationelse 0end,                        //2到4行的意思是，当这一行数据的label是pv的时候，取duration这个字段里的值，如果label是play的时候，取duration这个字段里的值，如果还没有，就取0from A group by a
除法取整//floor
select a,floor (X/100)  //-把X按100分档，0档表示X在[0,100)之间，1档表示X在[100,200)之间，以此类推from A group by a
筛选字段为空/不为空的方法//null
select a,sum (b)from A where type is not null //找出type 不是null的情况，不加"not",就是找出type 是null的情况group by a
各种常见类型字段、指定值的查询方法：
string：加单引号即可，例如一个字段type是string，就可以写：
select a,sum (b)from A where type='1'   //-string加单引号group by a
bigint：后面加一个L，例如一个字段type是bigint，就可以写：
select a,sum (b)from A where type=1L    //- bigint后加Lgroup by a
array：XXX代表数组内的字段类型，需要根据此类型的方式取数，假设model字段的类型是array：
select a,sum (b)from A where array_contains(model,123L)group by a
json：json经常会出现字段包字段的情况，例如常用的data是个json字段，里面会有a字段，a字段里面还会有b字段，如果想取出b，我们应该这么写：
select get_json_object(data,'$.a.b') from A
扩展阅读
一些提升效率的方法
时间分区有多种存储方式，查询where条件的时候需要注意：有的表是‘yymmdd’，有的表是‘yy-mm-dd’；字段名也不固定，有的表是p_date，有的表是date，但是对于单个表，分区字段一般是固定的，例如你经常查a.bcde这个表，上次他的时间分区格式是date=‘yymmdd’，下次查的时候它还会是date=‘yymmdd’；
有时表中的时间戳不是常见的yymmdd，而是一串数字，如果where条件里需要卡时间戳，却不知道日期对应的一串数字是什么，可使用时间戳转换器转换：https://tool.lu/timestamp/
sql没数、跑错怎么办：有时解析功能没有发现问题，但是数据直观感觉不对，可以用如下方式自查：
检查相关表的分区，和你取的分区一致不一致，例如日期有多种格式，例如yymmdd，yy-mm-dd，yy-mm-dd 00:00:00等等；
如果sql包含多个部分，比如有join，可以把其他部分的sql注释掉，分别看每个部分的sql哪里有问题；(注释方式：代码前加“//” 例如 //select ...)
需要研究单个json字段的逻辑：可以用这个网址整理json字段，方便阅读：https://www.json.cn/
同时编辑多行，可以按住shift+alt/option，鼠标点击起始行和结束行，就能同时编辑多行了，例如批量
常用概念的解释
全量表和增量表
增量表：每天存下来的数据，是当天产生的所有数据，例如日记，每日走路的步数，银行每天的收支信息等；
全量表：每天存下来的数据，是从有表开始所有的数据，相当于每天抄一份历史上所有的日记，再写今天的日记，例如银行账户的余额；
不同数据库的区别
mysql等实时查询的数据库：一般没有分区概念，存储的数据比较少，但是响应快；
hive等离线查询数据库：有分区概念，可以较低成本的存储海量数据，支持各种复杂处理，查询速度一般比mysql慢。

如何在一般情况下进行工作量的评估？
类比估算法：根据类似的项目工作量进行预估，再对估计值根据具体情况进行调整。
参数估算法：我们公司可能缺乏这方面的数据支持，比如通过估计某个项目可能会有的代码行数，配备的成员技能，来进行估计。举个例子，某个项目的代码行估计可能会有10000行，一个一般技能的开发工程师一天可以完成的代码行为500行，那么开发需要的时间可能就是20人日。
三点估算法：目的是为了尽量降低估算的不确定性。估算时对一个功能点分别估算最悲观的估算值、最乐观的估算值、最可能的估算值，最后确定的估算值=(最悲观的估算值+最乐观的估算值+4*最可能的估算值)/6。
Delphi法：由一组专家对项目进行估算。

具体的步骤为：

1，组织者发给每位专家一份软件系统的规格说明合一张记录估算值的表格，请专家估算。

2，专家详细研究软件规格后，对该软件提出最乐观的估算值、最可能的估算值和最悲观的估算值。

3，组织者对专家表格中的答复进行整理，计算每位专家的平均值E=（最悲观的估算值+最乐观的估算值+4*最可能的估算值）/6，然后计算出期望值：E=(E1+E2+....+EN)

4，综合结束后，再组织专家无记名填表格，比较估算偏差，并查找原因。

5，上述过程重复多次，最终可以获得一个多数专家共识的软件规模。
团队估算法：类似与Delphi法，但是形式比较松散，参与评估的团队成员包括项目组的各个角色，大家一起对某一个功能点提出自己的估计值，如果比较接近则计算一个平均值作为估算值；如果差别比较大，则由每个人发表意见说明自己的评估理由，然后进行第二轮评估，直到评估值比较接近。
计划扑克：Delphi法的一种演变。敏捷扑克的每种花色均是一组13张牌组成的估算扑克牌，牌正面上印刷有供估算用的数字与符号，数字分别是1/2，1~10和20，符号为“！”，代表一些未知情况，如无法提供准确估算值等。一般我们推荐4到8人参与估算；人数太少，会使估算结果偏差很大，人数太多，会拉长估算时间，降低估算效率。估算时，我们经常会估算相对值，而不是绝对值。注意不要深入研究代码编写细节，这些是实际开发是再去解决的问题。一般情况下，最多3轮就可以得出一个比较统一的意见。如果3轮之后依然没有得到一个统一的意见，比如第四轮出牌结果依然是2，5，5，8；那么Scrum 
 Muster应当立即中断该条目的估算，取平均值或其他大家比较能接受的值作为估算结果。没有任何一种估算是高可靠度的，扑克也不例外，扑克估算的目的就是为了能够在一个尽可能短的时间内，让团队成员更加多的了解需要做的工作，同时顺带得到一个可接受的估算结果。
其实每一种估算方法都仅仅是估算，估算的结果就可能是不准确的，所以首先不要有概念估算的结果和实际的结果一定是一致的。估算时项目经理要根据具体情况灵活运用各种估算方法，综合各种方法所长，让估算结果尽量接近实际值。


如何在需求不明确情况下进行工作量的评估？
给量级的评估，由于需求不明确，所以估计不可能准确，误差很可能比较大。
储备：储备要留足，需求越不明确储备越要多。
先总后分：需求不明确也要有一个限度，项目的整体范围，整体框架还是要确定了才能接手项目的。
接受计划改变的必然性，既然需求不明确，那么计划的改变可能性是非常大的，需要提前和相关各位沟通到位。
如何在跨部门情况下进行工作量的评估？
各个部门负责给出自己部分的工作量评估。
有专门的接口人负责协调资源，给出评估结果。
信任，很多时候我们并不了解对方的工作和流程，所以信任很重要。
信任的同时，尽可能多的了解对方的工作内容，积累经验，对未来的判断做准备。 
如何进行进度计划的安排？
理论基础：PDM(单代号网络图)，关键路径法和关键链法，时间提前量和滞后量。
具体步骤：

首先细分项目的每个功能点，针对功能点制定出我们需要进行的工作。
整理每项工作之间的逻辑关系，形成一个网络图。
评估每项工作的工作量。
安排每项工作对应的负责人。
根据具体负责人以及工作量调整网络图。
安排储备工作时间。
排出具体的进度计划
需求变更如何处理？
事前：

丑话当先，变更流程还是要有的。

变更流程可以分需求变更的规模，按大、中、小来区别对待，制定不同的流程。
事中：

执行过程中可能需要灵活应对了，对于需求的优先级和紧迫性需要有一个把握。不是不能变，但对流程还是要坚持的，否则乱了只能是自己。如果发布时间不能改变，需求又是一定要完成的，那我们就只能从其他方面来想办法了。这个可以参考六边形。
事后：

对人对事进行总结，未来对于类似的事情，相同的人，我们就需要更多的考虑需求变更的风险了。
对于前期需求不明确的项目如何控制需求范围？
前期需求的细节可以不清晰，但是整个项目的大范围需要确定。
项目的整体设计最好不要迭代，或者说不要做迭代的打算，一开始就对整体设计做一个统一的规划。
整体设计完成后，再对每个部分的功能分别来看。划分每个部分的系分功能点，各个功能点之间的优先级，是否需求已经明确，与其他功能点之间是否有关联等。
对已经比较清晰的功能点，并且与其他功能点之间的关联不是非常紧密的，先进行开发、测试。同时细化未清晰的功能点。
对于需求变更的控制重点把控。
这需要看项目经理的全局观，是否能对项目的整体设计，功能点间的关联关系有一个比较到位的把握。