概述:
1)Spark SQL 是 Spark 处理结构化数据的一个模块.与基础的 Spark RDD API 不同, Spark SQL 提供了查询结构化数据及计算结果等信息的接口.
2)Spark SQL可以加载任何地方的数据,例如mysql,hive,hdfs,hbase等,而且支持很多种格式如json, parquet, avro, csv格式。我们可以开发出任意的外部数据源来连接到Spark SQL,然后我们就可以通过外部数据源API来进行操作。
3)我们通过外部数据源API读取各种格式的数据,会得到一个DataFrame,这是我们熟悉的方式啊,就可以使用DataFrame的API或者SQL的API进行操作
4)外部数据源的API可以自动做一些列的裁剪,什么叫列的裁剪,假如一个user表有id,name,age,gender4个列,在做select的时候你只需要id,name这两列,那么其他列会通过底层的优化去给我们裁剪掉
5)保存操作可以选择使用SaveMode,指定如何保存现有数据(如果存在)
准备工作:
1导入依赖:
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_2.12</artifactId>
<version>${spark.version}</version>
</dependency>
2 Spark编程入口SparkSession 创建
import org.apache.spark.sql.SparkSession
val sparkSession= SparkSession
.builder()
.appName("Spark SQL basic example")
.config("spark.some.config.option", "some-value")
.getOrCreate()
// For implicit conversions like converting RDDs to DataFrames
import spark.implicits._
sparkSession.stop()
案例及源码分析:
DataFrame Datasets之间的关系:
源码中:
type DataFrame = Dataset[Row]
DataSets
一个 Dataset 是一个分布式的数据集合。 Dataset 是在 Spark 1.6 中被添加的新接口, 它提供了 RDD 的优点(强类型化, 能够使用强大的 lambda 函数)
与Spark SQL执行引擎的优点.一个 Dataset 可以从 JVM 对象来 构造 并且使用转换功能(map, flatMap, filter, 等等)
DataFrame --(表)
一个 DataFrame 是一个 Dataset 组成的指定列.它的概念与一个在关系型数据库或者在 R/Python 中的表是相等的, 但是有很多优化.
DataFrames 可以从大量的 sources 中构造出来, 比如: 结构化的文本文件, Hive中的表, 外部数据库, 或者已经存在的 RDDs.
1 读取 txt 文件数据
def text(sparkSession: SparkSession) = {
import sparkSession.implicits._
// 标准写法
val dataFrame: DataFrame = sparkSession.read.format("text").load("input/user.txt")
// 另外一种写法 (后面源码分析差异)
// sparkSession.read.text("input.user.txt")
val ds: Dataset[String] = sparkSession.read.textFile("input/user.txt","input/traffics.txt")
ds.show(20)
// dataFrame.show(20)
val result = ds.map(x=>{
val strings = x.split(" ")
//(strings(0),strings(1))
strings(0)
})
val result2 = dataFrame.rdd.map(x => {//dataFrame.rdd 要转化
val tmp = x.getString(0)
val strs = tmp.split(" ")
//(strs(0), strs(1))
strs(0)
})
// 保存 可以使用压缩
//result.write.option("compression","Gzip").mode(SaveMode.Overwrite).format("text").save("out")
result.write.mode(SaveMode.Overwrite).format("text").save("out2")
}
上述两种写法的源码分析差异:
/**
* Loads text files and returns a `DataFrame` whose schema starts with a string column named
* "value", and followed by partitioned columns if there are any. See the documentation on
* the other overloaded `text()` method for more details.
*
* @since 2.0.0
*/
def text(path: String): DataFrame = {
// This method ensures that calls that explicit need single argument works, see SPARK-16009
text(Seq(path): _*)
}
我们调用text() 方法其实进行了 overloaded
def text(paths: String*): DataFrame = format("text").load(paths : _*)
这个方法就很熟悉了,其实就是我们的标准写法,一目了然。 后文的json(),csv()等方法均类似
注意:
1.保存的文件夹不能存在,否则报错(默认情况下,可以选择不同的模式):org.apache.spark.sql.AnalysisException: path file:/home/hadoop/data already exists;
2.保存成文本(text)格式,只能保存一列,否则报错:org.apache.spark.sql.AnalysisException: Text data source supports only a single column, and you have 2 columns;
解决1中的问题:
保存模式 | 意义 |
---|---|
SaveMode.ErrorIfExists (default) | 将DataFrame保存到数据源时,如果数据已经存在,则预计会抛出异常 |
SaveMode.Append | 将DataFrame保存到数据源时,如果数据/表已存在,则DataFrame的内容预计会附加到现有数据 |
SaveMode.Overwrite | 覆盖模式意味着将DataFrame保存到数据源时,如果数据/表已存在,则预期现有数据将DataFrame的内容覆盖 |
SaveMode.Ignore | 忽略模式意味着将DataFrame保存到数据源时,如果数据已经存在,则保存操作不会保存DataFrame的内容,也不会更改现有的数据。这与SQL中的create table if not exists 类似 |
解决2中的问题:
数据保存之前先想办法将数据由多列压缩成单列,concat_ws : 用指定的字符连接字符
def mulitColumnOutput(df:DataFrame,delimiter:String=","): Unit ={
val columns = df.columns.mkString(",")
val result = df.selectExpr(s"concat_ws('$delimiter',$columns)as colums_name")
result.write.mode(SaveMode.Overwrite).format("text").save("out/")
}
2 读取json
def json(sparkSession: SparkSession) = {
import sparkSession.implicits._
//标准写法
val df = sparkSession.read.format("json").load("input/imput.log")
//写法2 (原理同上)
val dataFrame = sparkSession.read.json("input/imput.log")
df.printSchema()
// 所有字段展示
df.show(2)
+-----------------+--------+-------------+--------+-------------------+-------+------------+-------+
| appId|duration| ip|platform| time|traffic| user|version|
+-----------------+--------+-------------+--------+-------------------+-------+------------+-------+
|www.ruozedata.com| 6666|182.89.87.243| IOS|2019-09-19 10:59:13| ~~~~|ruozedataLog| 1.0.0|
|www.ruozedata.com| 6666| 123.235.55.4| Android|2019-09-19 10:59:16| 1242|ruozedataLog| 1.0.0|
+-----------------+--------+-------------+--------+-------------------+-------+------------+-------+
//根据条件截取我们所需要的列
df.select("appId","platform","ip").filter('platform === "IOS")
// .filter($"ip" === "106.95.18.65") $ 符号也可以
.show(3)
+-----------------+--------+--------------+
| appId|platform| ip|
+-----------------+--------+--------------+
|www.ruozedata.com| IOS| 182.89.87.243|
|www.ruozedata.com| IOS|123.233.211.65|
|www.ruozedata.com| IOS| 106.95.18.65|
+-----------------+--------+--------------+
// 保存数据 也支持压缩等
result.write.mode(SaveMode.Overwrite).format("json").save("out")
}
3 读取CSV 文件
def csv(sparkSession: SparkSession) = {
import sparkSession.implicits._
//不加修饰的读取
val df = sparkSession.read.format("csv").load("input/people.csv").show(3)
+------------------+
| _c0|
+------------------+
| name;age;job|
|Jorge;30;Developer|
| Bob;32;Developer|
+------------------+
// 添加表头,和分隔符
val df = sparkSession.read.option("header","true").option("sep",";").format("csv").load("input/people.csv").show(3)
+-----+---+---------+
| name|age| job|
+-----+---+---------+
|Jorge| 30|Developer|
| Bob| 32|Developer|
+-----+---+---------+
df.select("name","age").filter($"age" > 30)
.write.format("csv").mode("overwrite")
.save("out")
}
4 jdbc 方式读取
def jdbc(sparkSession: SparkSession) = {
import sparkSession.implicits._
val jdbcDF = sparkSession.read
.format("jdbc")
.option("url", "jdbc:mysql://192.168.76.109:3306/database")
// .option("dbtable", "database.table")
.option("user", "username")
.option("password", "password")
.option("query", "select id,nick from user")
.load()
jdbcDF.show(2)
// 保存到一个新表中
jdbcDF.filter('id === "2681")
.write.format("jdbc")
.option("url", "jdbc:mysql://192.168.76.109:3306")
.option("dbtable", "database.table")
.option("user", "username")
.option("password", "password")
// .mode(SaveMode.Overwrite)
.save()
}
生产中的操作:
通过将option 中的连接信息写入到配置文件中去
这里选用的scalikejdbc-config
<dependency>
<groupId>org.scalikejdbc</groupId>
<artifactId>scalikejdbc-config_2.12</artifactId>
<version>3.3.0</version>
</dependency>
创建 src/main/resources/application.conf 文件,并写入配置
def jdbcFromProperties(sparkSession: SparkSession) = {
import sparkSession.implicits._
// 从配置文件中导入连接信息
val config = ConfigFactory.load()
val url = config.getString("db.default.url")
val user = config.getString("db.default.user")
val password = config.getString("db.default.password")
val srcTable = config.getString("db.default.srctable")
val targetTable = config.getString("db.default.targettable")
val jdbcDF = sparkSession.read
.format("jdbc")
.option("url", url)
//.option("dbtable", "user")
.option("user", user)
.option("password",password)
.option("query", "select id,nick from user")
.load()
jdbcDF.show(2)
// 保存到一个新表中
jdbcDF.filter('id === "2685")
.write.format("jdbc")
.option("url", url)
.option("dbtable", targetTable)
.option("user", user)
.option("password", password)
.mode(SaveMode.Overwrite)
.save()
}