Spark SQL
一、sparkSQL的特点
1.支持多种数据源：hive RDD Partquet JSON JDBC
2.多种性能优化技术：in-memory columnar storage byte-code generation cost model 动态评估
3.组件扩展性：对于SQL的语法解析器、分析器、以及优化器，用户都可以自己重新开发，并且动态扩展
Spark sql 的性能优化技术简介
1.内存列存储（in-memory columnar storage）
内存列存储意味着spark sql的数据，不是使用java对象的方式进行存储，而是使用面向列存储的方式进行存储，也就是说，每一列，作为一个数据存储的单位，从而大大优化内存使用的效率。使用列存储之后，减少对内存的消耗，也就避免了对GC(垃圾回收)大量数据的性能开销
2.字节码生成技术（byte-code generation ）
Spark sql在其catalyst模块的Expressions中增加一codegen模块，对于sql语句中的计算表达式，比如select num + num from t 这种sql,就可以使用动态字节码生成技术来优化其性能。
3.Scala代码编写的优化
对于Scala代码编写中，可能会造成大量的性能的开销，自己重写，使用更加复杂的方式，来获取更好的性能。比如option样例类、for循环、map/filter/foreach等高阶函数，以及不可变对象，都改成用null,while循环来实现，并且重用可变的对象
二、dataframe的使用
1.spark sql 和 dataframe引言
Spark sql 是spark中的一个模块，主要是进行结构化数据的处理。他提供的最核心的编程抽象，就是dataframe。同时spark sql 还可以作为分布式的sql查询引擎。Spark sql最重要的功能之一就是从hive中查询数据
Dataframe，可以理解为时，以列的形式组织的，分布式的数据集合，他其实和关系型数据库中的表非常类似，但是底层做了很对的优化。Dataframe可以通过很多来源，包括：结构化数据文件，hive表，外部关系型数据库以及RDD
2.SQLContext
要使用spark sql ，首先就得创建一个SQLContext对象，或者是他的子类的对象(HiveContext)，比如HiveContext对象;
Java版本：
JavaSparkContext sc = ....;
SQLContext SQLContext = new SQLContext(sc);
Scala版本：
Val sc = SparkContext..
Val SQLContext = new SQLContext(sc)
Import SQLContext.implicits._
3.HiveContext
除了基本的SQLContext以外，还可以使用它的子类---HiveContext。HiveContext的功能除了包含SQLContext提供的所有的功能外，还包括额外的专门针对hive的一些功能。这些额外的功能包括：使用hive语法编写和执行sql，使用hive的UDF函数，从hive表中读取数据
要使用HiveContext，就必须预先安装好hive，SQLContext支持的数据源，HiveContext也同样支持，而不只是支持hive,对spark1.3.x以上的版本，都推荐使用HiveContext,因为其功能更加丰富和完善
Spark sql 还支持使用spark.sql.dialect参数设置sql方言，使用SQLContext的serConf()即可进行设置。对与SQLContext，他只支持”sql”一种方言。对于HiveContext,它默认的方言是“hiveql”
4.创建Dataframe
使用SQLContext，可以从RDD、hive表中或者其他额数据源，来创建dataframe。
Java版本：
package com.spark.spark_sql;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
/**
* 使用json文件创建dataframe
* @author Administrator
*/
public class DataFrameCreate {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("DataFrameCreate");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext SQLContext = new SQLContext(sc);
DataFrame df = SQLContext.read().json("hdfs://hadoop01:8020/spark_input/students.json");
df.show();
}
}
提交至集群：运行打包，上传。编写脚本进行提交
【这里是一台机器测试】
bin/spark-submit
--class com.spark.spark_sql.DataFrameCreate
--files /opt/modules/apache-hive-0.13.1-bin/conf/hive-site.xml
--driver-class-path /opt/softwares/mysql-connector-java-5.1.27-bin.jar
/opt/modules/spark-1.6.1-bin-2.5.0-cdh5.3.6/sql/sparksql_01.jar
运行的结果
+---+---+--------+
|age| id| name|
+---+---+--------+
| 10| 1| leo|
| 25| 2| kity|
| 30| 4| lucy|
| 20| 3| tom|
| 18| 7| jack|
| 23| 10| edison|
| 36| 5| owen|
| 20| 8| jiny|
| 40| 6| lisi|
| 45| 9|zhangsan|
+---+---+--------+
Scala版本：
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
object DataFrameCreate {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("DataFrameCreate")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
val df = sqlContext.read.json("hdfs://hadoop01:8020/spark_input/student.json")
df.show
}
}
Dataframe常用的操作
java
package com.spark.spark_sql;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
/**
* Dataframe的常用的操作
* @author Administrator
*
*/
public class DataFrameOperation {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("DataFrameOperation");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext SQLContext = new SQLContext(sc);
//创建出来的dataframe完全可以可以理解为一张表
DataFrame df = SQLContext.read().json("hdfs://hadoop01:8020/input/students.txt");
//打印dataframe中所有的数据
df.show();
//打印dataframe中元数据的信息
df.printSchema();
//查询某列所有的数据
df.select("name").show();
//查询某几列所有的数据，并对列进行计算
df.select(df.col("name"), df.col("age").plus(1)).show();//将查询出来的age进行加一
//根据某一列的值进行过滤
df.filter(df.col("age").gt(30)).show(); //年龄大于30的进行过滤
//根据某一列进行分组聚合
df.groupBy(df.col("age")).count().show();
}
}
Scala
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
object DataframeOperation {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("DataframeOperation")
val sc = new SparkContext(conf)
val SQLContext = new SQLContext(sc)
val df = SQLContext.read.json("hdfs://hadoop01:8020/spark_input/student.json"
df.show
df.printSchema()
df.select("name").show
df.select(df("name"),df("age")+1).show
df.filter(df("age") > 30).show
df.groupBy("age").count().show
}
}
5.RDD与Dataframe之间转换
为什么要将RDD转换为Dataframe？因为这样的话，我们就可以直接针对hdfs上的任何可以构建为RDD的数据，使用spark sql 进行sql查询，这个功能无比强大。想象一下，针对hdfs中的数据，直接就可以使用sql进行查询
Spark sql 支持两种方式来将RDD转换为Dataframe
第一种方式，是使用反射来推断包含了特定数据类型的RDD的元数据，这种基于反射的方式，代码比较简单，当你已经知道你的RDD的元数据时，是一种非常不错的方式。
第二种方式，是通过编程接口来创建dataframe，你可以在程序运行的时候动态构建一份元数据，然后将其应用到已经存在的RDD上，这种方式的代码比较冗长，但是如果在编写程序时，还不知道RDD的元数据，只有在程序运行时，才能动态得知元数据，那么只能通过这种动态构建元数据的方式。
1.使用反射的方式推断元数据
Java版本：spark sql是支持将包含javaBean的RDD转换为dataframe的，Javabean的信息，就定义了元数据。Spark sql 现在是不支持包含嵌套javabean或者list等复杂元数据的Javabean。
Scala版本:而scala由于具有隐式转换的特性，所以spark sql的scala接口，是支持自动将包含case class 的RDD转换为Dataframe的。Case class 就定义了元数据。Spark sql 会通过反射读取传递给 case class 的参数的名称，然后将其作为列名。与java不同的是，Spark sql是支持将包含了嵌套的数据结构的case class作为元数据的，比如包含了Array等。
Java版本：
package com.spark.spark_sql;
import java.io.Serializable;
public class Student implements Serializable {
private static final long serialVersionUID = 1L;
private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student() {
}
public Student(int id, String name, int age) {
super();
this.id = id;
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student [;
}
}
package com.spark.spark_sql;
import java.util.List;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SQLContext;
/**
* 使用反射的方式将RDD转换为dataframe
* @author Administrator
*
*/
public class RDD2DataframeReflection {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("RDD2DataframeReflection");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext SQLContext = new SQLContext(sc);
JavaRDD<String> lines = sc.textFile("E://student.txt");
JavaRDD<Student> students = lines.map(new Function<String, Student>() {
private static final long serialVersionUID = 1L;
@Override
public Student call(String line) throws Exception {
String[] split = line.split(",");
Student stu = new Student();
stu.setId(Integer.parseInt(split[0]));
stu.setName(split[1]);
stu.setAge(Integer.parseInt(split[2]));
return stu;
}
});
//使用反射的方式将RDD转换为dataframe
//将student.class传入进去其实就是通过反射的方式来创建dataframe
//因为student.class 本身就是反射的一个应用
//然后底层还得通过student class 进行反射。来获取其中的fields
//这里要求Javabean要实现Serializable接口，可以序列化
DataFrame studentDF = sqlContext.createDataFrame(students, Student.class);
//拿到一个dataframe之后，就可以将其注册为一张临时表，然后针对其中的数据进行sql语句
studentDF.registerTempTable("student");
//针对student临时表执行sql语句，查询年龄大于20岁的学生
DataFrame df =sqlContext.sql("select * from student where age > 20");
//将查询出来的dataframe再次转换为RDD
JavaRDD<Row> teenagerRDD = df.javaRDD();
//将RDD中的数据，进行映射，给每个人的年龄，然后映射为student
JavaRDD<Student> teenagerStudentRDD = teenagerRDD.map(new Function<Row, Student>() {
private static final long serialVersionUID = 1L;
@Override
public Student call(Row row) throws Exception {
//row中的顺序是按照字典顺序进行排列的
Student student = new Student();
student.setAge(row.getInt(0));
student.setId(row.getInt(1));
student.setName(row.getString(2));
return student;
}
});
//将数据collect 回来，打印出来
List<Student> studentList = teenagerStudentRDD.collect();
for (Student student : studentList) {
System.out.println(student);
}
}
}
Scala版本：
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
/**
* 如果要使用scala开发spark程序
* 然后在其中还要实现基于反射的RDD到dataframe的转换，就必须得用object extends App的方式
* 不能使用def main()方法的方式来运行程序，否则就会报错no typetag for ... class
*/
object RDD2DaframeReflection extends App{
val conf = new SparkConf().setMaster("local").setAppName("RDD2DaframeReflection")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
val lines = sc.textFile("e://student.txt", 1)
//在scala中使用反射的方式，进行RDD到Dataframe的转换，需要手动的导入一个隐士转换
import SQLContext.implicits._
case class Student(id : Int ,name : String ,age : Int)
//这里其实就是一个普通的，元素是case class 的rdd
val students = lines.map(line =>line.split(",")).map(arr => Student(arr(0).trim().toInt,arr(1),arr(2).trim().toInt))
//直接使用RDD的toDF,即可将其转换为dataframe
val studentDF=students.toDF()
//注册为一个临时表
studentDF.registerTempTable("student")
//
val teenagerDF = sqlContext.sql("select * from student where age > 20")
val teenagerRDD = teenagerDF.rdd
//在scala中，row中的数据的顺序，反而是按照我们期望的来排列的，这个是跟java是不一样的
teenagerRDD.map{row => Student(row(0).toString().toInt,row(1).toString(),row(2).toString().toInt )
}.collect().foreach(stu => print(stu.id+ ":" +stu.name+":"+stu.age))
//在scala中，对row的使用比java中的row更加的丰富
//在scala中，可以用row的getAs()方法，获取指定列名的列
teenagerRDD.map(row =>Student(row.getAs[Int]("id"),row.getAs("name"),row.getAs("age"))).collect()
.foreach(stu => print(stu.id+ ":" +stu.name+":"+stu.age))
//还可以通过row的getValuesMap,方法，获取指定几列的值，返回的是一个map
teenagerRDD.map(row => {
val map = row.getValuesMap(Array("id","name","age"))
Student(map("id").toString().toInt,map("name").toString(),map("age").toString().toInt)
}).collect().foreach(stu => print(stu.id+ ":" +stu.name+":"+stu.age))
}
2.通过编程接口来创建dataframe
Java版本：
package com.spark.spark_sql;
import java.util.ArrayList;
import java.util.List;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.SQLContext;
import org.apache.spark.sql.types.DataType;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
/**
* 以编程的方式动态的执行元数据，将RDD转化为dataframe
* @author Administrator
*
*/
public class RDD2DataProgrammatically {
public static void main(String[] args) {
//创建sparkconf
SparkConf conf = new SparkConf().setMaster("local").setAppName("RDD2DataProgrammatically");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
//第一步，创建一个普通的RDD,但是必须将其转换为RDD<Row>的格式
JavaRDD<String> lines = sc.textFile("e://student.txt");
JavaRDD<Row> rows = lines.map(new Function<String, Row>() {
private static final long serialVersionUID = 1L;
@Override
public Row call(String line) throws Exception {
String[] split = line.split(",");
return RowFactory.create(Integer.parseInt(split[0]),split[1],Integer.parseInt(split[2]));
}
});
//第二步，动态元数构造据
//比如说，id name age 等fields的名称和类型都是在程序运行过程中，
//动态的从MySQL等DB中或者是配置文件中,加载出来的，是不固定的
//所以特别适合这种编程的方式来构造元数据
List<StructField> fields = new ArrayList<StructField>();
fields.add(DataTypes.createStructField("id", DataTypes.IntegerType, true));
fields.add(DataTypes.createStructField("name", DataTypes.StringType, true));
fields.add(DataTypes.createStructField("age", DataTypes.IntegerType, true));
StructType structType = DataTypes.createStructType(fields);
//第三部，使用动态构造元数据，将RDD转换为dataframe
DataFrame studentDF = sqlContext.createDataFrame(rows, structType);
//后面就可以直接使用这个df了
//注册临时表
studentDF.registerTempTable("student");
DataFrame stus = sqlContext.sql("select * from student where age > 20");
List<Row> list = stus.javaRDD().collect();
for (Row row : list) {
System.out.println(row);
}
}
}
Scala版本：
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.Row
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.types.StructField
import org.apache.spark.sql.types.IntegerType
import org.apache.spark.sql.types.StringType
object RDD2DataframeProgramatically extends App{
val conf = new SparkConf().setMaster("local").setAppName("RDD2DataframeProgramatically");
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
//第一步：构造出元素为Row的普通的RDD
val studentRDD = sc.textFile("e://student.txt", 1)
.map(line => Row(
line.split(",")(0).toInt,
line.split(",")(1),
line.split(",")(2).toInt))
//第二步：以编程的方式构造元数据
val structType =StructType(Array(
StructField("id",IntegerType,true),
StructField("name",StringType,true),
StructField("age",IntegerType,true)))
//第三步：进行RDD到dataframe的转换
val studentDF = SQLContext.createDataFrame(studentRDD,structType )
studentDF.registerTempTable("student");
val teenagerDF = sqlContext.sql("select * from student where age > 20")
teenagerDF.rdd.collect.foreach(row => println(row))
}
6.通用的load和save操作
1.dataframe的load和save
对于的spark sql的dataframe来说，无论是从什么数据源创建出来的dataframe，都有一些共同的load和save操作，load操作主要是用于加载数据，创建出来的dataframe：save操作，主要用于将dataframe中的数据集保存到文件中（保存到的是一个目录中）
Java版本：
Dataframe df = sqlContext.read().load(“users.parquet”);
df.select(“name”,”facourite_color”).write().save(“nameAndFav_color_dir”);
Scala版本：
Val df = sqlContext.read.load(“users.parquet”)
Df.select(“name”,”facourite_color”).write().save(“nameAndFav_color_dir”)
Java版本：
package com.spark.spark_sql;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
/**
* 通用的load和save操作
* @author Administrator
*/
public class GenericLoadSave {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("GenericLoadSave");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
DataFrame usersDF = SQLContext.read().load("C://Users//Administrator//Desktop//users.parquet");
usersDF.printSchema();
usersDF.show();
usersDF.select("name","favourite_color").write().save("e://users2");
}
}
Scala版本：
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import scala.tools.scalap.Main
import org.apache.spark.sql.DataFrame
object GenericLoadSave {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("GenericLoadSave")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
val usersDF = sqlContext.read.load("hdfs://hadoop01:8020/spark_input/users.parquet")
usersDF.select("name","favourite_color").write.save("hdfs://hadoop01:8020/spark_output")
}
}
2.手动指定数据源：
也可以手动指定用来操作的数据源，数据源通常是使用其权限定名来指定，比如parquet是org.apache.spark.sql.parquet。但是spark sql内置了一些数据源类型，比如json，parquet.jdbc等等，实际上，通过这个功能，就可以在不同类型的数据源之间进行转换了。比如将json文件中的数据存储到parquet文件中。默认情况下，如果不指定数据源，默认就是parquet
Java版本：
DataFrame df =SQLContext.read().format(“json”).load(“people,json”)
Df.select(“name”,”age”).write().format(“parquet”).save(“out”)
Scala版本：
Val df = SQLContext.read.format(“json”).load(“people,json”)
Df.select(“name”,”age”).write.format(“parquet”).save(“out”)
Java版本
package com.spark.spark_sql;
import org.apache.spark.SparkConf;
import org.apache.spark.SparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
/**
* 手动指定数据源
* @author Administrator
*/
public class ManuallySpecifyOptions {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("ManuallySpecifyOptions");
SparkContext sc = new SparkContext(conf);
SQLContext SQLContext = new SQLContext(sc);
DataFrame df = SQLContext.read().format("json").load("e://users.parquet");
df.write().format("json").save("e://out");
}
}
3.Save mode
Spark sql 对于save操作，提供了不同的save mode.主要用来处理，当目标位置已经有数据时，应该如何处理。而且save操作并不会执行锁操作，并且不是原子的，因此是有一定风险出现脏数据的
Save mode 意义
SaveMode.ErrorIfExists(默认) 如果目标位置存在数据，那么就抛出异常
SaveMode.Append 如果目标位置存在数据，那么就将数据追加进去
SaveMode.Overwrite 如果目标位置存在数据，那么就将已经存在的数据删除，用新的数据进行覆盖
SaveMode.Ignore 如果目标位置存在数据，那么就忽略，不做任何的操作
Java版本：
package com.spark.spark_sql;
import org.apache.derby.impl.tools.sysinfo.Main;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
import org.apache.spark.sql.SaveMode;
/**
* savemode 示例
* @author Administrator
*/
public class SaveModeDemo {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("SaveModeDemo");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
DataFrame df = sqlContext.read().format("json").load("e://users.parquet");
df.save("e://out", SaveMode.Append);
}
}
三、Parquet数据源
1.使用编程方式加载数据
Parquet是面向分析型业务的列式存储格式，由Twitter和cloudera合作开发。2015年成为Apache的顶级项目
列式存储和行式存储相比较有哪些优点;
1.可以跳过不符合条件的数据，只读取需要的数据，降低IO数据量
2.压缩编码可以降低磁盘存储空间。由于同一列的数据类型是一样的，可以使用更高效的压缩编码（例如Run Length Encoding 和 Delta Encoding）进一步节约磁盘空间。
3.只读取需要的列，支持向量运算，能够获取更好的扫描性能
Java版本：
package com.spark.spark_sql;
import java.util.List;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.SQLContext;
/**
* parquet数据源之使用编程方式加载数据
*/
public class ParquetLoadData {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setMaster("local").setAppName("ParquetLoadData");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
//读取parquet文件中的数据，创建一个dataframe
DataFrame userDF = sqlContext.read().parquet("e://users.parquet");
//将其注册为临时表，使用sql查询所需要的数据
userDF.registerTempTable("users");
DataFrame userNamesDF = sqlContext.sql("select name from users");
//对查询出来的dataframe进行transformation操作，处理数据，然后打印出来
List<String> userNames = userNamesDF.javaRDD().map(new Function<Row, String>() {
private static final long serialVersionUID = 1L;
@Override
public String call(Row row) throws Exception {
return "Name: "+row.getString(0);
}
}).collect();
for (String name : userNames) {
System.out.println(name);
}
}
}
Scala版本：
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
object PatquetLoadData {
val conf = new SparkConf().setAppName("PatquetLoadData")
val sc = new SparkContext(conf)
val sqlContext =new SQLContext(sc)
val usersDF = sqlContext.read.parquet("hdfs://hadoop01:8020/spark_input/users.parquet");
usersDF.registerTempTable("user");
val userNameDF = sqlContext.sql("select * from user")
userNameDF.rdd.map(row => "Name: "+row(0)).collect.foreach(userName =>println(userName))
}
2.自动分区推断
表分区是一张常见的优化的方式，比如hive中就提供分区表的特性。在一个分区表中，不同分区的数据通常存储在不同的目录中，分区列的值通常就包含在了分区的目录名中。Spark sql中的parquet数据源，支持自动根据目录名推断出分区信息。例如，如果将入口数据存储在分区表中，并且使用性别和国家作为分区列。那么目录结构可能是如下所示：
|----tableName
|----gender=male
|----country=US
|.....
|----country=ZH
|----gender=female
|--country=...
|...
如果将tableName传入SQLContext.read.parquet()或者SQLContext.read.load()方法，那么sparksql就会自动根据目录的结构，推断出分区的信息，是gender和country。即使数据文件中包含两列的值name和age，但是sparksql返回的dataframe，调用printSchema()方法时，会打印出四个列的值：name age country gender .这就是自动分区推断的功能
此外，分区的列的数据类型，也是自动被推断出来的。目前，spark sql仅支持自动推断出数字类型和字符串类型。有时，用户也许不希望spark sql自动推断分区列的数据类型。此时只要设置一个配置即可，spark.sql.sources.partitionColumnTypeInference.enabled,默认是true，即自动推断分区列的类型，设置为false，即不会自动推断类型。进行自定推断分区列的类型时，所有的分区列的类型，就统一默认的是String
案列：
1.hdfs上创建相对应的目录结构：
bin/hdfs dfs -mkdir -p /spark_input/gender=male/country=US
2.将文件上传到目录下
bin/hdfs dfs -put users.parquet /spark_input/gender=male/country=US/
3.查询出schema
package com.spark.spark_sql;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.SQLContext;
/**
*parquet数据源之 自动推断分区
*/
public class ParquetPartitionDiscovery {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("ParquetPartitionDiscovery").setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
DataFrame userDF = sqlContext.read().parquet("hdfs://hadoop01:8020/spark_input/gender=male/country=US/users.parquet");
userDF.printSchema();
userDF.show();
}
}
4.结果：
root
|-- name: binary (nullable = true)
|-- favourite_color: binary (nullable = true)
|-- gender: string (nullable = true)
|-- country: string (nullable = true)
+----------------+-------------------+------+-------+
| name| favourite_color|gender|country|
+----------------+-------------------+------+-------+
| [6C 65 6F]| [72 65 64]| male| US|
| [6A 61 63 6B]|[79 65 6C 6C 6F 77]| male| US|
|[6B 69 74 74 79]| [77 68 69 74 65]| male| US|
| [74 6F 6D]| [67 72 65 65 6E]| male| US|
| [61 6C 6C]| [70 69 6E 6B]| male| US|
+----------------+-------------------+------+-------+
【注意】前面是因为parquet数据的问题，自己从hive中导出来的。可以利用json格式的数据load,然后save的时候以parquet的方式生成一个parquet文件，用于测试
3.合并元数据
如同ProtocolBuffer,Avro,Thrift一样，Parquet也是支持元数据合并的。用户可以一开始就定义一个简单的元数据，然后随着业务需要。逐渐往元数据中添加更多的列，在这种情况下，用户可能会创建多个parquet文件，有着多个不同的却互相兼容的元数据。Parquet数据源支持自动推断这种情况，并且进行多个parquet文件的元数据的合并
因为元数据合并是一种相对耗时的操作，而且在大多数的情况下不是一种必要的特性，从spark1.5.0版本开始，默认是关闭parquet文件的自动合并元数据的。可以通过以下的两种方式开启parquet数据源的自动合并元数据的特性
1.读取parquet文件时，将数据源的选项，mergeSchema,设置为true
2.根据sqlContext.setConf()方法，将spark.paquet.mergeSchema参数设置为true
案例：
合并学生的基本信息和成绩信息的元数据
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.SaveMode
object ParquetMergeSchema {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("ParquetMergeSchema")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
import SQLContext.implicits._
//创建一个dataframe，作为学生的基本信息，并写入一个parquet文件中
val studentsWithNameAge =Array(("leo",23),("jack",25))
val studentsWithNameAgeDF = sc.parallelize(studentsWithNameAge, 2).toDF("name","age")
studentsWithNameAgeDF.save("hdfs://hadoop01:8020/spark_out/students","parquet", SaveMode.Append)
//创建一个dataframe，作为学生的成绩信息，并写入一个parquet文件中
val studentsWithNameGrade =Array(("marry","A"),("jack","B"))
val studentsWithNameGradeDF = sc.parallelize(studentsWithNameGrade, 2).toDF("name","age")
studentsWithNameGradeDF.save("hdfs://hadoop01:8020/spark_out/students","parquet", SaveMode.Append)
//首先，第一个dataframe和第二个dataframe的元数据肯定是不一样的
//一个包含了name和age两个列，一个是包含name和grade两个列
//所以，这期望的是，读取出来的表数据，自动合并两个文件的元数据，出现三列，name age grade
//用mergeSchema的方式，读取students表中的数据，进行元数据的合并
val studentsDF = sqlContext.read.option("mergeSchema", "true").parquet("hdfs://hadoop01:8020/spark_out/students")
studentsDF.printSchema();
studentsDF.show();
}
}
四、JSON数据源
Spark sql 可以自动推断JSON文件的元数据，并且加载其数据，创建一个dataframe。可以使用SQLContext.read.json()方法，针对一个元素为String的RDD，或者是一个JSON文件
但是要注意的是，这里使用的JSON文件与传统意义上的JSON文件是不一样的。每行都必须也只能包含一个,单独的，自包含的，有效的JSON对象。不能让json对象分散在多行。否则会报错
综合性复杂案例：查询成绩为80分以上的学生的基本信息与成绩信息
Java 版本
package com.spark.spark_sql;
import java.util.ArrayList;
import java.util.List;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.SQLContext;
import org.apache.spark.sql.SaveMode;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import scala.Tuple2;
/**
* json数据源
*/
public class JSONDataSource {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("JSONDataSource").setMaster("local");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
// 针对json文件，创建出dataframe
DataFrame studentDF = sqlContext.read().json("e://student.json"); //hdfs://hadoop01:8020/spark_input/student.json
// 针对学生成绩信息的dataframe，注册临时表，查询分数大于80分的学生的姓名和分数
studentDF.registerTempTable("student");
DataFrame stuNameDF = sqlContext.sql("select name,score from student where score > 80");
List<String> goodName = stuNameDF.javaRDD().map(new Function<Row, String>() {
private static final long serialVersionUID = 1L;
@Override
public String call(Row row) throws Exception {
return row.getString(0);
}
}).collect();
// 针对JavaRDD<String> 创建dataframe
List<String> studentInfoJSONs = new ArrayList<String>();
studentInfoJSONs.add("{"name":"leo","age":18}");
studentInfoJSONs.add("{"name":"marry","age":15}");
studentInfoJSONs.add("{"name":"jack","age":30}");
JavaRDD<String> studentInfoJSONsRDD = sc.parallelize(studentInfoJSONs);
DataFrame studentInfoDF = sqlContext.read().json(studentInfoJSONsRDD);
// 针对学生的基本信息的dataframe，注册临时表，然后查询分数大于80分的学生的基本信息
studentInfoDF.registerTempTable("info");
String sql = "select name , age from info where name in (";
for (int i = 0; i < goodName.size(); i++) {
sql += "'" + goodName.get(i) + "'";
if (i < goodName.size() - 1) {
sql += ",";
}
}
sql += ")";
DataFrame goodStuInfosDF = sqlContext.sql(sql);
// 将两份数据的dataframe转换为javapairRDD,执行join transformation
JavaPairRDD<String, Tuple2<Integer, Integer>> pairs = goodStuInfosDF.javaRDD()
.mapToPair(new PairFunction<Row, String, Integer>() {
private static final long serialVersionUID = 1L;
@Override
public Tuple2<String, Integer> call(Row row) throws Exception {
return new Tuple2<String, Integer>(row.getString(0), Integer.valueOf((int) row.getLong(1)));
}
}).join(stuNameDF.javaRDD().mapToPair(new PairFunction<Row, String, Integer>() {
private static final long serialVersionUID = 1L;
@Override
public Tuple2<String, Integer> call(Row row) throws Exception {
return new Tuple2<String, Integer>(row.getString(0), Integer.valueOf((int) row.getLong(1)));
}
}));
//将封装在RDD中好学生的全部信息，转换为一个javaRDD<Row>的格式
JavaRDD<Row> rows = pairs.map(new Function<Tuple2<String,Tuple2<Integer,Integer>>, Row>() {
private static final long serialVersionUID = 1L;
@Override
public Row call(Tuple2<String, Tuple2<Integer, Integer>> t) throws Exception {
return RowFactory.create(t._1,t._2._2,t._2._1);
}
});
//创建一份元数据，将JavaRDD<Row>转换为dataframe
List<StructField> fields = new ArrayList<StructField>();
fields.add(DataTypes.createStructField("name", DataTypes.StringType, true));
fields.add(DataTypes.createStructField("score", DataTypes.IntegerType, true));
fields.add(DataTypes.createStructField("age", DataTypes.IntegerType, true));
StructType structType = DataTypes.createStructType(fields);
DataFrame goodStudentsDF =sqlContext.createDataFrame(rows, structType);
//将好学生的全部信息保存到json文件中去
goodStudentsDF.write().format("json").save("e://good"); //hdfs://hadoop01:8020/spark_out/goodStudent
}
}
Scala版本：
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.Row
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.types.StructField
import org.apache.spark.sql.types.StringType
import org.apache.spark.sql.types.IntegerType
object JSONDatasource {
val conf = new SparkConf().setAppName("JSONDatasource")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
val studentScoreDF =sqlContext.read.json("hdfs://hadoop01:8020/spark_input/student.json")
studentScoreDF.registerTempTable("stu_score")
val goodStuScoreDF = sqlContext.sql("select name , score from stu_score where score > 80")
val goodStuNames = goodStuScoreDF.map(row => row(0)).collect()
val studentInfoJSON =Array("{"name":"Leo","age":18}","{"name":"marry","age":15}","{"name":"jack","age":30}")
val studentInfoRDD =sc.parallelize(studentInfoJSON, 3)
val studentInfoDF = sqlContext.read.json(studentInfoRDD)//json格式特有的，可以接受RDD
studentInfoDF.registerTempTable("stu_info")
var sql = "select name , age from stu_info where name in ("
for(i <- 0 until goodStuNames.length){
sql += "'"+goodStuNames(i)+"'"
if(i < goodStuNames.length-1){
sql += ","
}
}
sql += ")"
val goodStuInfoDF = sqlContext.sql(sql)
val goodStuRDD = goodStuInfoDF.rdd.map{row => (row.getAs[String]("name"),row.getAs[Long]("age"))}.join (goodStuScoreDF.rdd.map{row => (row.getAs[String]("name"),row.getAs[Long]("score"))})
val goodStuRows = goodStuRDD.map(info => Row(info._1,info._2._2.toInt,info._2._1.toInt))
val structType = StructType(Array(StructField("name",StringType,true),StructField("score",IntegerType,true),StructField("age",IntegerType,true)))
val goodStudentDF = sqlContext.createDataFrame(goodStuRows, structType)
goodStudentDF.write.format("json").save("hdfs://hadoop01:8020/spark_out/good_scala")
}
五、Hive数据源
Spark sql 支持对hive中存储的数据进行读写，操作hive中的数据时，就必须创建HiveContext，而不是SQLContext。HiveContext继承SQLContext，但是增加了在hive元数据库中查找表，以及用hiveql语法编写SQL的功能。处理sql（）方法外，HiveContext还提供hql()方法，从而用hive语法来编译sql。
使用HiveContext，可以执行Hive的大部分功能，包括创建表、往表里导入数据以及用SQL语句查询表中的数据，查询出来的数据是一个row数组
将hive-site.xml拷贝到spark/conf目录下，将mysql connector拷贝到spark/lib目录下
HiveContext sqlContext = new HiveContext(sc);
sqlContext.sql(“create table if not exists student (name string ,age int)”)
sqlContext.sql(“load data local inpath ‘/usr/local/student.txt’into table students”);
Row[] teenagers = sqlContext.sql(“select name ,age from students where age <= 18”).collect();
将数据保存到表中
Spark sql还允许将数据保存到hive表中。调用Dataframe的saveAsTable,即可将dataframe中的数据保存到hive表中。与registerTempTable不同，saveAsTable是会将dataframe汇总的数据物化到hive表中，而且还会在hive元数据库中创建表的元数据
默认情况下，saveAsTable会创建一张hive managed table,也就是说，数据的位置都是有元数据库中的信息控制的。当managed table 被删除时，表中的数据也会一并内物理删除
RegisterTempTable只是注册一个临时的表，只要spark application重启或者停止了，那么表就没有了。而SaveAsTable创建的是物化的表，无论是spark application重启还是停止，表都会一直存在
调用HiveContext.table()方法，还可以直接针对hive中的表，创建一个dataframe
案例：查询分数大于80分的学生的信息
package com.spark.spark_sql;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.hive.HiveContext;
/**
* hive数据源
* @author Administrator
*/
public class HiveDataSource {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("HiveDataSource");
JavaSparkContext sc = new JavaSparkContext(conf);
//创建HiveContext，注意，这里接收的是sparkContext作为参数，不是Javasparkcontext
HiveContext hiveContext = new HiveContext(sc.sc());
//第一个功能，使用HiveContext的sql()/hql()方法，可以执行hive中可以执行的hiveQL语句
//判断是否存在student_info表，如果存在则删除
hiveContext.sql("drop table if exists student_info");
//判断student_info表是否不存在，不存在就创建该表
hiveContext.sql("create table if not exists student_info(name string,age int) row format delimited fields terminated by ' '");
//将学生基本信息导入到Student_info表
hiveContext.sql("load data local inpath '/home/hadoop/student_info.txt' into table student_info");
//用同样的方式向student_scores导入数据
hiveContext.sql("drop table if exists student_score");
hiveContext.sql("create table if not exists student_score(name string,score int)row format delimited fields terminated by ' '");
hiveContext.sql("load data local inpath '/home/hadoop/student_score.txt' into table student_score");
//第二个功能个，执行sql还可以返回dataframe，用于查询
//执行sql查询，关联两种表，查询成绩大于80 分的学生信息
DataFrame goodstudentDF = hiveContext.sql("select i.name,i.age,s.score from student_info i join student_score s on i.name=s.name where s.score >=80");
//第三个功能，可以将dataframe中的数据，理论上来说，dataframe对应的RDD的元素是ROW就可以
//将Dataframe中的数据保存到hive表中
//将dataframe中的数据保存到good_student_info表中
hiveContext.sql("drop table if exists good_student_info");
goodstudentDF.saveAsTable("good_student_info");
//第四个功能，可以使用table（）方法，针对hive表直接创建dataframe
//针对good_student_info表，直接创建dataframe
Row[] rows = hiveContext.table("good_student_info").collect();
for (Row row : rows) {
System.out.println(row);
}
sc.close();
}
}
Scala版本：
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.sql.hive.HiveContext
import org.apache.spark.sql.DataFrame
import org.apache.spark.sql.Row
import org.apache.spark.sql.DataFrame
import org.apache.spark.SparkContext
object HiveDataSource {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("HiveDataSource");
val sc = new SparkContext(conf)
//创建HiveContext，注意，这里接收的是sparkContext作为参数，不是Javasparkcontext
val hiveContext = new HiveContext(sc);
//第一个功能，使用HiveContext的sql()/hql()方法，可以执行hive中可以执行的hiveQL语句
//判断是否存在student_info表，如果存在则删除
hiveContext.sql("drop table if exists student_info");
//判断student_info表是否不存在，不存在就创建该表
hiveContext.sql("create table if not exists student_info(name string,age int) row format delimited fields terminated by ' '");
//将学生基本信息导入到Student_info表
hiveContext.sql("load data local inpath '/home/hadoop/student_info.txt' into table student_info");
//用同样的方式向student_scores导入数据
hiveContext.sql("drop table if exists student_score");
hiveContext.sql("create table if not exists student_score(name string,score int)row format delimited fields terminated by ' '");
hiveContext.sql("load data local inpath '/home/hadoop/student_score.txt' into table student_score");
//第二个功能个，执行sql还可以返回dataframe，用于查询
//执行sql查询，关联两种表，查询成绩大于80 分的学生信息
val goodstudentDF = hiveContext.sql("select i.name,i.age,s.score from student_info i join student_score s on i.name=s.name where s.score >=80");
//第三个功能，可以将dataframe中的数据，理论上来说，dataframe对应的RDD的元素是ROW就可以
//将Dataframe中的数据保存到hive表中
//将dataframe中的数据保存到good_student_info表中
hiveContext.sql("drop table if exists good_student_info");
goodstudentDF.saveAsTable("good_student_info");
//第四个功能，可以使用table（）方法，针对hive表直接创建dataframe
//针对good_student_info表，直接创建dataframe
val rows = hiveContext.table("good_student_info").collect();
for ( row <- rows) {
println(row);
}
}
}
六、内置函数
在spark 1.5.x版本，增加了一系列内置函数到dataframe API中，并且实现了code-generation的优化。与普通的函数不同，dataframe的函数并不会执行后立即返回一个结果值，而是返回一个Column对象，用于在并行作业中进行求值。Column可以用在dataframe的操作之中，比如select, filter,groupBy等操作。函数的输入值，也可以是Column。
种类 函数
聚合函数 approxCountDistinct,avg,count,
countDistinct,first,last,max,mean,min,sum,sumDistinct
集合函数 Array_contains,explode,size,sort_array
日期/时间函数 日期时间转换
Unix_timestamp,from_unixtime,to_date
Quarter,day,dayofyear,weekofyear,
From_utc_timestamp,to_utc_timestamp
从日期中提取字段
Year,month,dayofmonth,hour,minute,
second
日期/时间函数 日期时间计算
Dateiff,date_add,date_sub,add_months,
last_day,next_day,months_between
获取当前时间
Current_date,current_timestamp,trunc,
date_format
数学函数 Abs,scros,asin,atan,atan2,bin,cbrt,
ceil,conv,cos,sosh,exp,expm1,factorial,floor,hex,hypot,log,log10,log1p,log2,
Pmod,pow,rint,round,shiftLeft,
shiftRight,shiftRightUnsigned,sifnum,
Sin,sinh,sqrt,tan,tanh,toDegrees,
toRadians,unhex
混合函数 Array,bitwiseNOT,callUDF,coalesce,
crc32,greatest,if,inputFileName,isNaN,
isnotnull,isnull,least,lit,md5,
monotonicalliIncreasingId,nanvl,negate,not,rand,randn,randn
sha,sha1,sparkPartitionId,struct,when
字符串函数 Ascii,base64,concat,concat_ws,decode,encode,format_number,format_string,get_json_object,initcap,instr,length,levenshtein,locate,lower,lpad,ltrim,printf,redexp_extract,regexp_replace,repeat,reverse,rpad,rtrim,soundex,space,split,substring,substring_index,translate,trim,unbase64,upper
窗口函数 cumeDist,denseRank,lag,lead,ntile,percentRank,rank,rowNumber
案例：
根据每天的用户访问和购买日志，统计每日的UV和销售额
统计每日的UV
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.Row
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.types.StructField
import org.apache.spark.sql.types.StringType
import org.apache.spark.sql.types.IntegerType
import org.apache.spark.sql.functions._
object DailyUV {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setAppName("DailyUV")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
//构造用户 访问日志数据，并创建dataframe
//要使用spark内置函数，就必须在这里代入sparkcontext下的隐式转换
import sqlContext.implicits._
//模拟用户访问日志，日志用逗号隔开，第一列是日期，第二列是用户id
val userAccessLog = Array("2015-10-01,1122","2015-10-01,1122", "2015-10-01,1123", "2015-10-01,1125","2015-10-01,1125", "2015-10-02,1122", "2015-10-02,1124","2015-10-02,1122", "2015-10-02,1123")
val userAccessLogRDD= sc.parallelize(userAccessLog, 1);
//将模拟出来的用户日志RDD，转换为dataframe
//首先将普通的RDD转换为row的RDD
val userAccessLogRowRDD = userAccessLogRDD.map(log =>Row(log.split(",")(0),log.split(",")(1).toInt))
//构造dataframe元数据
val structType = StructType(Array(StructField("date",StringType,true),StructField("userid",IntegerType,true)))
val userAccessLogRowDF=sqlContext.createDataFrame(userAccessLogRowRDD, structType)
//这里正式使用spark1.5.x版本的提供的最新特性，内置函数，countDistinct
//每天都有很多用户来访问，但是每个用户可能每天都会访问很多次
//UV:指的是对用户进行去重以后的访问总数
//聚合函数的用法;
//首先对dataframe调用groupBy()方法，对某一列进行分组
//然后调用agg()方法，第一个参数，必须必须传入之前在groupBy方法中出现的字段
//第二个参数，传入countDistinct、sum,first等，spark提供的内置函数
//内置函数中，传入的参数也是用单引号作为前缀的，其他的字段
userAccessLogRowDF.groupBy("date").agg('date, countDistinct('userid)).map(row => Row(row(1),row(2))).collect.foreach(println)
}
}
统计每日的销售额
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.Row
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.types.StructField
import org.apache.spark.sql.types.StringType
import org.apache.spark.sql.types.DoubleType
import org.apache.spark.sql.functions._
object DailySale {
val conf = new SparkConf().setMaster("local").setAppName("DailySale")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
import sqlContext.implicits._
//模拟元数据
//实际上，有些时候，会出现日志的上报错误，比如日志里丢了用户的信息，那么这种，就一律不统计了
val userSaleLog = Array("2015-10-01,100,1122","2015-10-01,100,1133","2015-10-01,100,","2015-10-02,300,1122","2015-10-02,200,1122","2015-10-02,100,","2015-10-02,100,1122")
val userSaleLogRDD = sc.parallelize(userSaleLog, 1);
//进行过滤
val filteredUserSaleRowRDD = userSaleLogRDD.filter(log => if(log.split(",").length ==3) true else false)
val userSaleLogRowRDD = filteredUserSaleRowRDD.map(log => Row(log.split(",")(0),log.split(",")(1).toDouble))
val structType = StructType(Array(StructField("date",StringType,true),StructField("sale_amount",DoubleType,true)))
val userSaleLogDF = sqlContext.createDataFrame(userSaleLogRowRDD, structType)
//开始统计每日销售额的统计
userSaleLogDF.groupBy("date").agg('date, sum('sale_amount)).map(row => Row(row(1),row(2))).collect().foreach(println)
}
七、开窗函数
Spark1.4.x版本以后，为spark sql和dataframe引入了开窗函数，比如最经典最常用的row_number(),可以让我们实现分组取topN的逻辑
案例：统计每个种类的销售额排名前3 的产品
package com.spark.spark_sql;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.hive.HiveContext;
/**
* 开窗函数row_number
* @author Administrator
*/
public class RowNumberWindowFunction {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("NewNumberWindowFunction");
JavaSparkContext sc = new JavaSparkContext(conf);
HiveContext hiveContext = new HiveContext(sc.sc());
//创建销售表sales表
hiveContext.sql("drop table if exists sales");
hiveContext.sql("create table if not exists sales (product string,category string ,revenue bigint) row format delimited fields terminated by ' '");
hiveContext.sql("load data local inpath '/home/hadoop/sales.txt' into table sales");
//开始编写我们的统计逻辑，使用row_number()开窗函数
//先说明一下，row_number()开窗函数的作用
//其实就是给每一个分组的数据，按照其排序顺序，打上一个分组内的行号
//比如说，有一个分组date=20151001,里面有三条数据，1122 1121 1124
//那么对这个分组的每一行使用row_number（）开窗函数以后，三行依次会获得一个组内的行号
//行号从1开始递增，比如 1122 1， 1121 2， 1124 3
DataFrame top3SalesDF = hiveContext.sql("select product,category,revenue from "
+ "(select product,category,revenue ,row_number() over (partition by category order by revenue desc ) rank from sales) tmp_sales where rank <=3");
//row_number()开窗函数的语法说明
//首先，可以在select查询时，使用row_number()函数
//其次，row_number()函数后面先跟上over关键字
//然后括号中是partition by 也就是根据那个字段进行分组
//其次是可以使用order by进行组内排序
//然后row_number()就可以给每一个组内的行，一个组一个行号
//将每组排名前三的数据，保存到一个表中
hiveContext.sql("drop table if exists top3_sales");
top3SalesDF.saveAsTable("top3_sales");
sc.close();
}
}
函数名(列) OVER(选项)
八、UDF自定义函数
UDF:User Defined Function.用户自定义函数
package com.spark.spark_sql
import org.apache.spark.SparkConf
import org.apache.spark.SparkContext
import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.Row
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.types.StructField
import org.apache.spark.sql.types.StringType
object UDF {
def main(args: Array[String]): Unit = {
val conf = new SparkConf().setMaster("local").setAppName("UDF")
val sc = new SparkContext(conf)
val sqlContext = new SQLContext(sc)
//构造模拟数据
val names =Array("Leo","Marry","Jack","Tom")
val namesRDD = sc.parallelize(names, 1)
val namesRowRDD = namesRDD.map(name => Row(name))
val structType =StructType(Array(StructField("name",StringType)))
val namesRowDF =sqlContext.createDataFrame(namesRowRDD, structType)
//注册一张name表
namesRowDF.registerTempTable("names")
//定义和注册自定义函数
//定义函数
//注册函数
sqlContext.udf.register("strLen",(str:String) => str.length)
//使用自己的函数
sqlContext.sql("select name,strLen(name) from names").collect.foreach(println)
}
}
九、UDAF自定义聚合函数
UDAF:User Defined Aggregate Function。用户自定义聚合函数，是spark1.5.x引入的最新特性。
UDF针对的是单行输入，返回一个输出，
UDAF,则可以针对多行输入，进行聚合计算，返回一个输出，功能更加的强大
Scala代码：
import org.apache.spark.sql.Row
import org.apache.spark.sql.expressions.{MutableAggregationBuffer, UserDefinedAggregateFunction}
import org.apache.spark.sql.types._
class StringCount extends UserDefinedAggregateFunction {
//inputschema 指的是，输入数据的数据
override def inputSchema: StructType = {
StructType(Array(StructField("str",StringType,true)))
}
//bufferSchema，指的是，中间进行聚合时，所处理的数据类型
override def bufferSchema: StructType = {
StructType(Array(StructField("count",IntegerType,true)))
}
//dataType,指的是，函数的返回值的类型
override def dataType: DataType = {
IntegerType
}
override def deterministic: Boolean = {
true
}
//为每一个分组的数据执行初始化操作
override def initialize(buffer: MutableAggregationBuffer): Unit = {
buffer(0)=0
}
//指的是，每个分组，有新的值进来的时候，如何进行分组，对应的聚合值的计算
override def update(buffer: MutableAggregationBuffer, input: Row): Unit = {
buffer(0)=buffer.getAs[Int](0)+1
}
//由于spark是分布式的，所以一个分组的数据，可能会在不同的节点上进行局部的聚合，就是update
//但是，最后一个分组，在各个节点上的聚合值，要执行merge，也就是合并
override def merge(buffer1: MutableAggregationBuffer, buffer2: Row): Unit = {
buffer1(0)=buffer1.getAs[Int](0)+buffer2.getAs[Int](0)
}
//最后，指的是，一个分组的聚合，如何通过中间的缓存聚合值，随后返回一个最终的聚合值
override def evaluate(buffer: Row): Any = {
buffer.getAs[Int](0)
}
}
十、工作原理以及性能调优
1.工作原理
Sqlparse、Analyser、Optimizer、SparkPlan
2.性能调优
1.设置shuffle过程中的并行度spark.sql.shuffle.partitions（sqlContext.setConf()）
2.在hive数据仓库建设过程中，合理设置数据类型，比如能设置为int的就不要设置为bigint.减少数据类型导致的不必要的内存开销
3.编写sql时，尽量给出明确的列名，比如select name from students。不要写select * 的方式
4.并行处理查询结果：对于spark sql查询的结果，如果数据量比较大的话，比如超多1000条，那么就不要一次collect到driver在处理。使用foreach()算子，并行处理查询结果
5.缓存表：对于一条sql语句中可能多次使用到表，可以对其进行缓存没使用sqlContext.cache Table(tableName),或者DataFrame.cache()即可spark sql会用内存列存储的格式进行表的缓存。然后将spark sql就可以仅仅扫描需要使用的列，并且自动优化压缩，来最小化内存使用和GC开销。sqlcontext.uncacheTable(tableName)可以将表从缓存中移除。用sqlcontext.setConf(),设置spark.sql.inMemoryColumnarStorage.batchSize参数（默认10000），可以配置列存储单位
6.广播join表：spark.sql.autoBroadcastJoinThreshold.默认是10485760（10MB），也就是在10M以内的表将其广播出去，在内存足够用的情况下，增加其大小，让更多的表广播出去，就可以将join中的较小的表广播出去，而不是进行网络数据传输了。
7.钨丝计划：spark.sql.tungsten.enable,默认是true 自动管理内存
最有效的就是第四点，缓存表和广播join表也是非常不错的
十一、Hive on spark
背景：
Hive是目前大数据领域，事实上的sql标准。其底层默认是基于MapReduce实现的。但是由于mapreduce速度是在比较慢。因此这两年，陆续出来了新的sql查询引擎。包括spark sql，hive on Taz ,hive on spark
Spark sql 与hive on spark 是不一样的，spark sql 自己研发出来的针对各种数据源，包括hive、json、parquet、JDBC、RDD等都可以执行查询的，一套基于spark计算引擎的查询引擎。因此它是spark的一个项目，只不过提供了针对hive执行查询的功能而已。适合在一些使用spark技术栈的大数据应用类系统中使用。
而hive on spark是hive 的一个项目，他是指，不通过mapreudce作为唯一的引擎，而是将spark作为底层的查询引擎，hive on spark ，只适用于hive，在可预见的未来，很有可能hive默认的底层引擎从mapreduce切换为spark,适合于将原有的hive数据仓库以及数据分析替换为spark引擎，作为公司通用大数据统计计算分析引擎
Hive基本的工作原理：
hiveQL语句==>
语法分==>AST==>
生成逻辑执行计划==>operator Tree==>
优化逻辑执行计划==>optimized operator Tree==>
生成物理执行计划==>Task Tree==>
优化物理执行计划==>Optimized Task Tree==>
执行优化后的Optimized Task Tree
Hive on spark 的计算原理有如下的几个要点：
1.将hive表作为spark RDD来进行操作
2.使用hive 原语
对于一些针对RDD的操作，比如，groupByKey(),sortByKey()等等。不使用spark的transformation操作和原语。如果那样做的话，那么就需要重新实现一套hive的原语，而且hive增加了新功能，那么又要实现新的spark 原语。因此，选择将hive的原语包装为针对RDD的操作即可
3.新的物理执行计划生成机制
使用sparkCompiler将逻辑执行计划，集=即Operator Tree，转换为Task tree。提交spark task给spark进行执行。Sparktask包装了DAG,DAG包装为sparkwork，Sparktask根据sparkwork表示的DAG计算
4.sparkContext生命周期
Hive on spark 会为每一个用户的会话，比如执行一次sql语句，创建一个sparkcontext,但是spark不允许在一个JVM内创建多个sparkcontext，因此，需要在单独额JVM中启动每一个会话的sparkcontext，然后通过RPC与远程JVM中的sparkContext进行通信。
5.本地和远程运行模式
Hive on spark 提供两种运行模式，本地和远程。如果将spark master设置为local
十二、Spark sql与spark core整合
案例：每日top3热点搜索词统计案例
日志格式：
日期、用户、搜索词、城市、平台、版本
需求：
1.筛选出符合条件（城市、平台、版本））的数据
2.统计出每天搜索的UV排名前三的搜索词
3.按照每天的top3搜索词的UV搜总次数，倒序排列
4.将数据保存到hive表中
实现思路分析
1.针对原始的数据(HDFS文件），获取输入RDD
2.使用filter算子，去针对输入RDD中的数据，进行数据过滤，过滤出符合条件的数据
2.1普通的做法：直接在filter算子函数中，使用外部的查询条件（map），但是这样的话，是不是查询条件map，会发送到每一个task上一份副本（性能并不好）
2.2优化后的做法：将查询条件，封装为Broadcast广播变量，在filter算子中使用Broadcast广播变量
3.将数据转换为“日期_搜索词，用户”的格式，然后对他进行分组，再次进行映射。对每天每个搜索词的搜索用户进行去重操作，并统计去重后的数量，即为每天每个搜索词的UV,最后获得（日期_搜索词，UV）
4.将得到的每天的搜索词的UV，RDD映射为元素类型的Row的RDD，将RDD转换为dataframe
5.将dataframe注册为临时表，使用spark sql的开窗函数，来统计每天的UV排名前三的搜索词，以及他的搜索UV,最后获知，是一个dateframe
6.将dateframe转换为RDD。继续操作，按照每天日期进行分组。并进行映射。计算出每天的top3所搜词的搜索uv的总数，然后将UV总数作为key，将每天的top3搜索词以及搜索次数，拼接为一个字符串
7.按照每天的top3搜索总UV，进行排序，倒序排序
8.将排好序的数据，再次映射回来，变成“日期_搜索词_UV”的格式
9.再次映射为dataframe，并将数据保存到hive表中
package com.spark.spark_sql;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.api.java.function.FlatMapFunction;
import org.apache.spark.api.java.function.Function;
import org.apache.spark.api.java.function.PairFunction;
import org.apache.spark.broadcast.Broadcast;
import org.apache.spark.sql.DataFrame;
import org.apache.spark.sql.Row;
import org.apache.spark.sql.RowFactory;
import org.apache.spark.sql.hive.HiveContext;
import org.apache.spark.sql.types.DataTypes;
import org.apache.spark.sql.types.DateType;
import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import scala.Tuple2;
/**
* 每日top3热点搜索词统计
* @author Administrator
*
*/
public class DailyTop3Keyword {
public static void main(String[] args) {
SparkConf conf = new SparkConf().setAppName("DailyTop3Keyword");
JavaSparkContext jsc = new JavaSparkContext(conf);
HiveContext hiveContext = new HiveContext(jsc.sc());
//针对hdfs上的文件中的日志，获取输入的RDD
JavaRDD<String> rawRDD = jsc.textFile("hdfs://hadoop01:8020/keyword.txt");
//伪造一份数据，查询条件
//备注：实际上，在实际的企业的项目开发中，很可能，这个查询条件是J2EE平台发送到MySQL表中的
//然后，这里实际上通常是会用Spring框架和ORM框架的，去提取MySQL表中的查询条件
Map<String,List<String>> queryParamMap =new HashMap<String, List<String>>();
queryParamMap.put("city", Arrays.asList("beijing"));
queryParamMap.put("platform", Arrays.asList("android"));
queryParamMap.put("version", Arrays.asList("1.0","1.2","1.5","2.0"));
//将map封装为广播变量，每个work节点只拷贝一份数据即可，这样可以进行优化
final Broadcast<Map<String, List<String>>> queryParamMapBroadcast = jsc.broadcast(queryParamMap);
//使用广播变量进行筛选
JavaRDD<String> filterRDD = rawRDD.filter(new Function<String, Boolean>() {
private static final long serialVersionUID = 1L;
@Override
public Boolean call(String log) throws Exception {
String[] logSplited = log.split(" ");
String city =logSplited[3];
String platform =logSplited[4];
String version = logSplited[5];
//与查询条件进行比较,任何一个
Map<String, List<String>> queryParamMap = queryParamMapBroadcast.value();
List<String> cities = queryParamMap.get("city");
if(cities.size()>0 && !cities.contains(city)){
return false;
}
List<String> platforms = queryParamMap.get("city");
if(platforms.size()>0 && !platforms.contains(platform)){
return false;
}
List<String> versions = queryParamMap.get("city");
if(versions.size()>0 && !versions.contains(version)){
return false;
}
return true;
}
});
//将过滤出来的原始的日志进行映射为（日期_搜索词，用户）的格式
JavaPairRDD<String, String> dateKeywordUserRDD = filterRDD.mapToPair(new PairFunction<String, String, String>() {
private static final long serialVersionUID = 1L;
@Override
public Tuple2<String, String> call(String t) throws Exception {
String[] logSplited = t.split(" ");
String date =logSplited[0];
String user =logSplited[1];
String keyword =logSplited[2];
return new Tuple2<String, String>(date+"_"+keyword, user);
}
});
//进行分组，获取每天的搜索词，有哪些用户进行搜索了（没有去重）
JavaPairRDD<String, Iterable<String>> dateKeywordUsersRDD = dateKeywordUserRDD.groupByKey();
//对每天每个搜索词的搜索用户，执行去重操作，获得其UV值
JavaPairRDD<String, Long> dateKeywordUVRDD = dateKeywordUsersRDD.mapToPair(new PairFunction<Tuple2<String,Iterable<String>>, String, Long>() {
private static final long serialVersionUID = 1L;
@Override
public Tuple2<String, Long> call(Tuple2<String, Iterable<String>> t) throws Exception {
String dateKeyword = t._1;
Iterator<String> users = t._2.iterator();
//对用户进行去重，并且统计数量
List<String> distinctUsers = new ArrayList<String>();
while(users.hasNext()){
String user = users.next();
if(!distinctUsers.contains(user)){
distinctUsers.add(user);
}
}
//获取uv
long uv = distinctUsers.size();
return new Tuple2<String, Long>(dateKeyword, uv);
}
});
//将每天每个搜索词的UV数据转换成dataframe
JavaRDD<Row> dateKeywordUVRowRDD = dateKeywordUVRDD.map(new Function<Tuple2<String,Long>, Row>() {
@Override
public Row call(Tuple2<String, Long> v1) throws Exception {
String date = v1._1.split("_")[0];
String keyword = v1._1.split("_")[1];
long uv = v1._2;
return RowFactory.create(date,keyword,uv);
}
});
List<StructField> structFields = Arrays.asList(
DataTypes.createStructField("date", DataTypes.StringType, true),
DataTypes.createStructField("keyword", DataTypes.StringType,true),
DataTypes.createStructField("uv", DataTypes.LongType,true)
);
StructType structType =DataTypes.createStructType(structFields);
DataFrame dateKeywordUVDF = hiveContext.createDataFrame(dateKeywordUVRowRDD, structType);
//使用spark sql的开窗函数，统计每天的搜索排名前三的热点搜索词
dateKeywordUVDF.registerTempTable("daily_keyword_uv");
DataFrame dailyTop3KeywordDF = hiveContext.sql("select date,keyword,uv from "
+ "(select date,keyword,uv,row_number over (partition by date order by uv desc ) rank from daily_keyword_uv )tmp "
+ "where rank <=3");
//将dateframe 转换为RDD，然后映射，计算出每天的top3搜索词的搜索uv的总数
JavaPairRDD<String, String> Top3DateKeywordUvRDD = dailyTop3KeywordDF.javaRDD().mapToPair(new PairFunction<Row, String, String>() {
@Override
public Tuple2<String, String> call(Row row) throws Exception {
String date = String.valueOf(row.get(0));
String keyword =String.valueOf(row.get(1));
Long uv = Long.valueOf(String.valueOf(row.get(2)));
return new Tuple2<String, String>(date, keyword+"_"+uv);
}
});
JavaPairRDD<String, Iterable<String>> Top3DateKeywordRDD = Top3DateKeywordUvRDD.groupByKey();
JavaPairRDD<Long, String> uvDateKeywordsRDD = Top3DateKeywordRDD.mapToPair(new PairFunction<Tuple2<String,Iterable<String>>, Long, String>() {
@Override
public Tuple2<Long, String> call(Tuple2<String, Iterable<String>> t) throws Exception {
String date = t._1;
Iterator<String> keywordUvIterator = t._2.iterator();
Long totalUv = 0L;
String dateKeywordUv = date;
while(keywordUvIterator.hasNext()){
String keywordUv= keywordUvIterator.next();
Long uv = Long.valueOf(keywordUv.split("_")[1]);
totalUv+=uv;
dateKeywordUv+=","+keywordUv;
}
return new Tuple2<Long, String>(totalUv, dateKeywordUv);
}
});
//按照每天的总搜索进行倒序排序
JavaPairRDD<Long, String> sortedUvDateKeywordsRDD = uvDateKeywordsRDD.sortByKey(false);
//在此进行映射，将排序后的数据，映射回原始的格式Iterable<ROW>
JavaRDD<Row> sortedRowRDD = sortedUvDateKeywordsRDD.flatMap(new FlatMapFunction<Tuple2<Long,String>, Row>() {
@Override
public Iterable<Row> call(Tuple2<Long, String> t) throws Exception {
String dateKeywords=t._2;
String[] dateKeywordsSplited = dateKeywords.split(",");
String date = dateKeywordsSplited[0];
List<Row> rows= new ArrayList<Row>();
rows.add(RowFactory.create(date,
dateKeywordsSplited[1].split("_")[0],
Long.valueOf(dateKeywordsSplited[1].split("_")[1])
));
rows.add(RowFactory.create(date,
dateKeywordsSplited[1].split("_")[0],
Long.valueOf(dateKeywordsSplited[2].split("_")[1])
));
rows.add(RowFactory.create(date,
dateKeywordsSplited[1].split("_")[0],
Long.valueOf(dateKeywordsSplited[3].split("_")[1])
));
return rows;
}
});
//将最终的数据转换为dateframe
DataFrame finalDF = hiveContext.createDataFrame(sortedRowRDD, structType);
finalDF.saveAsTable("daily_top3_keyword_uv");
jsc.close();
}
}
