Spark SQL 外部数据源（External DataSource）以及常用操作

最新推荐文章于 2024-09-10 16:20:27 发布
最新推荐文章于 2024-09-10 16:20:27 发布
阅读量2.9k 收藏 1
点赞数
分类专栏： Spark spark sql spark学习专栏 文章标签： spark sql external DataSource 外部数据源 分区推测
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yu0_zhang0/article/details/80518612
版权

1 概述

  1. Spark1.2中，Spark SQL开始正式支持外部数据源。Spark SQL开放了一系列接入外部数据源的接口，来让开发者可以实现。使得Spark SQL可以加载任何地方的数据，例如mysql，hive，hdfs，hbase等，而且支持很多种格式如json, parquet, avro, csv格式。我们可以开发出任意的外部数据源来连接到Spark SQL，然后我们就可以通过外部数据源API了进行操作。
  2. 我们通过外部数据源API读取各种格式的数据，会得到一个DataFrame，这是我们熟悉的方式啊，就可以使用DataFrame的API或者SQL的API进行操作哈。
  3. 外部数据源的API可以自动做一些列的裁剪，什么叫列的裁剪，你如一个user表有id,name,age,gender4个列，在做select的时候你只需要id,name这几个列，那么其他列会通过底层的优化去给我们裁剪掉。
  4. 保存操作可以选择使用SaveMode，指定如何保存现有数据（如果存在）。

2 读取json文件

启动shell进行测试

//标准写法
val df=spark.read.format("json").load("path")
//另外一种写法
spark.read.json("path")

看看源码这两者之间到底有啥不同呢？
/**
   * Loads a JSON file and returns the results as a `DataFrame`.
   *
   * See the documentation on the overloaded `json()` method with varargs for more details.
   *
   * @since 1.4.0
   */
  def json(path: String): DataFrame = {
    // This method ensures that calls that explicit need single argument works, see SPARK-16009
    json(Seq(path): _*)
  }
我们调用josn() 方法其实进行了 overloaded ，我们继续查看
 def json(paths: String*): DataFrame = format("json").load(paths : _*)
 这句话是不是很熟悉，其实就是我们的标准写法


scala> val df=spark.read.format("json").load("file:///opt/software/spark-2.2.0-bin-2.6.0-cdh5.7.0/examples/src/main/resources/people.json")

df: org.apache.spark.sql.DataFrame = [age: bigint, name: string]

df.printSchema
root
 |-- age: long (nullable = true)
 |-- name: string (nullable = true)

 df.show
+----+-------+
| age|   name|
+----+-------+
|null|Michael|
|  30|   Andy|
|  19| Justin|
+----+-------+

3 读取parquet数据

val df=spark.read.format("parquet").load("file:///opt/software/spark-2.2.0-bin-2.6.0-cdh5.7.0/examples/src/main/resources/users.parquet")
df: org.apache.spark.sql.DataFrame = [name: string, favorite_color: string ... 1 more field]

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

4 读取hive中的数据

spark.sql("show tables").show
+--------+----------+-----------+
|database| tableName|isTemporary|
+--------+----------+-----------+
| default|states_raw|      false|
| default|states_seq|      false|
| default|        t1|      false|
+--------+----------+-----------+

spark.table("states_raw").show
+-----+------+
| code|  name|
+-----+------+
|hello|  java|
|hello|hadoop|
|hello|  hive|
|hello| sqoop|
|hello|  hdfs|
|hello| spark|
+-----+------+

scala> spark.sql("select name from states_raw ").show
+------+
|  name|
+------+
|  java|
|hadoop|
|  hive|
| sqoop|
|  hdfs|
| spark|
+------+

5 保存数据

注意：

  1. 保存的文件夹不能存在，否则报错(默认情况下，可以选择不同的模式)：org.apache.spark.sql.AnalysisException: path file:/home/hadoop/data already exists.;
  2. 报错成文本格式，只能报错一列，否则报错：org.apache.spark.sql.AnalysisException: Text data source supports only a single column, and you have 2 columns.;
val df=spark.read.format("json").load("file:///opt/software/spark-2.2.0-bin-2.6.0-cdh5.7.0/examples/src/main/resources/people.json")
//保存
df.select("name").write.format("text").save("file:///home/hadoop/data/out")

结果：
[hadoop@hadoop out]$ pwd
/home/hadoop/data/out
[hadoop@hadoop out]$ ll
total 4
-rw-r--r--. 1 hadoop hadoop 20 Apr 24 00:34 part-00000-ed7705d2-3fdd-4f08-a743-5bc355471076-c000.txt
-rw-r--r--. 1 hadoop hadoop  0 Apr 24 00:34 _SUCCESS
[hadoop@hadoop out]$ cat part-00000-ed7705d2-3fdd-4f08-a743-5bc355471076-c000.txt 
Michael
Andy
Justin


//保存为json格式
df.write.format("json").save("file:///home/hadoop/data/out1")

结果
[hadoop@hadoop data]$ cd out1
[hadoop@hadoop out1]$ ll
total 4
-rw-r--r--. 1 hadoop hadoop 71 Apr 24 00:35 part-00000-948b5b30-f104-4aa4-9ded-ddd70f1f5346-c000.json
-rw-r--r--. 1 hadoop hadoop  0 Apr 24 00:35 _SUCCESS
[hadoop@hadoop out1]$ cat part-00000-948b5b30-f104-4aa4-9ded-ddd70f1f5346-c000.json 
{"name":"Michael"}
{"age":30,"name":"Andy"}
{"age":19,"name":"Justin"}

上面说了在保存数据是如果目录已经存在，在默认模式下会报错，那我们下面讲解保存的几种模式：

保存模式意义
SaveMode.ErrorIfExists (default)将DataFrame保存到数据源时，如果数据已经存在，则预计会抛出异常。
SaveMode.Append将DataFrame保存到数据源时，如果数据/表已存在，则DataFrame的内容预计会附加到现有数据。
SaveMode.Overwrite覆盖模式意味着将DataFrame保存到数据源时，如果数据/表已存在，则预期现有数据将被DataFrame的内容覆盖。
SaveMode.Ignore忽略模式意味着将DataFrame保存到数据源时，如果数据已经存在，则保存操作不会保存DataFrame的内容，也不会更改现有数据。 这与SQL中的CREATE TABLE IF NOT EXISTS类似。

6 读取mysql中的数据

val jdbcDF = spark.read
.format("jdbc")
.option("url", "jdbc:mysql://localhost:3306")
.option("dbtable", "basic01.tbls")
.option("user", "root")
.option("password", "123456")
.load()

scala> jdbcDF.printSchema
root
 |-- TBL_ID: long (nullable = false)
 |-- CREATE_TIME: integer (nullable = false)
 |-- DB_ID: long (nullable = true)
 |-- LAST_ACCESS_TIME: integer (nullable = false)
 |-- OWNER: string (nullable = true)
 |-- RETENTION: integer (nullable = false)
 |-- SD_ID: long (nullable = true)
 |-- TBL_NAME: string (nullable = true)
 |-- TBL_TYPE: string (nullable = true)
 |-- VIEW_EXPANDED_TEXT: string (nullable = true)
 |-- VIEW_ORIGINAL_TEXT: string (nullable = true)
 
jdbcDF.show

7 spark SQL操作mysql表数据

CREATE TEMPORARY VIEW jdbcTable
USING org.apache.spark.sql.jdbc
OPTIONS (
  url "jdbc:mysql://localhost:3306",
  dbtable "basic01.tbls",
  user 'root',
  password '123456',
  driver "com.mysql.jdbc.Driver"
);

查看：
show tables;
default states_raw      false
default states_seq      false
default t1      false
jdbctable       true

select * from jdbctable;
1       1519944170      6       0       hadoop  0       1       page_views      MANAGED_TABLE   NULL    NULL
2       1519944313      6       0       hadoop  0       2       page_views_bzip2        MANAGED_TABLE   NULL    NULL
3       1519944819      6       0       hadoop  0       3       page_views_snappy       MANAGED_TABLE   NULL    NULL
21      1520067771      6       0       hadoop  0       21      tt      MANAGED_TABLE   NULL    NULL
22      1520069148      6       0       hadoop  0       22      page_views_seq  MANAGED_TABLE   NULL    NULL
23      1520071381      6       0       hadoop  0       23      page_views_rcfile       MANAGED_TABLE   NULL    NULL
24      1520074675      6       0       hadoop  0       24      page_views_orc_zlib     MANAGED_TABLE   NULL    NULL
27      1520078184      6       0       hadoop  0       27      page_views_lzo_index    MANAGED_TABLE   NULL    NULL
30      1520083461      6       0       hadoop  0       30      page_views_lzo_index1   MANAGED_TABLE   NULL    NULL
31      1524370014      1       0       hadoop  0       31      t1      EXTERNAL_TABLE  NULL    NULL
37      1524468636      1       0       hadoop  0       37      states_raw      MANAGED_TABLE   NULL    NULL
38      1524468678      1       0       hadoop  0       38      states_seq      MANAGED_TABLE   NULL    NULL

mysql中的tbls的数据已经存在jdbctable表中了。

8 分区推测（Partition Discovery）

表分区是在像Hive这样的系统中使用的常见优化方法。 在分区表中，数据通常存储在不同的目录中，分区列值在每个分区目录的路径中编码。 所有内置的文件源（包括Text / CSV / JSON / ORC / Parquet）都能够自动发现和推断分区信息。 例如，我们创建如下的目录结构;

hdfs dfs -mkdir -p /user/hive/warehouse/gender=male/country=CN

添加json文件：
people.json 
{"name":"Michael"}
{"name":"Andy", "age":30}
{"name":"Justin", "age":19}

 hdfs dfs -put people.json /user/hive/warehouse/gender=male/country=CN
  • 我们使用spark sql读取外部数据源：
val df=spark.read.format("json").load("/user/hive/warehouse/gender=male/country=CN/people.json")

scala> df.printSchema
root
 |-- age: long (nullable = true)
 |-- name: string (nullable = true)


scala> df.show

+----+-------+
| age|   name|
+----+-------+
|null|Michael|
|  30|   Andy|
|  19| Justin|
+----+-------+
  • 我们改变读取的目录
val df=spark.read.format("json").load("/user/hive/warehouse/gender=male/")
scala> df.printSchema
root
 |-- age: long (nullable = true)
 |-- name: string (nullable = true)
 |-- country: string (nullable = true)


scala> df.show
+----+-------+-------+
| age|   name|country|
+----+-------+-------+
|null|Michael|     CN|
|  30|   Andy|     CN|
|  19| Justin|     CN|
+----+-------+-------+

大家有没有发现什么呢？Spark SQL将自动从路径中提取分区信息。
注意，分区列的数据类型是自动推断的。目前支持数字数据类型，日期，时间戳和字符串类型。有时用户可能不想自动推断分区列的数据类型。对于这些用例，自动类型推断可以通过spark.sql.sources.partitionColumnTypeInference.enabled进行配置，默认为true。当禁用类型推断时，字符串类型将用于分区列。

从Spark 1.6.0开始，默认情况下，分区发现仅在给定路径下找到分区。对于上面的示例，如果用户将路径/到/ table / gender = male传递给SparkSession.read.parquet或SparkSession.read.load，则不会将性别视为分区列。如果用户需要指定分区发现应以其开始的基本路径，则可以在数据源选项中设置basePath。例如，当path / to / table / gender = male是数据路径并且用户将basePath设置为path / to / table /时，性别将是分区列。

9 Schema合并（Schema Merging）

与Protocol Buffer，Avro和Thrift一样，Parquet类型的文件也支持Schema合并操作。 用户可以合并多个Parquet文件。 Parquet数据源现在能够自动检测这种情况并合并所有这些文件的模式。

由于模式合并是一种相对昂贵的操作，并且在大多数情况下不是必需的，因此我们默认从1.5.0开始关闭它。 您可以启用它在读取Parquet文件时将数据源选项mergeSchema设置为true（如下面的示例所示），或将全局SQL选项spark.sql.parquet.mergeSchema设置为true。

val squaresDF = spark.sparkContext.makeRDD(1 to 5).map(i => (i, i * i)).toDF("value", "square")
squaresDF.write.parquet("/schema_merge/test_table/key=1") 
 
val cubesDF = spark.sparkContext.makeRDD(6 to 10).map(i => (i, i * i * i)).toDF("value", "cube")
cubesDF.write.parquet("/schema_merge/test_table/key=2") 

val mergedDF = spark.read.format("parquet").option("mergeSchema", "true").load("/schema_merge/test_table")

mergedDF.printSchema()
mergedDF.show
  • 如果不设置option("mergeSchema", "true")
+-----+------+---+
|value|square|key|
+-----+------+---+
|    1|     1|  1|
|    2|     4|  1|
|    3|     9|  1|
|    4|    16|  1|
|    5|    25|  1|
|    6|  null|  2|
|    7|  null|  2|
|    8|  null|  2|
|    9|  null|  2|
|   10|  null|  2|
+-----+------+---+
  • 如果设置：
+-----+------+----+---+
|value|square|cube|key|
+-----+------+----+---+
|    3|     9|null|  1|
|    4|    16|null|  1|
|    5|    25|null|  1|
|    8|  null| 512|  2|
|    9|  null| 729|  2|
|   10|  null|1000|  2|
|    1|     1|null|  1|
|    2|     4|null|  1|
|    6|  null| 216|  2|
|    7|  null| 343|  2|
+-----+------+----+---+
  • hdfs 上的文件
[root@hadoop ~]# hdfs dfs -ls /schema_merge/test_table
Found 2 items
drwxr-xr-x   - hadoop supergroup          0 2018-04-28 21:47 /schem_merge/test_table/key=1
drwxr-xr-x   - hadoop supergroup          0 2018-04-28 21:48 /schem_merge/test_table/key=2
爆发的~小宇宙
关注
专栏目录
grafana-simple-sql-datasource：Grafana SQL数据源
01-29
grafana-simple-sql-datasource 允许查询基于SQL的数据源，例如SQL Server。用法当前，该插件需要运行代理服务器才能与数据库通信。 安装sqlproxyserver 在dist/serverside文件夹中运行npm install以安装所有依赖项...
Iceberg与SparkSQL写操作整合
SunnyRivers
09-09 297
spark操作iceberg之前先要配置spark catalogs，详情参考Iceberg与Spark整合环境配置。有些操作需要在spark3中开启iceberg sql扩展。Iceberg使用Apache Spark的DataSourceV2 API来实现数据源和catalog。
Iceberg与SparkSQL查询操作整合
最新发布
SunnyRivers
09-10 337
spark操作iceberg之前先要配置spark catalogs，详情参考Iceberg与Spark整合环境配置。Iceberg使用Apache Spark的DataSourceV2 API来实现数据源和catalog。
Spark SQL实战(07)-Data Sources
JavaEdge全是干货的技术号
03-25 1692
Spark SQL通过DataFrame接口支持对多种数据源进行操作。DataFrame可使用关系型变换进行操作，也可用于创建临时视图。将DataFrame注册为临时视图可以让你对其数据运行SQL查询。本节介绍使用Spark数据源加载和保存数据的一般方法，并进一步介绍可用于内置数据源的特定选项。loadsave一种列式存储格式，在大数据环境中高效地存储和处理数据。由Hadoop生态系统中的Apache Parquet项目开发的。
数据湖Iceberg-SparkSQL集成(4)
jast
04-24 1126
Spark安装包下载地址：https://mirrors.huaweicloud.com/apache/sparkiceberg官网：https://iceberg.apache.org/releases/#110-release1.Spark与Iceberg的版本对应关系如下2.上传并解压Spark安装包 修改目录名为3.配置环境变量 4.拷贝iceberg的jar包到Spark的jars目录 iceberg-sparkjar包下载地址：https://search.maven.org/remotecon
SparkSQL使用MySQL中的数据进行写操作时出现的错误：无法解析 org.apache.spark.sql.AnalysisException
CqcVue的博客
10-16 1140
在使用SparkSQL时，当尝试使用MySQL中的数据进行写操作时，可能会遇到 org.apache.spark.sql.AnalysisException 无法解析的错误。在使用SparkSQL连接MySQL之前，首先确保已正确配置数据库连接参数，包括主机名、端口、用户名和密码等。当写入数据时，SparkSQL会根据表的定义和给定的数据进行类型匹配。请仔细检查在写操作中使用的表名和列名的拼写是否正确。请根据实际情况修改上述代码中的连接参数、数据路径、表名等信息，并确保已正确配置MySQL数据库。
spark生产问题之一：执行作业报错 “org.apache.spark.sql.AnalysisException: undefined function: ‘your_function‘ is~~
m0_70131998的博客
11-15 362
和正常环境相比，少了个配置项，conf.spark.yarn.archive ，说明一下，算子加载的依赖包有两部分，一个是算子lib下的，另一个是spark客户端jars下的。验证思路如下：查看spark-core的版本，进入到nodemanager节点的 /usr/hadoop3/spark2/jars 目录，spark-core是2.11版本，我们这里还使用了jodd工具包，解释下为什么我们在spark中使用这个包呢------背景是这样的：我们有三个环境，开发环境、服务环境测试态，服务环境生产态。
org.apache.spark.sql.AnalysisException: Table or view not found spark操作时报错
viho+的博客
04-28 2442
org.apache.spark.sql.AnalysisException: Table or view not found spark操作时报错 将HIVE_HOME/conf的hive-site。xml copy到SPARK_HOME/conf中 问题解决。
Spring Boot 自定义数据源DruidDataSource代码
08-25
Spring Boot 自定义数据源 DruidDataSource 代码 Spring Boot 是一个基于 Java 语言的开源框架，能够帮助开发者快速构建独立的、生产级别的基于 Spring 框架的应用程序。而 DruidDataSource 是阿里巴巴开源的数据库...
springboot多数据源配置(sqlserver,mysql)
04-13
在Spring Boot应用中，多数据源配置是一项关键的技术，它允许我们连接并操作多个数据库，例如MySQL和SQL Server。在本场景中，我们将探讨如何在Spring Boot中设置和管理这样的多数据源配置。 首先，我们需要了解`...
Spark SQL数据加载和保存实例讲解
09-09
在Spark SQL中，DataFrame是主要的数据结构，它支持各种数据源的读取和写入操作。本篇文章将深入探讨Spark SQL数据加载和保存的实例。 一、Spark SQL数据加载 数据加载主要是将外部数据源的数据转化为DataFrame，...
springboot多数据源切换mysql+sql server事例
04-28
以上就是关于"springboot多数据源切换mysql+sql server"的知识点介绍，涵盖Spring Boot的多数据源配置、数据源切换、MySQL和SQL Server的集成，以及开发环境的准备。这个示例代码为开发者提供了一个实际操作的平台，...
iceberg-Spark3.0SQL 测试案例
黑眼圈@~@从不出水文
04-06 2542
iceberg-spark3.0 测试案例 参考：官网，调研传送门 测试使用的Spark3.0版本，iceberg-Spark操作分3部分，SQL、DF、Streaming 一、配置及参数 1、配置jar包： iceberg0.11.0版本，官网下载jar包，放到spark的jars目录下。 点击下载spark2.4和spark3的驱动包。 注意：要在Spark中使用Iceberg，请首先配置catalogs(注意：Spark2.4不支持DDL操作) 2、注意： 1、iceberg命名空间:V1和V2表
Spark SQL之External DataSource外部数据源
白乔专栏
10-02 5522
http://blog.csdn.net/oopsoom/article/details/42061077一、Spark SQL External DataSource简介  随着Spark1.2的发布，Spark SQL开始正式支持外部数据源。Spark SQL开放了一系列接入外部数据源的接口，来让开发者可以实现。  这使得Spark SQL支持了更多的类型数据源，如json, parquet,
达梦 hive spark hbase phoenix相互关联查询
weixin_44121197的博客
11-02 1976
目的 对达梦的数据通过hive/spark进行分析计算，将结果存入hbase。 实际情况 有两种方式可供选择：1）利用spark与dm的jdbc链接直接读取dm中的数据进行计算，但是spark与hbase无法建立映射所以数据不能直接写入hbase中；2）hive可以与hbase建立映射但是无法与达梦建立连接烦死了 Solution 1.通过spark与dm的jdbc连接，先把数据导入hdfs。 两种：一种是全表导，一种是通过sql语句选择部分导入 CREATE table tmp_spark_table U
iceberg读写常见报错
yiweiyi329的博客
12-20 2417
flink写iceberg报错 场景：flink sink iceberg时，使用equalityFieldColumns指定字段时，报错如下： java.lang.IllegalArgumentException: Cannot write delete files in a v1 table at org.apache.iceberg.ManifestFiles.writeDeleteManifest(ManifestFiles.java:154) at org.apache.iceberg.Sna
Spark sql 读文件的源码分析
rover
08-17 1471
从spark jobs监控页面上经常看到这种job： Listing leaf files and directories for 100 paths: 如图： 这其实是spark sql在读一大堆文件。 最简单的demo语句，这样读文件： val df = session.read.json("path/to/your/resources/data.json") 或者 session.read.parquet(file_path) 或者 session.read.c...
Exception in thread “main“ org.apache.spark.sql.AnalysisException: Column “change_machine_id“ not fo
JIE的博客 --- moon_coder
11-14 801
如果这个问题出现在，你使用 Spark 将数据插入 MySQL 时，请检查你的字段名称是否与 MySQL 中目标表的字段名称是否一致，尝试使用。出现这个问题有可能是你写的字段错了，认值检查一下。
spark sql 外部数据源（external datasource）
03-16
Spark SQL 外部数据源是指在 Spark SQL 中使用的数据源，这些数据源不是 Spark 自带的数据源，而是通过外部连接方式引入的。这些外部数据源可以是关系型数据库、NoSQL 数据库、Hadoop 文件系统等。Spark SQL 提供了一些内置的外部数据源连接器，如 JDBC、Hive、Cassandra、HBase 等，同时也支持自定义外部数据源连接器。通过使用外部数据源，可以方便地将不同的数据源集成到 Spark SQL 中，从而进行统一的数据处理和分析。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值