SparkSQL和rdd的使用详解

最新推荐文章于 2024-01-13 20:25:03 发布
最新推荐文章于 2024-01-13 20:25:03 发布
阅读量1k 收藏 22
点赞数 28
分类专栏： 大数据 文章标签： spark 大数据 分布式 big data etl工程师 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_71257020/article/details/135535564
版权

一、什么是SparkSQL

1-1 介绍

Spark SQL是 Apache Spark 用于处理结构化数据（DataFrame和Datasets）的模块。

1-1-1 数据结构分类
  • 结构数据
    • 就是表结构数据，有行列组成，并且描述了数据的属性（字段）和类型 ，表信息
    • string  int
  • 半结构化数据   spark中可以通过方法将半结构化数据转化为结构化数据
    • xml 和json
    • 描述数据的存储结构，但是无法描述数据的类型
<name>zhansan</name>
<age>18</age>

{
	name:zhangsan
}
  • 非结构化数据  rdd可以处理
    • 文本 ，图片，视频

1-2 特点

  • 易整合
    • 使用sql配合spark一起使用，封装了不同语言的dsl方法
  • 统一数据访问
    • 使用read方法可以读取hdfs数据，mysql数据，不同类型的文件数据（json，csv，orc）
    • 使用write方法可以写入hdfs，mysql不同类型的文件
  • 兼容hive
    • 使用hivesql方法
  • 标准的数据连接
    • 使用jdbc和odbc连接方式连接sparkSQL

1-3 SparkSQL与hiveSQL关系

  • shark
    • 运行的模式是hive on spark
    • 会将hivesqsl转换为spark的rdd
    • shark是基于hive开的，维护麻烦，2015年停止维护
  • sparkSQL
    • 是spark团建独立开发的工具，2014年发布1.0版本
    • sparkSQL工具对spark的兼容性更好，优化性能得到提升
    • sparkSQL本质也是将sql语句转化为rdd执行，catalyst引擎负责将sql转化为rdd
    • sparkSQL可以连接使用hive的metastore服务，管理表的元数据

1-4 数据模型

spark封装一个基础数据模型（数据类型）rdd

然后根据rdd进行再次封装，得到新的数据类型 dataframe

然后根据dataframe再次封装得到了dataset类型

image.png

  • rdd  弹性分布式集合    使用Python ，java，scala，c，R
[1,张三，20,2，李四，30]
  • dataframe类型 结构化数据  行列，表信息（数据的属性（字段）和类型）   使用Python ，java，scala，c，R
    • Row类  行数据 rdd中一个列表元素
    • Schema类  表信息
[
    [1,张三，20],  Row1（）
    [2，李四,30], Row2（）
]
Schema
1：id  int  
2：name  string
3：age  int
  • datasets类型  机构化数据   java，scala
    • Row类  一行数据  一个dataframe
    • Schema类  表信息
    • 从dataset中取出一行数据可以当做datafram类型操作
[
    第一行  datafrema[row,scheme]
	第二行  datafrema[row,scheme]  
]

Schema
1：id  int  
2：name  string
3：age  int

二、DataFrame的详解（

  • Row 类型 表示一行数据
    • datafram就算是多行构成

[
row1,
row2
]

from pyspark.sql import Row

# 不指定字段名
# 定义每行数据
r1 = Row(1,'张三',20)
r2 = Row(2,'李四',22)

# 取行中的数据,没有字段名通过下标取值
print(r1[0])
print(r1[1])

# 定义每行数据 指定字段名
r3 = Row(id=1,name='张三',age=20)
r4 = Row(id=2,name='李四',age=22)

# 通过字段名取值
print(r4['name'])
print(r4['age'])
  • schema表信息
    • 定义dataframe中的表的字段名和字段类型
from pyspark.sql.types import *

# 定义表信息
# add方法添加指定表信息
# 第一个参数 字段名
# 第二个参数 字段类型
# 第二个参数  是否允许为空值 默认允许 。  nullable=False    不允许
schema_type = StructType().\
    add('id',IntegerType()).\
    add('name',StringType()).\
    add('age',IntegerType(),nullable=False)

三、DataFrame创建

  • 基本创建
# 定义行数据导入row，创建dataframe需要导入SparkSession
from pyspark.sql import SparkSession,Row
# 定义表信息需要导入类型
from pyspark.sql.types import *

# 定义行数据
# 定义每行数据
r1 = Row(1,'张三',20)
r2 = Row(2,'李四',22)

# 定义每行数据 指定字段名
r3 = Row(id=1,name='张三',age=20)
r4 = Row(id=2,name='李四',age=22)

# 定义表信息
schema_type = StructType().\
    add('user_id',IntegerType()).\
    add('username',StringType()).\
    add('age',IntegerType(),nullable=False)

# 创建dataframe  需要用到SparkSession类的对象，该对象有创建方法
# 固定的创建格式
ss = SparkSession.builder.getOrCreate()
# createDataFrame 创建dataframe数据 返回一个dataframe的类对象
#第一参数传递row行数据
# 第二参数  传递表信息
df = ss.createDataFrame([r1,r2],schema_type)

# 查看df数据信息  内部会自动print
df.show()

# 查看表结构信息
df.printSchema()

# 注意点
# 1、定义行数据时指定字段名，定义schema也指定不一样的字段名，以schema中定义的字段为主
# 2、定义的schema的字段个数和row的字段个数不一致,会报错，需要保持数量一致
# 3、定义的schema的字段类型和row的字段类型不一致,讲义定义类型时和实际数据类型保持一致
# 创建新的df
df2 = ss.createDataFrame([r3,r4],schema_type)
# 查看
df2.show()
  • rdd的二维数据转化为dataframe
    • rdd.toDF()
# 使用sparksql都要SparkSession
from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 创建SparkSession对象
ss = SparkSession.builder.getOrCreate()

# 在SparkSession对象下有一个sparkcontext对象属性
# 获取sparkcontext对象   不需要加括号
sc = ss.sparkContext

# 转化rdd  需要一个二维嵌套列表
rdd = sc.parallelize([
    [1,'张三',20],
    [2,'李四',22]
])

#rdd转为df
# 接收schema信息
schema_type = StructType().\
    add('id',IntegerType()).\
    add('name',StringType()).\
    add('age',IntegerType(),nullable=False)

df = rdd.toDF(schema_type)

df.show()
  • 案例  读取学生数据转化为DataFrame
from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 1、生成SparkSession对象
ss = SparkSession.builder.getOrCreate()
# 2、获取sparkcontext对象
sc = ss.sparkContext

# 3、 读取文件数据转为rdd
rdd = sc.textFile('/student')
# 4、查看rdd数据
print(rdd.collect())
# 5、对每行数据进行切割
rdd_map = rdd.map(lambda x:[int(x.split(',')[0]),x.split(',')[1],x.split(',')[2],int(x.split(',')[3]),x.split(',')[4]])
print(rdd_map.collect())

# 6、rdd转df
# 7、定义 表信息
schema_type= StructType().\
    add('id',IntegerType()).\
    add('name',StringType()).\
    add('gender',StringType()).\
    add('age',IntegerType()).\
    add('cls',StringType())

df = rdd_map.toDF(schema_type)

df.show()
  • df转为rdd
# df数据重新转为rdd
print(df.rdd.collect())
rdd_map1 = df.rdd.map(lambda x:x[0])
print(rdd_map1.collect())
rdd_map2 = df.rdd.map(lambda x:x['name'])
print(rdd_map2.collect())

四、DataFrame基本使用（

4-1 DSL方法

spark提供DSL方法和sql的关键词一样，使用方式和sql基本类似，在进行数据处理时，要按照sql的执行顺序去思考如何处理数据

from  join    知道数据在哪   df本身就是要处理的数据  df.join(df2)

where         过滤需要处理的数据   df.join(df2).where()

group by  聚合  数据的计算     df.join(df2).where().groupby().sum()

having        计算后的数据进行过滤 df.join(df2).where().groupby().sum().where()

select        展示数据的字段  df.join(df2).where().groupby().sum().where().select()

order by      展示数据的排序   df.join(df2).where().groupby().sum().where().select().orderBy()

limit         展示数据的数量  df.join(df2).where().groupby().sum().where().select().orderBy().limit()

from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 1、生成SparkSession对象
ss = SparkSession.builder.getOrCreate()
# 2、获取sparkcontext对象
sc = ss.sparkContext

# 3、 读取文件数据转为rdd
rdd = sc.textFile('/student')
# 4、查看rdd数据

# 5、对每行数据进行切割
rdd_map = rdd.map(lambda x:[int(x.split(',')[0]),x.split(',')[1],x.split(',')[2],int(x.split(',')[3]),x.split(',')[4]])


# 6、rdd转df
# 7、定义 表信息
schema_type= StructType().\
    add('id',IntegerType()).\
    add('name',StringType()).\
    add('gender',StringType()).\
    add('age',IntegerType()).\
    add('cls',StringType())

df = rdd_map.toDF(schema_type)
# 显示所有内容
df.show()

# df数据操作
# 第一种方式，使用dsl方法
# select() 指定显示的字段  返回结果是一个新的df
df_select =   df.select(df['id'],df['name'])

df_select2 =   df.select(['id','name'])
# 显示df数据
df_select.show()
df_select2.show()

# 数据的过滤方法 where  过滤后的数据会放入一个新的df中
# 一个条件的过滤
df_where = df.where('age > 20')
# 多个条件的与或非  and  or  和sql中的条件书写方式一样
df_where1 = df.where('age > 20 and  cls = "CS" ')

df_where.show()
df_where1.show()

# groupby 分组操作
# 直接分组计算 计算后的数据存储在新的df
df_groupby = df.groupby('cls').sum('age')
df_groupby.show()

# 配合where进行分组计算
df_new = df.where('age >= 20').groupBy(['cls','gender']).sum('age')
df_new.show()

# 分组聚合后的数据进行过滤
df_new1 = df.where('age >= 20').groupBy(['cls','gender']).sum('age').where('sum(age) > 22')
df_new1.show()

# orderBy 数据排序
df_new2 = df.where('age >= 20').groupBy(['cls','gender']).sum('age').orderBy('sum(age)',ascending=False)
df_new2.show()

# limit指定展示数量
df_new3 = df.where('age >= 20').groupBy(['cls','gender']).sum('age').orderBy('sum(age)',ascending=False).limit(2)
df_new3.show()

多个dsl方法配合使用要注意执行顺序

4-2 sql语句

from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 1、生成SparkSession对象
ss = SparkSession.builder.getOrCreate()
# 2、获取sparkcontext对象
sc = ss.sparkContext

# 3、 读取文件数据转为rdd
rdd = sc.textFile('/student')
# 4、查看rdd数据

# 5、对每行数据进行切割
rdd_map = rdd.map(lambda x:[int(x.split(',')[0]),x.split(',')[1],x.split(',')[2],int(x.split(',')[3]),x.split(',')[4]])


# 6、rdd转df
# 7、定义 表信息
schema_type= StructType().\
    add('id',IntegerType()).\
    add('name',StringType()).\
    add('gender',StringType()).\
    add('age',IntegerType()).\
    add('cls',StringType())

df = rdd_map.toDF(schema_type)
# 显示所有内容
df.show()

# df数据操作
# 第二种方式，SQL方式
# 先创建一个表
# 参数  指定一个表名
df.createTempView('stu') # 本质是创建了一个视图

# 使用sql方法编写sql字符串，返回一个新的df
# sql的语法和hivesql一样
df2 = ss.sql('select id,name from stu')

df2.show()

五、DataFrame的高级DSL方法

  • join关联
    • 内关联
    • 左关联
    • 右关联
from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 创建SparkSession对象
ss = SparkSession.builder.getOrCreate()

# 通过rdd创建df
sc = ss.sparkContext
schema_type = StructType(). \
    add('id', IntegerType()). \
    add('name', StringType()). \
    add('age', IntegerType(), nullable=False). \
    add('gender', StringType())

schema_type1 = StructType(). \
    add('user_id', IntegerType()). \
    add('name', StringType()). \
    add('age', IntegerType(), nullable=False). \
    add('gender', StringType())

df1 = sc.parallelize([
    [1, '张三', 20, '男'],
    [2, '李四', 21, '男'],
    [3, '王五', 22, '男'],
    [4, '赵六', 23, '男'],
    [6, '韩信', 26, '男'],
]).toDF(schema_type)

df2 = sc.parallelize([
    [1, '小红', 20, '女'],
    [2, '韩梅梅', 21, '女'],
    [3, '妲己', 22, '女'],
    [4, '小乔', 23, '女'],
    [5, '貂蝉', 25, '女'],
]).toDF(schema_type)

df3 = sc.parallelize([
    [1, '小红', 20, '女'],
    [2, '韩梅梅', 21, '女'],
    [3, '妲己', 22, '女'],
    [4, '小乔', 23, '女'],
    [5, '貂蝉', 25, '女'],
]).toDF(schema_type1)

# 两个df数据关联
# join
# 参数一 指定关联的df
# 参数二 指定关联的字段
# 参数三  指定关联方式 不写是内关联
# 返回一个新的df
df_new = df1.join(df2, 'id')
df_new.show()

# 左
df_new2 = df1.join(df2, 'id', 'left')
df_new2.show()
# 右
df_new3 = df1.join(df2, 'id', 'right')
df_new3.show()

# 字段不一样
df_new4 = df1.join(df3, df1['id'] == df3['user_id'])
df_new4.show()

# join 是按列拼接表数据

# union 按行拼接
df_new5 = df1.union(df2)
df_new5.show()
  • 缓存和checkpoint
    • 相同和不同点和rdd中的一样
# 使用sparksql都要SparkSession
from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 创建SparkSession对象
ss = SparkSession.builder.getOrCreate()


# 在SparkSession对象下有一个sparkcontext对象属性
# 获取sparkcontext对象   不需要加括号
sc = ss.sparkContext

# 指定保存路径
sc.setCheckpointDir('/spark_sql_check')

# 转化rdd  需要一个二维嵌套列表
rdd = sc.parallelize([
    [1,'张三',20],
    [2,'李四',22]
])

df = rdd.toDF()

# df 进行缓存
# df.persist()  # 不需要触发就可以自动缓存

# checkpoint
df.checkpoint()

res = df.count()
print(res)
  • 内置函数
  • 字符串
# 导入内置函数functions  as F命名别称
from pyspark.sql import SparkSession,functions as F
from pyspark.sql.types import *

# 1、生成SparkSession对象
ss = SparkSession.builder.getOrCreate()
# 2、获取sparkcontext对象
sc = ss.sparkContext
# 3、 读取文件数据转为rdd
rdd = sc.textFile('/student')
# 5、对每行数据进行切割
rdd_map = rdd.map(lambda x:[int(x.split(',')[0]),x.split(',')[1],x.split(',')[2],int(x.split(',')[3]),x.split(',')[4]])
# 6、rdd转df
# 7、定义 表信息
schema_type= StructType().\
    add('id',IntegerType()).\
    add('name',StringType()).\
    add('gender',StringType()).\
    add('age',IntegerType()).\
    add('cls',StringType())
df = rdd_map.toDF(schema_type)

df.show()

# 内置函数  select  where
# 字符串操作
# 拼接  内置函数的后面可以跟上alias 命名计算的后字段名
df_new = df.select(['name','gender',F.concat('name','gender').alias('concat')])
df_new.show()
# 指定拼接字符
df_new1 = df.select(['name','gender',F.concat_ws(':','name','gender').alias('concat')])
df_new1.show()

# 字符串切割
df_new2= df_new1.select(F.split('concat',':').alias('split_data'))
df_new2.show()

# 数组数据的下标取值
df_new3 = df_new2.select(df_new2['split_data'][0],df_new2['split_data'][1])
df_new3.show()

#字符串截取
df_new4 = df_new1.select(F.substring('concat',1,2))
df_new4.show()
  • 时间
# 导入内置函数functions  as F命名别称
from pyspark.sql import SparkSession, functions as F
from pyspark.sql.types import *

# 1、生成SparkSession对象
ss = SparkSession.builder.getOrCreate()
# 2、获取sparkcontext对象
sc = ss.sparkContext
# 3、 读取文件数据转为rdd
rdd = sc.textFile('/student')
# 5、对每行数据进行切割
rdd_map = rdd.map(
    lambda x: [int(x.split(',')[0]), x.split(',')[1], x.split(',')[2], int(x.split(',')[3]), x.split(',')[4]])
# 6、rdd转df
# 7、定义 表信息
schema_type = StructType(). \
    add('id', IntegerType()). \
    add('name', StringType()). \
    add('gender', StringType()). \
    add('age', IntegerType()). \
    add('cls', StringType())
df = rdd_map.toDF(schema_type)

df.show()

# 内置函数  select  where
# 字符串操作
# 拼接  内置函数的后面可以跟上alias 命名计算的后字段名
df_new = df.select(['name', 'gender', F.concat('name', 'gender').alias('concat')])
df_new.show()
# 指定拼接字符
df_new1 = df.select(['name', 'gender', F.concat_ws(':', 'name', 'gender').alias('concat')])
df_new1.show()

# 字符串切割
df_new2 = df_new1.select(F.split('concat', ':').alias('split_data'))
df_new2.show()

# 数组数据的下标取值
df_new3 = df_new2.select(df_new2['split_data'][0], df_new2['split_data'][1])
df_new3.show()

# 字符串截取
df_new4 = df_new1.select(F.substring('concat', 1, 2))
df_new4.show()

# 获取当前时间
df_new5 = df.select(['id', 'name', 'gender', F.current_date().alias('date'), F.current_timestamp().alias('timestamp'),
                     F.unix_timestamp().alias('uninx_timestamp')])
df_new5.show(truncate=False)

# 将unix转化为timestamp
df_new6 = df_new5.select(F.from_unixtime('uninx_timestamp', "yyyy/MM/dd HH:mm:ss"))
df_new6.show(truncate=False)

# 将timestamp转化为unix
df_new7 = df_new5.select(F.unix_timestamp('timestamp'))
df_new7.show(truncate=False)

# 时间加减
df_new8 = df_new5.select(['date',F.date_add('date',-1)])
df_new8.show(truncate=False)

# 年月日的取值
df_new9 = df_new5.select(['date',F.year('date'),F.month('date'),F.dayofweek('date')])
df_new9.show()
  • 聚合
# 聚合
df_new10 = df.groupby('cls').sum('age')
df_new10.show()
# agg()聚合方法配合内置函数使用
df_new11=df.groupby('cls').agg(F.sum('age').alias('sum_data'),F.avg('age').alias('avg_data'),F.max('age'))
df_new11.show()
  • 其他操作
    • sparksession的操作
# 使用sparksql都要SparkSession
from pyspark.sql import SparkSession
from pyspark.sql.types import *

# 创建SparkSession对象
# master 指定资源调度方式
# appName 指定任务名称
ss = SparkSession.builder.master('yarn').appName('yarn_saprksql').getOrCreate()
陆水A
关注
  • 28
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spark RDD详解
01-07
常见疑问 Spark与Apache Hadoop有何关系？ Spark是与Hadoop数据兼容的快速通用处理引擎。它可以通过YARN或Spark的Standalone在Hadoop集群中运行，并且可以处理HDFS、Hbase、Cassandra、Hive和任何Hadoop InputFormat中的数据。它旨在执行批处理(类似于MapReduce)和提供新的工作特性，例如流计算，SparkSQL交互式查询和Machine Learning机器学习等。 我的数据需要容纳在内存中才能使用Spark吗？ 不会。Spark的operators会在不适合内存的情况下将数据溢出到磁盘上，从而使其可以在任何
Spark RDD的简单使用+Spark SQL的简单使用+Spark Streaming的简单使用
qq_41617848的博客
11-15 1161
Spark 的核心是建立在统一的抽象弹性分布式数据集（Resiliennt Distributed Datasets，RDD）之上的，这使得 Spark 的各个组件可以无缝地进行集成，能够在同一个应用程序中完成大数据处理。本节将对 RDD 的基本概念及与 RDD 相关的概念做基本介绍,以及在Spark RDD的基础上的简单使用。 1.RDD的基本概念 RDD 是Spark提供的最重要的一种抽象概念...
SparkSql使用入门
01-07
Spark SQL是spark套件中一个模板，它将数据的计算任务通过SQL的形式转换成了RDD的计算，类似于Hive通过SQL的形式将数据的计算任务转换成了MapReduce。 Spark SQL的特点： 1、和Spark Core的无缝集成，可以在写整个RDD应用的时候，配置Spark SQL来完成逻辑实现。 2、统一的数据访问方式，Spark SQL提供标准化的SQL查询。 3、Hive的继承，Spark SQL通过内嵌的hive或者连接外部已经部署好的hive案例，实现了对hive语法的继承和操作。 4、标准化的连接方式，Spark SQL可以通过启动thrift Server来支持JD
Spark1.4.1 RDD算子详解
03-02
结合代码详细描述RDD算子的执行流程，并配上执行流程图
Spark源码系列（二）RDD详解
01-30
上一章讲了Spark提交作业的过程，这一章我们要讲RDD。简单的讲，RDD就是Spark的input，知道input是啥吧，就是输入的数据。RDD的全名是ResilientDistributedDataset，意思是容错的分布式数据集，每一个RDD都会有5个特征：1、有一个分片列表。就是能被切分，和hadoop一样的，能够切分的数据才能并行计算。2、有一个函数计算每一个分片，这里指的是下面会提到的compute函数。3、对其他的RDD的依赖列表，依赖还具体分为宽依赖和窄依赖，但并不是所有的RDD都有依赖。4、可选：key-value型的RDD是根据哈希来分区的，类似于mapreduce当中
SparkSQL详解
qq_40322236的博客
02-06 1801
Spark SQL是 Spark 用来处理结构化数据的一个模块，它提供了 2 个编程抽象：DataFrame 和 DataSet，并且作为分布式 SQL 查询引擎的作用。
RDD和SparkSQL综合应用
Python_Ai_Road的博客
01-02 920
公众号后台回复关键词：pyspark，获取本项目github地址。在pyspark大数据项目实践中，我们往往要综合应用SparkSQL和RDD来完成任务。通常，我们会使用SparkSQL...
SparkSQL学习——RDD&DataFrame&DataSet
Helen_1997_1997的博客
04-03 902
SparkSQL学习——RDD&DataFrame&DataSet
大数据技术之SparkSQL（超级详细）
wlove514的博客
04-25 6523
第1章 Spark SQL概述 1.1什么是Spark SQL Spark SQL是Spark用来处理结构化数据的一个模块，它提供了2个编程抽象：DataFrame和DataSet，并且作为分布式SQL查询引擎的作用。 它是将Hive SQL转换成MapRedu
spark中Rdd依赖和SparkSQL介绍--学习笔记
最新发布
yfq_29的博客
01-13 1074
rdd依赖，spark运行流程，sparkShuffle过程，Spark并行度设置，spark调优，SparkSQL基础学习
spark RDD操作详解
09-25
RDD即弹性分布式数据集，有容错机制并可以被并行操作的元素集合，具有只读、分区、容错、高效、无需物化、可以缓存、RDD依赖等特征。RDD只是数据集的抽象，分区内部并不会存储具体的数据。
SparkSQL -总结3- RDD的概念和特性
99滴神
06-19 241
RDD 概念 1、RDD是一个抽象分布式数据集DataSet，是一个数据描述。 2、RDD是Spark提供的核心抽象，表示一个可以进行并行操作的元素的不可变集合。 DataSet 可以理解成一个集合，集合里面存储了很多数据。 Distributed 它的数据是分布式存储的，每个分区指向一个存储在内存或者硬盘中的数据块 (Block)。 Resilient 弹性 在面对出错情况（例如任意一台节点宕机）时，Spark 能通过 RDD 之间的依赖关系恢复任意出错的 RDD（如 B 和 D 可以算出最后的 RD
SparkSQL核心编程
Faith_xzc
08-26 618
目录基本介绍DataFrame创建 DataFrameDataSet创建 DataSetRDD 转换为 DataSetDataSet 转换为 RDDDataFrame 和 DataSet 转换RDD、DataFrame、DataSet 三者的关系三者的共性三者的区别三者的互相转换 基本介绍 DataFrame 和 DataSet 模型是Spark SQL 所提供的两个编程抽象，SparkSQL核心编程主要是关于使用DataFrame 和 DataSet 模型进行编程以及它们之间的关系和转换。 Spark C
spark介绍之sparksql
weixin_41745141的博客
03-03 1048
spark sql详细介绍
Spark SQL编程之RDD-概述
hu10131013的博客
04-28 851
RDD简述 RDD（Resilient Distributed Dataset）叫做分布式数据集，是Spark中最基本的数据抽象。代码中是一个抽象类，它代表一个不可变、可分区、里面的元素可并行计算的集合 RDD属性 RDD官方文档中给出5个主要的属性 1 一组分区（Partition），即数据集的基本组成单位 2 一个计算每个分区的函数 3 RDD之间的依赖关系 4 一个Partitioner，即RDD的分片函数 5 一个列表，..
Spark编程基础3RDD编程、Spark SQL
AthlenaA的博客
12-23 2130
第5章 RDD编程 5.1 RDD编程基础 5.1.1 RDD创建 5.1.2 RDD操作 5.1.3 持久化 5.1.4 分区 5.1.5 一个综合实例 5.2 键值对RDD RDD编程 四个元素构成RDDmap join操作，只有key相同时才能进行连接。刚才两个RDD中，对key相等的把它们的fast连接起来。在关系型数据库中连接操作是很普遍的。 求平均值 rdd.mapValues(x=x...
spark的rdd、sql以及简单机器学习的使用
qq_47248788的博客
05-15 572
pyspark的案例
Spark SQL实战(06)-RDD与DataFrame的互操作
JavaEdge全是干货的技术号
03-24 291
虽然这种方法更冗长，但它允许在运行时构造 Dataset，当列及其类型直到运行时才知道时很有用。使用SparkSession的createDataFrame方法将RDD转换为DataFrame。这种基于反射的方法可以使代码更简洁，在编写 Spark 应用程序时已知schema时效果很好。构造一个schema，然后将其应用到现有的 RDD。包含特定对象类型的 RDD 的schema。
【spark】架构原理rdd使用详解
06-06
Spark是一个分布式计算框架，其核心是RDD（Resilient Distributed Datasets）。 RDD是一种可靠的、分布式的数据集合，可以在集群中进行并行计算。它的特点是不可变性、容错性和可分区性。 不可变性：RDD中的数据集合是不可变的，一旦创建就不能修改。如果需要对数据进行修改，需要创建一个新的RDD。 容错性：RDD具有容错性，即在集群中的任何一个节点出现故障时，Spark可以自动恢复该节点上的数据。 可分区性：RDD可以分成多个分区，每个分区可以在不同的节点上进行并行计算，从而提高计算效率。 RDD支持两种操作：转换操作和行动操作。转换操作是指对RDD进行转换，生成一个新的RDD，而不会改变原有的RDD。行动操作是指对RDD进行计算，返回一个结果或将结果保存到外部存储系统中。 常见的转换操作有map、filter、flatMap、union、distinct、groupByKey、reduceByKey等。常见的行动操作有count、collect、reduce、foreach等。 总之，RDD是Spark的核心，掌握RDD的使用方法对于理解Spark的架构原理非常重要。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值