SparkSQL系列-6、外部数据源 DataSource？

最新推荐文章于 2024-08-22 09:40:31 发布
最新推荐文章于 2024-08-22 09:40:31 发布
阅读量994 收藏 1
点赞数
分类专栏： 大数据专栏 文章标签： spark 大数据 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l848168/article/details/126419845
版权

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

传送门：大数据系列文章目录

官方网址：http://spark.apache.org/、 http://spark.apache.org/sql/
在这里插入图片描述

目录

SparkSQL支持哪些外部数据源？

在SparkSQL模块，提供一套完成API接口，用于方便读写外部数据源的的数据（从Spark 1.4版本提供），框架本身内置外部数据源：
在这里插入图片描述
在Spark 2.4版本中添加支持Image Source（图像数据源）和Avro Source。

数据源与格式

数据分析处理中，数据可以分为结构化数据、非结构化数据及半结构化数据。
在这里插入图片描述

1）、结构化数据（Structured）

  • 结构化数据源可提供有效的存储和性能。例如， Parquet和ORC等柱状格式使从列的子集中提取值变得更加容易。
  • 基于行的存储格式（如Avro）可有效地序列化和存储提供存储优势的数据。然而，这些优点通常以灵活性为代价。如因结构的固定性，格式转变可能相对困难。

2）、非结构化数据（UnStructured）

  • 相比之下，非结构化数据源通常是自由格式文本或二进制对象，其不包含标记或元数据以定义数据的结构。
  • 报纸文章，医疗记录，图像，应用程序日志通常被视为非结构化数据。这些类型的源通常要求数据周围的上下文是可解析的。

3）、半结构化数据（Semi-Structured）

  • 半结构化数据源是按记录构建的，但不一定具有跨越所有记录的明确定义的全局模式。每个数据记录都使用其结构信息进行扩充。
  • 半结构化数据格式的好处是，它们在表达数据时提供了最大的灵活性，因为每条记录都是自我描述的。但这些格式的主要缺点是它们会产生额外的解析开销，并且不是特别为ad-hoc(特定)查询而构建的。

加载/保存数据

SparkSQL提供一套通用外部数据源接口，方便用户从数据源加载和保存数据，例如从MySQL表中既可以加载读取数据： load/read，又可以保存写入数据： save/write。
在这里插入图片描述
由于SparkSQL没有内置支持从HBase表中加载和保存数据，但是只要实现外部数据源接口，也能像上面方式一样读取加载数据

Load 加载数据

在SparkSQL中读取数据使用SparkSession读取，并且封装到数据结构Dataset/DataFrame中。
在这里插入图片描述
DataFrameReader专门用于加载load读取外部数据源的数据，基本格式如下：
在这里插入图片描述
SparkSQL模块本身自带支持读取外部数据源的数据：
在这里插入图片描述
总结起来三种类型数据，也是实际开发中常用的：

第一类：文件格式数据

  • 文本文件text、 csv文件和json文件

第二类：列式存储数据

  • Parquet格式、 ORC格式

第三类：数据库表

  • 关系型数据库RDBMS： MySQL、 DB2、 Oracle和MSSQL
  • Hive仓库表

在这里插入图片描述

官方文档： http://spark.apache.org/docs/2.4.5/sql-data-sources-load-save-functions.html

此外加载文件数据时， 可以直接使用SQL语句，指定文件存储格式和路径：
在这里插入图片描述

Save 保存数据

SparkSQL模块中可以从某个外部数据源读取数据，就能向某个外部数据源保存数据，提供相应接口，通过DataFrameWrite类将数据进行保存。
在这里插入图片描述
与DataFrameReader类似，提供一套规则，将数据Dataset保存，基本格式如下：
在这里插入图片描述
SparkSQL模块内部支持保存数据源如下：
在这里插入图片描述
所以使用SpakrSQL分析数据时，从数据读取，到数据分析及数据保存，链式操作，更多就是ETL操作。 当将结果数据DataFrame/Dataset保存至Hive表中时，可以设置分区partition和分桶bucket，形式如下：
在这里插入图片描述

案例演示

加载json格式数据，提取name和age字段值，保存至Parquet列式存储文件。

// 加载json数据
val peopleDF = spark.read.format("json").load("/datas/resources/people.json")
val resultDF = peopleDF.select("name", "age")
// 保存数据至parquet
resultDF.write.format("parquet").save("/datas/people-parquet")

在spark-shell上执行上述语句，截图结果如下：
在这里插入图片描述

查看HDFS文件系统目录，数据已保存值parquet文件，并且使用snappy压缩。
在这里插入图片描述

保存模式（SaveMode）

将Dataset/DataFrame数据保存到外部存储系统中，考虑是否存在，存在的情况下的下如何进行保存， DataFrameWriter中有一个mode方法指定模式：
在这里插入图片描述
通过源码发现SaveMode时枚举类，使用Java语言编写，如下四种保存模式：

  1. Append 追加模式，当数据存在时，继续追加；
  2. Overwrite 覆写模式，当数据存在时，覆写以前数据，存储当前最新数据；
  3. ErrorIfExists 存在及报错；
  4. Ignore 忽略，数据存在时不做任何操作；

实际项目依据具体业务情况选择保存模式，通常选择Append和Overwrite模式。

parquet 数据

SparkSQL模块中默认读取数据文件格式就是parquet列式存储数据， 通过参数
【spark.sql.sources.default】设置，默认值为【parquet】。
范例演示代码： 直接load加载parquet数据和指定parquet格式加载数据。

import org.apache.spark.sql.{DataFrame, SparkSession}
/**
 * SparkSQL读取Parquet列式存储数据
 */
object SparkSQLParquet {
  def main(args: Array[String]): Unit = {
    // 构建SparkSession实例对象，通过建造者模式创建
    val spark: SparkSession = SparkSession
      .builder()
      .appName(this.getClass.getSimpleName.stripSuffix("$"))
      .master("local[3]")
      .getOrCreate()
    import spark.implicits._
    // TODO: 从LocalFS上读取parquet格式数据
    val usersDF: DataFrame = spark.read.parquet("datas/resources/users.parquet")
    usersDF.printSchema()
    usersDF.show(10, truncate = false)
    // SparkSQL默认读取文件格式为parquet
    val df = spark.read.load("datas/resources/users.parquet")
    df.printSchema()
    df.show(10, truncate = false)
    // 应用结束，关闭资源
    spark.stop()
  }
}

运行程序结果：

root
 |-- name: string (nullable = true)
 |-- favorite_color: string (nullable = true)
 |-- favorite_numbers: array (nullable = true)
 |    |-- element: integer (containsNull = true)

+------+--------------+----------------+
|name  |favorite_color|favorite_numbers|
+------+--------------+----------------+
|Alyssa|null          |[3, 9, 15, 20]  |
|Ben   |red           |[]              |
+------+--------------+----------------+

root
 |-- name: string (nullable = true)
 |-- favorite_color: string (nullable = true)
 |-- favorite_numbers: array (nullable = true)
 |    |-- element: integer (containsNull = true)

+------+--------------+----------------+
|name  |favorite_color|favorite_numbers|
+------+--------------+----------------+
|Alyssa|null          |[3, 9, 15, 20]  |
|Ben   |red           |[]              |
+------+--------------+----------------+

text 数据

SparkSession加载文本文件数据，提供两种方法，返回值分别为DataFrame和Dataset，前面【入门案例：词频统计WordCount】中已经使用，下面看一下方法声明：
在这里插入图片描述
可以看出textFile方法底层还是调用text方法，先加载数据封装到DataFrame中，再使用as[String]方法将DataFrame转换为Dataset，实际项目中推荐使用textFile方法，从Spark 2.0开始提供。

无论是text方法还是textFile方法读取文本数据时， 一行一行的加载数据，每行数据使用UTF-8编码的字符串，列名称为【value】 。

范例演示： 分别使用text和textFile方法加载数据。

import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}
/**
 * SparkSQL加载文本文件数据，方法text和textFile
 */
object SparkSQLText {
  def main(args: Array[String]): Unit = {
    // 构建SparkSession实例对象，通过建造者模式创建
    val spark: SparkSession = SparkSession
      .builder()
      .appName(this.getClass.getSimpleName.stripSuffix("$"))
      .master("local[3]")
      .getOrCreate() // 底层实现：单例模式，创建SparkContext对象
    Logger.getRootLogger.setLevel(Level.WARN)
    // TODO: text方法加载数据，封装至DataFrame中
    val dataframe: DataFrame = spark.read.text("datas/resources/people.txt")
    dataframe.printSchema()
    dataframe.show(10, truncate = false)
    println("=================================================")
    val dataset: Dataset[String] = spark.read.textFile("datas/resources/people.txt")
    dataset.printSchema()
    dataset.show(10, truncate = false)
    spark.stop()// 应用结束，关闭资源
  }
}

执行结果：

root
 |-- value: string (nullable = true)

+-----------+
|value      |
+-----------+
|Michael, 29|
|Andy, 30   |
|Justin, 19 |
+-----------+

=================================================
root
 |-- value: string (nullable = true)

+-----------+
|value      |
+-----------+
|Michael, 29|
|Andy, 30   |
|Justin, 19 |
+-----------+

json 数据

实际项目中，有时处理数据以JSON格式存储的，尤其后续结构化流式模块：
StructuredStreaming，从Kafka Topic消费数据很多时候是JSON个数据，封装到DataFrame中，需要解析提取字段的值。以读取github操作日志JSON数据为例，数据结构如下：
在这里插入图片描述
1）、操作日志数据使用GZ压缩： 2015-03-01-11.json.gz，先使用json方法读取。

// 构建SparkSession实例对象，通过建造者模式创建
val spark: SparkSession = SparkSession
.builder()
.appName(this.getClass.getSimpleName.stripSuffix("$"))
.master("local[3]")
// 底层实现：单例模式，创建SparkContext对象
.getOrCreate()
import spark.implicits._

// TODO: 从LocalFS上读取json格式数据(压缩）
val jsonDF: DataFrame = spark.read.json("datas/json/2015-03-01-11.json.gz")
jsonDF.printSchema()
jsonDF.show(10, truncate = true)

2）、使用textFile加载数据，对每条JSON格式字符串数据，使用SparkSQL函数库functions中自带get_json_obejct函数提取字段： id、 type、 public和created_at的值。

函数： get_json_obejct使用说明
在这里插入图片描述
范例演示完整代码：

import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}

/**
 * SparkSQL读取JSON格式文本数据
 */
object SparkSQLJson {
  def main(args: Array[String]): Unit = {
    // 构建SparkSession实例对象，通过建造者模式创建
    val spark: SparkSession = SparkSession
      .builder()
      .appName(this.getClass.getSimpleName.stripSuffix("$"))
      .master("local[3]")
      // 底层实现：单例模式，创建SparkContext对象
      .getOrCreate()
    Logger.getRootLogger.setLevel(Level.WARN)
    import spark.implicits._
    // TODO: 从LocalFS上读取json格式数据(压缩）
    val jsonDF: DataFrame = spark.read.json("datas/json/2015-03-01-11.json.gz")
    jsonDF.printSchema()
    jsonDF.show(10, truncate = true)
    println("===================================================")
    val githubDS: Dataset[String] = spark.read.textFile("datas/json/2015-03-01-11.json.gz")
    githubDS.printSchema() // value 字段名称，类型就是String
    githubDS.show(1)
    // TODO：使用SparkSQL自带函数，针对JSON格式数据解析的函数
    import org.apache.spark.sql.functions._
    // 获取如下四个字段的值： id、 type、 public和created_at
    val gitDF: DataFrame = githubDS.select(
      get_json_object($"value", "$.id").as("id"),
      get_json_object($"value", "$.type").as("type"),
      get_json_object($"value", "$.public").as("public"),
      get_json_object($"value", "$.created_at").as("created_at")
    )
    gitDF.printSchema()
    gitDF.show(10, truncate = false)
    // 应用结束，关闭资源
    spark.stop()
  }
}

csv 数据

在机器学习中，常常使用的数据存储在csv/tsv文件格式中，所以SparkSQL中也支持直接读取格式数据，从2.0版本开始内置数据源。关于CSV/TSV格式数据说明：

在这里插入图片描述
SparkSQL中读取CSV格式数据，可以设置一些选项，重点选项：

1）、分隔符： sep

  • 默认值为逗号，必须单个字符

2）、数据文件首行是否是列名称： header

  • 默认值为false，如果数据文件首行是列名称，设置为true

3）、是否自动推断每个列的数据类型： inferSchema

  • 默认值为false，可以设置为true

官方提供案例：

在这里插入图片描述

当读取CSV/TSV格式数据文件首行是否是列名称，读取数据方式（参数设置）不一样的 。

第一点：首行是列的名称，如下方式读取数据文件

// TODO: 读取TSV格式数据
val ratingsDF: DataFrame = spark.read
// 设置每行数据各个字段之间的分隔符， 默认值为 逗号
.option("sep", "\t")
// 设置数据文件首行为列名称，默认值为 false
.option("header", "true")
// 自动推荐数据类型，默认值为false
.option("inferSchema", "true")
// 指定文件的路径
.csv("datas/ml-100k/u.dat")
ratingsDF.printSchema()
ratingsDF.show(10, truncate = false)

第二点：首行不是列的名称，如下方式读取数据（设置Schema信息）

// 定义Schema信息
val schema = StructType(
StructField("user_id", IntegerType, nullable = true) ::
StructField("movie_id", IntegerType, nullable = true) ::
StructField("rating", DoubleType, nullable = true) ::
StructField("timestamp", StringType, nullable = true) :: Nil
)
// TODO: 读取TSV格式数据
val mlRatingsDF: DataFrame = spark.read
// 设置每行数据各个字段之间的分隔符， 默认值为 逗号
.option("sep", "\t")
// 指定Schema信息
.schema(schema)
// 指定文件的路径
.csv("datas/ml-100k/u.data")
mlRatingsDF.printSchema()
mlRatingsDF.show(5, truncate = false)

将DataFrame数据保存至CSV格式文件，演示代码如下：

/**
* 将电影评分数据保存为CSV格式数据
*/
mlRatingsDF
// 降低分区数，此处设置为1，将所有数据保存到一个文件中
.coalesce(1)
.write
// 设置保存模式，依据实际业务场景选择，此处为覆写
.mode(SaveMode.Overwrite)
.option("sep", ",")
// TODO: 建议设置首行为列名
.option("header", "true")
.csv("datas/ml-csv-" + System.nanoTime())

范例演示完整代码SparkSQLCsv.scala如下：

import org.apache.log4j.{Level, Logger}
import org.apache.spark.SparkContext
import org.apache.spark.sql.types._
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}

/**
 * SparkSQL 读取CSV/TSV格式数据：
 * i). 指定Schema信息
 * ii). 是否有header设置
 */
object SparkSQLCsv {
  def main(args: Array[String]): Unit = {
    // 构建SparkSession实例对象
    val spark: SparkSession = SparkSession.builder()
      .appName(SparkSQLCsv.getClass.getSimpleName)
      .master("local[2]")
      .getOrCreate()

    Logger.getRootLogger.setLevel(Level.WARN)
    import spark.implicits._
    // 获取SparkContext实例对象
    val sc: SparkContext = spark.sparkContext
    /**
     * 实际企业数据分析中
     * csv\tsv格式数据，每个文件的第一行（head, 首行），字段的名称（列名）
     */
    // TODO: 读取TSV格式数据
    val ratingsDF: DataFrame = spark.read
      // 设置每行数据各个字段之间的分隔符， 默认值为 逗号
      .option("sep", "\t")
      // 设置数据文件首行为列名称，默认值为 false
      .option("header", "true")
      // 自动推荐数据类型，默认值为false
      .option("inferSchema", "true")
      // 指定文件的路径
      .csv("datas/ml-100k/u.dat")
    ratingsDF.printSchema()
    ratingsDF.show(10, truncate = false)
    // 定义Schema信息
    val schema = StructType(
      StructField("user_id", IntegerType, nullable = true) ::
        StructField("movie_id", IntegerType, nullable = true) ::
        StructField("rating", DoubleType, nullable = true) ::
        StructField("timestamp", StringType, nullable = true) :: Nil
    )
    // TODO: 读取TSV格式数据
    val mlRatingsDF: DataFrame = spark.read
      // 设置每行数据各个字段之间的分隔符， 默认值为 逗号
      .option("sep", "\t")
      // 指定Schema信息
      .schema(schema)
      // 指定文件的路径
      .csv("datas/ml-100k/u.data")
    mlRatingsDF.printSchema()
    mlRatingsDF.show(5, truncate = false)
    // 将电影评分数据保存为CSV格式数据
    mlRatingsDF
      // 降低分区数，此处设置为1，将所有数据保存到一个文件中
      .coalesce(1)
      .write
      // 设置保存模式，依据实际业务场景选择，此处为覆写
      .mode(SaveMode.Overwrite)
      .option("sep", ",")
      // TODO: 建议设置首行为列名
      .option("header", "true")
      .csv("datas/ml-csv-" + System.nanoTime())
    // 关闭资源
    spark.stop()
  }
}

执行结果：

root
 |-- userId: integer (nullable = true)
 |-- movieId: integer (nullable = true)
 |-- rating: integer (nullable = true)
 |-- timestamp: integer (nullable = true)

+------+-------+------+---------+
|userId|movieId|rating|timestamp|
+------+-------+------+---------+
|196   |242    |3     |881250949|
|186   |302    |3     |891717742|
|22    |377    |1     |878887116|
|244   |51     |2     |880606923|
|166   |346    |1     |886397596|
|298   |474    |4     |884182806|
|115   |265    |2     |881171488|
|253   |465    |5     |891628467|
|305   |451    |3     |886324817|
|6     |86     |3     |883603013|
+------+-------+------+---------+
only showing top 10 rows

root
 |-- user_id: integer (nullable = true)
 |-- movie_id: integer (nullable = true)
 |-- rating: double (nullable = true)
 |-- timestamp: string (nullable = true)

+-------+--------+------+---------+
|user_id|movie_id|rating|timestamp|
+-------+--------+------+---------+
|196    |242     |3.0   |881250949|
|186    |302     |3.0   |891717742|
|22     |377     |1.0   |878887116|
|244    |51      |2.0   |880606923|
|196    |242     |3.0   |881250949|
+-------+--------+------+---------+
only showing top 5 rows

rdbms 数据

回顾在SparkCore中读取MySQL表的数据通过JdbcRDD来读取的，在SparkSQL模块中提供对应接口，提供三种方式读取数据：

方式一： 单分区模式
在这里插入图片描述
方式二： 多分区模式，可以设置列的名称，作为分区字段及列的值范围和分区数目
在这里插入图片描述

方式三： 高度自由分区模式，通过设置条件语句设置分区数据及各个分区数据范围
在这里插入图片描述
当加载读取RDBMS表的数据量不大时，可以直接使用单分区模式加载；当数据量很多时，考虑使用多分区及自由分区方式加载。

从RDBMS表中读取数据，需要设置连接数据库相关信息，基本属性选项如下：
在这里插入图片描述

范例演示： 以MySQL数据库为例，加载订单表so数据，首先添加数据库驱动依赖包：

<dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>8.0.19</version>
</dependency>

完整演示代码如下：

import java.util.Properties

import org.apache.log4j.{Level, Logger}
import org.apache.spark.sql.{DataFrame, SparkSession}

/**
 * 使用SparkSession从RDBMS 表中读取数据，此处以MySQL数据库为例
 */
object SparkSQLMySQL {
  def main(args: Array[String]): Unit = {
    // 在SparkSQL中，程序的同一入口为SparkSession实例对象，构建采用是建造者模式
    val spark: SparkSession = SparkSession.builder()
      .master("local[4]")
      .appName("SparkSQLMySQL")
      .config("spark.sql.shuffle.partitions", "4")
      .getOrCreate()
    Logger.getRootLogger.setLevel(Level.WARN)
    // 导入隐式转换
    import spark.implicits._
    // 连接数据库三要素信息
    val url: String = "jdbc:mysql://localhost:3306/test?serverTimezone=UTC&characterEncoding=utf8&useUnicode = true"
      val table: String = "t_pay_log"
      // 存储用户和密码等属性
      val props: Properties = new Properties ()
      props.put ("driver", "com.mysql.cj.jdbc.Driver")
      props.put ("user", "root")
      props.put ("password", "123456")
      // TODO: 从MySQL数据库表：支付记录表
      // def jdbc(url: String, table: String, properties: Properties): DataFrame
      val sosDF: DataFrame = spark.read.jdbc (url, table, props)
      println (s"Count = ${sosDF.count()}"
    )
    sosDF.printSchema()
    sosDF.show(10, truncate = false)
    // 关闭资源
    spark.stop()
  }
}

执行结果：

Count = 622
root
 |-- id: long (nullable = true)
 |-- create_date: timestamp (nullable = true)
 |-- modify_date: timestamp (nullable = true)
 |-- store_id: long (nullable = true)
 |-- distributor_id: long (nullable = true)
 |-- pay_order_type: integer (nullable = true)
 |-- payer_user_id: string (nullable = true)
 |-- payee_user_id: string (nullable = true)
 |-- payee_account_number: string (nullable = true)
 |-- order_id: long (nullable = true)
 |-- order_no: string (nullable = true)
 |-- amount: decimal(20,2) (nullable = true)
 |-- deduction_amount: decimal(20,2) (nullable = true)
 |-- credit_amount: decimal(20,2) (nullable = true)
 |-- net_receipts_amount: decimal(20,2) (nullable = true)
 |-- net_receipts_amount_cent: string (nullable = true)
 |-- pay_time: timestamp (nullable = true)
 |-- pay_sn: string (nullable = true)
 |-- binding_tx_sn: string (nullable = true)
 |-- binding_card_id: long (nullable = true)
 |-- pay_status_name: string (nullable = true)
 |-- pay_status: string (nullable = true)
 |-- pay_type: string (nullable = true)
 |-- pay_name: string (nullable = true)
 |-- is_send_cpcn_pay: boolean (nullable = true)
 |-- pay_business_type: integer (nullable = true)
 |-- ext_type: integer (nullable = true)
 |-- is_deduction_amount_return: boolean (nullable = true)
 |-- callback_time: timestamp (nullable = true)
 |-- service_charge: decimal(20,2) (nullable = true)
 |-- is_duplicate_pay: boolean (nullable = true)
 |-- accept_time: timestamp (nullable = true)
 |-- is_delete: boolean (nullable = true)
 |-- remark: string (nullable = true)

+---+-------------------+-------------------+--------+--------------+--------------+----------------------+----------------------+--------------------+--------+---------------------+------+----------------+-------------+-------------------+------------------------+-------------------+---------------------------+---------------------------+---------------+---------------+----------+--------+--------+----------------+-----------------+--------+--------------------------+-------------+--------------+----------------+-----------+---------+------+
|id |create_date        |modify_date        |store_id|distributor_id|pay_order_type|payer_user_id         |payee_user_id         |payee_account_number|order_id|order_no             |amount|deduction_amount|credit_amount|net_receipts_amount|net_receipts_amount_cent|pay_time           |pay_sn                     |binding_tx_sn              |binding_card_id|pay_status_name|pay_status|pay_type|pay_name|is_send_cpcn_pay|pay_business_type|ext_type|is_deduction_amount_return|callback_time|service_charge|is_duplicate_pay|accept_time|is_delete|remark|
+---+-------------------+-------------------+--------+--------------+--------------+----------------------+----------------------+--------------------+--------+---------------------+------+----------------+-------------+-------------------+------------------------+-------------------+---------------------------+---------------------------+---------------+---------------+----------+--------+--------+----------------+-----------------+--------+--------------------------+-------------+--------------+----------------+-----------+---------+------+
|3  |2021-10-23 21:49:52|2021-11-28 18:44:15|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7328    |STO816349545592226499|0.02  |0.00            |null         |0.02               |2                       |null               |202110231349288471914024279|202110211551567835530441719|218            |支付失败       |40        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|4  |2021-10-25 17:36:56|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7328    |STO816349545592226499|0.02  |0.00            |null         |0.02               |2                       |null               |202110250936497741984473432|202110211551567835530441719|218            |支付失败       |40        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|5  |2021-10-25 17:49:48|2021-11-28 18:44:23|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7328    |STO816349545592226499|0.02  |0.00            |null         |0.02               |2                       |null               |202110250949434516009115077|202110211551567835530441719|218            |支付失败1      |40        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|6  |2021-10-25 19:16:05|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7328    |STO816349545592226499|0.02  |0.00            |null         |0.02               |2                       |null               |202110251116020875276500203|202110211551567835530441719|218            |支付失败       |40        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|7  |2021-10-25 19:32:28|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7328    |STO816349545592226499|0.02  |0.00            |null         |0.02               |2                       |null               |202110251132225246101010159|202110211551567835530441719|218            |支付失败       |40        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |false    |null  |
|8  |2021-10-25 20:13:11|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7329    |STO816351349582806323|0.02  |0.00            |null         |0.02               |2                       |null               |202110251213063509169295561|202110211551567835530441719|218            |支付处理中     |20        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|9  |2021-10-25 20:25:16|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7329    |STO816351349582806323|0.02  |0.00            |null         |0.02               |2                       |2021-10-25 20:26:54|202110251225113602792072707|202110211551567835530441719|218            |支付成功       |30        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|10 |2021-10-25 20:35:29|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7329    |STO816351349582806323|0.02  |0.00            |null         |0.02               |2                       |null               |202110251235236495282362928|202110211551567835530441719|218            |支付失败       |40        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|11 |2021-10-25 20:41:24|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7329    |STO816351349582806323|0.02  |0.00            |null         |0.02               |2                       |null               |202110251241198087141763857|202110211551567835530441719|218            |支付处理中     |20        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |true     |null  |
|12 |2021-10-25 20:47:25|2021-11-15 23:57:25|24098   |1             |1             |PE20211021153512861672|PE20211013104025354326|null                |7330    |STO816351371385476431|0.02  |0.00            |null         |0.02               |2                       |null               |202110251247195197853981367|202110211551567835530441719|218            |支付失败       |40        |0       |快捷支付|true            |0                |null    |false                     |null         |0.00          |false           |null       |false    |null  |
+---+-------------------+-------------------+--------+--------------+--------------+----------------------+----------------------+--------------------+--------+---------------------+------+----------------+-------------+-------------------+------------------------+-------------------+---------------------------+---------------------------+---------------+---------------+----------+--------+--------+----------------+-----------------+--------+--------------------------+-------------+--------------+----------------+-----------+---------+------+
only showing top 10 rows

可以使用option方法设置连接数据库信息，而不使用Properties传递，代码如下：

// TODO： 使用option设置参数
val dataframe: DataFrame = spark.read
.format("jdbc")
.option("driver", "com.mysql.cj.jdbc.Driver")
.option("url", "jdbc:mysql://localhost:3306/test?serverTimezone=UTC&characterEncoding=utf8&useUnicode=tru
.option("user", "root")
.option("password", "123456")
.option("dbtable", "t_pay_log")
.load()
dataframe.show(5, truncate = false)

hive 数据

Spark SQL模块从发展来说，从Apache Hive框架而来，发展历程： Hive（MapReduce） -> Shark(Hive on Spark) -> Spark SQL（SchemaRDD -> DataFrame -> Dataset)，所以SparkSQL天然无缝集成Hive，可以加载Hive表数据进行分析。

官方文档： http://spark.apache.org/docs/2.4.5/sql-data-sources-hive-tables.html

spark-shell 集成 Hive

第一步、当编译Spark源码时，需要指定集成Hive，命令如下：

在这里插入图片描述
官方文档： http://spark.apache.org/docs/2.4.5/building-spark.html#building-with-hive-and-jdbc-support

第二步、 SparkSQL集成Hive本质就是： 读取Hive框架元数据MetaStore，此处启动Hive MetaStore服务即可。

  • Hive 元数据MetaStore读取方式： JDBC连接四要素和HiveMetaStore服务
    在这里插入图片描述
  • 启动Hive MetaStore 服务，脚本【metastore-start.sh】内容如下：
#!/bin/sh
HIVE_HOME=/export/server/hive
## 启动服务的时间
DATE_STR=`/bin/date '+%Y%m%d%H%M%S'`
# 日志文件名称(包含存储路径)
HIVE_SERVER2_LOG=${HIVE_HOME}/hivemetastore-${DATE_STR}.log
## 启动服务
/usr/bin/nohup ${HIVE_HOME}/bin/hive --service metastore > ${HIVE_SERVER2_LOG} 2>&1 &

第三步、连接HiveMetaStore服务配置文件hive-site.xml，放于【$SPARK_HOME/conf】目录

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
<configuration>
	<property>
		<name>hive.metastore.uris</name>
		<value>thrift://node1.cn:9083</value>
	</property>
</configuration>

将hive-site.xml配置发送到集群中所有Spark按照配置目录，此时任意机器启动应用都可以访问Hive表数据

第四步、案例演示，读取Hive中db_hive.emp表数据，分析数据

  • 其一、读取表的数据，使用DSL分析

在这里插入图片描述

  • 其二、直接编写SQL语句
    在这里插入图片描述

复杂SQL分析语句执行：

spark.sql("select e.ename, e.sal, d.dname from db_hive.emp e join db_hive.dept d on e.deptno = d.deptno").show()

IDEA 集成 Hive

在IDEA中开发应用，集成Hive，读取表的数据进行分析，构建SparkSession时需要设置HiveMetaStore服务器地址及集成Hive选项，首先添加MAVEN依赖包：

<!-- Spark SQL 与 Hive 集成 依赖 -->
<dependency>
	<groupId>org.apache.spark</groupId>
	<artifactId>spark-hive_${scala.binary.version}</artifactId>
	<version>${spark.version}</version>
</dependency>

范例演示代码如下：

import org.apache.spark.sql.SparkSession

/**
 * SparkSQL集成Hive，读取Hive表的数据进行分析
 */
object SparkSQLHive {
  def main(args: Array[String]): Unit = {
    // TODO: 构建SparkSession实例对象
    val spark: SparkSession = SparkSession.builder()
      .appName(this.getClass.getSimpleName.stripSuffix("$"))
      .master("local[4]")
      .config("spark.sql.shuffle.partitions", "4")
      // 指定Hive MetaStore服务地址
      .config("hive.metastore.uris", "thrift://node1.cn:9083")
      // TODO: 表示集成Hive，读取Hive表的数据
      .enableHiveSupport()
      .getOrCreate()
    // 导入隐式转换
    import spark.implicits._
    // 导入函数库
    import org.apache.spark.sql.functions._
    // TODO： 读取Hive表的数据
    spark.sql(
      """
        |SELECT deptno, ROUND(AVG(sal), 2) AS avg_sal FROM db_hive.emp GROUP BY deptno
""".stripMargin)
      .show(10, truncate = false)
    println("===========================================================")
    import org.apache.spark.sql.functions._
    spark.read
      .table("db_hive.emp")
      .groupBy($"deptno")
      .agg(round(avg($"sal"), 2).alias("avg_sal"))
      .show(10, truncate = false)
    // 应用结束，关闭资源
    spark.stop()
  }
}

运行程序结果如下：
在这里插入图片描述

技术武器库
关注
专栏目录
dynamic-datasource-spring-boot-starter_多数据源_
10-04
`dynamic-datasource-spring-boot-starter`项目正致力于解决这个问题，它是一个基于Spring Boot的启动器，用于实现动态数据源切换，提供灵活的数据源管理功能。 **动态数据源**指的是在一个应用中可以动态地选择...
大数据技术之SparkSQL（超级详细）
热门推荐
未来社会二十年发展的核心技术趋势由ABCD四个字母组成，分别是AI（人工智能）、BlockChain（区块链）、Cloud（云）、和Data（大数据）每一次进步都有新的认知和感触
01-11 3万+
Spark SQL是Spark用来处理结构化数据的一个模块，它提供了2个编程抽象：DataFrame和DataSet，并且作为分布式SQL查询引擎的作用。 它是将Hive SQL转换成MapReduce然后提交到集群上执行，大大简化了编写MapReduc的程序的复杂性，由于MapReduce这种计算模型执行效率比较慢。所以Spark SQL的应运而生，它是将Spark SQL转换成RDD，然后提交到集群执行，执行效率非常快！
Spark DataSource表
dreamBoat的博客
05-09 1286
一、什么是DataSource表 二、DataSource表的优势 三、DataSource表的缺点 四、建DataSource表方法 一、什么是DataSource表 Spark除了兼容Hive表之外，还支持datasource表。Spark针对Datasource表做了多项优化，读写性能较Hive表有非常大的提升。 二、DataSource表的优势 （1）写入文件方面： DataSource表在文件写入阶段并不会挨个重命名小文件，而是直接将整个临时文件目录重命名为分区名后移动到对应位置，大.
大数据-96 Spark 集群 SparkSQL Scala编写SQL操作SparkSQL的数据源：JSON、CSV、JDBC、Hive
最新发布
永远好奇，无限进步！
08-22 6005
上节研究了SparkSQL的核心操作，Action详细解释+测试案例，与Transformation详细解释+测试案例。本节研究SparkSQL的数据源操作，输入与输出数据。df.write.format(“jdbc”).option(“url”, “jdbc:mysql://host/db”).option(“dbtable”, “table”).option(“user”, “username”).option(“password”, “password”).save()
Spark DataSource V1 & V2 API 一文理解
penriver的博客
04-13 3362
1. Spark Connector 介绍 Spark Connector 是一个 Spark 的数据连接器，可以通过该连接器进行外部数据系统的读写操作。Spark Connector 包含两部分，分别是 Reader 和 Writer。 DataSource的API的代码位于spark_sql【如spark-sql_2.11-2.4.4.jar】 模块中的org.apache.spark.sql.sources包下，定义了如何从存储系统进行读写的相关 API API分为v1、v2两个版本，v2的代码
spark sql（六）sparksql自定义数据源
Interest1_wyt的博客
03-19 1938
sparksql通过DataSourceRegister查找规则实现自定义hbase数据源
Spark SQL支持DataFrame操作的数据源
晓晓的天空
03-16 1077
Spark SQL支持DataFrame操作的数据源
grafana-simple-sql-datasource：Grafana SQL数据源
01-29
grafana-simple-sql-datasource 允许查询基于SQL的数据源，例如SQL Server。用法当前，该插件需要运行代理服务器才能与数据库通信。 安装sqlproxyserver 在dist/serverside文件夹中运行npm install以安装所有依赖项...
spring-cloud-alibaba-sentinel-datasource-2021.1-API文档-中文版.zip
05-09
赠送源代码：spring-cloud-alibaba-sentinel-datasource-2021.1-sources.jar； 赠送Maven依赖信息文件：spring-cloud-alibaba-sentinel-datasource-2021.1.pom； 包含翻译后的API文档：spring-cloud-alibaba-...
SpringBoot多数据源配置（方式五：使用dynamic-datasource动态数据源插件）.docx
05-28
### Spring Boot 多数据源配置（使用 dynamic-datasource 动态数据源插件） #### 一、多数据源背景及介绍 在 Spring Boot 应用开发过程中，开发者通常会为项目配置一个单一的数据源来执行数据库操作。然而，在某些...
mybatis-plus多数据源/动态数据源配置示例代码
11-30
在Java Web应用中，这通常通过DataSource接口实现，每个数据源都由一个DataSource实例表示。 1. **配置多数据源**： - 在Spring框架中，我们可以使用`@Configuration`和`@Bean`注解来声明不同的DataSource。例如，...
spark sql（五）sparksql支持查询哪些数据源，查询hive与查询mysql的区别
Interest1_wyt的博客
03-04 3598
sparksql支持查询的数据源类型，以及查询mysql和查询hive的源码过程简析
Spark SQL读数据库时不支持某些数据类型的问题
嘻哈吼嘿呵的博客
11-28 1847
在大数据平台中，经常需要做数据的ETL，从传统关系型数据库RDBMS中抽取数据到HDFS中。之前开发数据湖新版本时使用Spark SQL来完成ETL的工作，但是遇到了 Spark SQL 不支持某些数据类型（比如ORACLE中的Timestamp with local Timezone）的问题。 一、系统环境 Spark 版本：2.1.0.cloudera1 JDK 版本：Jav...
SparkSQL数据源
m0_53510670的博客
06-21 2282
第1关：SparkSQL加载和保存 代码： packagecom.educoder.bigData.sparksql2; importorg.apache.spark.sql.AnalysisException; importorg.apache.spark.sql.SaveMode; importorg.apache.spark.sql.SparkSession; publicclassTest1{ publicstaticvo...
利用 Spark DataSource API 实现Rest数据源
大数据星球-浪尖
02-02 527
来源：http://www.jianshu.com/p/6441eaa4d064Spark DataSource API 的提出使得各个数据源按规范实现适配，那么就可以高效的利用Spar...
Spark SQL数据源
米斯特拉克的博客
11-20 292
1. 数据源1：JDBC 1.1 使用load方法连接JDBC读取数据 package com.bigdata.spark.day1021 import java.util.Properties import org.apache.log4j.{Level, Logger} import org.apache.spark.sql._ /** * JDBC 数据源 */ object JDB...
SparkSQL 数据源的加载与保存
weixin_47243236的博客
12-22 2941
Spark SQL 支持通过 DataFrame 接口对多种数据源进行操作。可以使用关系转换对 DataFrame 进行操作，也可以用于创建临时视图。将 DataFrame 注册为临时视图允许对其数据运行 SQL 查询。 1. 通用的加载/保存功能 数据源由它们的完全限定名称（即org.apache.spark.sql.parquet）指定，但对于内置源，可以使用它们的短名称（json、parquet、jdbc、orc、libsvm、csv、text）。从任何数据源类型加载的 DataFrame 都可以.
Spark DataSource 源码解析
qq_41775852的博客
01-08 1102
文章目录SparkSession.read()DataFrameReaderformatschemaoptionjson、csv、text...loadDataSource.lookupDataSourceDataFrameReader.loadV1SourceDataSource.resolveRelationSparkSession.baseRelationToDataFrame数据源有关的StrategyFileSourceStrategyFileSourceScanExecDataSourceStr
Spark 3.0 Data Source v2
zhixingheyi_tian的博客
09-11 793
以parquet 来举例 基本的接口实现 DataSourceV2 => Table => ScanBuilder => Scan => PartitionReaderFactory= (VectorizedParquetRecordReader ) ParquetPartitionReaderFactory ParquetPartitionReaderFactory 包装了 VectorizedParquetRecordReader ...
如何配置动态数据源（dynamic-datasource）的primary设置？
01-07
根据提供的引用内容，以下是配置动态数据源（dynamic-datasource）的primary设置的步骤示例： 1. 在项目的配置文件中，添加dynamic-datasource的相关配置项。 ```yaml spring: dynamic: datasource: primary: ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

技术武器库

一句真诚的谢谢，胜过千言万语

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

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

打赏作者

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

抵扣说明：

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

余额充值