SparkSQL数据源

于 2024-04-24 17:44:19 发布
阅读量1.5k 收藏 29
点赞数 25
分类专栏： 云计算应用开发 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51439828/article/details/138164910
版权

SparkSQL加载和保存

任务描述

本关任务：编写一个SparkSQL程序，完成加载和保存数据。

相关知识

为了完成本关任务，你需要掌握：

  1. 加载数据

  2. 直接在文件上运行SQL

  3. 保存到路径

  4. 保存模式介绍

  5. 保存到持久表

  6. 存储和排序或分区

加载数据

DataFrameReader用于从外部存储系统（例如文件系统，键值存储等）加载数据集的接口。使用SparkSession.read来访问它。

DataFrameReader提供了（json，parquet，jdbc，orc，libsvm，csv，text）格式支持，DataFrameReader.load(String... paths)方法支持多个路径的数据源，默认使用parquet格式（除非另有配置，spark.sql.sources.default）用于所有操作

  1. Dataset<Row> usersDF = spark.read().load("examples/src/main/resources/users.parquet");

您还可以手动指定将要使用的数据源以及要传递给数据源的任何其他选项。数据源通过其全名指定（即org.apache.spark.sql.parquet），但内置的来源，你也可以使用自己的短名称（json，parquet，jdbc，orc，libsvm，csv，text）。从任何数据源类型加载的 Dataset 都可以使用此语法转换为其他类型。

要加载JSON文件，您可以使用：

  1. //加载
  2. Dataset<Row> peopleDF =
  3. spark.read().format("json").load("examples/src/main/resources/people.json");

要加载CSV文件，您可以使用：

  1. Dataset<Row> peopleDFCsv = spark.read().format("csv")
  2. .option("sep", ";")
  3. .option("inferSchema", "true")
  4. .option("header", "true")
  5. .load("examples/src/main/resources/people.csv");
直接在文件上运行SQL

您可以直接使用SQL查询该文件，而不是使用读取API将文件加载到 Dataset并进行查询。

  1. Dataset<Row> sqlDF =
  2. spark.sql("SELECT * FROM parquet.`src/main/resources/users.parquet`");
保存到路径

DataFrameWriter用于将数据集写入外部存储系统的接口（例如文件系统，键值存储等）, 使用Dataset.write访问它。

使用DataFrameWriter.save(String path)，就可以将Dataset的内容保存在指定的路径中。

  1. //写入并保存到指定路径
  2. peopleDF.select("name","age").write().format("parquet").save("F:\\test\\anamesAndAges");
保存模式介绍

save()方法支持设置保存模式，使用DataFrameWriter.mode(SaveMode saveMode)可用于指定将Dataset保存到数据源的预期行为，指定如何处理现有数据（例如，执行时设置类型为Overwrite，则数据将在写出新数据之前被删除。）但需要注意的这些保存模式不使用任何锁定并且不是原子的。

SaveMode 类型如下：

Scala/Java含义
SaveMode.ErrorIfExists （默认）将Dataset保存到数据源时，如果数据已存在，则会引发异常。
SaveMode.Append将Dataset保存到数据源时，如果数据/表已存在，则Dataset的内容应附加到现有数据。
SaveMode.Overwrite覆盖模式意味着在将Dataset保存到数据源时，如果数据/表已经存在，则预期现有数据将被Dataset的内容覆盖。
SaveMode.Ignore忽略模式意味着在将Dataset保存到数据源时，如果数据已存在，则预期保存操作不会保存Dataset的内容而不会更改现有数据。这与CREATE TABLE IF NOT EXISTSSQL中的类似。
  1. //覆盖原有数据并写入到F:\\test\\anamesAndAges路径上
  2. peopleDF.select("name","age").write().mode("overwrite").save("F:\\test\\anamesAndAges")
保存到持久表

Dataset也可以使用saveAsTable 命令将持久表保存到Hive Metastore中。请注意，使用此功能不需要现有的Hive部署。Spark将为您创建默认的本地Hive Metastore（使用Derby）。

与createOrReplaceTempView命令不同，saveAsTable将实现DataSet的内容并创建指向Hive Metastore中数据的指针。只要您保持与同一 Metastore的连接，即使您的Spark程序重新启动后，持久表仍然存在。可以通过spark.sql()方法通过表的名称调用来创建持久表的Dataset。

对于基于文件的数据源，例如text，parquet，json等，您可以通过path选项指定自定义表路径 ，例如：

  1. df.write.option("path", "/some/path").saveAsTable("t")

删除表时，将不会删除自定义表路径，并且表数据仍然存在。如果未指定自定义表路径，则Spark会将数据写入仓库目录下的默认表路径。删除表时，也将删除默认表路径。

从Spark 2.1开始，持久数据源表将每个分区元数据存储在Hive Metastore中。这带来了几个好处：

由于Metastore只能返回查询所需的分区，因此不再需要在表的第一个查询中发现所有分区。

Hive DDL ALTER TABLE PARTITION ... SET LOCATION现在可用于使用 Datasource API创建的表。

请注意，在创建外部数据源表（带有path选项的表）时，默认情况下不会收集分区信息。要同步Metastore中的分区信息，可以调用MSCK REPAIR TABLE。

  1. //写入到t1表
  2. peopleDF.select("name","age").write().saveAsTable("t1")
存储和排序或分区

对于基于文件的数据源，还可以对输出进行存储和排序或分区。存储和排序仅适用于持久表：

  1. peopleDF.write().bucketBy(42,"name").sortBy("age").saveAsTable("people_bucketed");

分区可以在save和saveAsTable时使用

  1. usersDF
  2. .write()
  3. .partitionBy("name")
  4. .format("parquet")
  5. .save("people");

分区后结构：

可以对单个表名称进行分区

  1. peopleDF
  2. .write()
  3. .partitionBy("name")
  4. .bucketBy(42, "age")
  5. .saveAsTable("people");

分区后结构：

编程要求

在右侧编辑器补充代码，加载people.json文件，以覆盖的方式保存到people路径里，继续加载people1.json文件，以附加的方式保存到people路径里，最后以表格形式显示people里前20行Dataset。

people.json、people1.json文件内容分别如下:

  1. {"age":21,"name":"张三", "salary":"3000"}
  2. {"age":22,"name":"李四", "salary":"4500"}
  3. {"age":23,"name":"王五", "salary":"7500"}
  4. {"name":"Michael", "salary":"6000"}
  5. {"name":"Andy", "age":30 , "salary":"9000"}
  6. {"name":"Justin", "age":19 , "salary":"6900"}
测试说明

平台将对你编写的代码进行评测：

预期输出：

  1. +----+-------+------+
  2. | age| name|salary|
  3. +----+-------+------+
  4. | 21| 张三| 3000|
  5. | 22| 李四| 4500|
  6. | 23| 王五| 7500|
  7. |null|Michael| 6000|
  8. | 30| Andy| 9000|
  9. | 19| Justin| 6900|
  10. +----+-------+------+

package com.educoder.bigData.sparksql2;

import org.apache.spark.sql.AnalysisException;

import org.apache.spark.sql.SaveMode;

import org.apache.spark.sql.SparkSession;

import org.apache.spark.sql.Dataset;

import org.apache.spark.sql.Row;


 

public class Test1 {

   

    public static void main(String[] args) throws AnalysisException {

        SparkSession  spark  =  SparkSession

                  .builder()

                  .appName("test1")

                  .master("local")

                  .getOrCreate();

        /********* Begin *********/

       

        Dataset<Row> peopleDF =spark.read().format("json").load("people.json");

        peopleDF.write().mode("overwrite").save("people");

        Dataset<Row> peopleDF1=spark.read().format("json").load("people1.json");

        peopleDF1.write().mode("append").save("people");

        //输出

        spark.read().load("people").show();    

       

       

       

        /********* End *********/

    }

}

Parquet文件介绍

任务描述

本关任务：编写Parquet分区文件，并输出表格内容

相关知识

为了完成本关任务，你需要掌握：

  1. 编程方式加载Parquet文件

  2. Parquet分区

  3. 结构合并

  4. 元数据刷新

  5. Parquet参数配置

编程方式加载Parquet文件

Parquet是一种柱状格式，许多其他数据处理系统都支持它。Spark SQL支持读取和写入Parquet文件，这些文件自动保留原始数据的模式。在编写 Parquet文件时，出于兼容性原因，所有列都会自动转换为可为空：

  1. import org.apache.spark.api.java.function.MapFunction;
  2. import org.apache.spark.sql.Encoders;
  3. import org.apache.spark.sql.Dataset;
  4. import org.apache.spark.sql.Row;
  6. Dataset<Row> peopleDF = spark.read().json("examples/src/main/resources/people.json");
  8. //Dataset写入到Parquet文件
  9. peopleDF.write().parquet("people.parquet");
  11. //读入上面创建的Parquet文件。
  12. //Parquet文件是自描述的，因此保留了模式
  13. //加载Parquet文件的结果也是Dataset
  14. Dataset<Row> parquetFileDF = spark.read().parquet("people.parquet");
  16. // Parquet文件也可用于创建临时视图，然后在SQL语句
  17. parquetFileDF.createOrReplaceTempView("parquetFile");
  18. Dataset<Row> namesDF = spark.sql("SELECT name FROM parquetFile WHERE age BETWEEN 13 AND 19");
  19. Dataset<String> namesDS = namesDF.map(
  20. (MapFunction<Row, String>) row -> "Name: " + row.getString(0),
  21. Encoders.STRING());
  22. namesDS.show();
  23. // +------------+
  24. // | value|
  25. // +------------+
  26. // |Name: Justin|
  27. // +------------+
Parquet分区

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

例如，我们可以使用以下目录结构将所有以前使用的填充数据存储到分区表中，使用两个额外的列，gender和country作为分区列：

  1. path
  2. └── to
  3. └── table
  4. ├── gender=male
  5. │ ├── ...
  6. │ │
  7. │ ├── country=US
  8. │ │ └── data.parquet
  9. │ ├── country=CN
  10. │ │ └── data.parquet
  11. │ └── ...
  12. └── gender=female
  13. ├── ...
  14. │
  15. ├── country=US
  16. │ └── data.parquet
  17. ├── country=CN
  18. │ └── data.parquet
  19. └── ...

通过SparkSession.read.parquet或者SparkSession.read.load方法读取路径path/to/table，Spark SQL将自动从路径中提取分区信息。返回的 Dataset的结构信息为：

  1. root
  2. |-- name: string (nullable = true)
  3. |-- age: long (nullable = true)
  4. |-- gender: string (nullable = true)
  5. |-- country: string (nullable = true)

请注意，分区列的数据类型是自动推断的。目前，支持数字数据类型，日期，时间戳和字符串类型。有时，可能不希望自动推断分区列的数据类型。

对于这些用例，可以配置是否允许自动推断类型spark.sql.sources.partitionColumnTypeInference.enabled，默认为true。禁用类型推断后，分区列的数据类型为字符串类型。如下：

  1. SparkSession spark = SparkSession
  2. .builder()
  3. .appName("Java Spark SQL基本示例")
  4. .master("local")
  5. .config("spark.sql.sources.partitionColumnTypeInference.enabled" , "false")
  6. .getOrCreate();
  7. spark.read().load("people").printSchema();
  8. // age由自动推断的数字数据类型，变成字符串类型
  9. // root
  10. // |-- name: string (nullable = true)
  11. // |-- age: string (nullable = true)
  12. // |-- gender: string (nullable = true)
  13. // |-- country: string (nullable = true)

从Spark 1.6.0开始，分区默认只查找给定路径下的分区。对于上面的示例，如果用户传递path/to/table/gender=male给 SparkSession.read.parquet或者SparkSession.read.load，gender则不会将其视为分区列。

如果用户需要指定分区发现应该开始的基本路径，则可以basePath在option中进行设置。例如，当path / to / table / gender = male是数据的路径，用户将basePath设置为path / to / table /时，gender将成为分区列。

  1. //不设置basePath
  2. spark.read().load("people/age=21").printSchema();
  3. //root
  4. //|-- name: string (nullable = true)
  5. //|-- salary: string (nullable = true)
  7. //设置basePath
  8. spark.read().option("basePath", "people").load("people/age=21").printSchema();
  9. //root
  10. //|-- name: string (nullable = true)
  11. //|-- salary: string (nullable = true)
  12. //|-- age: integer (nullable = true)
结构合并

Parquet支持模式演变。用户可以从简单模式开始，并根据需要逐渐向模式添加更多列。通过这种方式，用户可能最终得到具有不同但相互兼容的模式的多个 Parquet文件。Parquet数据源现在能够自动检测这种情况并合并所有这些文件的模式。

由于模式合并是一项相对昂贵的操作，并且在大多数情况下不是必需的，默认是关闭的。可以通过一下两个方法启用它：

  1. option设置参数mergeSchema为true

  2. 将全局config设置spark.sql.parquet.mergeSchema为true

示例如下：

  1. import java.io.Serializable;
  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. import org.apache.spark.sql.Dataset;
  7. import org.apache.spark.sql.Row;
  9. public static class Square implements Serializable {
  10. private int value;
  11. private int square;
  12. // Getters and setters...
  13. }
  15. public static class Cube implements Serializable {
  16. private int value;
  17. private int cube;
  18. // Getters and setters...
  19. }
  21. List<Square> squares = new ArrayList<>();
  22. for (int value = 1; value <= 5; value++) {
  23. Square square = new Square();
  24. square.setValue(value);
  25. square.setSquare(value * value);
  26. squares.add(square);
  27. }
  29. // 创建一个简单的Dateset，存储到一个分区目录中
  30. Dataset<Row> squaresDF = spark.createDataFrame(squares, Square.class);
  31. squaresDF.write().parquet("data/test_table/key=1");
  33. List<Cube> cubes = new ArrayList<>();
  34. for (int value = 6; value <= 10; value++) {
  35. Cube cube = new Cube();
  36. cube.setValue(value);
  37. cube.setCube(value * value * value);
  38. cubes.add(cube);
  39. }
  41. //在新的分区目录中创建另一个Dataset，
  42. //添加新列并删除现有列
  43. Dataset<Row> cubesDF = spark.createDataFrame(cubes, Cube.class);
  44. cubesDF.write().parquet("data/test_table/key=2");
  46. // 读取分区表
  47. Dataset<Row> mergedDF = spark.read().option("mergeSchema", true).parquet("data/test_table");
  48. mergedDF.printSchema();
  50. //最终模式由Parquet文件中的所有3列组成
  51. //分区列出现在分区目录路径中
  52. // root
  53. // |-- value: int (nullable = true)
  54. // |-- square: int (nullable = true)
  55. // |-- cube: int (nullable = true)
  56. // |-- key: int (nullable = true)
元数据刷新

Spark SQL缓存Parquet元数据以获得更好的性能。启用Hive Metastore Parquet表转换后，还会缓存这些转换表的元数据。

如果这些表由Hive或其他外部工具更新，则需要手动刷新它们以确保元数据一致。

  1. spark.catalog().refreshTable("my_table");
参数配置

可以使用SQL setConf上的方法SparkSession或通过SET key=value使用SQL运行 命令来完成Parquet的配置。

参数名称默认值描述
spark.sql.parquet.binaryAsStringfalse其他一些Parquet生成系统，特别是Impala，Hive和旧版本的Spark SQL，在写出Parquet模式时不区分二进制数据和字符串。此标志告诉Spark SQL将二进制数据解释为字符串，以提供与这些系统的兼容性。
spark.sql.parquet.int96AsTimestamptrue一些Parquet生产系统，特别是Impala和Hive，将时间戳存储到INT96中。此标志告诉Spark SQL将INT96数据解释为时间戳，以提供与这些系统的兼容性。
spark.sql.parquet.compression.codecture设置编写Parquet文件时使用的压缩编解码器。如果在特定于表的选项/属性中指定了“compression”或“parquet.compression”，则优先级为“compression”，“parquet.compression”，“spark.sql.parquet.compression.codec”。可接受的值包括：none，uncompressed，snappy，gzip，lzo，brotli，lz4，zstd。请注意，zstd需要在Hadoop 2.9.0之前安装ZStandardCodec，brotli需要安装BrotliCodec。
spark.sql.parquet.filterPushdowntrue设置为true时启用Parquet过滤器下推优化。
spark.sql.hive.convertMetastoreParquettrue设置为false时，Spark SQL将使用Hive SerDe作为镶木桌而不是内置支持。
spark.sql.parquet.mergeSchemafalse如果为true，则Parquet数据源合并从所有数据文件收集的模式，否则，如果没有可用的摘要文件，则从摘要文件或随机数据文件中选取模式。
spark.sql.parquet.writeLegacyFormatfalse如果为true，则数据将以Spark 1.4及更早版本的方式写入。例如，十进制值将以Apache Parquet的固定长度字节数组格式写入，其他系统（如Apache Hive和Apache Impala）也使用该格式。如果为false，将使用Parquet中的较新格式。例如，小数将以基于int的格式写入。如果Parquet输出旨在用于不支持此较新格式的系统，请设置为true。
编程要求

在右侧编辑器补充代码，把文件people、people1存在people路径下，通过id=1和id=2进行分区，以表格方式显示前20行内容。

people.json、people1.json文件内容分别如下：

  1. {"age":21,"name":"张三", "salary":"3000"}
  2. {"age":22,"name":"李四", "salary":"4500"}
  3. {"age":23,"name":"王五", "salary":"7500"}
  4. {"name":"Michael", "salary":"6000"}
  5. {"name":"Andy", "age":30 , "salary":"9000"}
  6. {"name":"Justin", "age":19 , "salary":"6900"}
测试说明

平台将对你编写的代码进行评测：

预期输出：

  1. +----+-------+------+---+
  2. | age| name|salary| id|
  3. +----+-------+------+---+
  4. | 21| 张三| 3000| 1|
  5. | 22| 李四| 4500| 1|
  6. | 23| 王五| 7500| 1|
  7. |null|Michael| 6000| 2|
  8. | 30| Andy| 9000| 2|
  9. | 19| Justin| 6900| 2|
  10. +----+-------+------+---+

package com.educoder.bigData.sparksql2;

import org.apache.spark.sql.AnalysisException;

import org.apache.spark.sql.SparkSession;

import org.apache.spark.sql.Dataset;

import org.apache.spark.sql.Row;

public class Test2 {

    public static void main(String[] args) throws AnalysisException {

        SparkSession  spark  =  SparkSession

                  .builder()

                  .appName("test1")

                  .master("local")

                  .getOrCreate();

        /********* Begin *********/

        Dataset<Row> peopleDF =spark.read().format("json").load("people.json");

        peopleDF.write().mode("overwrite").save("people/id=1");

        Dataset<Row> peopleDF1=spark.read().format("json").load("people1.json");

        peopleDF1.write().mode("append").save("people/id=2");

        spark.read().load("people").show();

       

        /********* End *********/

    }

}

json文件介绍

任务描述

本关任务：编写一个sparksql程序，统计平均薪水。

相关知识

为了完成本关任务，你需要掌握json文件介绍及使用。

json文件介绍

Spark SQL可以自动推断JSON数据集的模式并将其加载为Dataset<Row>。可以使用SparkSession.read().json()。

请注意，作为json文件提供的文件不是典型的JSON文件。每行必须包含一个单独的，自包含的有效JSON对象。有关更多信息，请参阅JSON Lines文本格式，也称为换行符分隔的JSON。

例如：

  1. {"age":21,"name":"张三", "salary":"3000"}
  2. {"age":22,"name":"李四", "salary":"4500"}
  3. {"age":23,"name":"王五", "salary":"7500"}

对于常规多行JSON文件，请将multiLine选项设置为true。

  1. import org.apache.spark.sql.Dataset;
  2. import org.apache.spark.sql.Row;
  4. //路径指向JSON数据集。
  5. //路径可以是单个文本文件，也可以是存储文本文件的目录
  6. Dataset<Row> people = spark.read().json("examples/src/main/resources/people.json");
  8. //可以使用printSchema（）方法显示推断的模式
  9. people.printSchema();
  10. // root
  11. // |-- age: long (nullable = true)
  12. // |-- name: string (nullable = true)
  14. //使用Dataset创建临时视图
  15. people.createOrReplaceTempView("people");
  17. //可以使用spark提供的sql方法运行SQL语句
  18. Dataset<Row> namesDF = spark.sql("SELECT name FROM people WHERE age BETWEEN 13 AND 19");
  19. namesDF.show();
  20. // +------+
  21. // | name|
  22. // +------+
  23. // |Justin|
  24. // +------+
  26. //或者，可以为表示的JSON数据集创建Dataset
  27. //数据集<String>每个字符串存储一个JSON对象。
  28. List<String> jsonData = Arrays.asList(
  29. "{\"name\":\"Yin\",\"address\":{\"city\":\"Columbus\",\"state\":\"Ohio\"}}");
  30. Dataset<String> anotherPeopleDataset = spark.createDataset(jsonData, Encoders.STRING());
  31. Dataset<Row> anotherPeople = spark.read().json(anotherPeopleDataset);
  32. anotherPeople.show();
  33. // +---------------+----+
  34. // | address|name|
  35. // +---------------+----+
  36. // |[Columbus,Ohio]| Yin|
  37. // +---------------+----+
编程要求

在右侧编辑器补充代码，通过people文件和people1文件，统计薪水平均值。

people.json、people1.json文件内容分别如下:

  1. {"age":21,"name":"张三", "salary":"3000"}
  2. {"age":22,"name":"李四", "salary":"4500"}
  3. {"age":23,"name":"王五", "salary":"7500"}
  4. {"name":"Michael", "salary":"6000"}
  5. {"name":"Andy", "age":30 , "salary":"9000"}
  6. {"name":"Justin", "age":19 , "salary":"6900"}
测试说明

平台将对你编写的代码进行评测：

预期输出：

  1. +---------------------------+
  2. |avg(CAST(salary AS DOUBLE))|
  3. +---------------------------+
  4. | 6150.0|
  5. +---------------------------+

package com.educoder.bigData.sparksql2;

import org.apache.spark.sql.AnalysisException;

import org.apache.spark.sql.SparkSession;

import org.apache.spark.sql.Dataset;

import org.apache.spark.sql.Row;


 

public class Test3 {

   

    public static void main(String[] args) throws AnalysisException {

        SparkSession  spark  =  SparkSession

                  .builder()

                  .appName("test1")

                  .master("local")

                  .getOrCreate();

        /********* Begin *********/

        Dataset<Row> peopleDF =spark.read().format("json").load("people.json");

        peopleDF.write().mode("overwrite").save("people");

        Dataset<Row> peopleDF1=spark.read().format("json").load("people1.json");

        peopleDF1.write().mode("append").save("people");

        spark.read().load("people").createOrReplaceTempView("people");

        //输出

        spark.sql("select avg(salary) from people").show();

        /********* End *********/

    }

}

JDBC读取数据源

任务描述

本关任务：编写sparksql程序，保存文件信息到mysql，并从mysql进行读取。

相关知识

为了完成本关任务，你需要掌握如何使用JDBC读取数据源。

使用JDBC如何读取数据源

Spark SQL 还包括一个可以使用JDBC从其他数据库读取数据的数据源，与使用JdbcRDD相比，此功能应该更受欢迎。这是因为结果作为DataSet返回，可以在Spark SQL中轻松处理，也可以与其他数据源连接。

JDBC数据源也更易于使用Java或Python，因为它不需要用户提供 ClassTag。（请注意，这与Spark SQL JDBC服务器不同，后者允许其他应用程序使用Spark SQL运行查询）。

首先，您需要在spark类路径中包含特定数据库的JDBC驱动程序。例如，要从 Spark Shell连接到postgres，您将运行以下命令：

bin/spark-shell --driver-class-path postgresql-9.4.1207.jar --jars postgresql-9.4.1207.jar

可以使用Data Sources API将远程数据库中的表加载为Dataset或Spark SQL临时视图。用户可以在数据源选项中指定JDBC连接属性。 user 和 password通常作为用于登录数据源的连接属性提供。除连接属性外，Spark 还支持以下不区分大小写的选项：

常量名称含义
url要连接的JDBC URL。可以在URL中指定特定于源的连接属性。例如，jdbc:postgresql://localhost/test?user=fred&password=secret
dbtable应该读取或写入的JDBC表。请注意，在读取路径中使用它时，可以使用在FROMSQL查询的子句中有效的任何内容。例如，您也可以在括号中使用子查询，而不是完整的表。不允许同时指定dbtable和query选项。
query将用于将数据读入Spark的查询。指定的查询将被括起来并在FROM子句中用作子查询。Spark还会为子查询子句分配别名。
driver用于连接到此URL的JDBC驱动程序的类名。
partitionColumn, lowerBound, upperBound如果指定了任何选项，则必须全部指定这些选项。另外， numPartitions必须指定。它们描述了在从多个工作者并行读取时如何对表进行分区。 partitionColumn必须是相关表中的数字，日期或时间戳列。请注意，lowerBound和upperBound只是用来决定分区步幅，而不是在表中过滤行。因此，表中的所有行都将被分区并返回。此选项仅适用于阅读。
numPartitions表读取和写入中可用于并行的最大分区数。这还确定了最大并发JDBC连接数。如果要写入的分区数超过此限制，我们通过coalesce(numPartitions)在写入之前调用将其减少到此限制。
queryTimeout驱动程序等待Statement对象执行到指定秒数的秒数。零意味着没有限制。在写入路径中，此选项取决于JDBC驱动程序如何实现API setQueryTimeout，例如，h2 JDBC驱动程序检查每个查询的超时而不是整个JDBC批处理。它默认为0。
fetchsizeJDBC提取大小，用于确定每次往返要获取的行数。这可以帮助JDBC驱动程序的性能，默认为低读取大小（例如，Oracle有10行）。此选项仅适用于阅读。
batchsizeJDBC批处理大小，用于确定每次往返要插入的行数。这可以帮助JDBC驱动程序的性能。此选项仅适用于书写。它默认为1000。
isolationLevel事务隔离级别，适用于当前连接。它可以是一个NONE，READ_COMMITTED，READ_UNCOMMITTED，REPEATABLE_READ，或SERIALIZABLE，对应于由JDBC的连接对象定义，缺省值为标准事务隔离级别READ_UNCOMMITTED。此选项仅适用于书写。请参阅文档java.sql.Connection。
sessionInitStatement在向远程数据库打开每个数据库会话之后，在开始读取数据之前，此选项将执行自定义SQL语句（或PL / SQL块）。使用它来实现会话初始化代码。例：option("sessionInitStatement", """BEGIN execute immediate 'alter session set "_serial_direct_read"=true'; END;""")
truncate这是JDBC编写器相关选项。当SaveMode.Overwrite启用时，此选项会导致火花截断，而不是删除和重建其现有的表。这可以更有效，并防止删除表元数据（例如，索引）。但是，在某些情况下，例如新数据具有不同的架构时，它将无法工作。它默认为false。此选项仅适用于书写。
cascadeTruncate这是JDBC编写器相关选项。如果JDBC数据库（PostgreSQL和Oracle目前）启用并支持，则此选项允许执行a TRUNCATE TABLE t CASCADE（在TRUNCATE TABLE ONLY t CASCADE执行PostgreSQL的情况下执行a以防止无意中截断后代表）。这将影响其他表，因此应谨慎使用。此选项仅适用于书写。它默认为有问题的JDBC数据库的默认级联截断行为，isCascadeTruncate在每个JDBCDialect中指定。
createTableOptions这是JDBC编写器相关选项。如果指定，则此选项允许在创建表时设置特定于数据库的表和分区选项（例如，CREATE TABLE t (name string) ENGINE=InnoDB.）。此选项仅适用于书写。
createTableColumnTypes创建表时要使用的数据库列数据类型而不是默认值。数据类型信息应以与CREATE TABLE列语法相同的格式指定（例如："name CHAR(64), comments VARCHAR(1024)")。指定的类型应该是有效的spark sql数据类型。此选项仅适用于写入。
customSchema用于从JDBC连接器读取数据的自定义架构。例如，"id DECIMAL(38, 0), name STRING"。您还可以指定部分字段，其他字段使用默认类型映射。例如，"id DECIMAL(38, 0)"。列名应与JDBC表的相应列名相同。用户可以指定Spark SQL的相应数据类型，而不是使用默认值。此选项仅适用于阅读。
pushDownPredicate用于启用或禁用谓词下推到JDBC数据源的选项。默认值为true，在这种情况下，Spark会尽可能地将过滤器下推到JDBC数据源。否则，如果设置为false，则不会将过滤器下推到JDBC数据源，因此所有过滤器都将由Spark处理。当Spark通过比JDBC数据源更快地执行谓词过滤时，谓词下推通常会被关闭。
  1. //注意：可以通过load / save或jdbc方法实现JDBC加载和保存
  2. //从JDBC源
  3. Dataset<Row> jdbcDF = spark.read()
  4. .format("jdbc")
  5. .option("url", "jdbc:postgresql:dbserver")
  6. .option("dbtable", "schema.tablename")
  7. .option("user", "username")
  8. .option("password", "password")
  9. .load();
  11. Properties connectionProperties = new Properties();
  12. connectionProperties.put("user", "username");
  13. connectionProperties.put("password", "password");
  14. Dataset<Row> jdbcDF2 = spark.read()
  15. .jdbc("jdbc:postgresql:dbserver", "schema.tablename", connectionProperties);
  17. //将数据保存到mysql源
  18. jdbcDF.write()
  19. .format("jdbc")
  20. .option("url", "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&cha\fracterEncoding=utf-8")
  21. .option("dbtable", "schema.tablename")
  22. .option("user", "username")
  23. .option("password", "password")
  24. .save();
  26. jdbcDF2.write()
  27. .jdbc("jdbc:postgresql:dbserver", "schema.tablename", connectionProperties);
  29. //写入
  30. jdbcDF.write()
  31. .option("createTableColumnTypes", "name CHAR(64), comments VARCHAR(1024)")
  32. .jdbc("jdbc:postgresql:dbserver", "schema.tablename", connectionProperties);
编程要求

在右侧编辑器补充代码，读取people、people1文件到mysql的people表,并从people表里读取内容，以表格方式显示前20行内容。

people.json、people1.json文件内容分别如下:

  1. {"age":21,"name":"张三", "salary":"3000"}
  2. {"age":22,"name":"李四", "salary":"4500"}
  3. {"age":23,"name":"王五", "salary":"7500"}
  4. {"name":"Michael", "salary":"6000"}
  5. {"name":"Andy", "age":30 , "salary":"9000"}
  6. {"name":"Justin", "age":19 , "salary":"6900"}
测试说明

平台将对你编写的代码进行评测：

预期输出：

  1. +----+-------+------+
  2. | age| name|salary|
  3. +----+-------+------+
  4. | 21| 张三| 3000|
  5. | 22| 李四| 4500|
  6. | 23| 王五| 7500|
  7. |null|Michael| 6000|
  8. | 30| Andy| 9000|
  9. | 19| Justin| 6900|
  10. +----+-------+------+

package com.educoder.bigData.sparksql2;

import org.apache.spark.sql.Dataset;

import org.apache.spark.sql.Row;

import org.apache.spark.sql.SaveMode;

import org.apache.spark.sql.SparkSession;

import org.apache.spark.sql.Dataset;

import org.apache.spark.sql.Row;



 

public class Test4 {

  public static void case4(SparkSession spark) {

   

    /********* Begin *********/

    //读取文件数据

    Dataset<Row> peopleDF =spark.read().format("json").load("people.json");

    //写入数据表中

    peopleDF.write().format("jdbc")

                    .option("url", "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&cha\fracterEncoding=utf-8")

                    .option("dbtable", "people")

                    .option("user", "root")

                    .option("password", "123123")

                    .mode(SaveMode.Overwrite)

                    .save();

    Dataset<Row> peopleDF1 =spark.read().format("json").load("people1.json");

    peopleDF1.write().format("jdbc")

                    .option("url", "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&cha\fracterEncoding=utf-8")

                    .option("dbtable", "people")

                    .option("user", "root")

                    .option("password", "123123")

                    .mode(SaveMode.Append)

                    .save();

        Dataset<Row> df = spark.read()

                                  .format("jdbc")

                                  .option("url", "jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&cha\fracterEncoding=utf-8")

                                  .option("dbtable", "people")

                                  .option("user", "root")

                                  .option("password", "123123")

                                  .load();

    df.show();

    /********* End *********/

  }

}

念婷
关注
  • 25
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spark SQL之数据源
FBB360JAVA的博客
02-07 961
前言 本篇文章来源于官方文档。 Spark SQL 通过 DataFrame 接口支持操作各种数据源。一个 DataFrame 能够通过使用关系转换和创建临时视图来操作数据。当你使用临时视图注册一个 DataFrame 时，你可以在这数据上运行 SQL 查询。 注意，本文中的完整代码和所需的资源文件如下 【官方案例】SQLDataSourceExample.scala 资源文件 通用的读取、保存函...
SparkSQL数据源代码分析
05-26 1308
Spark SQL支持通过DataFrame接口对各种数据源进行操作。DataFrame 可以使用关系转换进行操作，也可以用于创建临时视图。将DataFrame注册为临时视图允许您对其数据运行SQL查询。 本实训介绍使用Spark数据源加载和保存数据的一般方法，然后介绍可用于内置数据源的特定选项。 第1关：SparkSQL加载和保存： DataFrameReader用于从外部存储系统（例如文件系统，键值存储等）加载数据集的接口。使用SparkSession.read来访问它。 DataFrameRe
表格标签—表格高级样式的设置
wangyongqi的博客
11-29 1986
第1关：表格高级样式设置相关概念 任务描述 本关任务：完成一组表格高级样式设置的概念题。 相关知识 为了完成本关任务，你需要掌握：1.外边框线样式的设置，2.内部边框线的设置，3.单元格的合并。 外边框线样式属性frame 表格的外边框线的样式可用属性frame的取值来确定，frame取值与相应的样式如下： above：显示上边框 below：显示下边框 hsides：显示上下边框 vsides：显示左右边框 lhs：显示左边框 rhs：显示右边框 border：显示上下左右边框 void：不显示边框 内部
Spark数据源educoder
qq_48664727的博客
06-07 2936
educoder-Spark数据源答案JAVA代码
头歌 MySql数据库参考答案
热门推荐
balti的博客
06-26 2万+
这个实训是用Java完成的，可以给大家做一下参考，列出来的答案都是在头歌平台上编译通过的，最好还是不要直接照搬代码，先自己写完再看,后面会一直更新的。
Spark SQL常见4种数据源详解
09-09
在本文中，我们将深入探讨Spark SQL中的四种常见数据源：Parquet、JSON、CSV和JDBC，并了解如何使用它们进行数据读取和写入操作。 1. **Parquet数据源** Parquet是一种列式存储格式，广泛应用于大数据处理场景，...
SparkSQL最全面案例数据集
03-25
它提供了一个DataFrame API来编写SQL查询，这些查询可以处理来自各种数据源的数据，并返回DataFrame作为结果。DataFrame是一个分布式的数据集合，可以包含多种类型的数据，并提供了一种方便的方式来处理和分析这些...
spark-sql入门
01-12
这通常通过读取数据源（如CSV、JSON、Parquet或Hive表）完成。例如，我们可以使用`spark.read.format("csv").option("header", "true").load("path")`来读取CSV文件。 Spark SQL还支持JOIN操作，允许用户将多个...
SparkSQL-DataFrame
01-16
这可以通过`SparkSession`的`read.format()`方法完成，指定数据源为"csv"，并提供文件路径。 2. **数据预处理**: 数据集可能包含缺失值、异常值或不一致的格式。我们可以使用DataFrame的函数进行数据清洗，如`na....
SparkSql技术
08-16
4.3：不同数据源的运行计划 34 4.3.1 json文件 34 4.3.2 parquet文件 35 4.3.3 hive数据 36 4.4：不同查询的运行计划 36 4.4.1 聚合查询 36 4.4.2 join操作 37 4.4.3 Distinct操作 37 4.5：查询的优化 38 4.5.1 ...
Spark SQL数据源：JDBC
梁辰兴的博客
06-14 3594
Spark SQL还可以使用JDBC API从其他关系型数据库读取数据，返回的结果仍然是一个DataFrame，可以很容易地在Spark SQL中处理，或者与其他数据源进行连接查询。执行上述命令（dbtable属性的值是一个子查询，相当于SQL查询中的FROM关键字后的一部分）注意：Spark 2.4.0开始的Spark SQL的JDBC属性里才有query属性。将数据帧内容以jdbc格式写入数据库spark_db的test表。查看结果数据帧内容，执行命令：resultDF.show()
Spark SQL 数据源
最新发布
03-26 3万+
Spark SQL支持读取很多种数据源，比如parquet文件，json文件，文本文件，数据库等。先把people.json导入到hdfs的tmp目录下。
实验六 MapReduce数据清洗-气象数据清洗
36.6°博客
11-12 9435
实验六 MapReduce数据清洗-气象数据清洗第1关：数据清洗任务描述编程要求测试说明代码实现命令行代码文件step1/com/Weather.javastep1/com/WeatherMap.javastep1/com/WeatherReduce.javastep1/com/Auto.javastep1/com/WeatherTest.java 第1关：数据清洗 任务描述 本关任务：对数据按照一定规则进行清洗。 编程要求 根据提示，在右侧编辑器补充代码，对数据按照一定规则进行清洗。 数据说明如下：a.t
SparkSQL-数据的加载和保存(包含数据库)
qq_40607631的博客
09-05 440
适配的文件类型读文件时直接在文件上进行查询: 文件格式.`文件路径`
SPARKSQL3.0-Spark兼容多版本Hive源码分析
探索大数据世界 - 深入解析数据存储、分布式计算与人工智能
12-01 2262
SPARKSQL3.0-Spark兼容多版本Hive源码分析
练习1-22
wcgwuxinwei的专栏
01-16 676
这个一维数组是用来保存我输入的那些全部字符，就是依次输入的很长的那些字符 这个数组是用来保存分割后的那些一行一行的字符 二维数组 第一维是保存行，第二维是保存每行的全部字符 这里就是把输入的字符按照一行一行的赋值到这个二维数组里面 下面else部分其实是每完成一行的赋值就输出一行 这是我和顾逸同学的一些聊天记录，大家凑和着看吧 另外这个在windows
第1关：数据清洗MapReduce综合应用案例 — 招聘数据清洗
qq_61604164的博客
11-15 1万+
第1关：数据清洗 MapReduce综合应用案例 — 招聘数据清洗
dolphinscheduler 配置sparksql数据源
03-30
1. 配置SparkSQL数据源 在DolphinScheduler的web管理页面中，点击左侧的“数据源”菜单，然后点击“新增”按钮，在弹出的页面中选择“SparkSQL”数据源类型，填写相关配置信息，如下图所示： ![image.png](https://cdn.nlark.com/yuque/0/2022/png/215728/1644455710852-7e500e9c-7d03-453b-9d7e-17b1c7e8510d.png#clientId=u7f8b614c-2d08-4&from=paste&id=ua1e4f4e4&margin=%5Bobject%20Object%5D&originHeight=1184&originWidth=2542&originalType=binary&ratio=1&status=done&style=none&taskId=u6d5f7a55-6a8e-4dcd-9d3a-3a6f4b6a4b6) 其中，配置信息的具体含义如下： - 数据源名称：自定义数据源的名称，例如“SparkSQL”； - 数据源类型：选择“SparkSQL”； - JDBC URL：填写SparkSQL连接的JDBC URL，例如“jdbc:spark://localhost:7077”； - 用户名：填写SparkSQL连接的用户名，例如“root”； - 密码：填写SparkSQL连接的密码，例如“123456”。 2. 测试SparkSQL数据源 配置完成后，点击“测试连接”按钮，测试数据源是否能够连接成功。如果连接成功，则会出现“连接成功”的提示信息；如果连接失败，则会出现“连接失败”的提示信息。 3. 在任务中使用SparkSQL数据源 在DolphinScheduler的web管理页面中，点击左侧的“任务”菜单，然后点击“新增”按钮，在弹出的页面中选择要创建的任务类型（例如“SQL”任务），然后填写任务相关信息，如下图所示： ![image.png](https://cdn.nlark.com/yuque/0/2022/png/215728/1644455731711-6558c0b9-7a63-4f1f-aa8a-08e2d63c94f6.png#clientId=u7f8b614c-2d08-4&from=paste&id=udbcb1c3d&margin=%5Bobject%20Object%5D&originHeight=1184&originWidth=2542&originalType=binary&ratio=1&status=done&style=none&taskId=u9f7a46d1-1f7a-4aa2-8d45-71e84d7c1a9) 其中，配置信息的具体含义如下： - 任务名称：自定义任务的名称，例如“SparkSQL任务”； - 任务类型：选择要创建的任务类型，例如“SQL”任务； - 数据源类型：选择“SparkSQL”； - SQL语句：填写要执行的SQL语句，例如“select * from table”； - 运行参数：填写任务的运行参数，例如“--executor-memory 512m”。 配置完成后，点击“保存”按钮，保存任务信息。然后，点击“运行”按钮，运行任务。如果任务能够正常运行，则会出现“运行成功”的提示信息；如果任务运行失败，则会出现“运行失败”的提示信息。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值