大数据面试题

MySQL索引有哪些

1.普通索引index :加速查找 
2.唯一索引
主键索引:primary key :加速查找+约束(不为空且唯一)
唯一索引:unique:加速查找+约束 (唯一) 
3.联合索引 -primary key(id,name):联合主键索引 -unique(id,name):联合唯一索引 -index(id,name):联合普通索引
4.全文索引fulltext :用于搜索很长一篇文章的时候，效果最好。 
5.空间索引spatial :了解就好，几乎不用

压缩

在hadoop中使用lzo的压缩算法可以减小数据的大小和数据的磁盘读写时间，不仅如此，lzo是基于block分块的，这样他就允许数据被分解成chunk，并行的被hadoop处理。这样的特点，就可以让lzo在hadoop上成为一种非常好用的压缩格式。

HDFS读写流程

1.1.1 写数据流程
1. 客户端发出请求 hdfs dfs -put /etc/profile /qf/data
2. namenode查看维护的目录结构，检查/qf/data是否存在，如不存在直接报错”no such file or directory“，如存在返回给客户端同意上传文件请求，将操作写入日志文件
3. 客户端请求上传第一个块，询问namenode块的存储位置
4. namenode查看自己的datanode池，返回给客户端一个datanode列表
5. 客户端发出请求建立pipeline
6. 客户端先把文件写入缓存，达到一个块的大小时,会在客户端和第一个datanode建立连接开始流式的传输数据，这个datanode会一小部分一小部分(4K)的接收数据然后写入本地仓库，同时会把 这些数据传输到第二个datanode，第二个datanode也同样一小部分一小部分的接收数据并写入本 地仓库，同时传输给第三个datanode... (在流式复制时，逐级传输和响应采用响应队列来等待传输 结果。队列响应完成后返回给客户端)
7. 第一个数据块传输完成后会使用同样的方式传输下面的数据块直到整个文件上传完成。 
8. 整个文件完成，namenode更新内存元数据
1.1.2 读数据流程
1. 客户端向namenode发起RPC调用，请求读取文件数据。
2. namenode检查文件是否存在，如果存在则获取文件的元信息(blockid以及对应的datanode列表)。
3. 客户端收到元信息后选取一个网络距离最近的datanode，依次请求读取每个数据块。客户端首先要校检文件是否损坏，如果损坏，客户端会选取另外的datanode请求。
4. datanode与客户端建立socket连接，传输对应的数据块，客户端收到数据缓存到本地，之后写入文件。
5. 依次传输剩下的数据块，直到整个文件合并完成。

Spark的持久化机制和检查点，区别是什么，应用场景？

3.6 持久化(重点)
spark通过catch和persist方法对结果进行一个持久化，persist方法共有5个参数，对应12个缓存级别， 这12个级别分别从磁盘存储、内存存储、堆外内存存储、是否反序列化和备份数五个角度设定。其中 catch使用的是Memory_Only，只在内存持久化。
3.7 检查点(重点)
spark通过checkPoint方法将RDD状态保存在高可用存储中，与持久化不同的是，它是对RDD状态的一 个复制持久化，执行checkPoint后不再保存依赖链。此外，持久化存储的缓存当程序运行结束后就会被 自动删除，检查点保存的RDD状态只能手动清理。

Yarn的提交工作原理？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rKSe2AtO-1670548055438)(/Users/wyh/Library/Application Support/typora-user-images/image-20220928082038353.png)]

Hive的内部表和外部表的区别？

hive外部表是使用external关键字并指定一个hdfs目录创建的表。 
hive内部表在创建时会在对应hive目录下创建相应的文件夹，外部表则以指定文件夹为数据源创建表。 
hive内部表在删除时会将整个文件夹一并删除，外部表则只会删除元数据。

Hive的OrderBy和SortBy区别？

12.1 order by
需要加载所有数据到reduce中排序，排序方法可能是冒泡、快排、归并，无论如何都要加载所有数据
12.3 sort by
局部排序，最终生成的每个文件都有序但不能保证全局有序

Flume会不会发生数据重复，解释说明？

会，我们在获取Channel批次数据的时候，每个批次是基于一个事务性的，一旦发生宕机或者Flume进 行挂掉，那么就会回滚，数据写入失败，下次再重启写入时候数据就重复.

Flume拦截器分为那些？

Source 将 Event 写入到 Channel 之前可以使用拦截器对 Event 进行各种形式的处理，Source 和 Channel 之间可以有多个拦截器，不同拦截器使用不同的规则处理 Event，包括时间、主机、UUID、 正则表达式等多种形式的拦截器。

Sqoop增量导入和全量导入的区别？

全量全部数据覆盖导入，增量是按照条件进行append追加，一般使用job方式记录last-value，全量一般是做少量更新数据的表，增量一般是做大数据量更新的表

数仓与数据库的区别？

操作上:数据库是面向事务的，往往是行级操作;数仓则是面向分析的，往往是范围操作 
功能上:数据库提供即时的增删改查，数仓则寻求的是分析数据提供决策支持 
设计上:数据库基于ER模型，面向业务;数仓基于星型/雪花模型，面向主题 
数据上:数据库只保存最新的、近期的数据;数仓则保存所有数据 
性能上:数据库往往依靠索引快速返回;数仓则往往需要大范围磁盘扫描 
数据量:数据库数据一般为GB 级别，数仓的数据则往往上百TB 
响应速度:数据库是毫秒级，数仓任务的执行时间往往数小时 
存储上:数据库是真实的物理存储，数仓则是逻辑存储。

Spark的累加器是什么？如何应用？

spark提供了一个累加器用于在整个流程中额外执行一个MR任务，它可以在driver端被初始化发送给各个Task，然后在每个Task中为它添加数据，最终经过reduce将结果聚合后返回driver端。可以自定义累加器的类型，通过实现一个聚合方法来创建自定义累加器。除此之外spark2还支持特殊的累加器-收集器，它不需要执行reduce，会将数据原原本本存放在集合中返回。 注意:如果累加操作在transform算 子并且action算子有多个时，需要catch该转换算子，否则可能造成重复累加。

Redis的持久化策略？

RDB持久化
符合一定条件时redis会将内存中所有数据以二进制方式生成一份副本存储到硬盘上(快照)，redis重启时可以通过该副本恢复数据，生成快照时redis进入阻塞状态。
AOF持久化
redis将日志追加到磁盘文件中，redis启动时优先选择从AOF文件恢复数据。由于每次写操作都会记录 日志，因此AOF会降低性能，但比起RDB的一次性阻塞式备份数据，AOF消耗的内存和资源更少。 AOF 文件达到阀值时(或执行bgrewriteaof命令)，会重写一次AOF文件，将每个Key只保留最新的value的 日志
混合持久化
开启混合持久化后，redis按照正常RDB快照规则生成快照文件，在两次快照期间则通过AOF追加日志到 RDB数据后面，因此最终生成的AOF文件是一个以RDB数据开头，多个日志操作结尾的文本文件，新产生的AOF文件会直接覆盖旧的AOF文件。 优点:兼具了RDB加载快、数据量小和AOF数据高安全性(日 志)的优点，而且也不需要重写过程了。 缺点:redis4之前的版本不识别混合AOF文件。

Redis的数据类型？

String、hash、list、set、sorted set

Spark的RDD、算子分类？

Transformation（转换）算子概述

RDD中的所有转换都是延迟加载的，也就是说，它们并不会直接计算结果。相反的，它们只是记住这些应用到基础数据集（例如一个文件）上的转换动作。只有当发生一个要求返回结果给Driver的动作时，这些转换才会真正运行。这种设计让Spark更加有效率地运行。

列举部分算子：

转换	含义
map(func)	返回一个新的RDD，该RDD由每一个输入元素经过func函数转换后组成
filter(func)	返回一个新的RDD，该RDD由经过func函数计算后返回值为true的输入元素组成
flatMap(func)	类似于map，但是每一个输入元素可以被映射为0或多个输出元素（所以func应该返回一个序列，而不是单一元素）
mapPartitions(func)	类似于map，但独立地在RDD的每一个分片上运行，因此在类型为T的RDD上运行时，func的函数类型必须是Iterator[T] => Iterator[U]
mapPartitionsWithIndex(func)	类似于mapPartitions，但func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Iterator[T]) => Iterator[U]
sample(withReplacement, fraction, seed)	根据fraction指定的比例对数据进行采样，可以选择是否使用随机数进行替换，seed用于指定随机数生成器种子
union(otherDataset)	对源RDD和参数RDD求并集后返回一个新的RDD
intersection(otherDataset)	对源RDD和参数RDD求交集后返回一个新的RDD
distinct([numTasks]))	对源RDD进行去重后返回一个新的RDD
groupByKey([numTasks])	在一个(K,V)的RDD上调用，返回一个(K, Iterator[V])的RDD
reduceByKey(func, [numTasks])	在一个(K,V)的RDD上调用，返回一个(K,V)的RDD，使用指定的reduce函数，将相同key的值聚合到一起，与groupByKey类似，reduce任务的个数可以通过第二个可选的参数来设置,在shuffle之前有预聚合
aggregateByKey(zeroValue)(seqOp, combOp, [numTasks])	相同的Key值进行聚合操作，在聚合过程中同样使用了一个中立的初始值zeroValue:中立值,定义返回value的类型，并参与运算seqOp:用来在同一个partition中合并值combOp:用来在不同partiton中合并值
sortByKey([ascending], [numTasks])	在一个(K,V)的RDD上调用，K必须实现Ordered接口，返回一个按照key进行排序的(K,V)的RDD
sortBy(func,[ascending], [numTasks])	与sortByKey类似，但是更灵活
join(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个相同key对应的所有元素对在一起的(K,(V,W))的RDD
cogroup(otherDataset, [numTasks])	在类型为(K,V)和(K,W)的RDD上调用，返回一个(K,(Iterable,Iterable))类型的RDD
cartesian(otherDataset)	笛卡尔积
pipe(command, [envVars])	将一些shell命令用于Spark中生成新的RDD
coalesce(numPartitions**)**	重新分区
repartition(numPartitions)	重新分区
repartitionAndSortWithinPartitions(partitioner)	重新分区和排序

Action（行动）算子概述

在RDD上运行计算,并返回结果给Driver或写入文件系统

动作	含义
reduce(func)	通过func函数聚集RDD中的所有元素，这个功能必须是可交换且可并联的
collect()	在驱动程序中，以数组的形式返回数据集的所有元素
count()	返回RDD的元素个数
first()	返回RDD的第一个元素（类似于take(1)）
take(n)	返回一个由数据集的前n个元素组成的数组
takeSample(withReplacement,num, [seed])	返回一个数组，该数组由从数据集中随机采样的num个元素组成，可以选择是否用随机数替换不足的部分，seed用于指定随机数生成器种子
takeOrdered(n, [ordering])	takeOrdered和top类似，只不过以和top相反的顺序返回元素
saveAsTextFile(path)	将数据集的元素以textfile的形式保存到HDFS文件系统或者其他支持的文件系统，对于每个元素，Spark将会调用toString方法，将它装换为文件中的文本
saveAsSequenceFile(path)	将数据集中的元素以Hadoop sequencefile的格式保存到指定的目录下，可以使HDFS或者其他Hadoop支持的文件系统。
saveAsObjectFile(path)
countByKey()	针对(K,V)类型的RDD，返回一个(K,Int)的map，表示每一个key对应的元素个数。
foreach(func)	在数据集的每一个元素上，运行函数func进行更新。

Kafka的分区分配策略

1)random(随机):随机分配数据，会导致数据倾斜 
2)RoundRobin(轮询):将Topic中的每个分区以轮询的方式发送给消费者线程进行消费 
3)指定分区

Kafka丢不丢数据（Ack应答机制）？

我们公司设置ack为-1，并且设置ISR队列中必须至少有两个kafka服务节点(默认ISR队列只有一个Leader，因为这种情况相当于ack等于1)，以此来保证可靠性
ack = 0 ，生产者发送完数据就不管了，数据可能会丢
ack = 1，生产者发送数据，Leader也接收到了数据，写入了磁盘，但还未来得及同步数据到其它 节点，Leader就宕机了，此时数据会丢
ack = -1，生产者发送数据，Leader接收数据并写入磁盘，也进行了副本同步，若此时Leader宕 机，可能发生重复消费，数据可能会重复

Kafka的ISR作用（副本同步策略）？

ISR中包括Leader和Follower，若Leader进程挂掉，controller会在ISR队列中选择一个服务作为新的Leader(该队列的作用就是选举老大) 
有两个参数决定一台kafka服务是否能加入ISR队列:延迟时间和延迟条数。在0.10版本移除了延迟条数，防止kafka服务频繁的进出ISR队列

数仓的数据模型？

星型模型
数仓(具体说是dwd层)中只有一张包含历史数据且不冗余的事实表和一组附属维度表，每个维度一张。事实表与维度表之间通过外键和主键关联。 星型模型的维度表可能存在冗余，因此是反三范式的， 这种模型在数据维护上较麻烦，但是性能更高，业界普遍使用星型模型。 星型模型的难点在于拉链表的维护，拉链表一般不能有冗余。
雪花模型
针对星型模型的维度表进行扩展的模型，将维度表拆解成维度表+说明表，说明表又可以进一步拆分， 最终形成事实表-维度表-说明表的多次连接。 雪花模型的表一般遵循三范式，在数据的维护上会很方便，但是多表join影响性能。
星系模型
多个事实表采用星型模型共享维度表，就形成了一个星系。

数仓架构有哪些？分别说明

inmon架构
自上而下的开发模式，从多个数据源出发，根据需求将不同数据源的数据经过ETL过程获取到各个主题 需求的数据集成到数仓中，完成了数据治理后再进行统计业务，将统计结果存入数据集市。
kimball架构
自下而上的开发模式，往往已经存在某个关系明确的业务数据库，架构师需要根据数据库中的数据寻找出有价值的分析指标，然后根据这些指标建立数据集市，再从数据集市出发向下建设需要的数据仓库表。

Spark的内存模型有哪些？分别说明

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-40IYmMzW-1670548055440)(/Users/wyh/Library/Application Support/typora-user-images/image-20221006140340118.png)]

executor的内存分为4+1块:
Execution:计算用内存，用于执行各种算子时存放临时对象的内存
Storage:缓存用内存，主要存储catch到内存中的数据,广播变量也存在这里
User Memory:用户用内存，存储RDD依赖关系等RDD的信息
Reserved Memory:预留内存，用来存储Spark自己的对象
Off-heap Memory:堆外内存，开启之后计算和缓存的内存都分别可以存在堆外内存。堆外内存不受 spark GC的影响。
Execution和Storage采用联合内存机制，可以互相借用对方的内存区域，但是Execution可以强制征收 Storage的内存，反过来不行。
Task共用executor的内存区域，spark准备了一个hashMap用来记录各个task使用的内存，task申请新 的内存时，如果剩余内存不够则会阻塞直到有足够的内存为止。每个task至少需要1/2N的内存才能被启 动。

Kafka数据积压怎么办？

1)提升消费者组中的消费者数以及Topic中的分区数，让二者相等，我们公司设置为3个分区 =3CPU 
2)提高消费者拉取数据的能力，比如Flume每次拉取的数据可以由1000条改为3000条、Spark中将限流的参数增大、Flink中保证数据的处理效率等

Kafka中的数据是有序的吗？

单分区内有序，分区间无序。如果想让数据有序，可以在生产者生产数据时指定key，让相同的key 进入同一个分区中，因为单分区内有序，所以我们在实际开发中用库名+表名作为key值，以此来保证一 张表中的数据有序

Spark数据倾斜调优方案？

比起hive来说，spark对数据倾斜的优化可以更细一些(也可以说更麻烦些)。
1. 先用sample(false,0.x)采样key，找出倾斜的key
2. 把数据集拆成倾斜的部分和不倾斜的部分，不倾斜的部分走正常流程
3. 倾斜的部分key前面加上一个定长的随机字符串，然后执行重分区
4. 重分区后进行一个聚合操作，然后去除定长前缀再聚合一次。
5. 如果是大表join大表，其中一个表有数据倾斜，就需要用膨胀法，将倾斜部分的key加上一个0-n的前缀，一条数据膨胀成n条，然后将另一个表的这部分key也加上相应的前缀，然后单独对这部分数据进行一次双重聚合，与不倾斜的数据进行union操作，完成聚合。
6. 空值看作是特殊的key，空值多了一样用3的方法去解决。

SparkSQL的DF和DS是什么？

DataFrame = DataSet[Row] DataSet是强类型JVM object的集合，DataFrame则是由每行弱类型的JVM object组成，二者都是按列存储，前者是结构化数据集，后者则是半结构化数据集

SparkSQL的自定义函数？

spark支持三种自定义函数，UDF、UDAF(用户自定义聚合函数)、UDTF(用户自定义生成函数)
UDAF和UDTF都需要继承对应的自定义函数类，实现相应的抽象方法才可以使用 UDF则可以在spark.udf.register方法中使用函数直接注册使用。

SparkShuffle有哪些？

1.1.1 SortShuffle
1. mapTask将map(聚合算子)或array(join算子)写入内存
2. 达到阀值发生溢写，溢写前根据key排序，分批写入磁盘，最终将所有临时文件合并成一个最终文
件，并建立一份索引记录分区信息。一个mapTask最终形成一个文件。
3. reduceTask拉取各个task中自己的分区数据去计算。
1.1.2 和hadoop shuffle的区别
1. MR没有所谓的DAG划分，一次MR任务就意味着一次shuffle;spark则是RDD驱动的，行动算子触 发时才会按宽窄依赖划分阶段，只有宽依赖才会发生shuffle
2. MR在reduce端还会进行一次合并排序，spark则在map端就完成了排序，采用Tim-Sort排序算法
3. MR的reduce拉取的数据直接放磁盘再读，spark则是先放内存，放不下才放磁盘
4. MR在数据拉取完毕后才开始计算，spark则是边拉边计算(reduceByKey原理)
5. 基于以上种种原因，MR自定义分区器时往往还需要自定义分组，spark则不需要(或者说map结构已经是自定义分组了)。


1.未经优化的HashShuffleManager下一个stage有n个task，则该stage的有m个task都生成n文件，在落盘时会生成nm个文件，大量小文件性能效率差
2.优化的HashShuffleManager一个Excutor里面的同stage的task共用一个buffler内存，在shuffle过程中，task就不用为下游stage的每个task创建一个磁盘文件了，而是允许使用不同的task共用同一批磁盘文件，在一定程度上可以将多个task的磁盘文件合并，减少磁盘文件数量，数量为 excutor的核数乘以下一级stage的task数量
3.SortShuffleManager 每个Task数据会先写入到一个内存数据结构中，此时根据shuffle的算子的不同，采用不同的数据结构，比如reduceByKey采用的时map的结构，join这种直接放在Array数据结构中，每一条数据直接进入内存数据结构中，会判断是否到达刷写阈值，到达后会将内存中的数据排序，排序后分批将数据写到磁盘中，批次大小默认为10000，多次溢写操作产生多个文件，最后会将这些这些临时文件merge只剩下一个文件，该文件保存着下个stage的所有task的数据，所以还会单独写一份索引文件，表示了每个task的起始数据位置
4.bypass 与未优化的hashShuffleManager一样，只是在最后会合并成一个磁盘文件，合并过程与sortShuffleManager一样，但是不排序
触发条件：
1.shuffle map task 数量小于 spark.shuffle.sort.bypassMergeThreshold参数的值
2、不是聚合类的shuffle算子（比如reduceByKey）。因为不像第3种机制那样会对聚合类算子以map的数据结构存储，在写的过程中会先进行局部聚合。

Hive的文件存储格式有那些？区别是什么？

一般选择ORC+bzip/gzip作为数据源的存储，选择则ORC+Snappy作为中间数据的存储分区表单文件不大可以采用gzip压缩，桶表需要用bzip或lzo支持分片的方式压缩

Hive的开窗排名函数有哪些？

row_number 不并列不跳过: 1 2 3 4 dense_rank 并列不跳过: 1 1 2 3 rank 并列跳过: 1 1 3 4

Hive的分区和分桶关系？

6.1 分区表
将数据按照分区字段拆分存储的表，在hdfs中以文件夹的形式分别存放不同分区的数据，可以避免全表查询，提高查询效率。
6.3 分桶表
根据分桶字段hash值分组拆分数据的表，在hdfs中表现为将单个的数据文件拆分为多个文件。
6.4 总结
分区字段的每个值都对应一个文件夹和一个分区文件，而分桶字段则是多个值对应一个桶文件。如果同时使用分区和分桶，则会先按照分区划分文件，再对每个文件按照分桶进行拆分。

Hive数据倾斜

一、Hive倾斜之group by聚合倾斜
二、Hive倾斜之Map和Reduce优化
原因1：当出现小文件过多，需要合并小文件。可以通过set hive.merge.mapredfiles=true来解决；
原因2：输入数据存在大块和小块的严重问题，比如 说：一个大文件128M，还有1000个小文件，每 个1KB。 解决方法：任务输入前做文件合并，将众多小文件合并成一个大文件。通过set hive.merge.mapredfiles=true解决；
原因3：单个文件大小稍稍大于配置的block块的大小，此时需要适当增加map的个数。解决方法：set mapred.map.tasks的个数；
原因4：文件大小适中，但是map端计算量非常大，如：select id,count(*),sum(case when…),sum(case when …)…需要增加map个数。解决方法：set mapred.map.tasks个数，set mapred.reduce.tasks个数；
三、Hive倾斜之HQL中包含count(distinct)时
四、Hive倾斜之HQL中join优化

Hive 调优有哪些？

减少distinct：使用distinct容易造成数据倾斜问题，使用group by的子查询代替它。
map任务数量优化：
实际业务中往往存在大量的分区表，每个分区表都实际存储一定量的文件，其中必然有些分区的数据量
很少。正常读取时往往有多少个文件就创建多少个map，此时可以通过设置一些参数，让sql语句在执
行前先合并表文件。 -参数： mapred.min.split.size.per.node = {设置一个节点中分片至少的大小}byte
mapred.min.split.size.per.rack= {设置一个交换机中分片至少的大小}byte mapred.max.split.size =
{设置分片的最太小}byte.hive.input.format=org.apache.hadoop.hive.ql.io.CombineHiveInputFormat 设置hive先合并文件再
执行 -效果： 假设我全部设置为100000000（相当于100M），经过配置后，hive会首先合并文件，切
分成各种100M，最后再把剩下来的各个节点上的散碎数据合并到一起再生成几个分片。 还有一种情
况，当一个map任务中处理数据量很大时（大小很小，但是条数很多），可以采用分桶法，先用一个查
询语句把该表数据查出来分桶写入，再使用这个分桶表。相当于增加map任务数量，增加并行度。
并行度优化： 1.手动设置reduce数量 mapred.reduce.tasks 2.避免全局的聚合函数，使用聚合函数尽
量要分组 3.避免全局的order by，有时候全局排序很难避免，但可以根据topN需求，再各个分区中只
留下N个值，再进行全局排序。 4.避免笛卡尔积 5.设置mapTask分片大小
小文件问题： 1.避免产生小文件：少用动态分区、根据需求使用reduce 2.使用Sequencefile作为表存
储格式，不要用textfile，在一定程度上可以减少小文件 3.使用hadoop archive命令把小文件进行归档
4.重建表，建表时减少reduce数量 5.参数设置： hive.merge.mapfiles = true 设置map端输出合并
hive.merge.mapredfiles = true 设置reduce输出合并 hive.merge.size.per.task = 25610001000 设置
合并文件的大小 hive.merge.smallfiles.avgsize=16000000 设置当平均大小小于该值时合并
存储格式 1.使用ORCfile存储，可以显著提高join操作的查询速度 2.使用压缩格式存储，可以显著降低
网络IO和存储大小
使用map端join
使用tez作为默认引擎
使用向量化查询：一次执行1024行数据的操作 hive.vectorized.execution.enabled = true;
hive.vectorized.execution.reduce.enabled = true;
设置本地模式、并行模式（自动并行非依赖阶段）、严格模式
开启JVM重用

减少distinct 
设置读取时合并小文件和合理拆分大文件 
优化并行度 
设置存储格式和压缩格式 
设置输出时合并小文件 
设置map端JOIN 
更换引擎 
设置本地模式、并行模式、严格模式 
开启JVM重用 开启推测执行

Kafka的Segment是什么？里面包含什么？

一个partition当中有多个segment文件组成，每个segment文件，包含两部分，一个是.log文件，另外一个是.index文件，其中.log文件包含了我们发送的数据存储，.index文件，记录的是我们.log文件的数据索引值，以便于我们加快数据的查询速度

Kafka架构？

生产者、Broker主机节点、消费者、Zookeeper保存Broker id和消费者offsets信息

Spark的DAG是什么，说明其功能？

ClickHouse表引擎有哪些，详细介绍一下MergeTree引擎

Log系列表引擎:TinyLog.StripLog.Log

MergeTree在写入一批数据时，数据总会以数据片段的形式写入磁盘，且数据片段不可修改。为了避免片段过多，ClickHouse会通过后台线程，定期合并这些数据片段，属于相同分区的数据片段会被合成一个新的片段。这种数据片段往复合并的特点，也正是合并树名称的由来。

MergeTree作为家族系列最基础的表引擎，主要有以下特点：

- 存储的数据按照主键排序：允许创建稀疏索引，从而加快数据查询速度
- 支持分区，可以通过PRIMARY KEY语句指定分区字段。
- 支持数据副本
- 支持数据采样

引擎分类	引擎名称
MergeTree系列	MergeTree 、ReplacingMergeTree 、SummingMergeTree 、 AggregatingMergeTree CollapsingMergeTree 、 VersionedCollapsingMergeTree 、GraphiteMergeTree
Log系列	TinyLog 、StripeLog 、Log
Integration Engines	Kafka 、MySQL、ODBC 、JDBC、HDFS
Special Engines	Distributed 、MaterializedView、 Dictionary 、Merge 、File、Null 、Set 、Join 、 URL View、Memory 、 Buffer

ClickHouse位图函数和行列转换函数分别是什么？

#### 4.1.9 位图函数

**bitmapBuild** 
从无符号整数数组构建位图对象。

~~~sql
SELECT bitmapBuild([1, 2, 3, 4, 5]) AS res
~~~

**bitmapToArray** 
将位图转换为整数数组。

~~~sql
SELECT bitmapToArray(bitmapBuild([1, 2, 3, 4, 5])) AS res
~~~

**bitmapSubsetInRange** 
将位图指定范围（不包含range_end）转换为另一个位图。

~~~sql
SELECT bitmapToArray(bitmapSubsetInRange(bitmapBuild([25,26,27,28,29,30,31,32,33,100,200,500]), toUInt32(30), toUInt32(200))) AS res
~~~

**bitmapContains** 
检查位图是否包含指定元素。

~~~sql
SELECT bitmapContains(bitmapBuild([1,5,7,9]), toUInt32(9)) AS res
~~~

**bitmapHasAny** 
与hasAny(array，array)类似，如果位图有任何公共元素则返回1，否则返回0。
对于空位图，返回0。

~~~sql
SELECT bitmapHasAny(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res
~~~

**bitmapHasAll** 
与hasAll(array，array)类似，如果第一个位图包含第二个位图的所有元素，则返回1，否则返回0。
如果第二个参数是空位图，则返回1。

~~~sql
SELECT bitmapHasAll(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res
~~~

**bitmapAnd**
为两个位图对象进行与操作，返回一个新的位图对象。

~~~sql
SELECT bitmapToArray(bitmapAnd(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res
~~~

**bitmapOr**
为两个位图对象进行或操作，返回一个新的位图对象。

~~~sql
SELECT bitmapToArray(bitmapOr(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res
~~~

**bitmapXor** 
为两个位图对象进行异或操作，返回一个新的位图对象。

~~~sql
SELECT bitmapToArray(bitmapXor(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res
~~~

**bitmapAndnot** 
计算两个位图的差异，返回一个新的位图对象。

~~~sql
SELECT bitmapToArray(bitmapAndnot(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res
~~~

**bitmapCardinality** 
返回一个UInt64类型的数值，表示位图对象的基数。

~~~sql
SELECT bitmapCardinality(bitmapBuild([1, 2, 3, 4, 5])) AS res
~~~

**bitmapMin** 
返回一个UInt64类型的数值，表示位图中的最小值。如果位图为空则返回UINT32_MAX。

~~~sql
SELECT bitmapMin(bitmapBuild([1, 2, 3, 4, 5])) AS res
~~~

**bitmapMax** 
返回一个UInt64类型的数值，表示位图中的最大值。如果位图为空则返回0。

~~~sql
SELECT bitmapMax(bitmapBuild([1, 2, 3, 4, 5])) AS res
~~~

**bitmapAndCardinality**
为两个位图对象进行与操作，返回结果位图的基数。

~~~sql
SELECT bitmapAndCardinality(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res;
~~~

**bitmapOrCardinality** 
为两个位图进行或运算，返回结果位图的基数。

~~~sql
SELECT bitmapOrCardinality(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res;
~~~

**bitmapXorCardinality** 
为两个位图进行异或运算，返回结果位图的基数。

~~~sql
SELECT bitmapXorCardinality(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res;
~~~

#### 


#### 4.1.8 行列转换函数

~~~sql
create table tb_array_join(id Int8 , msg String) engine=TinyLog ;
insert into tb_array_join  values (1, 'a,b,c') ;
insert into tb_array_join  values (2, 'h,j,k') ;
---------------------------------行转列
select id, arrayJoin(splitByChar(',',msg)) from tb_array_join;
SELECT id, arrayJoin(splitByChar(',', msg)) FROM tb_array_join;

ClickHouse的数据类型有哪些？

基础类型只有数值(整数.浮点数)、字符串(变长字符串.定长字符串FixedString)、时间三种类型(DateTime、DateTime64、Date)，没有Boolean类型，但可以使用整型的0或1替代。

Zookeeper 选举机制

1. 各节点会先选自己作为leader，然后将选票携带事务id:zxid发送出去
2. 各节点拿到选票后，先排除非本轮的票，然后比对自己的选票跟各个节点发来的选票，先比较zxid（越大说明数据越新），相同时比较myid，大的一方获胜，将票投给获胜方，然后各自发回节点。（假如自己是1节点，3节点发来的票，比对后要么返回1要么返回3） 
3. 投票后，各个节点会统计投票信息，判断如果有过半选票则认为选出了leader，更新自身状态为follow或leader，如果没有则一直重复2直到满足条件为止。
4. 选举出leader后，新节点或原leader节点宕机恢复后，会直接变为follow状态，不再进行选举。

SparkOnHive与HiveOnSpark如何实现，区别是什么？

1、Spark on Hive

数据源是：hive，Spark 获取hive中的数据，然后进行SparkSQL的操作  （hive只是作为一个spark的数据源）。

spark on hive 是spark 通过spark-sql 使用hive 语句操作hive ,底层运行的还是 spark rdd.
*（1）就是通过sparksql，加载hive的配置文件，获取到hive的元数据信息
* （2）spark sql获取到hive的元数据信息之后就可以拿到hive的所有表的数据
* （3）接下来就可以通过spark sql来操作hive表中的数据

2、Hive on Spark

（数据源是hive本身）   Hive 将自己的MapReduce计算引擎替换为Spark，当我们执行HiveSQL(HQL)时底层以经不是将HQL转换为MapReduce任务，而是跑的Spark任务（即：将HQL转换为Spark任务）。

hive on spark是hive 等的执行引擎变成spark , 不再是mapreduce. 

Spark On Yarn工作原理？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iVc34OfT-1670548055440)(/Users/wyh/Library/Application Support/typora-user-images/image-20221010083126313.png)]

1. 客户端向yarn的RM申请启动AM，同时在自身的sparkContext中创建DAGScheduler和 TASKScheduler（创建driver） 2. 按照正常Yarn流程，一个NM领取到AM任务作为AM与客户端的driver产生连接（在yarn-cluster中该AM直接作为driver而不是连接driver） 3. driver根据任务信息通过AM向RM申请资源（计算容器）
4. AM通知领取到任务的NM向driver的sparkContext反注册并申请Task
5. driver的sparkContext分配Task给各个计算节点，并随时掌握各个任务运行状态
6. 应用程序运行完成后，sparkContext向RM申请注销并关闭自己。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GMaT9ryk-1670548055441)(/Users/wyh/Library/Application Support/typora-user-images/image-20221010083229099.png)]

1. 先将driver作为一个AM在一个NM中启动
2. 由AM创建应用程序，走正常的yarn流程启动Executor运行Task，直到运行完成

Spark任务提交工作原理？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CeJhJ3m9-1670548055441)(/Users/wyh/Library/Application Support/typora-user-images/image-20221010083356518.png)]

1. driver端:通过反射获取主类执行main方法 -> 创建sparkconf和sparkContext，创建通信环境、后端调度器（负责向master发送注册信息、向excutor发送task的调度器）、task调度器、DAG（根据宽窄依赖划分stage）调度器 ->封装任务信息提交给Master
2. Master端:缓存任务信息并将其放入任务队列 -> 轮到该任务时，调用调度方法进行资源调度 ->发送调度信息给对应的worker
3. Worker端:worker将调度信息封装成对象 -> 调用对象的start方法，启动excutor进程
4. Excutor进程:启动后向driver端反向注册(driver端拿到信息后注册excutor，向其发送任务) -> 创建线程池，封装任务对象 -> 获取池中线程执行任务 -> 反序列化TastSet，执行给定的各种算子步骤

Spark的优化

JVM的GC是什么？

JVM内存按回收机制可分为年轻代和老年代，年轻代分为eden区和多个幸存区，老年代则不分区。
无论是YGC还是Full GC，都会使java线程暂停，但是YGC暂停的事件极短，因此基本是针对减少Full GC
的方向优化。 可以通过参数指定分配的最大堆大小、初始堆大小、年轻代大小、比值、指定并发收集
器、并行收集器等等。
2.1 YGC
新的对象会存入eden区，当eden区满了放不下的时候，会对年轻代的内存进行垃圾回收，eden中有用
的对象移到幸存区，清空eden区，称为YGC。
2.2 Full GC
某个对象经过多次YGC后依然存活，会移植到老年代。当老年代满了放不下的时候，就会触发FullGC，
对整个内存进行一次垃圾回收。
无论是YGC还是Full GC，都会使java线程暂停，但是YGC暂停的事件极短，因此基本是针对减少Full GC
的方向优化。
可以通过参数指定分配的最大堆大小、初始堆大小、年轻代大小、比值、指定并发收集器、并行收集器
等等。
2.3 垃圾回收机制（算法原理）
引用计数法：对象每被引用一次就+1，为0时回收，速度很快但是无法识别循环引用
标记清除法：遍历所有对象，标记没被引用的，然后统一清除。缺点是效率低、清理后内存不连续。
复制清除法：将内存分为两块，其中一块写满后，遍历对象标记有用的对象复制到另一块，然后把这一
块清理，这样复制的内容很少而且内存始终连续，缺点是始终需要有一块内存空出来用于复制。
标记整理法：遍历出有用的对象，将这些对象全都向一端移动，然后清理其它空间，一样能腾出连续的
内存，但是移动对象的成本比复制大得多。
GC采用分代收集法：年轻代采用复制清除法，每当eden满时，就遍历出eden和幸存者1区的有用对象
复制到幸存者2区，然后清空重新写起。因此无论何时一定有一个幸存者区是空的。 老年代由于有用的
对象很多所以复制成本高，采用标记整理法减少复制。

数据仓库的数据发散如何产生的？如何解决？

Flink 状态存储？

Flink在做计算的过程中经常需要存储中间状态，来避免数据丢失和状态恢复。选择的状态存储策略不同，会影响状态持久化如何和 checkpoint 交互。Flink提供了三种状态存储方式：MemoryStateBackend、FsStateBackend、RocksDBStateBackend。

Flink 窗口？

会话 全局 滑动 滚动
Flink 支持两种划分窗口的方式，按照time和count。
如果根据时间划分窗口，那么它就是一个time-window 如果根据数据划分窗口，那么它就是一个count-window。
flink支持窗口的两个重要属性（size和interval）
如果size=interval,那么就会形成tumbling-window(无重叠数据)如果size>interval,那么就会形成
sliding-window(有重叠数据)如果size< interval, 那么这种窗口将会丢失数据。比如每5秒钟，统计
过去3秒的通过路口汽车的数据，将会漏掉2秒钟的数据。
通过组合可以得出四种基本窗口：
time-tumbling-window 无重叠数据的时间窗口，设置方式举例：timeWindow(Time.seconds(5))
time-sliding-window 有重叠数据的时间窗口，设置方式举例：timeWindow(Time.seconds(5),
Time.seconds(3))
count-tumbling-window无重叠数据的数量窗口，设置方式举例：countWindow(5)
count-sliding-window 有重叠数据的数量窗口，设置方式举例：countWindow(5,3)

Flink State分类？

State：指一个具体的Task/Operator的状态。State可以被记录，在失败的情况下数据还可以恢复，
Flink中有两种基本类型的State： Keyed State ， Operator State 。Sate在数据在容错恢复起了非常
关键的作用
Operator State
Task里面没有Shuffle操作的State，换句话说，就是没有keyBy操作
1. Operator State是Task级别的state，就是每个Task对应一个State
2. Kafka Connector Source中的每个分区（Task）都需要记录消费的Topic的Partition和Offset
等信息，这些信息就是state。
Keyed State
表示和Key相关的一种State，基于KeyedStream上的状态。Keyed State事先按照Key对数据集进
行了分区，每个Key State仅对应一个Operator和Key的组合。Keyed State可以通过Key Groups
进行管理，主要用于当算子并行度发生变化时，自动重新分布Keyed State数据。在系统运行过程
种，一个Keyed算子实例可能运行一个或者多个Key Groups 的 Keys

Flink checkpoint 和savepoint 区别？

Checkpoint 是为 runtime 准备的，Savepoint 是为用户准备的。Checkpoint 机制的目标在于保证
Flink 作业意外崩溃重启不影响 exactly once 准确性，通常用于系统容错。而 Savepoint 的目的在于在
Flink 作业维护（比如更新作业代码）时将作业状态写到外部系统，以便维护结束后重新提交作业可以
到恢复原本的状态。
Checkpoint 异常恢复，保证可用性，在任务发生故障时，为任务提供给自动恢复机制；
Savepoint 需手动备份、恢复暂停作业的方法。
Checkpoint 被设计成轻量和快速恢复数据的机制，Savepoint 更多地关注数据的可移植性，并支
持对作业做任何更改而状态能保持兼容
Checkpoint 是自动和定期的，它们由 Flink 自动地周期性地创建和删除，无需用户的交互。相
反，Savepoint 是由用户手动地管理（调度、创建、删除）的。

Flink的延迟数据如何处理？有哪些方案？

小延迟（乱序），用 watermark 容错（减慢时间的推进，让本已迟到的数据被认为没有迟到）
中延迟（乱序），用 allowLateness （允许一定限度内的迟到，并对迟到数据重新触发窗口计算）
大延迟（乱序），用 sideOutputLateData（将超出 allowLateness 的迟到数据输出到一个侧流中）

Flink 如何处理乱序事件？

Flink 使用Watermark 机制来处理乱序事件。我们知道，流处理从事件产生，到流经source，再到
operator，中间是有一个过程和时间的。虽然大部分情况下，流到operator的数据都是按照事件产生的
时间顺序来的，但是也不排除由于网络、背压等原因，导致乱序的产生(out-of-order或者说late
element),但是对于late element，我们又不能无限期的等下去，必须要有个机制来保证一个特定的时间
后，必须触发window去进行计，这个机制，就是watermark，它本质上就是一个时间戳。

Flink的Slot和Parallelism是什么？有什么关系？

Slot 是指 TaskManager 的并发执行能力，如果代码运行前我们将 slot 的个数配置为
3（taskmanager.numberOfTaskSlots） ，那么每个 TaskManager 会分配 3 个 Slot 来执行 task，如
果配置了 3 个 taskmanager 那么就如图一共有 9 个 Slot。

Parallelism 是指 TaskManager 在实际运行过程中的并发。默认并行度的配置为
1（parallelism.default），那么如图 9 个 Slot 只有一个是在工作的，其他 8 个都空闲。在用户开发的
过程中可以通过 setParallelism 方法给每个 Operators 算子配置并行度。

Flink的分布式缓存是什么？

Flink 提供了一个分布式缓存，类似于 hadoop，可以使用户在并行函数中很方便的读取本地文件，并把
它放在 taskmanager 节点中，防止 task 重复拉取。
此缓存的工作机制如下：程序注册一个文件或者目录(本地或者远程文件系统，例如 hdfs 或者 s3)，通
过 ExecutionEnvironment 注册缓存文件并为它起一个名称。
当程序执行，Flink 自动将文件或者目录复制到所有 taskmanager 节点的本地文件系统，仅会执行一
次。用户可以通过这个指定的名称查找文件或者目录，然后从 taskmanager 节点的本地文件系统访问
它。

Flink On Yarn分类，分别说明区别？

Flink的Standalone工作原理？