Spark SQL函数详解：案例解析(第8天)

已于 2024-06-30 11:58:29 修改
阅读量1.6k 收藏 37
点赞数 39
分类专栏： spark学习 文章标签： spark sql 学习 大数据 python
于 2024-06-20 07:15:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/syhiiu/article/details/139755888
版权

系列文章目录

1- Spark SQL函数定义（掌握）
2- Spark 原生自定义UDF函数案例解析（掌握）
3- Pandas自定义函数案例解析（熟悉）
4- Apache Arrow框架案例解析（熟悉）
5- spark常见面试题

文章目录

前言

本文主要通过案例解析工作中常用的Spark SQL函数，以及应用场景

一、Spark SQL函数定义（掌握）

1. 窗口函数

回顾之前学习过的窗口函数：

分析函数 over(partition by xxx order by xxx [asc|desc] [rows between xxx and xxx])

分析函数可以大致分成如下3类：
1- 第一类: 聚合函数 sum() count() avg() max() min()
2- 第二类: 排序函数 row_number() rank() dense_rank() 
3- 第三类: 其他函数 ntile()  first_value() last_value() lead() lag() 

三个排序函数的区别?
row_number(): 巧记 1234  特点: 唯一且连续
rank(): 巧记 1224 特点: 并列不连续
dense_rank(): 巧记 1223  特点: 并列且连续

在Spark SQL中使用窗口函数案例：

已知数据如下:

cookie1,2018-04-10,1
cookie1,2018-04-11,5
cookie1,2018-04-12,7
cookie1,2018-04-13,3
cookie1,2018-04-14,2
cookie1,2018-04-15,4
cookie1,2018-04-16,4
cookie2,2018-04-10,2
cookie2,2018-04-11,3
cookie2,2018-04-12,5
cookie2,2018-04-13,6
cookie2,2018-04-14,3
cookie2,2018-04-15,9
cookie2,2018-04-16,7

需求: 要求找出每个cookie中pv排在前3位的数据，也就是分组取TOPN问题

# 导包
import os
from pyspark.sql import SparkSession,functions as F,Window as W

# 绑定指定的python解释器
os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ['PYSPARK_PYTHON'] = '/root/anaconda3/bin/python3'
os.environ['PYSPARK_DRIVER_PYTHON'] = '/root/anaconda3/bin/python3'

# 创建main函数
if __name__ == '__main__':
    # 1.创建SparkContext对象
    spark = SparkSession.builder.appName('pyspark_demo').master('local[*]').getOrCreate()

    # 2.数据输入
    df = spark.read.csv(
        path='file:///export/data/spark_project/spark_sql/data/cookie.txt',
        sep=',',
        schema='cookie string,datestr string,pv int'
    )
    # 3.数据处理(切分,转换,分组聚合)
    # 4.数据输出
    etldf = df.dropDuplicates().dropna()
    # SQL方式
    etldf.createTempView('cookie_logs')
    spark.sql(
        """
        select cookie,datestr,pv
        from (
           select cookie,datestr,pv,
              dense_rank() over(partition by cookie order by pv desc) as rn
           from cookie_logs
        ) temp where rn <=3 
        """
    ).show()
    # DSL方式
    etldf.select(
        'cookie', 'datestr', 'pv',
        F.dense_rank().over( W.partitionBy('cookie').orderBy(F.desc('pv')) ).alias('rn')
    ).where('rn <=3').select('cookie', 'datestr', 'pv').show()


    # 5.关闭资源
    spark.stop()

运行结果截图：

在这里插入图片描述

2. 自定义函数背景

2.1 回顾函数分类标准

SQL函数，主要分为以下三大类：

  • UDF函数：普通函数
    • 特点：一对一，输入一个得到一个
    • 例如：split() …
  • UDAF函数：聚合函数
    • 特点：多对一，输入多个得到一个
    • 例如：sum() avg() count() min() max() …
  • UDTF函数：表生成函数
    • 特点：一对多，输入一个得到多个
    • 例如：explode() …

在SQL中提供的所有的内置函数，都是属于以上三类中某一类函数

2.2 自定义函数背景

思考：有这么多的内置函数，为啥还需要自定义函数呢?

	为了扩充函数功能。在实际使用中，并不能保证所有的操作函数都已经提前的内置好了。很多基于业务处理的功能，其实并没有提供对应的函数，提供的函数更多是以公共功能函数。此时需要进行自定义，来扩充新的功能函数

​ 在Spark SQL中，针对Python语言，对于自定义函数，原生支持的并不是特别好。目前原生仅支持自定义UDF函数，而无法自定义UDAF函数和UDTF函数。

​ 在1.6版本后，Java 和scala语言支持自定义UDAF函数，但Python并不支持。

1- SparkSQL原生的时候，Python只能开发UDF函数
2- SparkSQL借助其他第三方组件(Arrow,pandas...)，Python可以开发UDF、UDAF函数,同时也提升效率

在这里插入图片描述

​ Spark SQL原生UDF函数存在的问题：大量的序列化和反序列

	虽然Python支持自定义UDF函数，但是其效率并不是特别的高效。因为在使用的时候，传递一行处理一行，返回一行的方式。这样会带来非常大的序列化的开销的问题，导致原生UDF函数效率不好
	
早期解决方案: 基于Java/Scala来编写自定义UDF函数，然后基于python调用即可
	
目前主要的解决方案: 引入Arrow框架，可以基于内存来完成数据传输工作，可以大大的降低了序列化的开销，提供传输的效率，解决原生的问题。同时还可以基于pandas的自定义函数，利用pandas的函数优势完成各种处理操作

在这里插入图片描述

二、Spark原生自定义UDF函数

1. 自定义函数流程

第一步: 在PySpark中创建一个Python的函数，在这个函数中书写自定义的功能逻辑代码即可

第二步: 将Python函数注册到Spark SQL中
	注册方式一: udf对象 = sparkSession.udf.register(参数1,参数2,参数3)
		参数1: 【UDF函数名称】，此名称用于后续在SQL中使用，可以任意取值，但是要符合名称的规范
		参数2: 【自定义的Python函数】，表示将哪个Python的函数注册为Spark SQL的函数
		参数3: 【UDF函数的返回值类型】。用于表示当前这个Python的函数返回的类型
		udf对象: 返回值对象，是一个UDF对象，可以在DSL中使用
	
		说明: 如果通过方式一来注册函数, 【可以用在SQL和DSL】
	
	注册方式二:  udf对象 = F.udf(参数1,参数2)
		参数1: Python函数的名称，表示将那个Python的函数注册为Spark SQL的函数
		参数2: 返回值的类型。用于表示当前这个Python的函数返回的类型
		udf对象: 返回值对象，是一个UDF对象，可以在DSL中使用
		
		说明: 如果通过方式二来注册函数，【仅能用在DSL中】
		
	注册方式三:  语法糖写法  @F.udf(returnType=返回值类型)  放置到对应Python的函数上面
		说明: 实际是方式二的扩展。如果通过方式三来注册函数，【仅能用在DSL中】
	
		
第三步: 在Spark SQL的 DSL/ SQL 中进行使用即可
1.1 自定义演示一

需求1: 请自定义一个函数，完成对 数据 统一添加一个后缀名的操作 , 例如后缀名 ‘_itheima’

效果如下:

在这里插入图片描述

# 导包
import os
from pyspark.sql import SparkSession,functions as F
from pyspark.sql.types import StringType

# 绑定指定的python解释器

os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ['PYSPARK_PYTHON'] = '/root/anaconda3/bin/python3'
os.environ['PYSPARK_DRIVER_PYTHON'] = '/root/anaconda3/bin/python3'

# 创建main函数
if __name__ == '__main__':
    # 1.创建SparkContext对象
    spark = SparkSession.builder.appName('pyspark_demo').master('local[*]').getOrCreate()


    # 2.数据输入
    df = spark.createDataFrame(
        data=[(1,'张三','广州'),(2,'李四','深圳')],
        schema='id int,name string,address string'
    )
    df.show()
    
    # 3.SparkSQL自定义udf函数
    # 第一步.自定义python函数
    def add_suffix(data):
        return data+'_itheima'

    # 第二步.把python函数注册到SparkSQL
    # ① spark.udf.register注册
    dsl1_add_suffix = spark.udf.register('sql_add_suffix',add_suffix,StringType())
    # ②F.udf注册
    dsl2_add_suffix = F.udf(add_suffix, StringType())
    # ③@F.udf注册
    @F.udf( StringType())
    def candy_add_suffix(data):
        return data+'_itheima'

    # 第三步.在SparkSQL中调用自定义函数
    # SQL方式
    df.createTempView('temp')
    spark.sql(
        """select id,name,sql_add_suffix(address) as new_address from temp"""
    ).show()
    
    # DSL方式
    # 调用dsl1_add_suffix
    df.select(
        'id', 'name', dsl1_add_suffix('address').alias('new_address')
    ).show()
    # 调用dsl2_add_suffix
    df.select(
        'id', 'name', dsl2_add_suffix('address').alias('new_address')
    ).show()
    # 调用candy_add_suffix
    df.select(
        'id', 'name', candy_add_suffix('address').alias('new_address')
    ).show()

    # 4.关闭资源
    spark.stop()

博主友情提醒: 可能遇到的问题如下

在这里插入图片描述

原因: 在错误的地方调用了错误的函数。spark.udf.register参数1取的函数名只能在SQL中使用，不能在DSL中用。
1.2 自定义演示二

需求2: 请自定义一个函数，返回值类型为复杂类型: 列表

效果如下:

在这里插入图片描述

参考代码:

# 导包
import os
from pyspark.sql import SparkSession,functions as F
from pyspark.sql.types import StringType, ArrayType

# 绑定指定的python解释器

os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ['PYSPARK_PYTHON'] = '/root/anaconda3/bin/python3'
os.environ['PYSPARK_DRIVER_PYTHON'] = '/root/anaconda3/bin/python3'

# 创建main函数
if __name__ == '__main__':
    # 1.创建SparkContext对象
    spark = SparkSession.builder.appName('pyspark_demo').master('local[*]').getOrCreate()


    # 2.数据输入
    df = spark.createDataFrame(
        data=[(1,'张三_广州'),(2,'李四_深圳')],
        schema='id int,name_address string'
    )
    df.show()

    # 3.SparkSQL自定义udf函数
    # 第一步.自定义python函数
    def my_split(data:str):
        list1 = data.split('_')
        return list1

    # 第二步.把python函数注册到SparkSQL
    # ① spark.udf.register注册
    dsl1_add_suffix = spark.udf.register('sql_add_suffix',my_split,ArrayType(StringType()))
    # ②F.udf注册
    dsl2_add_suffix = F.udf(my_split, ArrayType(StringType()))
    # ③@F.udf注册
    @F.udf(ArrayType(StringType()))
    def candy_add_suffix(data):
        list1 = data.split('_')
        return list1

    # 第三步.在SparkSQL中调用自定义函数
    # SQL方式
    df.createTempView('temp')
    spark.sql(
        """select id,sql_add_suffix(name_address) as new_address from temp"""
    ).show()

    # DSL方式
    # 调用dsl1_add_suffix
    df.select(
        'id',  dsl1_add_suffix('name_address').alias('new_name_address')
    ).show()
    # 调用dsl2_add_suffix
    df.select(
        'id',dsl2_add_suffix('name_address').alias('new_name_address')
    ).show()
    # 调用candy_add_suffix
    df.select(
        'id',candy_add_suffix('name_address').alias('new_name_address')
    ).show()


    # 4.关闭资源
    spark.stop()
1.3 自定义演示三

需求3: 请自定义一个函数，返回值类型为复杂类型: 字典

效果如下:

在这里插入图片描述

注意: 注意: 如果是字典类型,StructType中列名需要和字典的key值一致,否则是null补充

# 导包
import os
from pyspark.sql import SparkSession,functions as F
from pyspark.sql.types import StringType, ArrayType, StructType

# 绑定指定的python解释器

os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ['PYSPARK_PYTHON'] = '/root/anaconda3/bin/python3'
os.environ['PYSPARK_DRIVER_PYTHON'] = '/root/anaconda3/bin/python3'

# 创建main函数
if __name__ == '__main__':
    # 1.创建SparkContext对象
    spark = SparkSession.builder.appName('pyspark_demo').master('local[*]').getOrCreate()


    # 2.数据输入
    df = spark.createDataFrame(
        data=[(1,'张三_广州'),(2,'李四_深圳')],
        schema='id int,name_address string'
    )
    df.show()

    # 3.SparkSQL自定义udf函数
    # 第一步.自定义python函数
    def my_split(data:str):
        list1 = data.split('_')
        return {'name':list1[0],'address':list1[1]}

    # 第二步.把python函数注册到SparkSQL
    # 注意: 如果是字典类型,StructType中列名需要和字典的key值一致,否则是null
    t = StructType().add('name',StringType()).add('address',StringType())
    # ① spark.udf.register注册
    dsl1_add_suffix = spark.udf.register('sql_add_suffix',my_split,t)
    # ②F.udf注册
    dsl2_add_suffix = F.udf(my_split, t)
    # ③@F.udf注册
    @F.udf(t)
    def candy_add_suffix(data):
        list1 = data.split('_')
        return {'name':list1[0],'address':list1[1]}

    # 第三步.在SparkSQL中调用自定义函数
    # SQL方式
    df.createTempView('temp')
    spark.sql(
        """select id,sql_add_suffix(name_address) as new_name_address from temp"""
    ).show()

    # DSL方式
    # 调用dsl1_add_suffix
    df.select(
        'id', dsl1_add_suffix('name_address').alias('new_name_address')
    ).show()
    # 调用dsl2_add_suffix
    df.select(
        'id',dsl2_add_suffix('name_address').alias('new_name_address')
    ).show()
    # 调用candy_add_suffix
    df.select(
        'id',candy_add_suffix('name_address').alias('new_name_address')
    ).show()

    # 4.关闭资源
    spark.stop()

三、Pandas的自定义函数

1. Apache Arrow框架

​ Apache Arrow是Apache旗下的一款顶级的项目。是一个跨平台的在内存中以列式存储的数据层，它的设计目标就是作为一个跨平台的数据层，来加快大数据分析项目的运行效率

​ Pandas 与 Spark SQL 进行交互的时候，建立在Apache Arrow上，带来低开销 高性能的UDF函数

​

如何安装? 三个节点建议都安装（注：集群搭建后续会更新）

检查服务器上是否有安装pyspark
pip list | grep pyspark  或者 conda list | grep pyspark

如果服务器已经安装了pyspark的库，那么仅需要执行以下内容，即可安装。例如在 node1安装
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyspark[sql]
	
如果服务器中python环境中没有安装pyspark，建议执行以下操作，即可安装。例如在 node2 和 node3安装
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pyarrow==16.1.0

在这里插入图片描述

Arrow并不会自动使用，在某些情况下，需要配置 以及在代码中需要进行小的更改才可以使用

如何使用呢? 默认不会自动启动的, 一般建议手动配置

spark.conf.set('spark.sql.execution.arrow.pyspark.enabled',True)

2. 基于Arrow完成Pandas和Spark的DataFrame互转

Pandas中DataFrame：

DataFrame：表示一个二维表对象，就是表示整个表

字段、列、索引；Series表示一列

在这里插入图片描述

Spark SQL中DataFrame：

在这里插入图片描述

使用场景：

1- Spark的DataFrame -> Pandas的DataFrame：当大数据处理到后期的时候，可能数据量会越来越少，这样可以考虑使用单机版的Pandas来做后续数据的分析

2- Pandas的DataFrame -> Spark的DataFrame：当数据量达到单机无法高效处理的时候，或者需要和其他大数据框架集成的时候，可以转成Spark中的DataFrame

Pandas的DataFrame -> Spark的DataFrame: spark.createDataFrame(data=pandas_df)
Spark的DataFrame -> Pandas的DataFrame: init_df.toPandas()

示例:

# 导包
import os
from pyspark.sql import SparkSession

# 绑定指定的python解释器
os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ['PYSPARK_PYTHON'] = '/root/anaconda3/bin/python3'
os.environ['PYSPARK_DRIVER_PYTHON'] = '/root/anaconda3/bin/python3'

# 创建main函数
if __name__ == '__main__':
    # 1.创建SparkContext对象
    spark = SparkSession.builder.appName('pyspark_demo').master('local[*]').getOrCreate()

    # TODO: 手动开启arrow框架
    spark.conf.set('spark.sql.execution.arrow.pyspark.enabled', True)

    # 2.数据输入
    df = spark.createDataFrame(
        data=[(1,'张三_广州'),(2,'李四_深圳')],
        schema='id int ,name_address string'
    )
    df.show()
    print(type(df))
    print('------------------------')

    # 3.数据处理(切分,转换,分组聚合)
    # 4.数据输出
    # spark->pandas
    pd_df = df.toPandas()
    print(pd_df)
    print(type(pd_df))

    print('------------------------')
    # pandas->spark
    df2 = spark.createDataFrame(pd_df)
    df2.show()
    print(type(df2))
    

    # 5.关闭资源
    spark.stop()

3. 基于Pandas自定义函数

​ 基于Pandas的UDF函数来转换为Spark SQL的UDF函数进行使用。底层是基于Arrow框架来完成数据传输，允许向量化（可以充分利用计算机CPU性能）操作。

​ Pandas的UDF函数其实本质上就是Python的函数，只不过函数的传入数据类型为Pandas的类型

​ 基于Pandas的UDF可以使用自定义UDF函数和自定义UDAF函数

3.1 自定义函数流程
第一步: 在PySpark中创建一个Python的函数，在这个函数中书写自定义的功能逻辑代码即可

第二步: 将Python函数包装成Spark SQL的函数
	注册方式一: udf对象 = spark.udf.register(参数1, 参数2)
		参数1: UDF函数名称。此名称用于后续在SQL中使用，可以任意取值，但是要符合名称的规范
		参数2: Python函数的名称。表示将哪个Python的函数注册为Spark SQL的函数
		使用: udf对象只能在DSL中使用。参数1指定的名称只能在SQL中使用
		
		
	注册方式二: udf对象 = F.pandas_udf(参数1, 参数2)
		参数1: 自定义的Python函数。表示将哪个Python的函数注册为Spark SQL的函数
		参数2: UDF函数的返回值类型。用于表示当前这个Python的函数返回的类型对应到Spark SQL的数据类型
		udf对象: 返回值对象，是一个UDF对象。仅能用在DSL中使用
	
	注册方式三: 语法糖写法  @F.pandas_udf(returnType)  放置到对应Python的函数上面
		说明: 实际是方式二的扩展。仅能用在DSL中使用
	
第三步: 在Spark SQL的 DSL/ SQL 中进行使用即可

基于pandas方式还支持自定义UDAF函数
注意: 如果要用于自定义UDAF函数,理论上只能用上述注册方式三语法糖方式,也就意味着理论只能DSL使用
注意: 如果还想同时用SQL方式和DSL方式,可以把加了语法糖的函数,再传入到方式register注册,就可以使用了!
3.2 自定义UDF函数

  • 自定义Python函数的要求：SeriesToSeries

    在这里插入图片描述

# 导包
import os
from pyspark.sql import SparkSession,functions as F
import pandas as pd

# 绑定指定的python解释器
from pyspark.sql.types import LongType, IntegerType

os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ['PYSPARK_PYTHON'] = '/root/anaconda3/bin/python3'
os.environ['PYSPARK_DRIVER_PYTHON'] = '/root/anaconda3/bin/python3'

# 创建main函数
if __name__ == '__main__':
    # 1.创建SparkContext对象
    spark = SparkSession.builder.appName('pyspark_demo').master('local[*]').getOrCreate()

    # TODO: 开启Arrow的使用
    spark.conf.set('spark.sql.execution.arrow.pyspark.enabled', 'True')

    # 2.数据输入
    df = spark.createDataFrame(
        data = [(1,1),(2,2),(3,3)],
        schema= 'num1 int,num2 int'
    )
    df.show()
    # 3.基于pandas自定义函数 :SeriesTOSeries
    # 第一步: 自定义python函数
    def multiply(num1:pd.Series,num2:pd.Series)->pd.Series:
        return num1*num2

    # 第二步: 把python注册为SparkSQL函数
    # ①spark.udf.register注册
    dsl1_multiply = spark.udf.register('sql_multiply',multiply)
    # ②F.pandas_udf注册
    dsl2_multiply = F.pandas_udf(multiply,IntegerType())
    # ③@F.pandas_udf注册
    @F.pandas_udf(IntegerType())
    def candy_multiply(num1: pd.Series, num2: pd.Series) -> pd.Series:
        return num1 * num2

    # 第三步: 在SparkSQL中调用注册后函数
    # SQL方式
    df.createTempView('temp')
    spark.sql(
        """select num1,num2,sql_multiply(num1,num2) as result from temp"""
    ).show()
    # DSL方式
    #调用dsl1_multiply
    df.select(
        'num1','num2',dsl1_multiply('num1','num2').alias('result')
    ).show()
    # 调用dsl2_multiply
    df.select(
        'num1', 'num2', dsl2_multiply('num1', 'num2').alias('result')
    ).show()
    # 调用candy_multiply
    df.select(
        'num1', 'num2', candy_multiply('num1', 'num2').alias('result')
    ).show()

    # 4.关闭资源
    spark.stop()
3.3 自定义UDAF函数

  • 自定义Python函数的要求：Series To 标量

    表示：自定义函数的输入数据类型是Pandas中的Series对象，返回值数据类型是标量数据类型。也就是Python中的数据类型，例如：int、float、bool、list…

    在这里插入图片描述

基于pandas方式还支持自定义UDAF函数
注意: 如果要用于自定义UDAF函数,理论上只能用上述注册方式三语法糖方式,也就意味着理论只能DSL使用
注意: 如果还想同时用SQL方式和DSL方式,可以把加了语法糖的函数,再传入到方式register注册,就可以使用了!

# 导包
import os
from pyspark.sql import SparkSession, functions as F
import pandas as pd

# 绑定指定的python解释器
from pyspark.sql.types import LongType, IntegerType, FloatType

os.environ['SPARK_HOME'] = '/export/server/spark'
os.environ['PYSPARK_PYTHON'] = '/root/anaconda3/bin/python3'
os.environ['PYSPARK_DRIVER_PYTHON'] = '/root/anaconda3/bin/python3'

# 创建main函数
if __name__ == '__main__':
    # 1.创建SparkContext对象
    spark = SparkSession.builder.appName('pyspark_demo').master('local[*]').getOrCreate()

    # TODO: 开启Arrow的使用
    spark.conf.set('spark.sql.execution.arrow.pyspark.enabled', 'True')

    # 2.数据输入
    df = spark.createDataFrame(
        data=[(1, 1.0), (1, 2.0), (2, 3.0), (2, 5.0), (2, 10.0)],
        schema='id int,value float'
    )
    df.show()


    # 3.基于pandas自定义函数 :SeriesTOSeries
    # 第一步: 自定义python函数
    # ③@F.pandas_udf注册  注意: 理论上UDAF只能用注册方式三语法糖方式,也就意味着只能DSL使用
    @F.pandas_udf(FloatType())
    def candy_mean_v(value: pd.Series) -> float:
        return value.mean()


    # 第二步: 注意: 如果还想同时用SQL方式和DSL方式,可以把加了语法糖的函数,再传入到方式一register注册
    # ①spark.udf.register注册
    dsl1_mean_v = spark.udf.register('sql_mean_v', candy_mean_v)

    # 第三步: 在SparkSQL中调用注册后函数
    # DSL方式
    # 调用candy_mean_v
    df.groupBy('id').agg(
        candy_mean_v('value').alias('result')
    ).show()

    # 调用dsl1_mean_v
    df.groupBy('id').agg(
        dsl1_mean_v('value').alias('result')
    ).show()

    # SQL方式
    df.createTempView('temp')
    spark.sql(
        """select id,sql_mean_v(value) as result from temp group by id"""
    ).show()

    # 4.关闭资源
    spark.stop()

四、Spark常见面试题

1. Spark client 和Spark cluster的区别？

区别是driver 进程在哪运行，client模式driver运行在master节点上，不在worker节点上；cluster模式
driver运行在worker集群某节点上，不在master节点上。
一般来说，如果提交任务的节点（即Master）和Worker集群在同一个网络内，此时client mode比较合
适。
如果提交任务的节点和Worker集群相隔比较远，就会采用cluster mode来最小化Driver和Executor之间
的网络延迟。
yarn client模式：driverzai当前提交任务的节点上，可以打印任务运行的日志信息。
yarn cluster模式：driver在AppMaster所有节点上，分布式分配，不能再提交任务的本机打印日志信
息。

2. Spark常用端口号

Spark-shell任务端口：4040
内部通讯端口：7077
查看任务执行情况端口：8080
历史服务器：18080
Oozie端口号：11000

3. Repartitons和Coalesce区别

  • 关系：两者都是用来改变 RDD 的 partition 数量的，repartition 底层调用的就是 coalesce 方 法：
    coalesce(numPartitions, shuffle = true)
  • 区别：repartition 一定会发生 shuffle，coalesce 根据传入的参数来判断是否发生 shuffle 一般情况
    下增大 rdd 的 partition 数量使用 repartition，减少 partition 数量时使用 coalesce。
大数据小朋友
关注
  • 39
    点赞
  • 踩
  • 37
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 16
    评论
专栏目录
sparkSql分析函数和窗口函数（rows/range）的语法及案例
csdnliu123的博客
04-29 3196
sparkSql分析函数（rows/range）的语法及案例 sum、max、 min、 count、 avg等聚合函数 lead、 lag等比较函数 rank等排名函数 2.1 rank()排名函数案例： 2.2lag() ，lead() 函数使用及案例： 4.3range()和rows()的使用及案例： rows/range: 窗口子句，是在分组(partition by)后，表示组内的子分组(也即窗口)，是分析函数的计算范围窗口
spark函数解析
u010563350的博客
02-16 122
1.reduce 1 to 50 reduce((a,b)=>(ab))就是12作为下一个a,然后和b. 而reduceByKey则是处理： （s,1）(a,1)(b,3)(s,5)这样的。 不同点在于 (s,1),(s,5)中的value会成为a和b, 因为按照key来的嘛
spark基本函数
Python300的博客
04-09 446
aggregate()函数可以对一个RDD中的所有元素进行聚合计算，并返回一个结果。与reduce()不同的是，aggregate()可以同时对多个聚合函数进行计算。filter()函数可以根据条件过滤出符合条件的元素，并返回一个新的RDD。map()函数可以将RDD中的每个元素都执行一个函数，并返回一个新的RDD。groupBy()函数可以根据指定的键将数据分组，并返回一个新的RDD。reduce()函数可以将一个RDD中的所有元素进行聚合计算，并返回一个结果。# 过滤出年龄大于25岁的数据。
Hive/Spark SQL常用函数(窗口分析函数、行列转换、JSON处理)
行走的数据智能
05-17 1735
文章目录 窗口分析函数 1. 分析函数 2. 聚合函数 3. 窗口函数 行列转换 1. 行转列 2. 列转行 JSON处理 1. JSON对象 2. JSON数组 Hive SQL Spark SQL 时间处理 窗口分析函数 函数中用到的表数据如下图： 1. 分析函数 row_number() rank() dense_rank() 这3个函数通常用在组内.
大数据实战：基于Spark SQL统计分析函数求分组TopN
kwame211的博客
08-01 3358
做大数据分析时，经常遇到求分组TopN的问题，如：求每一学科成绩前5的学生；求今日头条各个领域指数Top 30%的头条号等等。Spark SQL提供了四个排名相关的统计分析函数： dense_rank() 返回分区内每一行的排名，排名是连续的。 rank() 返回分区内每一行的排名，排名可能不连续。 percent_rank() 返回相对百分比排名。 row_number() 返回每个分区...
spark sql解析-源码分析
03-16
4. **SQL解析器**：解析器是Spark SQL的第一步，它将SQL字符串转换为AST。这个过程涉及到词法分析和语法分析，使用的是Apache Calcite库提供的解析器。 5. **DataFrame转换与操作**：DataFrame API提供了一系列操作...
摸鱼大数据-Spark SQL-Spark SQL函数定义
06-29
Spark SQL函数定义资源
Spark sql 第6天电影案例分析所需文件
06-17
Spark sql 第6天电影案例分析所需文件
Spark SQL操作JSON字段的小技巧
09-09
总结来说，Spark SQL提供了强大的工具来解析和操作JSON数据，包括 `get_json_object` 用于提取单个字段，`from_json` 用于根据模式解析JSON，以及 `to_json` 用于将数据转化为JSON格式。随着Spark SQL对JSON支持的...
spark-xml:Spark SQL和DataFrames的XML数据源
05-12
Apache Spark的XML数据源 一个用于使用解析和查询XML数据的库，用于Spark SQL和DataFrames。 结构和测试工具大部分是从复制的。 该软件包支持以分布式方式处理无格式的XML文件，这与Spark中的JSON数据源限制嵌入式...
spark各种函数解析
Jor_rosen的技术博客
08-10 2404
1.combineByKey：使用用户设置好的聚合函数对每个Key中的Value进行组合(combine)。可以将输入类型为RDD[(K, V)]转成成RDD[(K, C)]。 函数原型 def combineByKey[C](createCombiner: V => C, mergeValue: (C, V) => C,     mergeC
SparkSQL学习中SQL分析函数的使用
qq_34116784的博客
05-08 857
SparkSQL/Hive 提供了许多的分析函数，用于完成复杂统计分析。 sum、avg、min、max，分别用于计算分组内相关统计信息。 1、用SQL实现下面的操作 测试数据： ±-------±------------------±–+ |cookieid| createtime| pv| ±-------±------------------±–+ | cookie1|201...
Spark分析窗口函数
u011007180的博客
11-30 3183
Spark1.4发布，支持了窗口分析函数(window functions)。 在离线平台中，90%以上的离线分析任务都是使用Hive实现，其中必然会使用很多窗口分析函数，如果SparkSQL支持窗口分析函数， 那么对于后面Hive向SparkSQL中的迁移的工作量会大大降低，使用方式如下： 1、初始化数据 创建表 [sql] view p
hive／spark分析函数介绍（转载）
xxxx000的专栏
01-16 536
窗口函数应用场景： （1）用于分区排序 （2）动态Group By （3）Top N （4）累计计算 （5）层次查询   一、分析函数 用于等级、百分点、n分片等。 函数 说明 RANK() 返回数据项在分组中的排名，排名相等会在名次中留下空位 DENSE_RANK() 返回数据项在分组中的排名，排名相等会在名次中不会留下空位 NTILE() ...
spark shell
最新发布
m0_74934794的博客
07-19 194
2.1.1读取linux文件系统的文件创建RDD。2.1.2读取hdfs文件系统上的文件创建RDD。--需要保证每一个worker中都有该文件。--过滤数据,保留每行中含有hello的数据。2.2使用Parallelize创建RDD。2.3从其他的RDD中创建新的RDD。--对RDD中的数据进行过滤操作。--统计RDD中的数据记录表。2.1 读取文件创建RDD。--读取RDD的第一条数据。4.实现wordcount。1.进行shell命令行。3.对RDD进行操作。--读取中的N条数据。
数据仓库中事实表设计的关键步骤解析
weixin_72431427的博客
07-17 616
选择业务过程及确定事实表类型，声明粒度，确定维度，确定事实
Spark核心技术架构
在路上的专栏
07-15 1172
Apache Spark是一个开源的分布式计算系统，它提供了一个快速、通用和易于使用的集群计算环境。Spark 支持多种编程语言，如 Scala、Java 和 Python，并针对大规模数据处理进行了优化。
【游戏/社交】BFS算法评价用户核心程度or人群扩量（基于SparkGraphX）
LUyan10086的博客
07-19 523
在游戏和社交网络领域，评估用户的核心程度或进行人群扩量是提升用户粘性和拓展社交圈的关键。广度优先搜索（BFS）算法以其在图结构中评估节点重要性的能力，为这一目标提供了一种有效的技术手段。本文将详细探讨一种运用BFS算法来评价用户的核心程度，并探索其在人群扩量策略中的应用潜力的方案。在游戏和社交网络行业中，识别并培养核心用户群体对于增强用户粘性和推动社区发展至关重要。为了进一步扩大影响力并吸引更多用户参与，基于这些核心用户进行有效的外扩和评估是必不可少的策略。在这一过程中，我们希望建立一种机制，能够根据用户与
大数据之spark（四）：spark sql
03-16
Spark SQL是Spark生态系统中的一个组件，它提供了一种用于结构化数据处理的高级API。Spark SQL支持使用SQL语言进行数据查询和分析，并且可以与Spark的其他组件（如Spark Streaming和MLlib）无缝集成。Spark SQL还提供了DataFrame API，它可以让开发人员使用类似于SQL的语法进行数据处理，同时还可以利用Spark的分布式计算能力进行高效的数据处理。Spark SQL的一个重要特性是支持多种数据源，包括Hive、JSON、Parquet、Avro等。Spark SQL的出现使得Spark在处理结构化数据方面变得更加强大和灵活。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大数据小朋友

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值