1. Spark
- 基于Spark计算框架之上且兼容Hive语法的SQL执行引擎
- 底层的计算采用了Spark，性能比MapReduce的Hive普遍快2倍以上
- Shark是完全兼容Hive的语法，表结构以及UDF函数等
- Shark底层依赖于Hive的解析器，查询优化器 -- 对Hive依赖太强,难以长远发展
2. SparkSql
2.2 SparkSQL介绍
SparkSQL产生的根本原因是其完全脱离了Hive的限制。
- SparkSQL支持查询原生的RDD。 RDD是Spark平台的核心概念，是Spark能够高效的处理大数据的各种场景的基础。
- 能够在scala中写SQL语句。支持简单的SQL语法检查，能够在Scala中写Hive语句访问Hive数据，并将结果取回作为RDD使用。
2.3 Spark on Hive和Hive on Spark
- Spark on Hive： Hive只作为储存角色，Spark负责sql解析优化，执行。
- Hive on Spark：Hive即作为存储又负责sql的解析优化，Spark负责执行。
2.3 Dataset与DataFrame
Dataset也是一个分布式数据容器。与RDD类似，然而Dataset更像传统数据库的二维表格，除了数据以外，还掌握schema。同时，与Hive类似，Dataset也支持嵌套数据类型（struct、array和map）。从API易用性的角度上 看， Dataset API提供的是一套高层的关系操作，比函数式的RDD API要更加友好，门槛更低。
Dataset的底层封装的是RDD，当RDD的泛型是Row类型的时候，我们也可以称它为DataFrame。即Dataset<Row> = DataFrame
2.4 SparkSQL的数据源
SparkSQL的数据源可以是JSON类型的字符串，JDBC,Parquent,Hive，HDFS等。
2.5 SparkSQL底层架构
首先拿到sql后解析一批未被解决的逻辑计划，再经过分析得到分析后的逻辑计划，再经过一批优化规则转换成一批最佳优化的逻辑计划，再经过SparkPlanner的策略转化成一批物理计划，随后经过消费模型转换成一个个的Spark任务执行。
拿到SQL解析-->逻辑计划-->优化后的逻辑计划-->物理计划-->spark任务-->执行
2.6 谓词下推（predicate Pushdown）
谓词下推就是指将各个条件先应用到对应的数据上，而不是根据写入的顺序执行，这样就可以先过滤掉部分数据，降低join等一系列操作的数据量级，提高运算速度.
3. 创建Dataset的几种方式
3.1 读取json格式的文件创建Dataset
public class SqlDemo {
public static void main(String[] args) throws AnalysisException {
SparkSession sparkSession = SparkSession.builder()
.master("local").appName("sqldemo").getOrCreate();
Dataset<Row> json = sparkSession.read().format("json").load("file/json");
//Dataset<Row> json = sparkSession.read().json("file/json");
//schema信息, 字段按ascii码排序
json.printSchema();
//默认打印20行
json.show(10);
//将DataSet注册成内存临时表,建议使用createGlobalTempView
//json.registerTempTable("user");
json.createGlobalTempView("user");
Dataset<Row> result = sparkSession.sql("select * from user where age<20");
result.show();
sparkSession.stop();
}
}注意：
json文件中的json数据不能嵌套json格式数据。
Dataset是一个一个Row类型的RDD，ds.rdd()/ds.javaRdd()。
可以两种方式读取json格式的文件。
df.show()默认显示前20行数据。
Dataset原生API可以操作Dataset（不方便）。
注册成临时表时，表中的列默认按ascii顺序显示列。
3.2 通过json格式的RDD创建Dataset
JavaRDD<String> nameRdd = jsc.parallelize(Arrays.asList(
"{'name':'zhangsan','age':\"18\"}",
"{\"name\":\"lisi\",\"age\":\"19\"}",
"{\"name\":\"wangwu\",\"age\":\"20\"}"
));
//rdd转dataset
Dataset<Row> nameds = sparkSession.read().json(nameRdd);3.3 非json格式的RDD创建Dataset
3.3.1 通过反射的方式将非json格式的RDD转换成Dataset
- 自定义类要可序列化(implements Serializable, idea-settring-搜索Serializable class without...后面打钩,alt+enter可字段添加序列UID)
- 自定义类的访问级别是Public
- RDD转成Dataset后会根据映射将字段按Assci码排序
- 将Dataset转换成RDD时获取字段两种方式,一种是ds.getInt(0)下标获取（不推荐使用），另一种是ds.getAs(“列名”)获取（推荐使用）
/**RDD反射转dataset
* 注意：
* 1.自定义类要实现序列化接口
* 2.自定义类访问级别必须是Public
* 3.RDD转成Dataset会把自定义类中字段的名称按assci码排序
*/
JavaRDD<String> lineRdd = jsc.textFile("file/person");
//转为Person RDD
JavaRDD<Person> personRdd = lineRdd.map(line ->
new Person(line.split(",")[0],
line.split(",")[1],
line.split(",")[2])
);
//rdd转dataset
Dataset<Row> dataFrame = sparkSession.createDataFrame(personRdd, Person.class);
dataFrame.show();
//dataset转rdd
JavaRDD<Row> rowJavaRDD = dataFrame.javaRDD();
//getAs(fieldName)获取字段值
JavaRDD<Person> map = rowJavaRDD.map(row ->
new Person(row.getAs("id"), row.getAs("name"), row.getAs("age"))
);
3.3.2 动态创建Schema将非json格式的RDD转换成Dataset
JavaRDD<String> lineRdd = jsc.textFile("file/person");
//转换成row类型的rdd
JavaRDD<Row> rowRdd = lineRdd.map(line ->
RowFactory.create(Integer.valueOf(line.split(",")[0]),
line.split(",")[1],Integer.valueOf(line.split(",")[2]))
);
//schema的字段信息list
List<StructField> structFields = Arrays.asList(
DataTypes.createStructField("id", DataTypes.IntegerType, true),
DataTypes.createStructField("name", DataTypes.StringType, true),
DataTypes.createStructField("age", DataTypes.IntegerType, true)
);
//根据元数据信息创建StructType
StructType structType = DataTypes.createStructType(structFields);
//传入数据和schema创建dataset
Dataset<Row> df = sparkSession.createDataFrame(rowRdd, structType);
df.printSchema();
df.show();3.4 读取parquet文件创建Dataset
public static void main(String[] args) throws AnalysisException {
SparkSession sparkSession = SparkSession.builder()
.master("local").appName("sqldemo").getOrCreate();
Dataset<Row> ds = sparkSession.read().json("file/json");
//可以将Dataset存储成parquet文件。保存成parquet文件的方式有两种
//SaveMode指定文件保存时的模式. Overwrite：覆盖, Append：追加, Ignore：如果存在就忽略
ds.write().mode(SaveMode.Overwrite).format("parquet").save("file/parquet");
//ds.write().mode(SaveMode.Overwrite).parquet("file/parquet");
//加载parquet文件成DataFrame
//Dataset load = sparkSession.read().format("parquet").load("file/parquet");
Dataset load = sparkSession.read().parquet("file/parquet");
load.show();
sparkSession.stop();
}3.5 读取JDBC中的数据创建Dataset(MySql为例),并将结果存入mysql
两种方式连接mysql
public static void main(String[] args) throws AnalysisException {
SparkSession sparkSession = SparkSession.builder().master("local").appName("sqldemo").getOrCreate();
Dataset<Row> ds = sparkSession.read().json("file/json");
/**
* 第一种方式读取mysql数据的方式
*/
Map<String,String> options = new HashMap<>();
options.put("url", "jdbc:mysql://192.168.7.171:3306/spark");
options.put("driver", "com.mysql.jdbc.Driver");
options.put("user", "root");
options.put("password", "111111");
options.put("dbtable", "user");
Dataset<Row> user = sparkSession.read().format("jdbc").options(options).load();
user.show();
user.createOrReplaceTempView("user");
/**
* 第二种方式读取mysql数据的方式
*/
DataFrameReader reader = sparkSession.read().format("jdbc");
reader.option("url", "jdbc:mysql://192.168.7.171:3306/spark");
reader.option("driver", "com.mysql.jdbc.Driver");
reader.option("user", "root");
reader.option("password", "111111");
reader.option("dbtable", "score");
Dataset<Row> score = reader.load();
score.show();
score.createOrReplaceTempView("score");
Dataset<Row> result = sparkSession.sql("select u.id, u.name,u.age, s.score from user u left join score s " +
"on u.id = s.id where s.score>60");
result.show();
/**
* 将dataset保存到mysql
*/
Properties properties = new Properties();
properties.setProperty("user","root");
properties.setProperty("password","111111");
/**
* SaveMode:
* Overwrite：覆盖
* Append:追加
* ErrorIfExists:如果存在就报错
* Ignore:如果存在就忽略
*/
//注:spark会根据字段创建表
result.write().mode(SaveMode.Append).jdbc("jdbc:mysql://192.168.7.171:3306/spark", "user_socre", properties);
System.out.println("-----------FINISH-----------");
sparkSession.stop();
}3.6 读取Hive中的数据加载成Dataset
SparkSession sparkSession = SparkSession
.builder()
.master("local")
.appName("hvie")
//开启hive的支持，接下来就可以操作hive表了
// 前提需要是需要开启hive metastore 服务
.enableHiveSupport()
.getOrCreate();
sparkSession.sql("USE spark");
sparkSession.sql("DROP TABLE IF EXISTS student_infos");
//在hive中创建student_infos表
sparkSession.sql("CREATE TABLE IF NOT EXISTS student_infos (name STRING,age INT) row format delimited fields terminated by '\t' ");
sparkSession.sql("load data local inpath '/root/student_infos' into table student_infos");
//注意：此种方式，程序需要能读取到数据（如/root/student_infos），同时也要能读取到 metastore服务的配置信息。
sparkSession.sql("DROP TABLE IF EXISTS student_scores");
sparkSession.sql("CREATE TABLE IF NOT EXISTS student_scores (name STRING, score INT) row format delimited fields terminated by '\t'");
sparkSession.sql("LOAD DATA "
+ "LOCAL INPATH '/root/student_scores'"
+ "INTO TABLE student_scores");
// Dataset<Row> df = hiveContext.table("student_infos");//读取Hive表加载Dataset方式
/**
* 查询表生成Dataset
*/
Dataset<Row> goodStudentsDF = sparkSession.sql("SELECT si.name, si.age, ss.score "
+ "FROM student_infos si "
+ "JOIN student_scores ss "
+ "ON si.name=ss.name "
+ "WHERE ss.score>=80");
goodStudentsDF.registerTempTable("goodstudent");
Dataset<Row> result = sparkSession.sql("select * from goodstudent");
result.show();
/**
* 将结果保存到hive表 good_student_infos
*/
sparkSession.sql("DROP TABLE IF EXISTS good_student_infos");
goodStudentsDF.write().mode(SaveMode.Overwrite).saveAsTable("good_student_infos");
sparkSession.stop();4. Spark On Hive的配置
4.1在Spark客户端配置spark On hive
在Spark客户端安装包下spark-2.2.1/conf中创建文件hive-site.xml：
配置hive的metastore路径
| <configuration> <property> <name>hive.metastore.uris</name> <value>thrift://node1:9083</value> </property> </configuration> |
4.2 启动Hive的metastore服务
| hive --service metastore & |
4.3 启动zookeeper集群，启动HDFS集群。
4.4 启动SparkShell 读取Hive中的表总数，对比hive中查询同一表查询总数测试时间。
| ./spark-shell --master spark://node1:7077 spark.sql("select * from day_table").show; |
- 注意：
如果使用Spark on Hive 查询数据时，出现错误：
找不到HDFS集群路径，要在客户端机器conf/spark-env.sh中设置HDFS的路径：
4.5 序列化问题。
4.6 储存DataSet
- 将DataSet存储为parquet文件。
- 将DataSet存储到JDBC数据库。
- 将DataSet存储到Hive表。
7. 自定义函数UDF和UDAF
7.2UDF:用户自定义函数。
SparkSession sparkSession = SparkSession
.builder()
.appName("udf")
.master("local")
.getOrCreate();
JavaSparkContext sc = new JavaSparkContext(sparkSession.sparkContext());
JavaRDD<String> parallelize = sc.parallelize(Arrays.asList("zhangsan","lisi","wangwu"));
JavaRDD<Row> rowRDD = parallelize.map(new Function<String, Row>() {
/**
*
*/
private static final long serialVersionUID = 1L;
@Override
public Row call(String s) throws Exception {
return RowFactory.create(s);
}
});
/**
* 动态创建Schema方式加载DF
*/
List<StructField> fields = new ArrayList<StructField>();
fields.add(DataTypes.createStructField("name", DataTypes.StringType,true));
StructType schema = DataTypes.createStructType(fields);
Dataset<Row> df = sparkSession.createDataFrame(rowRDD,schema);
df.registerTempTable("user");
/**
* 根据UDF函数参数的个数来决定是实现哪一个UDF UDF1，UDF2。。。。UDF1xxx
*/
sparkSession.udf().register("StrLen",new UDF2<String, Integer, Integer>() {
/**
*
*/
private static final long serialVersionUID = 1L;
@Override
public Integer call(String t1, Integer t2) throws Exception {
return t1.length() + t2;
}
} ,DataTypes.IntegerType );
sparkSession.sql("select name ,StrLen(name,100) as length from user").show();
//
sparkSession.stop();
7.2 UDAF:用户自定义聚合函数。
- 实现UDAF函数如果要自定义类要实现UserDefinedAggregateFunction类
SparkSession sparkSession = SparkSession
.builder()
.appName("udaf")
.master("local")
.getOrCreate();
JavaSparkContext sc = new JavaSparkContext(sparkSession.sparkContext());
JavaRDD<String> parallelize = sc.parallelize(Arrays.asList("zhansan","lisi","wangwu","zhangsan","zhangsan","lisi"));
JavaRDD<Row> rowRDD = parallelize.map(new Function<String, Row>() {
/**
*
*/
private static final long serialVersionUID = 1L;
@Override
public Row call(String s) throws Exception {
return RowFactory.create(s);
}
});
List<StructField> fields = new ArrayList<StructField>();
fields.add(DataTypes.createStructField("name", DataTypes.StringType, true));
StructType schema = DataTypes.createStructType(fields);
Dataset df = sparkSession.createDataFrame(rowRDD, schema);
df.registerTempTable("user");
/**
* 注册一个UDAF函数,实现统计相同值得个数
* 注意：这里可以自定义一个类继承UserDefinedAggregateFunction类也是可以的
*/
sparkSession.udf().register("StringCount", new UserDefinedAggregateFunction() {
/**
*
*/
private static final long serialVersionUID = 1L;
/**
* 更新 可以认为一个一个地将组内的字段值传递进来 实现拼接的逻辑
* buffer.getInt(0)获取的是上一次聚合后的值
* 相当于map端的combiner，combiner就是对每一个map task的处理结果进行一次小聚合
* 大聚和发生在reduce端.
* 这里即是:在进行聚合的时候，每当有新的值进来，对分组后的聚合如何进行计算
*/
@Override
public void update(MutableAggregationBuffer buffer, Row arg1) {
buffer.update(0, buffer.getInt(0)+1);
}
/**
* 合并 update操作，可能是针对一个分组内的部分数据，在某个节点上发生的 但是可能一个分组内的数据，会分布在多个节点上处理
* 此时就要用merge操作，将各个节点上分布式拼接好的串，合并起来
* buffer1.getInt(0) : 大聚和的时候 上一次聚合后的值
* buffer2.getInt(0) : 这次计算传入进来的update的结果
* 这里即是：最后在分布式节点完成后需要进行全局级别的Merge操作
*/
@Override
public void merge(MutableAggregationBuffer buffer1, Row buffer2) {
buffer1.update(0, buffer1.getInt(0) + buffer2.getInt(0));
}
/**
* 指定输入字段的字段及类型
*/
@Override
public StructType inputSchema() {
return DataTypes.createStructType(
Arrays.asList(DataTypes.createStructField("name",
DataTypes.StringType, true)));
}
/**
* 初始化一个内部的自己定义的值,在Aggregate之前每组数据的初始化结果
*/
@Override
public void initialize(MutableAggregationBuffer buffer) {
buffer.update(0, 0);
}
/**
* 最后返回一个和DataType的类型要一致的类型，返回UDAF最后的计算结果
*/
@Override
public Object evaluate(Row row) {
return row.getInt(0);
}
@Override
public boolean deterministic() {
//设置为true
return true;
}
/**
* 指定UDAF函数计算后返回的结果类型
*/
@Override
public DataType dataType() {
return DataTypes.IntegerType;
}
/**
* 在进行聚合操作的时候所要处理的数据的结果的类型
*/
@Override
public StructType bufferSchema() {
return
DataTypes.createStructType(
Arrays.asList(DataTypes.createStructField("bf", DataTypes.IntegerType,
true)));
}
});
sparkSession.sql("select name ,StringCount(name) from user group by name").show();
sparkSession.stop();
8. 开窗函数
注意：
row_number() 开窗函数是按照某个字段分组，然后取另一字段的前几个的值，相当于 分组取topN
开窗函数格式：
row_number() over (partitin by XXX order by XXX)
SparkSession sparkSession = SparkSession
.builder()
.appName("window")
.master("local")
//开启hive的支持，接下来就可以操作hive表了
// 前提需要是需要开启hive metastore 服务
.enableHiveSupport()
.getOrCreate();
sparkSession.sql("use spark");
sparkSession.sql("drop table if exists sales");
sparkSession.sql("create table if not exists sales (riqi string,leibie string,jine Int) "
+ "row format delimited fields terminated by '\t'");
sparkSession.sql("load data local inpath '/root/test/sales' into table sales");
/**
* 开窗函数格式：
* 【 rou_number() over (partitin by XXX order by XXX) 】
*/
Dataset<Row> result = sparkSession.sql("select riqi,leibie,jine "
+ "from ("
+ "select riqi,leibie,jine,"
+ "row_number() over (partition by leibie order by jine desc) rank "
+ "from sales) t "
+ "where t.rank<=3");
result.show();
sparkSession.stop();
958
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
