数据仓库岗面试

1.自我介绍

2.求用户连续登录3天，要讲出多种解法

解法1（使用SQL）：

SELECT
    userid
FROM
    loginrecord
WHERE
    DATEDIFF(day,time, LAG(time)OVER(PARTITIONBY userid ORDERBYtime))=1AND DATEDIFF(day, LAG(time)OVER(PARTITIONBY userid ORDERBYtime),TIME)=2;

解法2（使用Hive）：

SELECT
    userid
FROM(SELECT
            userid,time,
            LAG(time)OVER(PARTITIONBY userid ORDERBYtime)AS prev_time,
            DATEDIFF(day,time, prev_time)AS days_diff
        FROM
            loginrecord
    )AStempWHERE
    days_diff =1AND DATEDIFF(day, prev_time,TIME)=2;

解法3（使用Python）：

from datetime import datetime, timedelta

defis_continuous_login(login_records):
    user_login_days ={}for record in login_records:
        userid, time = record
        days_diff =(datetime.now()- datetime.strptime(time,"%Y-%m-%d")).days
        if userid notin user_login_days:
            user_login_days[userid]=[]iflen(user_login_days[userid])>0and days_diff ==1:
            prev_time = user_login_days[userid][-1][1]if days_diff ==1and(datetime.now()- datetime.strptime(prev_time,"%Y-%m-%d")).days ==2:returnTrue
        user_login_days[userid].append(time)returnFalse

login_records =[(1,"2022-01-01"),(1,"2022-01-02"),(1,"2022-01-03"),(1,"2022-01-04"),(2,"2022-01-01"),(2,"2022-01-02"),(2,"2022-01-03"),]print(is_continuous_login(login_records))

以上三种解法均可实现求用户连续登录3天的目的。

3.将数据表行转列

行转列通常使用以下方法：

1. 使用SQL查询实现行转列：SELECT column1 AS column1, column2 AS column2, column3 AS column3FROM your_tableGROUPBY column1, column2, column3;
2. 使用SAS编程实现行转列：data want; set your_table; transpose data = want; run;
3. 在ASP.NET中使用报表行转列：在Visual Studio中，创建一个新的报表项目，然后将数据源绑定到报表中。在设计器中，将“行”转换为“列”的方式有以下几种：> a. 使用“分组与排序”任务窗格对数据进行分组。> b. 使用“聚合”功能将数据按照指定的字段进行聚合。> c. 使用“交叉表”功能将数据行转换为列。
4. 使用MySQL实现行转列：SELECT column1 AS column1,SUM(IF(name2 ='yes',1,0))AS column2,SUM(IF(name3 ='yes',1,0))AS column3,SUM(IF(name4 ='yes',1,0))AS column4FROM your_tableGROUPBY column1;``````CREATEVIEW column_view ASSELECT column1, column2 AS column2, column3 AS column3, column4 AS column4 FROM your_table GROUPBY column1;
5. 使用Oracle实现行转列：SELECT column1 AS column1,SUM(IF(column2 ='yes',1,0))AS column2,SUM(IF(column3 ='yes',1,0))AS column3,SUM(IF(column4 ='yes',1,0))AS column4FROM your_tableGROUPBY column1;注意：具体实现行转列的方法和SQL语句取决于您的数据表结构和需求。在实际操作中，请根据实际情况调整相应的代码。

4.求两数之和，除了哈希之外的其他解法

一种简单的非哈希解法是使用双指针法。以下是Python代码示例：

defadd(a, b):
    result =[]
    carry =0
    p1, p2 =0,0while b !=0:
        x = a[p1]+ b[p2]+ carry
        carry = x //10
        result.append(x %10)

        p1 +=1
        p2 +=1while carry:
        result.append(carry %10)
        carry //=10return result

a =[1,2,3]
b =[4,5,6]print(add(a, b))# 输出：[5, 7, 9]

这种方法的时间复杂度为O(n)，其中n是两个数的长度。这里使用了Python列表来存储结果，你可以根据需要使用其他数据结构。

5.对scala的了解

Scala是一门多范式的编程语言，设计初衷是实现可伸缩的语言，并集成面向对象编程和函数式编程的各种特性。它运行在标准的Java平台上，可以与所有的Java类库无缝协作。

Scala的特点包括：

1. 面向对象：Scala是一种面向对象的语言，每个值都是对象，每个方法都是调用。举例来说，如果你执行1+2，则对于Scala而言，实际是在调用Int类里定义的名为+的方法。
2. 函数式编程：Scala也是功能完整的函数式编程语言。函数式编程以两大核心理念为指导：函数是一等公民；程序中的操作应该将输入值映射成输出值，而不是当场修改数据。即方法不应该有副作用。
3. 与Java的兼容性：Scala可以与Java无缝对接，其在执行时会被编译成JVM字节码，这使得其性能与Java相当。Scala可以直接调用Java中的方法、访问Java中的字段、继承Java类、实现Java接口。Scala重度复用并包装了原生的Java类型，并支持隐式转换。
4. 精简的语法：Scala的程序通常比较简洁，相比Java而言，代码行数会大大减少，这使得程序员对代码的阅读和理解更快，缺陷也更少。
5. 高级语言的特性：Scala具有高级语言的特定，对代码进行了高级别的抽象，能够让你更好地控制程序的复杂度，保证开发的效率。
6. 静态类型：Scala拥有非常先进的静态类型系统，Scala不仅拥有与Java类似的允许嵌套类的类型系统，还支持使用泛型对类型进行参数化，用交集（intersection）来组合类型，以及使用抽象类型来进行隐藏类型的细节。通过这些特性，可以更快地设计出安全易用的程序和接口。

总的来说，Scala是一门功能强大的编程语言，具有多种特点，能够满足不同开发需求。

6.求两数之和要用到Spark的什么算子？

在Spark中，求两数之和的算子是

+

运算符。如果你要在Spark中计算两个数列之间的和，可以使用

union

算子将两个数列合并，然后使用

map

算子对每个元素进行加法运算。以下是一个简单的例子：

from pyspark import SparkContext

# 创建两个数列
sc = SparkContext()
array1 =[1,2,3]
array2 =[4,5,6]# 将两个数列转换为RDD
rdd1 = sc.parallelize(array1)
rdd2 = sc.parallelize(array2)# 计算两数之和
rdd_sum = rdd1.union(rdd2).map(lambda x: x +1)# 获取结果
result = rdd_sum.collect()print(result)# 输出：[2, 3, 4, 5, 6, 7, 8, 9]

在这个例子中，我们首先创建了两个数列（array1和array2），然后将它们转换为Spark的RDD。接下来，我们使用

union

算子将两个RDD合并，然后使用

map

算子对每个元素进行加法运算。最后，我们使用

collect

方法将结果收集到一个数列中。

在Scala中，使用Spark求两数之和可以使用

reduce

算子。以下是一个示例：

importorg.apache.spark.SparkConf
importorg.apache.spark.api.java.JavaRDD
importorg.apache.spark.api.java.JavaSparkContext

object SparkSum {def main(args: Array[String]):Unit={val conf =new SparkConf().setAppName("SparkSum").setMaster("local")val sc =new JavaSparkContext(conf)val nums = sc.parallelize(Seq(1,2,3,4,5))val sum = nums.reduce((a, b)=> a + b)

    println("Sum: "+ sum)
    sc.close()}}

在这个示例中，我们首先创建了一个`SparkConf`对象，用于配置应用程序的名称和运行模式。然后，我们创建了一个`JavaSparkContext`对象，用于执行后续的操作。

接下来，我们使用`parallelize`算子将一个Seq对象转换为一个RDD。然后，我们使用`reduce`算子计算RDD中所有元素的和。最后，我们打印出计算结果并关闭`JavaSparkContext`。

7.数仓分层具体可分为哪些层？

数仓分层具体可分为以下几层：

1. ODS层（原始数据层）：存放原始的数据，直接加载原始日志、数据，数据保持原貌不作处理。

2. DWD层（明细数据层）：结构和粒度与原始数据表保持一致，对ODS层数据进行清洗（去除空值，脏数据，超过极限范围的数据），并进行轻度汇总。

3. DWS层（服务数据层）：以DWD层为基础，进行轻度汇总。一般聚集到以用户当日，设备当日，商家当日，商品当日等等的粒度。

4. ADS层（数据应用层）：为各种统计表提供数据，也有的地方把这层叫做APP层。

这些层次划分有助于对数据进行有系统的分析整理，便于进行联机分析处理（OLAP）和数据挖掘等操作。

8.ods到dwd层做了哪些处理？

数据从ODS层（Operational Data Store）到DWD层（Data Warehouse Detail）的主要处理包括：

1. 数据清洗：去除无效数据、处理异常值、填补缺失值等。
2. 数据转换：将ods层的数据按照预定的格式和标准进行转换，以便后续的分析和处理。
3. 数据合并：将来自不同源的数据进行整合，形成统一的数据存储。
4. 数据分区：根据业务需求，将数据按照时间、地域、产品等维度进行分区。
5. 数据压缩：对DWD层的数据进行压缩，以节省存储空间。
6. 数据建模：构建数据模型，为数据分析和报表提供支持。

这些处理步骤旨在提高数据质量、简化数据处理过程、降低数据存储成本，并为后续的数据分析和决策提供可靠的数据基础。

9.数据倾斜

 数据倾斜是指在分布式计算系统中，任务分配不均导致某些节点的负载过高，从而使得整个系统的性能受到影响。在大数据处理过程中，数据倾斜表现为以下几个方面：

1. 在Hadoop中，数据倾斜表现为有一个或几个Reduce任务卡住，进度停滞在99.99%，无法完成。同时，各种Container报错，OOM（内存溢出）等异常现象也会出现。异常的Reducer读写数据量极大，远超过其他正常Reducer。

2. 在Hive中，数据倾斜主要发生在SQL的Group By和Join On操作上，尤其是与数据逻辑关系密切的查询。

3. 在Spark中，数据倾斜包括Map阶段的倾斜和Reduce阶段的倾斜。Map阶段的倾斜表现为某些Mapper处理的数据量远大于其他Mapper，Reduce阶段的倾斜则与Hadoop类似，表现为某些Reducer任务进度滞后。

数据倾斜的原因主要有：

1. 负载均衡实施不佳：缓存数据在分布式节点间的分布不均，导致部分节点负担过重。

2. 聚合操作：如Group By、Join On等操作可能导致数据倾斜。

3. 空值产生的数据倾斜：空值在聚合操作中会被忽略，可能导致数据分布不均。

4. 数据量差异：不同数据源的数据量差异过大，导致部分任务处理的数据量过大。

解决数据倾斜的方法：

1. 调整任务数：根据数据量和节点性能，合理调整任务数，避免任务数过少或过多。

2. 数据预处理：对数据进行预处理，如过滤、去重、拆分等，减小数据倾斜的影响。

3. 修改SQL：优化SQL查询，如使用Map Join替代Reduce Join，避免使用Count(Distinct)等操作。

4. 子查询处理：对子查询结果进行去重处理，避免重复数据导致的倾斜。

5. 优化排序和选择：在查询中使用排序和选择操作，提高数据分布的均匀性。

6. 调整缓存策略：优化缓存数据分布，避免数据倾斜。