数据仓库岗面试

1.自我介绍

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

解法1（使用SQL）：

SELECT
    userid
FROM
    loginrecord
WHERE
    DATEDIFF(day, time, LAG(time) OVER (PARTITION BY userid ORDER BY time)) = 1
    AND DATEDIFF(day, LAG(time) OVER (PARTITION BY userid ORDER BY time), TIME) = 2;

解法2（使用Hive）：

SELECT
    userid
FROM
    (
        SELECT
            userid,
            time,
            LAG(time) OVER (PARTITION BY userid ORDER BY time) AS prev_time,
            DATEDIFF(day, time, prev_time) AS days_diff
        FROM
            loginrecord
    ) AS temp
WHERE
    days_diff = 1
    AND DATEDIFF(day, prev_time, TIME) = 2;

解法3（使用Python）：

from datetime import datetime, timedelta

def is_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 not in user_login_days:
            user_login_days[userid] = []
        if len(user_login_days[userid]) > 0 and days_diff == 1:
            prev_time = user_login_days[userid][-1][1]
            if days_diff == 1 and (datetime.now() - datetime.strptime(prev_time, "%Y-%m-%d")).days == 2:
                return True
        user_login_days[userid].append(time)
    return False

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 column3
   FROM
       your_table
   GROUP BY
       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 column4
   FROM
       your_table
   GROUP BY
       column1;
   

   CREATE VIEW column_view AS
       SELECT
           column1,
           column2 AS column2,
           column3 AS column3,
           column4 AS column4
       FROM
           your_table
       GROUP BY
           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 column4
   FROM
       your_table
   GROUP BY
       column1;
   

   注意：具体实现行转列的方法和SQL语句取决于您的数据表结构和需求。在实际操作中，请根据实际情况调整相应的代码。

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

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

def add(a, b):
    result = []
    carry = 0
    p1, p2 = 0, 0

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

        p1 += 1
        p2 += 1

    while carry:
        result.append(carry % 10)
        carry //= 10

    return 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算子。以下是一个示例：

import org.apache.spark.SparkConf
import org.apache.spark.api.java.JavaRDD
import org.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. 调整缓存策略：优化缓存数据分布，避免数据倾斜。