devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spark SQL概述与基本操作

作者：我家自动化 | 2024-07-01 13:05:32

赞

踩

spark sql

目录

一、Spark SQL概述

        （1）概念

        （2）特点

        （3）Spark SQL与Hive异同

        （4）Spark的数据抽象

二、Spark Session对象执行环境构建

          (1)Spark Session对象

        （2）代码演示

三、DataFrame创建

        （1）DataFrame组成

        （2）DataFrame创建方式（转换）

        （3）DataFrame创建方式（标准API读取）

四、DataFrame编程

        （1）DSL语法风格

        （2）SQL语法风格

五、Spark SQL——wordcount代码示例

        （1）pyspark.sql.functions包

        （2）代码示例

一、Spark SQL概述

        （1）概念

        Spark SQL是Apache Spark的一个模块，它用于处理结构化和半结构化的数据。Spark SQL允许用户使用SQL查询和操作数据，这种操作可以直接在Spark的DataFrame/Dataset API中进行。此外，Spark SQL还支持多种语言，包括Scala、Java、Python和R。

        （2）特点

        ①融合性：SQL可以无缝集成在代码中，随时用SQL处理数据。

        ②统一数据访问：一套标准API可读写不同的数据源。

        ③Hive兼容：可以使用Spark SQL直接计算生成Hive数据表。

        ④标准化连接：支持标准化JDBC \ ODBC连接，方便和各种数据库进行数据交互。

        （3）Spark SQL与Hive异同

        共同点：Hive和Spark均是:“分布式SQL计算引擎”，均是构建大规模结构化数据计算的绝佳利器，同时SparkSQL拥有更好的性能。

        （4）Spark的数据抽象

        Spark SQL的数据抽象：

        Data Frame与RDD：

二、Spark Session对象执行环境构建

          (1)Spark Session对象

        在RDD阶段，程序的执行入口对象是:SparkContext。在Spark 2.0后，推出了SparkSession对象，作为Spark编码的统一入口对象。

        Spark Session对象作用：

        ①用于SparkSQL编程作为入口对象。

        ②用于SparkCore编程，可以通过Spark Session对象中获取到Spark Context。

        （2）代码演示
  1. # cording:utf8
  2.  
  3. # Spark Session对象的导包，对象是来自于pyspark.sql包中
  4. from pyspark.sql import SparkSession
  5. if __name__ == '__main__':
  6.     # 构建Spark Session执行环境入口对象
  7.     spark = SparkSession.builder.\
  8.             appName('test').\
  9.             master('local[*]').\
  10.             getOrCreate()
  11.     # 通过Spark Session对象 获取SparkContext对象
  12.     sc = spark.sparkContext
  13.  
  14.     # SparkSQL测试
  15.     df = spark.read.csv('../input/stu_score.txt', sep=',', header=False)
  16.     df2 = df.toDF('id', 'name', 'score')
  17.     # 打印表结构
  18.     # df2.printSchema()
  19.     # 打印数据内容
  20.     # df2.show()
  21.  
  22.     df2.createTempView('score')
  23.     # SQL风格
  24.     spark.sql("""SELECT * FROM score WHERE name='语文' LIMIT 5
  25.     """).show()
  26.  
  27.     # DSL 风格
  28.     df2.where("name='语文'").limit(5).show()

三、DataFrame创建

        （1）DataFrame组成

        DataFrame是一个二维表结构，表格结构的组成：

                ①行

                ②列

                ③表结构描述

        比如，在MySQL中的一个表：

                ①有许多列组成

                ②数据也被分为多个列

                ③表也有表结构信息（列、列名、列类型、列约束等）

        基于这个前提下，DataFrame的组成如下：

                在结构层面：

                        ①StructType对象描述整个DataFrame的表结构

                        ②StructField对象描述一个列的信息

                在数据层面：

                        ①Row对象记录一行数据

                        ②Column对象记录一列数据并包含列的信息

        （2）DataFrame创建方式（转换）

        ①基于RDD方式

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4.  
  5. if __name__ == '__main__':
  6.     # 构建执行环境对象Spark Session
  7.     spark = SparkSession.builder.\
  8.         appName('test').\
  9.         master('local[*]').\
  10.         getOrCreate()
  11.  
  12.     # 构建SparkContext
  13.  
  14.     sc = spark.sparkContext
  15.  
  16.     # 基于RDD转换为DataFrame
  17.     rdd = sc.textFile('../input/people.txt').\
  18.         map(lambda x: x.split(',')).\
  19.         map(lambda x: (x[0], int(x[1])))
  20.  
  21.     # 构建DataFrame对象
  22.     # 参数1，被转换的RDD
  23.     # 参数2，指定列名，通过list的形式指定，按照顺序依次提供字符串名称即可
  24.     df = spark.createDataFrame(rdd,schema=['name', 'age'])
  25.  
  26.     # 打印Data Frame的表结构
  27.     df.printSchema()
  28.  
  29.     # 打印df中的数据
  30.     # 参数1，表示 展示出多少条数据，默认不传的话是20
  31.     # 参数2，表示是否对列进行截断，如果列的数据长度超过20个字符串长度，厚旬欸日不显示，以....代替
  32.     # 如果给False 表示不截断全部显示，默认是True
  33.     df.show(20,False)
  34.  
  35.     # 将DF对象转换成临时视图表，可供sql语句查询
  36.     df.createOrReplaceTempView('people')
  37.     spark.sql('SELECT * FROM people WHERE age < 30').show()

        ②通过StructType对象来定义DataFrame的 ‘ 表结构 ’ 转换RDD

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, IntegerType, StringType
  5. if __name__ == '__main__':
  6.     # 构建执行环境对象Spark Session
  7.     spark = SparkSession.builder.\
  8.         appName('test').\
  9.         master('local[*]').\
  10.         getOrCreate()
  11.  
  12.     # 构建SparkContext
  13.  
  14.     sc = spark.sparkContext
  15.  
  16.     # 基于RDD转换为DataFrame
  17.     rdd = sc.textFile('../input/people.txt').\
  18.         map(lambda x: x.split(',')).\
  19.         map(lambda x: (x[0], int(x[1])))
  20.  
  21.     # 构建表结构的描述对象：StructType 对象
  22.     # 参数1，列名
  23.     # 参数2，列数据类型
  24.     # 参数3，是否允许为空
  25.     schema = StructType().add('name', StringType(), nullable=True).\
  26.         add('age', IntegerType(), nullable=False)
  27.  
  28.     # 构建DataFrame对象
  29.     # 参数1，被转换的RDD
  30.     # 参数2，指定列名，通过list的形式指定，按照顺序依次提供字符串名称即可
  31.     df = spark.createDataFrame(rdd, schema=schema)
  32.  
  33.     df.printSchema()
  34.     df.show()

        ③通过RDD的toDF方法创建RDD

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, IntegerType, StringType
  5. if __name__ == '__main__':
  6.     # 构建执行环境对象Spark Session
  7.     spark = SparkSession.builder.\
  8.         appName('test').\
  9.         master('local[*]').\
  10.         getOrCreate()
  11.  
  12.     # 构建SparkContext
  13.  
  14.     sc = spark.sparkContext
  15.  
  16.     # 基于RDD转换为DataFrame
  17.     rdd = sc.textFile('../input/people.txt').\
  18.         map(lambda x: x.split(',')).\
  19.         map(lambda x: (x[0], int(x[1])))
  20.  
  21.     # toDF构建DataFrame
  22.     # 第一种构建方式，只能设置列名，列类型靠RDD推断，默认允许为空
  23.     df1 = rdd.toDF(['name', 'name'])
  24.     df1.printSchema()
  25.     df1.show()
  26.     # toDF方式2：通过StructType来构造
  27.     # 设置全面，能设置列名、列数据类型、是否为空
  28.     # 构建表结构的描述对象：StructType 对象
  29.     # 参数1，列名
  30.     # 参数2，列数据类型
  31.     # 参数3，是否允许为空
  32.     schema = StructType().add('name', StringType(), nullable=True).\
  33.         add('age', IntegerType(), nullable=False)
  34.  
  35.     df2 = rdd.toDF(schema=schema)
  36.     df2.printSchema()
  37.     df2.show()
  38.  
  39.  
  40.  
  41.

        ④基于Pandas的DataFrame创建DataFrame

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. import pandas as pd
  5.  
  6. if __name__ == '__main__':
  7.     # 构建执行环境入口对象SparkSession
  8.     spark = SparkSession.builder.\
  9.         appName('test').\
  10.         master('local[*]').\
  11.         getOrCreate()
  12.     sc = spark.sparkContext
  13.  
  14.     # 基于pandas的DataFrame构建SparkSQL的DataFrame对象
  15.     pdf = pd.DataFrame(
  16.         {
  17.             'id': [1, 2, 3],
  18.             'name': ['张大仙', '王晓晓', '吕不韦'],
  19.             'age': [1, 2, 3]
  20.         }
  21.     )
  22.  
  23.     df = spark.createDataFrame(pdf)
  24.  
  25.     df.printSchema()
  26.     df.show()

        （3）DataFrame创建方式（标准API读取）

        统一API示例代码：

        ①读取本地text文件

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, StringType
  5.  
  6. if __name__ == '__main__':
  7.     # 构建执行环境入口对象SparkSession
  8.     spark = SparkSession.builder.\
  9.         appName('test').\
  10.         master('local[*]').\
  11.         getOrCreate()
  12.     sc = spark.sparkContext
  13.  
  14.     # 构建StructType，text数据源，
  15.     # text读取数据的特点是：将一整行只作为一个列读取，默认列名是value 类型是String
  16.     schema = StructType().add('data', StringType(),nullable=True)
  17.     df = spark.read.format('text').\
  18.         schema(schema=schema).\
  19.         load('../input/people.txt')
  20.  
  21.     df.printSchema()
  22.     df.show()

        ②读取json文件

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, StringType
  5.  
  6. if __name__ == '__main__':
  7.     # 构建执行环境入口对象SparkSession
  8.     spark = SparkSession.builder.\
  9.         appName('test').\
  10.         master('local[*]').\
  11.         getOrCreate()
  12.     sc = spark.sparkContext
  13.  
  14.     # json文件类型自带Schema信息
  15.     df = spark.read.format('json').load('../input/people.json')
  16.     df.printSchema()
  17.     df.show()

        ③读取csv文件

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, StringType
  5.  
  6. if __name__ == '__main__':
  7.     # 构建执行环境入口对象SparkSession
  8.     spark = SparkSession.builder.\
  9.         appName('test').\
  10.         master('local[*]').\
  11.         getOrCreate()
  12.     sc = spark.sparkContext
  13.  
  14.     # 读取csv文件
  15.     df = spark.read.format('csv').\
  16.         option('sep', ';').\
  17.         option('header', True).\
  18.         option('encoding', 'utf-8').\
  19.         schema('name STRING, age INT, job STRING').\
  20.         load('../input/people.csv')
  21.  
  22.     df.printSchema()
  23.     df.show()

        ④读取parquet文件

        parquet文件：是Spark中常用的一种列式存储文件格式，和Hive中的ORC差不多，他们都是列存储格式。

        parquet对比普通的文本文件的区别：

                ①parquet内置schema（列名、列类型、是否为空）

                ②存储是以列作为存储格式

                ③存储是序列化存储在文件中的（有压缩属性体积小）

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, StringType
  5.  
  6. if __name__ == '__main__':
  7.     # 构建执行环境入口对象SparkSession
  8.     spark = SparkSession.builder.\
  9.         appName('test').\
  10.         master('local[*]').\
  11.         getOrCreate()
  12.     sc = spark.sparkContext
  13.  
  14.     # 读取parquet文件
  15.     df = spark.read.format('parquet').load('../input/users.parquet')
  16.  
  17.     df.printSchema()
  18.     df.show()

四、DataFrame编程

        （1）DSL语法风格
  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, StringType
  5.  
  6. if __name__ == '__main__':
  7.     # 构建执行环境入口对象SparkSession
  8.     spark = SparkSession.builder.\
  9.         appName('test').\
  10.         master('local[*]').\
  11.         getOrCreate()
  12.     sc = spark.sparkContext
  13.  
  14.     df = spark.read.format('csv').\
  15.         schema('id INT, subject STRING, score INT').\
  16.         load('../input/stu_score.txt')
  17.  
  18.     # Column对象的获取
  19.     id_column = df['id']
  20.     subject_column = df['subject']
  21.  
  22.     # DLS风格
  23.     df.select(['id', 'subject']).show()
  24.     df.select('id', 'subject').show()
  25.     df.select(id_column, subject_column).show()
  26.  
  27.     # filter API
  28.     df.filter('score < 99').show()
  29.     df.filter(df['score'] < 99).show()
  30.  
  31.     # where API
  32.     df.where('score < 99').show()
  33.     df.where(df['score'] < 99).show()
  34.  
  35.     # group By API
  36.     # df.groupBy API的返回值为 GroupedData类型1
  37.     # GroupedData对象不是DataFrame
  38.     # 它是一个 有分组关系的数据结构，有一些API供我们对分组做聚合
  39.     # SQL：group by 后接上聚合： sum avg count min max
  40.     # GroupedData 类似于SQL分组后的数据结构，同样由上述5中聚合方法
  41.     # GroupedData 调用聚合方法后，返回值依旧是DayaFrame
  42.     # GroupedData 只是一个中转的对象，最终还是会获得DataFrame的结果
  43.     df.groupBy('subject').count().show()
  44.     df.groupBy(df['subject']).count().show()
        （2）SQL语法风格

        DataFrame的一个强大之处就是我们可以将它看作是一个关系型数据表，然后可以通过在程序中使用spark.sql()来执行SQL语句查询，结果返回一个DataFrame。
        如果想使用SQL风格的语法，需要将DataFrame注册成表，采用如下的方式：        

  1. df.createTempView( "score")            #注册一个临时视图(表)
  2. df.create0rReplaceTempView("score")    #注册一个临时表，如果存在进行替换。
  3. df.createGlobalTempView( "score")      #注册一个全局表

        全局表：跨SparkSession对象使用，在一个程序内的多个SparkSession中均可调用，查询前带上前缀：
        global_temp.
        临时表：只在当前SparkSession中可用

  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql.types import StructType, StringType
  5.  
  6. if __name__ == '__main__':
  7.     # 构建执行环境入口对象SparkSession
  8.     spark = SparkSession.builder.\
  9.         appName('test').\
  10.         master('local[*]').\
  11.         getOrCreate()
  12.     sc = spark.sparkContext
  13.  
  14.     df = spark.read.format('csv').\
  15.         schema('id INT, subject STRING, score INT').\
  16.         load('../input/stu_score.txt')
  17.  
  18.     # 注册成临时表
  19.     df.createTempView('score')              # 注册临时视图（表）
  20.     df.createOrReplaceTempView('score_2')   # 注册或者替换为临时视图
  21.     df.createGlobalTempView('score_3')      # 注册全局临时视图 全局临时视图使用的时候 需要在前面带上global_temp. 前缀
  22.  
  23.     # 可以通过SparkSession对象的sql api来完成sql语句的执行
  24.     spark.sql("SELECT subject, COUNT(*) AS cnt FROM score GROUP BY subject").show()
  25.     spark.sql("SELECT subject, COUNT(*) AS cnt FROM score_2 GROUP BY subject").show()
  26.     spark.sql("SELECT subject, COUNT(*) AS cnt FROM global_temp.score_3 GROUP BY subject").show()

五、Spark SQL——wordcount代码示例

        （1）pyspark.sql.functions包

        这个包里面提供了一系列的计算函数供SparkSQL使用

        导包：from pyspark.sql import functions as F

        这些函数返回值多数都是Column对象。

        （2）代码示例
  1. # cording:utf8
  2.  
  3. from pyspark.sql import SparkSession
  4. from pyspark.sql import functions as F
  5.  
  6. if __name__ == '__main__':
  7.     spark = SparkSession.builder.appName('wordcount').master('local[*]').getOrCreate()
  8.     sc = spark.sparkContext
  9.  
  10.     # TODO 1：SQL风格进行处理
  11.     rdd = sc.textFile('../input/words.txt').\
  12.         flatMap(lambda x: x.split(' ')).\
  13.         map(lambda x: [x])
  14.  
  15.     df = rdd.toDF(['word'])
  16.  
  17.     # 注册DF为表格
  18.     df.createTempView('words')
  19.  
  20.     spark.sql('SELECT word,COUNT(*) AS cnt FROM words GROUP BY word ORDER BY cnt DESC').show()
  21.  
  22.     # TODO 2:DSL 风格处理
  23.     df = spark.read.format('text').load('../input/words.txt')
  24.  
  25.     # withColumn 方法
  26.     # 方法功能：对已存在的列进行操作，返回一个新的列，如果名字和老列相同，那么替换，否则作为新列存在
  27.     df2 = df.withColumn('value', F.explode(F.split(df['value'], ' ')))
  28.     df2.groupBy('value').\
  29.         count().\
  30.         withColumnRenamed('value', 'word').\
  31.         withColumnRenamed('count', 'cnt').\
  32.         orderBy('cnt', ascending=False).show()
  33.  
  34.     # withColumnRenamed() 对列名进行重命名
  35.     # orderBy() 排序

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/776495
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号