Spark SQL--- 数据源（二）

最新推荐文章于 2024-06-25 07:52:18 发布
最新推荐文章于 2024-06-25 07:52:18 发布
阅读量1k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42051034/article/details/105568920
版权

Spark SQL --- 数据源

2. 数据源

Spark SQL支持基于DataFrame操作一系列不同的数据源。DataFrame既可以当成一个普通RDD来操作，也可以将其注册成一个临时表来查询。把DataFrame注册为table之后，你就可以基于这个table执行SQL语句了。本节将描述加载和保存数据的一些通用方法，包含了不同的Spark数据源，然后深入介绍一下内建数据源可用选项。

2.1 通用加载/保存函数

在最简单的情况下，所有操作都会以默认类型数据源来加载数据（默认是Parquet，除非修改了spark.sql.sources.default 配置）。

2.1.1 手动指定选项

你也可以手动指定数据源，并设置一些额外的选项参数。数据源可由其全名指定（如，org.apache.spark.sql.parquet），而对于内建支持的数据源，可以使用简写名（json, parquet, jdbc）。任意类型数据源创建的DataFrame都可以用下面这种语法转成其他类型数据格式。

2.1.2 直接对文件使用SQL

Spark SQL还支持直接对文件使用SQL查询，不需要用read方法把文件加载进来。

2.1.3 保存模式

Save操作有一个可选参数SaveMode，用这个参数可以指定如何处理数据已经存在的情况。很重要的一点是，这些保存模式都没有加锁，所以其操作也不是原子性的。另外，如果使用Overwrite模式，实际操作是，先删除数据，再写新数据。

仅Scala/Java所有支持的语言含义
SaveMode.ErrorIfExists (default)“error” (default)（默认模式）从DataFrame向数据源保存数据时，如果数据已经存在，则抛异常。
SaveMode.Append“append”如果数据或表已经存在，则将DataFrame的数据追加到已有数据的尾部。
SaveMode.Overwrite“overwrite”如果数据或表已经存在，则用DataFrame数据覆盖之。
SaveMode.Ignore“ignore”如果数据已经存在，那就放弃保存DataFrame数据。这和SQL里CREATE TABLE IF NOT EXISTS有点类似。

2.1.4 保存到持久化表

在使用HiveContext的时候，DataFrame可以用saveAsTable方法，将数据保存成持久化的表。与registerTempTable不同，saveAsTable会将DataFrame的实际数据内容保存下来，并且在HiveMetastore中创建一个游标指针。持久化的表会一直保留，即使Spark程序重启也没有影响，只要你连接到同一个metastore就可以读取其数据。读取持久化表时，只需要用用表名作为参数，调用SQLContext.table方法即可得到对应DataFrame。

默认情况下，saveAsTable会创建一个”managed table“，也就是说这个表数据的位置是由metastore控制的。同样，如果删除表，其数据也会同步删除。

2.1.5 分组，排序和分区

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

  • python
df.write.bucketBy(42, "name").sortBy("age").saveAsTable("people_bucketed")
  • scala
peopleDF.write.bucketBy(42, "name").sortBy("age").saveAsTable("people_bucketed")

分区可以同时使用save和saveAsTable使用数据集API时使用。

  • python
df.write.partitionBy("favorite_color").format("parquet").save("namesPartByColor.parquet")
  • scala
usersDF.write.partitionBy("favorite_color").format("parquet").save("namesPartByColor.parquet")

可以对单个表使用分区和存储桶：

  • python
df = spark.read.parquet("examples/src/main/resources/users.parquet")
(df
    .write
    .partitionBy("favorite_color")
    .bucketBy(42, "name")
    .saveAsTable("people_partitioned_bucketed"))
  • scala
usersDF
  .write
  .partitionBy("favorite_color")
  .bucketBy(42, "name")
  .saveAsTable("users_partitioned_bucketed")

partitionBy按照“ 分区发现”部分中的描述创建目录结构。因此，它对具有高基数的列的适用性有限。相反， bucketBy将数据分布在固定数量的存储桶中，并且当许多唯一值不受限制时可以使用。

2.2 Parquet文件

Parquet 是一种流行的列式存储格式。Spark SQL提供对Parquet文件的读写支持，而且Parquet文件能够自动保存原始数据的schema。写Parquet文件的时候，所有的字段都会自动转成nullable，以便向后兼容。

2.2.1 编程方式加载数据

  • scala
// 我们继续沿用之前例子中的sqlContext对象
// 为了支持RDD隐式转成DataFrame
import spark.implicits._

val peopleDF = spark.read.json("examples/src/main/resources/people.json")

// DataFrames can be saved as Parquet files, maintaining the schema information
peopleDF.write.parquet("people.parquet")

// Read in the parquet file created above
// Parquet files are self-describing so the schema is preserved
// The result of loading a Parquet file is also a DataFrame
val parquetFileDF = spark.read.parquet("people.parquet")

// Parquet files can also be used to create a temporary view and then used in SQL statements
parquetFileDF.createOrReplaceTempView("parquetFile")
val namesDF = spark.sql("SELECT name FROM parquetFile WHERE age BETWEEN 13 AND 19")
namesDF.map(attributes => "Name: " + attributes(0)).show()
// +------------+
// |       value|
// +------------+
// |Name: Justin|
// +------------+

2.2.2 分区发现

像Hive这样的系统，一个很常用的优化手段就是表分区。在一个支持分区的表中，数据是保存在不同的目录中的，并且将分区键以编码方式保存在各个分区目录路径中。Parquet数据源现在也支持自动发现和推导分区信息。例如，我们可以把之前用的人口数据存到一个分区表中，其目录结构如下所示，其中有2个额外的字段，gender和country，作为分区键：

通过传递path/to/table给SparkSession.read.parquet或SparkSession.read.load，Spark SQL将自动从路径中提取分区信息。现在，返回的DataFrame的架构变为：

注意，分区键的数据类型将是自动推导出来的。目前，只支持数值类型和字符串类型数据作为分区键。

有的用户可能不想要自动推导出来的分区键数据类型。这种情况下，你可以通过 spark.sql.sources.partitionColumnTypeInference.enabled （默认是true）来禁用分区键类型推导。禁用之后，分区键总是被当成字符串类型。

从Spark-1.6.0开始，分区发现默认只在指定目录的子目录中进行。以上面的例子来说，如果用户把 path/to/table/gender=male 作为参数传给 SQLContext.read.parquet 或者 SQLContext.read.load，那么gender就不会被作为分区键。如果用户想要指定分区发现的基础目录，可以通过basePath选项指定。例如，如果把 path/to/table/gender=male作为数据目录，并且将basePath设为 path/to/table，那么gender仍然会最为分区键。

2.2.3 Schema合并

像ProtoBuffer、Avro和Thrift一样，Parquet也支持schema演变。用户从一个简单的schema开始，逐渐增加所需的新字段。这样的话，用户最终会得到多个schema不同但互相兼容的Parquet文件。目前，Parquet数据源已经支持自动检测这种情况，并合并所有文件的schema。

因为schema合并相对代价比较大，并且在多数情况下不是必要的，所以从Spark-1.5.0之后，默认是被禁用的。你可以这样启用这一功能：

  1. 读取Parquet文件时，将选项mergeSchema设为true（见下面的示例代码）
  2. 或者，将全局选项spark.sql.parquet.mergeSchema设为true

2.3 Hive metastore Parquet table转换

在读写Hive metastore Parquet 表时，Spark SQL用的是内部的Parquet支持库，而不是Hive SerDe，因为这样性能更好。这一行为是由spark.sql.hive.convertMetastoreParquet 配置项来控制的，而且默认是启用的。
Hive/Parquet schema调和
Hive和Parquet在表结构处理上主要有2个不同点：

  1. Hive对大小写不敏感，而Parquet则相反
  2. Hive所有字段都是nullable的，而Parquet需要显示设置

由于以上原因，我们必须在Hive metastore Parquet table转Spark SQL Parquet table的时候，对Hive metastore schema做调整，调整规则如下：

  1. 两种schema中字段名和字段类型必须一致（不考虑nullable）。调和后的字段类型必须在Parquet格式中有相对应的数据类型，所以nullable是也是需要考虑的。
  2. 调和后Spark SQL Parquet table schema将包含以下字段：* 只出现在Parquet schema中的字段将被丢弃； * 只出现在Hive metastore schema中的字段将被添加进来，并显式地设为nullable。

刷新元数据
Spark SQL会缓存Parquet元数据以提高性能。如果Hive metastore Parquet table转换被启用的话，那么转换过来的schema也会被缓存。这时候，如果这些表由Hive或其他外部工具更新了，你必须手动刷新元数据。

  • python
 # spark is an existing SparkSession
spark.catalog.refreshTable("my_table")
  • scala
// spark is an existing SparkSession
spark.catalog.refreshTable("my_table")

2.4 配置

Parquet配置可以通过 SQLContext.setConf 或者 SQL语句中 SET key=value来指定。

属性名默认值含义
spark.sql.parquet.binaryAsStringfalse有些老系统，如：特定版本的Impala，Hive，或者老版本的Spark SQL，不区分二进制数据和字符串类型数据。这个标志的意思是，让Spark SQL把二进制数据当字符串处理，以兼容老系统。
spark.sql.parquet.int96AsTimestamptrue有些老系统，如：特定版本的Impala，Hive，把时间戳存成INT96。这个配置的作用是，让Spark SQL把这些INT96解释为timestamp，以兼容老系统。
spark.sql.parquet.cacheMetadatatrue缓存Parquet schema元数据。可以提升查询静态数据的速度。
spark.sql.parquet.compression.codecgzip设置Parquet文件的压缩编码格式。可接受的值有：uncompressed, snappy, gzip（默认）, lzo
spark.sql.parquet.filterPushdowntrue启用过滤器下推优化，可以讲过滤条件尽量推导最下层，已取得性能提升
spark.sql.hive.convertMetastoreParquettrue如果禁用，Spark SQL将使用Hive SerDe，而不是内建的对Parquet tables的支持
spark.sql.parquet.output.committer.classorg.apache.parquet.hadoop.ParquetOutputCommitterParquet使用的数据输出类。这个类必须是 org.apache.hadoop.mapreduce.OutputCommitter的子类。一般来说，它也应该是 org.apache.parquet.hadoop.ParquetOutputCommitter的子类。注意：1. 如果启用spark.speculation, 这个选项将被自动忽略; 2. 这个选项必须用hadoop configuration设置，而不是Spark SQLConf; 3. 这个选项会覆盖 spark.sql.sources.outputCommitterClassSpark SQL有一个内建的org.apache.spark.sql.parquet.DirectParquetOutputCommitter, 这个类的在输出到S3的时候比默认的ParquetOutputCommitter类效率高。
spark.sql.parquet.mergeSchemafalse如果设为true，那么Parquet数据源将会merge 所有数据文件的schema，否则，schema是从summary file获取的（如果summary file没有设置，则随机选一个）

2.4 ORC文件

从Spark 2.3开始，Spark支持矢量化ORC读取器，其ORC文件格式为新的ORC文件格式。为此，新添加了以下配置。USING ORC当spark.sql.orc.impl 设置为native和spark.sql.orc.enableVectorizedReader设置为时，矢量化阅读器用于本机ORC表（例如，使用子句创建的表）true。对于Hive ORC Serde表（例如，使用子句创建的表USING HIVE OPTIONS (fileFormat ‘ORC’)），将矢量化阅读器spark.sql.hive.convertMetastoreOrc设置为true。

物业名称默认含义
spark.sql.orc.implnativeORC实现的名称。可以是native和之一hive。native表示基于Apache ORC 1.4构建的本机ORC支持。“ hive”是指Hive 1.2.1中的ORC库。
spark.sql.orc.enableVectorizedReadertrue在native实现中启用向量化orc解码。如果为false，则在native实现中使用新的非矢量化ORC读取器。为了hive实现，这被忽略。

2.5 JSON文件

Spark SQL在加载JSON数据的时候，可以自动推导其schema并返回DataFrame。用SQLContext.read.json读取一个包含String的RDD或者JSON文件，即可实现这一转换。

注意，通常所说的json文件只是包含一些json数据的文件，而不是我们所需要的JSON格式文件。JSON格式文件必须每一行是一个独立、完整的的JSON对象。因此，一个常规的多行json文件经常会加载失败。

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

  • scala
// 
通过在创建数据集时导入
原始类型（Int，String等）和产品类型（案例类）编码器来支持//。导入 spark.implicits._

//路径指向JSON数据集。
//路径可以是单个文本文件，也可以是存储文本文件的目录
val  path  =  “ examples / src / main / resources / people.json” 
val  peopleDF  =  spark 。阅读。json （路径）

//可以使用printSchema（）方法
peopleDF 可视化推断的模式。printSchema （）
//根
// |-年龄：长（nullable = true）
// |-名称：字符串（nullable = true）

//使用DataFrame 
peopleDF 创建一个临时视图。createOrReplaceTempView （“ people” ）

// SQL语句可以使用spark 
val  teenNamesDF  =  spark 提供的sql方法运行。sql （“从13和19岁之间的人中选择姓名” ）
teenNamesDF 。show （）
// + ------ + 
// | 名称| 
// + ------ + 
// | Justin | 
// + ------ +

//或者，可以为由
// Dataset [String] 
表示的JSON数据集创建DataFrame，该数据集每个字符串存储一个JSON对象val  otherPeopleDataset  =  spark 。createDataset （
  “”“ {” name“：” Yin“，” address“：{” city“：”哥伦布“，” state“：”俄亥俄州“}}”“”  ::  Nil ）
val  otherPeople  =  spark 。阅读。json （otherPeopleDataset ）
otherPeople 。show （）
// + --------------- + ---- + 
// | 地址|名称| 
// + --------------- + ---- + 
// | [俄亥俄州哥伦布] | 尹|
// + --------------- + ---- +

在Spark存储库中的“ examples / src / main / scala / org / apache / spark / examples / sql / SQLDataSourceExample.scala”中找到完整的示例代码。

2.6 Hive表

Spark SQL支持从Apache Hive读写数据。然而，Hive依赖项太多，所以没有把Hive包含在默认的Spark发布包里。要支持Hive，需要在编译spark的时候增加-Phive和-Phive-thriftserver标志。这样编译打包的时候将会把Hive也包含进来。注意，hive的jar包也必须出现在所有的worker节点上，访问Hive数据时候会用到（如：使用hive的序列化和反序列化SerDes时）。

Hive配置在conf/目录下hive-site.xml，core-site.xml（安全配置），hdfs-site.xml（HDFS配置）文件中。请注意，如果在YARN cluster（yarn-cluster mode）模式下执行一个查询的话，lib_mananged/jar/下面的datanucleus 的jar包，和conf/下的hive-site.xml必须在驱动器（driver）和所有执行器（executor）都可用。一种简便的方法是，通过spark-submit命令的–jars和–file选项来提交这些文件。

如果使用Hive，则必须构建一个HiveContext，HiveContext是派生于SQLContext的，添加了在Hive Metastore里查询表的支持，以及对HiveQL的支持。用户没有现有的Hive部署，也可以创建一个HiveContext。如果没有在hive-site.xml里配置，那么HiveContext将会自动在当前目录下创建一个metastore_db目录，再根据HiveConf设置创建一个warehouse目录（默认/user/hive/warehourse）。所以请注意，你必须把/user/hive/warehouse的写权限赋予启动spark应用程序的用户。

  • scala
import java.io.File

import org.apache.spark.sql.{Row, SaveMode, SparkSession}

case class Record(key: Int, value: String)

// warehouseLocation points to the default location for managed databases and tables
val warehouseLocation = new File("spark-warehouse").getAbsolutePath

val spark = SparkSession
  .builder()
  .appName("Spark Hive Example")
  .config("spark.sql.warehouse.dir", warehouseLocation)
  .enableHiveSupport()
  .getOrCreate()

import spark.implicits._
import spark.sql

sql("CREATE TABLE IF NOT EXISTS src (key INT, value STRING) USING hive")
sql("LOAD DATA LOCAL INPATH 'examples/src/main/resources/kv1.txt' INTO TABLE src")

// Queries are expressed in HiveQL
sql("SELECT * FROM src").show()
// +---+-------+
// |key|  value|
// +---+-------+
// |238|val_238|
// | 86| val_86|
// |311|val_311|
// ...

// Aggregation queries are also supported.
sql("SELECT COUNT(*) FROM src").show()
// +--------+
// |count(1)|
// +--------+
// |    500 |
// +--------+

// The results of SQL queries are themselves DataFrames and support all normal functions.
val sqlDF = sql("SELECT key, value FROM src WHERE key < 10 ORDER BY key")

// The items in DataFrames are of type Row, which allows you to access each column by ordinal.
val stringsDS = sqlDF.map {
  case Row(key: Int, value: String) => s"Key: $key, Value: $value"
}
stringsDS.show()
// +--------------------+
// |               value|
// +--------------------+
// |Key: 0, Value: val_0|
// |Key: 0, Value: val_0|
// |Key: 0, Value: val_0|
// ...

// You can also use DataFrames to create temporary views within a SparkSession.
val recordsDF = spark.createDataFrame((1 to 100).map(i => Record(i, s"val_$i")))
recordsDF.createOrReplaceTempView("records")

// Queries can then join DataFrame data with data stored in Hive.
sql("SELECT * FROM records r JOIN src s ON r.key = s.key").show()
// +---+------+---+------+
// |key| value|key| value|
// +---+------+---+------+
// |  2| val_2|  2| val_2|
// |  4| val_4|  4| val_4|
// |  5| val_5|  5| val_5|
// ...

// Create a Hive managed Parquet table, with HQL syntax instead of the Spark SQL native syntax
// `USING hive`
sql("CREATE TABLE hive_records(key int, value string) STORED AS PARQUET")
// Save DataFrame to the Hive managed table
val df = spark.table("src")
df.write.mode(SaveMode.Overwrite).saveAsTable("hive_records")
// After insertion, the Hive managed table has data now
sql("SELECT * FROM hive_records").show()
// +---+-------+
// |key|  value|
// +---+-------+
// |238|val_238|
// | 86| val_86|
// |311|val_311|
// ...

// Prepare a Parquet data directory
val dataDir = "/tmp/parquet_data"
spark.range(10).write.parquet(dataDir)
// Create a Hive external Parquet table
sql(s"CREATE EXTERNAL TABLE hive_bigints(id bigint) STORED AS PARQUET LOCATION '$dataDir'")
// The Hive external table should already have data
sql("SELECT * FROM hive_bigints").show()
// +---+
// | id|
// +---+
// |  0|
// |  1|
// |  2|
// ... Order may vary, as spark processes the partitions in parallel.

// Turn on flag for Hive Dynamic Partitioning
spark.sqlContext.setConf("hive.exec.dynamic.partition", "true")
spark.sqlContext.setConf("hive.exec.dynamic.partition.mode", "nonstrict")
// Create a Hive partitioned table using DataFrame API
df.write.partitionBy("key").format("hive").saveAsTable("hive_part_tbl")
// Partitioned column `key` will be moved to the end of the schema.
sql("SELECT * FROM hive_part_tbl").show()
// +-------+---+
// |  value|key|
// +-------+---+
// |val_238|238|
// | val_86| 86|
// |val_311|311|
// ...

spark.stop()
  • python
from os.path import expanduser, join, abspath

from pyspark.sql import SparkSession
from pyspark.sql import Row

# warehouse_location points to the default location for managed databases and tables
warehouse_location = abspath('spark-warehouse')

spark = SparkSession \
    .builder \
    .appName("Python Spark SQL Hive integration example") \
    .config("spark.sql.warehouse.dir", warehouse_location) \
    .enableHiveSupport() \
    .getOrCreate()

# spark is an existing SparkSession
spark.sql("CREATE TABLE IF NOT EXISTS src (key INT, value STRING) USING hive")
spark.sql("LOAD DATA LOCAL INPATH 'examples/src/main/resources/kv1.txt' INTO TABLE src")

# Queries are expressed in HiveQL
spark.sql("SELECT * FROM src").show()
# +---+-------+
# |key|  value|
# +---+-------+
# |238|val_238|
# | 86| val_86|
# |311|val_311|
# ...

# Aggregation queries are also supported.
spark.sql("SELECT COUNT(*) FROM src").show()
# +--------+
# |count(1)|
# +--------+
# |    500 |
# +--------+

# The results of SQL queries are themselves DataFrames and support all normal functions.
sqlDF = spark.sql("SELECT key, value FROM src WHERE key < 10 ORDER BY key")

# The items in DataFrames are of type Row, which allows you to access each column by ordinal.
stringsDS = sqlDF.rdd.map(lambda row: "Key: %d, Value: %s" % (row.key, row.value))
for record in stringsDS.collect():
    print(record)
# Key: 0, Value: val_0
# Key: 0, Value: val_0
# Key: 0, Value: val_0
# ...

# You can also use DataFrames to create temporary views within a SparkSession.
Record = Row("key", "value")
recordsDF = spark.createDataFrame([Record(i, "val_" + str(i)) for i in range(1, 101)])
recordsDF.createOrReplaceTempView("records")

# Queries can then join DataFrame data with data stored in Hive.
spark.sql("SELECT * FROM records r JOIN src s ON r.key = s.key").show()
# +---+------+---+------+
# |key| value|key| value|
# +---+------+---+------+
# |  2| val_2|  2| val_2|
# |  4| val_4|  4| val_4|
# |  5| val_5|  5| val_5|
# ...

和不同版本的Hive Metastore交互
Spark SQL对Hive最重要的支持之一就是和Hive metastore进行交互，这使得Spark SQL可以访问Hive表的元数据。从Spark-1.4.0开始，Spark SQL有专门单独的二进制build版本，可以用来访问不同版本的Hive metastore，其配置表如下。注意，不管所访问的hive是什么版本，Spark SQL内部都是以Hive 1.2.1编译的，而且内部使用的Hive类也是基于这个版本（serdes，UDFs，UDAFs等）

以下选项可用来配置Hive版本以便访问其元数据：

属性名默认值含义
spark.sql.hive.metastore.version1.2.1Hive metastore版本，可选的值为0.12.0 到 2.3.3
spark.sql.hive.metastore.jarsbuiltin初始化HiveMetastoreClient的jar包。这个属性可以是以下三者之一：1.builtin 目前内建为使用Hive-1.2.1，编译的时候启用-Phive，则会和spark一起打包。如果没有-Phive，那么spark.sql.hive.metastore.version要么是1.2.1，要就是未定义; 2.maven 使用maven仓库下载的jar包版本。这个选项建议不要再生产环境中使用; 3.JVM格式的classpath。 这个classpath必须包含所有Hive及其依赖的jar包，且包含正确版本的hadoop。这些jar包必须部署在driver节点上，如果你使用yarn-cluster模式，那么必须确保这些jar包也随你的应用程序一起打包
spark.sql.hive.metastore.sharedPrefixescom.mysql.jdbc,org.postgresql,com.microsoft.sqlserver,oracle.jdbc一个逗号分隔的类名前缀列表，这些类使用classloader加载，且可以在Spark SQL和特定版本的Hive间共享。例如，用来访问hive metastore 的JDBC的driver就需要这种共享。其他需要共享的类，是与某些已经共享的类有交互的类。例如，自定义的log4j appender
spark.sql.hive.metastore.barrierPrefixes(empty)一个逗号分隔的类名前缀列表，这些类在每个Spark SQL所访问的Hive版本中都会被显式的reload。例如，某些在共享前缀列表（spark.sql.hive.metastore.sharedPrefixes）中声明为共享的Hive UD函数

2.7 JDBC到其他数据库

Spark SQL也可以用 JDBC 访问其他数据库。这一功能应该优先于使用 JdbcRDD。因为它返回一个DataFrame，而 DataFrame 在 Spark SQL 中操作更简单，且更容易和来自其他数据源的数据进行交互关联。JDBC数据源在 java 和 python 中用起来也很简单，不需要用户提供额外的ClassTag。（注意，这与Spark SQL JDBC server不同，Spark SQL JDBC server允许其他应用执行Spark SQL查询）

首先，你需要在spark classpath中包含对应数据库的JDBC driver，例如，要从Spark Shell连接到postgres，您可以运行以下命令：

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

远程数据库的表可以通过Data Sources API，用DataFrame或者SparkSQL 临时表来装载。以下是选项列表：

属性名含义
url需要连接的JDBC URL
dbtable需要读取的JDBC表。注意，任何可以填在SQL的where子句中的东西，都可以填在这里。（既可以填完整的表名，也可填括号括起来的子查询语句）
driverJDBC driver的类名。这个类必须在master和worker节点上都可用，这样各个节点才能将driver注册到JDBC的子系统中。
partitionColumn, lowerBound, upperBound, numPartitions这几个选项，如果指定其中一个，则必须全部指定。他们描述了多个worker如何并行的读入数据，并将表分区。partitionColumn必须是所查询的表中的一个数值字段。注意，lowerBound和upperBound只是用于决定分区跨度的，而不是过滤表中的行。因此，表中所有的行都会被分区然后返回。
fetchSizeJDBC fetch size，决定每次获取多少行数据。在JDBC驱动上设成较小的值有利于性能优化（如，Oracle上设为10）

2.8 故障排除

JDBC driver class必须在所有client session或者executor上，对java的原生classloader可见。这是因为Java的DriverManager在打开一个连接之前，会做安全检查，并忽略所有对原声classloader不可见的driver。最简单的一种方法，就是在所有worker节点上修改compute_classpath.sh，并包含你所需的driver jar包。

一些数据库，如H2，会把所有的名字转大写。对于这些数据库，在Spark SQL中必须也使用大写。

参考

https://spark.apache.org/docs/latest/sql-programming-guide.html

Zhouxk96
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spark SQL的数据源(Spark2.3.2)
jmx_bigdata的博客
11-01 1237
版权声明：本文为博主原创(翻译)文章，未经博主允许不得转载。https://blog.csdn.net/jmx_bigdata/article/details/83619838 目录 一、 普通的Load/Save方式   1. 手动指定文件格式 2.使用SQL直接查询文件 3.保存模式 4.保存为永久的表 5. 分桶、排序与分区 二、Parquet文件 1.编程的方式加载数据 ...
SparkSQL-数据源
weixin_44085996的博客
09-24 718
1、通用加载/保存方法 1）手动指定选项 Spark SQL的DataFrame接口支持多种数据源的操作。一个DataFrame可以进行RDDs方式的操作，也可以被注册为临时表。把DataFrame注册为临时表之后，就可以对该DataFrame执行SQL查询。 Spark SQL的默认数据源为Parquet格式。数据源为Parquet文件时，Spark SQL可以方便的执行所有的操作。修改配置项spark.sql.sources.default，可修改...
Hive新增/变更字段后，Hive metastore与Hive tblproperties缓存的spark schema不一致处理
mypowerhere的专栏
07-13 1384
Hive新增/变更字段后，Hive metastore与Hive tblproperties缓存的spark schema不一致处理
【Spark报错】cannot read table property ‘spark.sql.sources.schema‘ as it‘s corrupted
hhnail7799的博客
03-05 267
u表和b表的表结构有问题，查询count(1)后发现也报错Cannot read table property 'spark.sql.sources.schema，建表SQL调整后就可以了。用Spark，连接u表和b表关联后插入a表。
Spark SQL----ORC文件
最新发布
Gabriel Wang的博客
06-25 1349
Apache ORC是一种列式格式，它有更高级的功能，如原生zstd压缩、bloom filter和列式加密。
Spark 任务常见错误以及解决方案
热门推荐
qq_31806205的博客
09-23 1万+
Table or view not found: aaa.bbb The column number of the existing table dmall_search.query_embedding_data_1(struct<>) doesn’t match the data schema(struct<user_id:string,dt:string,sku_list:array>); Cannot insert into table ddw_ware.purchase_d.
SparkSQL与Hive metastore Parquet转换
weixin_45906054的博客
05-20 1987
Spark SQL为了更好的性能，在读写Hive metastore parquet格式的表时，会默认使用自己的Parquet SerDe，而不是采用Hive的SerDe进行序列化和反序...
spark读取hive表异常，处理WARN HiveExternalCatalog: The table schema given by Hive metastore
qq_28658621的博客
04-05 5755
spark读取hive表异常：WARN HiveExternalCatalog: The table schema given by Hive metastore...We have to fall back to the table schema from Hive metastore which is not case preserving.
sparksql参数调优
MDZ_1122333322的博客
07-29 1196
所以就会出现，即使你设置了spark.sql.files.ignoreMissingFiles的情况下，仍然报FileNotFoundException的情况，异常栈如下, 可以看到这里面走到了HadoopRDD，而且后面是org.apache.hadoop.hive.ql.io.parquet.read.ParquetRecordReaderWrappe可见是查询一张hive表。上面的两个参数在分区表情况下是针对分区路径存在的情况下，分区路径下面的文件不存在或者损坏的处理。
spark-sql读取不到parquet格式的hive表
onway_goahead的博客
02-07 1468
情况一： 当向Hive metastore中读写Parquet表时，Spark SQL将使用Spark SQL自带的Parquet SerDe（SerDe：Serialize/Deserilize的简称,目的是用于序列化和反序列化），而不是用Hive的SerDe，Spark SQL自带的SerDe拥有更好的性能。这个优化的配置参数为spark.sql.hive.convertMetastoreParquet，默认值为开启。 所以有时会发生spark自带的序列化方式无法解析hive中的parquet数据，
Learning Spark SQL - Aurobindo Sarkar
12-25
《Learning Spark SQL - Aurobindo Sarkar》这本书是针对Apache Spark SQL的深入学习指南，由Aurobindo Sarkar撰写。Spark SQL是Apache Spark框架的一部分，它允许开发者使用SQL或者DataFrame API处理大规模数据。...
Spark-SQL外部数据源.md
08-09
Spark-SQL外部数据源.md
spark-sql数据.rar
08-21
在本项目实例中，我们有一个名为"spark-sql数据.rar"的压缩包，其中包含了与Spark SQL相关的数据集，主要涉及城市信息、地区信息和点击信息。下面将详细介绍这三个方面的知识点。 1. 城市信息数据： 这部分数据...
spark-2.4.7-bin-hadoop2.6.tgz
03-17
5. **Spark Streaming**：Spark Streaming提供了微批处理的方式处理实时流数据，它能够处理来自各种数据源（如Kafka、Flume等）的连续数据流。 6. **MLlib**：Spark的机器学习库MLlib包含了多种机器学习算法，如...
spark-xml:Spark SQL和DataFrames的XML数据源
05-12
Apache Spark的XML数据源 一个用于使用解析和查询XML数据的库，用于Spark SQL和DataFrames。 结构和测试工具大部分是从复制的。 该软件包支持以分布式方式处理无格式的XML文件，这与Spark中的JSON数据源限制嵌入式...
基于Hive进行数仓建设的资源元数据信息统计：Spark篇
weixin_48967543的博客
04-09 753
在数据仓库建设中，元数据管理是非常重要的环节之一。根据Kimball的数据仓库理论，可以将元数据分为这三类： 技术元数据，如表的存储结构结构、文件的路径 业务元数据，如血缘关系、业务的归属 过程元数据，如表每天的行数、占用HDFS空间、更新时间 而基于这3类元数据"搭建"起来的元数据系统，通常又会实现如下核心功能： 1. 血缘关系 如表级别/字段级别的血缘关系，这些主要体现在我们日常的SQL和ETL任务里。 2. 大数据集群计算资源管理 针对利用不同的计算引擎如Spark/Flink/Mapreduce，.
DataFrame持久存储
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
07-02 1278
大数据实验教学系统DataFrame持久存储DataFrame数据经过计算以后，可以持久到外部存储中，如关系型数据库和HDFS中。Spark对此提供了支持。掌握DataFrame存储操作。将DataFrame持久存储。具体包含如下内容：   - 写入MySQL   - 写入HDFS硬件：x86_64 ubuntu 16.04服务器   软件：JDK 1.8，Spark-2.3.2，Hadoop-2.7.3，zeppelin-0.8.11、右击Ubuntu操作系统桌面，从弹出菜单中选择【】命令打开终端。   
hive 文件存储parquet格式, sparkSql解析部分字段为null
u012075079的专栏
09-27 5982
hive 版本2.1.0， hdfs 上同一份数据 （1） 用hive 建表， 部分字段hive 读取有值， sparksql读取值为null CREATE EXTERNAL TABLE business_log.rule_business_log2 (                            id bigint,                             bu
Spark SQL操作多数据源
不清不慎的博客
06-18 5847
Spark SQL支持通过DataFrame接口操作的多种不同的数据源。DataFrame提供支持统一的接口加载和保存数据源中的数据，包括：结构化数据，Parquet文件，JSON文件，Hive表 ，以及通过JDBC连接外部数据源。 与Hive类似的，Spark SQL也可以创建临时表和持久表（即管理表），使用registerTempTable命令创建临时表，使用saveAsTable命令将数据...
spark-sql -e
04-30
Spark-SQL是Spark的一个模块，它允许开发者使用SQL语言对Spark中的数据进行查询和分析。可以通过Spark-SQL轻松地读取各种数据源，并编写SQL查询语句对数据进行分析和处理。Spark-SQL具有灵活性高，适用于处理结构化和半结构化数据（如JSON），甚至还可以将Spark-SQL查询集成到现有的Java和Scala应用程序中。Spark-SQL模块提供了一种强大的API，用于创建表和视图，对表和视图执行各种操作，并在Spark集群上执行查询。 而Spark-SQL -e的命令是用于运行一些SQL查询的。Spark-SQL -e可以接受一条查询作为参数，执行该查询，并将结果输出到终端。例如，如果我们想在Spark-SQL中查找所有学生的平均成绩，可以运行以下查询：spark-sql -e "SELECT AVG(grade) FROM students"。在执行查询时，可以使用各种选项来调整查询执行的环境设置。有些选项允许我们控制查询并行度，有些可以用于调整查询的内存使用情况。Spark-SQL -e可以用于处理大型数据集，因为它可以自动地将查询优化并分发到集群中的多个节点上。这使得Spark-SQL -e成为大数据处理的一个有用工具。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值