简介
spark1.0版本就已经退出SparkSQL最早叫shark
Shark是基于spark框架并且兼容hive,执行SQL执行引擎,因为底层使用了Spark,比MR的Hive普遍要快上两倍左右,当数据全部load到内存中,此时会比Hive快上10倍以上,SparkSQL就是一种交互式查询应用服务
特点
1.内存列存储–可以大大优化内存的使用率,减少内存消耗,避免GC对大量数据性能的开销
2.字节码生成技术–可以使用动态 的字节码技术优化性能
3.Scala代码的优化
SparkSql 的官网是: http://spark.apache.org/sql/
SparkSQL是spark用来处理结构化的一个模块,它提供一个抽象的数据集DataFrame,并且是作为分布式SQL查询引擎的应用。
为什么要学习SparkSQL?
之前已经学习了hive,它将HiveSQL转换成MR,然后提交到集群上去执行,减少编写MR查询的复杂性,但是因为采用计算框架,所以执行效率比较慢,所以spark就应运而生。
1.易整合
2.统一的数据访问方式
3.兼容hive
4.提供了统一的数据连接方式(JDBC/ODBC)
DataFrames
与RDD类型,DataFrame也是是一个分布式数据容器,然而DataFrame更像传统数据库中二维表格
除了记录数据之外,还记数据的结构信息(schema),同时与Hive类型,DataFrame也支持嵌套数据类型(struct,map,array),从API易用角度来看,DataFrame提供更高级的API,比函数RDDAPI更加友好。
RDD和DataFrame的区别
创建DataFrames
1)spark-shell版本
spark中已经创建好了SparkContext和SQLContext对象
2)代码:
spark-shell --master spark://hadoop1:7077 --executor-memory 512m --total-executor-cores 2
//创建了一个数据集,实现了并行化
val seq= Seq((“1”,“xiaoming”,15),(“2”,“xiaohong”,20),(“3”,“xiaobi”,10))
将当前的rdd对象转换为DataFrame对象(数据信息和数据结构信息存储到DataFrame)
//_1:string,_2:string,3:int
//在使用toDF进行转换的时候,空参的情况下。默认是+数据 作为列名,数字从1开始逐渐递增
_1:列名,String当前列的数据类型
//查看数据 show 算子来打印,show是一个action类型 算子
df.show
DSL 风格语法
1.查询:
df.select("name").show
df.select("name","age")..show
//条件过滤
df.select("name","age").filter("age >10").show
//参数必须是一个字符串,filter中的表达式也需要时一个字符串
//2.参数是类名col (“列名”)
df.select(“name”,“age”).filter(col(“age”) >10).show
//3.分组统计个数
df.groupBy("age").count().show()
df.printSchema
Sql 风格语法:
1.将DataFrame注册成表(临时表),表会被存储
df.registerTempTable(“t_person”)
查询语法:需要通过SQLContext对象调用sql方法写入sql语句(两种)
sqlContext.sql(“select name,age from t_person where age > 10”).show
sqlContext.sql(“select name,age from t_person order by age desc limit 2”).show
Hive中orderby和sortby的区别?
1.使用orderby全局排序
2.使用distribute和sort进行分组排序
3.distribute by + sort by 通过当前distribute by 设定字段为key,数据会被hash到不同reduce机器上
4.然后同sort by 会对同一个reduce机器上的数据进行局部排序
5.orderby 是全局有序 distribute sort by :局部有序,全局无序
结构表信息:
sqlContext.sql(“desc t_person”).show
以编码的形式来执行sparkSQL
先将工程中的maven添加配置
<dependency>
<groupId>org.apache.spark</groupId>
<artifactId>spark-sql_2.10</artifactId>
<version>1.6.3</version>
</dependency>
第一种通过反射方式推断
SparkSQLDemo1.scala
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SQLContext}
import org.apache.spark.{SparkConf, SparkContext}
/**
* sparkSQL --就是查询
*/
object SparkSQLDemo1 {
def main(args: Array[String]): Unit = {
//之前在spark-shell中,sparkContext和SQLContext是创建好的 所以不需要创建
//因为是代码编程,需要进行创建
val conf = new SparkConf().setAppName("SparkSQLDemo1").setMaster("local")
val sc =new SparkContext(conf)
//创建SQLContext对象
val sqlc = new SQLContext(sc)
//集群中获取数据生成RDD
val lineRDD: RDD[Array[String]] = sc.textFile("hdfs://hadoop2:8020/Person.txt").map(_.split(" "))
//lineRDD.foreach(x => println(x.toList))
//将获取数据 关联到样例类中
val personRDD: RDD[Person] = lineRDD.map(x => Person(x(0).toInt,x(1),x(2).toInt))
import sqlc.implicits._
//toDF相当于反射,这里若要使用的话,需要导入包
/**
* DataFrame [_1:int,_2:String,_3:Int]
* spark-shell 数据是一个自己生成并行化数据并没有使用样例类来 存数据而是直接使用
* 直接调用toDF的时候,使用就是默认列名 _+数字 数字从1开始逐渐递增
* 可以在调用toDF方法的时候指定类的名称(指定名称多余数据会报错)
*
* 列名不要多余,也不要少于
* 也就是说列名要和数据一一对应
*
* 使用代码编程数据是存储到样例类中,样例类中的构造方法中的参数就是对应的列名
* 所以通过toDF可以直接获取对应的属性名作为列名使用
* 同时也可以自定义列名
*
*/
val personDF: DataFrame = personRDD.toDF()
//val personDF: DataFrame = personRDD.toDF("ID","NAME","AGE")
personDF.show()
//使用Sql语法
//注册临时表,这个表相当于存储在 SQLContext中所创建对象中
personDF.registerTempTable("t_person")
val sql = "select * from t_person where age > 20 order by age"
//查询
val res = sqlc.sql(sql)
// def show(numRows: Int, truncate: Boolean): Unit = println(showString(numRows, truncate))
//默认打印是20行
res.show()
//固化数据
//将数据写到文件中mode是以什么形式写 写成什么文件
/**
* def mode(saveMode: String): DataFrameWriter = {
* this.mode = saveMode.toLowerCase match {
* case "overwrite" => SaveMode.Overwrite -复写
* case "append" => SaveMode.Append -- 追加
* case "ignore" => SaveMode.Ignore
* case "error" | "default" => SaveMode.ErrorIfExists
* case _ => throw new IllegalArgumentException(s"Unknown save mode: $saveMode. " +
* "Accepted modes are 'overwrite', 'append', 'ignore', 'error'.")
*
*/
// res.write.mode("append").json("out3")
// hdfs://hadoop2:8020/out111")
//除了这两种还可以csv模式,json模式
//csv在 1.6.3 spark中需要第三方插件,才能使用能使用,,,,2.0之后自动集成
//这个方法不要使用因为在2.0会被删除
res.write.mode("append").save("hdfs://hadoop2:8020/out111")
}
case class Person(id:Int,name:String,age:Int)
}
第二通过StructType
SparkSQLStructTypeDemo.scala
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Row, SQLContext}
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}
import org.apache.spark.{SparkConf, SparkContext}
object SparkSQLStructTypeDemo {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("SparkSQLStructTypeDemo").setMaster("local")
val sc = new SparkContext(conf)
val sqlcontext = new SQLContext(sc)
//获取数据并拆分
val lineRDD = sc.textFile("hdfs://hadoop2:8020/Person.txt").map(_.split(" "))
//创建StructType对象 封装了数据结构(类似于表的结构)
val structType: StructType = StructType {
List(
//列名 数据类型 是否可以为空值
StructField("id", IntegerType, false),
StructField("name", StringType, true),
StructField("name", IntegerType, false)
//列需要和数据对应,但是StructType这种可以:
/**
* 列的数据大于数据,所对应列的值应该是null
* 列数是不能小于数据,不然会抛出异常
* StructField("oop", IntegerType, false)
* StructField("poo", IntegerType, false)
*/
)
}
//将数据进行一个映射操作
val rowRDD: RDD[Row] = lineRDD.map(arr => Row(arr(0).toInt,arr(1),arr(2).toInt))
//将RDD转换为DataFrame
val personDF: DataFrame = sqlcontext.createDataFrame(rowRDD,structType)
personDF.show()
}
}
1.将当前程序打包操作提交到集群,需要做 一定的更改 ,注意path路径 修改为 args(下标)
模式:
spark-submit
–class 类名(类的全限定名(包名+类名))
–master spark://集群:7077
/root/jar包路径
输入数据路径
输出路径数据
2.查看运行结果(多个文件的情况下)
hdfs dfs -cat /输入文件路径/part-r-* //这个代表查看多个文件
JDBC数据源
SparkSql可以通过JDBC从关系型数据库中读取数据的方式创建DataFrame,在通过对DataFrame的一系列操作,还可以将数据写到关系型数据库中
使用spark-shell
必须执行mysql的连接驱动jar
spark-shell --master spark://hadoop1:7077 --executor-memory 512m --total-executor-cores 2 --jars /root/mysql-connector-java-5.1.32.jar --driver-class-path /root/mysql-connector-java-5.1.32.jar
将数据写入到Mysql中
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, Row, SQLContext}
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}
import org.apache.spark.{SparkConf, SparkContext}
object DataFormeInputJDBC {
/* def createSC(AppName:String,Master:String):SparkContext = {
}
def createSC(AppName:String,Master:String,sc:SparkContext):SQLContext = {
}*/
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("DataFormeInputJDBC").setMaster("local")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
//获取数据拆分
val lines = sc.textFile("hdfs://hadoop1:8020/Person.txt").map(_.split(" "))
// StructType 存的表结构
val structType: StructType = StructType(Array(StructField("id", IntegerType, false),
StructField("name", StringType, true),
StructField("age", IntegerType, true)))
//开始映射
val rowRDD: RDD[Row] = lines.map(arr => Row(arr(0).toInt,arr(1),arr(2).toInt))
//将当前RDD转换为DataFrame
val personDF: DataFrame = sqlContext.createDataFrame(rowRDD,structType)
//创建一个用于写入mysql配置信息
val prop = new Properties()
prop.put("user","root")
prop.put("password","123")
prop.put("driver","com.mysql.jdbc.Driver")
//提供mysql的URL
val jdbcurl = "jdbc:mysql://hadoop1:3306/mydb1"
//表名
val table = "person"
//数据库要对,表若不存在会自动创建并存储
//需要将数据写入到jdbc
//propertities的实现是HashTable
personDF.write.mode("append").jdbc(jdbcurl,table,prop)
println("插入数据成功")
sc.stop()
}
}
HIVE-on-Spark
hive底层是通过MR进行计算,将其改变为SparkCore来执行
配置步骤
1.在不是高可用集群的前提下,只需要将Hadoop安装目录中的core-site.xml拷贝到spark的配置conf文件目录下即可
2.将hive安装路径下的hive-site.xml拷贝到spark的配置conf配置文件目录下即可
注意:
若是高可用:需要将hadoop安装路径下的core-site,xml和hdfs-site.xml拷到spark的conf目录下
操作完成后建议重启集群
通过sparksql来操作,需要在spark安装路径中sbin目录
启动:
spark-sql \
--master spark://hadoop1:7077 \
--executor-memory 512m \
--total-executor-cores 2 \
--jars /root/mysql-connector-java-5.1.32.jar \
--driver-class-path /root/mysql-connector-java-5.1.32.jar
基本操作:
1.创建表:
create table person1(id int,name string,age int)row format delimited fields terminated by ' '
2.加载数据:(本地加载)
load data local inpath '/root/Person.txt' into table person1;
3.查询:
select * from person1;
select name,age from person where age > 20 order by age;
4.删除
drop table person
内部表和外部表
表没有被external修饰的 都是内部表,被修饰的就是外部表
hive本身不能存储数,依托于HDFS。
区别:
内部表存储数据被删除,同时会删除数据和原信息
外部表存储数据被删除,仅仅会删除元数据,HDFS中存储的数据会被表留下来