一、SparkSQL介紹

1.1、Shark介紹

hark是基於Spark計算框架之上且兼容Hive語法的SQL執行引擎，由於底層的計算採用了Spark，性能比MapReduce的Hive普遍快2倍以上，當數據全部load在內存的話，將快10倍以上，因此Shark可以作爲交互式查詢應用服務來使用。

Shark是完全兼容Hive的語法，表結構以及UDF函數等，已有的HiveSql可以直接進行遷移至Shark上Shark底層依賴於Hive的解析器，查詢優化器，但正是由於Shark的整體設計架構對Hive的依賴性太強，難以支持其長遠發展，比如不能和Spark的其他組件進行很好的集成，無法滿足Spark的一棧式解決大數據處理的需求。

1.2、SparkSQL介紹

Hive是Shark的前身，Shark是SparkSQL的前身,SparkSQL產生的根本原因是其完全脫離了Hive的限制

SparkSQL支持查詢原生的RDD。 RDD是Spark平臺的核心概念，是Spark能夠高效的處理大數據的各種場景的基礎。
能夠在Scala中寫SQL語句。支持簡單的SQL語法檢查，能夠在Scala中寫Hive語句訪問Hive數據，並將結果取回作爲RDD使用。

1.3、Spark on Hive和Hive on Spark

Spark on Hive： Hive只作爲儲存角色，Spark負責sql解析優化，執行。

Hive on Spark：Hive即作爲存儲又負責sql的解析優化，Spark負責執行。

1.4、分佈式數據容器DataFrame

DataFrame也是一個分佈式數據容器。與RDD類似，然而DataFrame更像傳統數據庫的二維表格，除了數據以外，還掌握數據的結構信息，即schema。同時，與Hive類似，DataFrame也支持嵌套數據類型（struct、array和map）。

從API易用性的角度上看， DataFrame API提供的是一套高層的關係操作，比函數式的RDD API要更加友好，門檻更低。

DataFrame的底層封裝的是RDD，只不過RDD的泛型是Row類型。

1.5、SparkSQL的數據源

SparkSQL的數據源可以是JSON類型的字符串，JDBC,Parquent,Hive，HDFS等。

1.6、SparkSQL底層架構

首先拿到sql後解析一批未被解決的邏輯計劃，再經過分析得到分析後的邏輯計劃，再經過一批優化規則轉換成一批最佳優化的邏輯計劃，再經過SparkPlanner的策略轉化成一批物理計劃，隨後經過消費模型轉換成一個個的Spark任務執行。

二、創建DataFrame的幾種方式

2.1、讀取json格式的文件創建DataFrame

注意：

json文件中的json數據不能嵌套json格式數據。
DataFrame是一個一個Row類型的RDD，df.rdd()/df.javaRdd()。
可以兩種方式讀取json格式的文件。
df.show()默認顯示前20行數據。
DataFrame原生API可以操作DataFrame（不方便）。
註冊成臨時表時，表中的列默認按ascii順序顯示列。

Java：

SparkConf conf = new SparkConf();
conf.setMaster("local").setAppName("jsonfile");
SparkContext sc = new SparkContext(conf);
		
//創建sqlContext
SQLContext sqlContext = new SQLContext(sc);
		
/**
 * DataFrame的底層是一個一個的RDD  RDD的泛型是Row類型。
 * 以下兩種方式都可以讀取json格式的文件
 */
 DataFrame df = sqlContext.read().format("json").load("sparksql/json");
// DataFrame df2 = sqlContext.read().json("sparksql/json.txt");
// df2.show();
 /**
  * DataFrame轉換成RDD
  */
 RDD<Row> rdd = df.rdd();
/**
 * 顯示 DataFrame中的內容，默認顯示前20行。如果現實多行要指定多少行show(行數)
 * 注意：當有多個列時，顯示的列先後順序是按列的ascii碼先後顯示。
 */
// df.show();
/**
 * 樹形的形式顯示schema信息
 */
 df.printSchema();
		
 /**
  * dataFram自帶的API 操作DataFrame
  */
  //select name from table
 // df.select("name").show();
 //select name age+10 as addage from table
	 df.select(df.col("name"),df.col("age").plus(10).alias("addage")).show();
 //select name ,age from table where age>19
	 df.select(df.col("name"),df.col("age")).where(df.col("age").gt(19)).show();
 //select count(*) from table group by age
 df.groupBy(df.col("age")).count().show();
		
 /**
   * 將DataFrame註冊成臨時的一張表，這張表臨時註冊到內存中，是邏輯上的表，不會霧化到磁盤
  */
 df.registerTempTable("jtable");
		
 DataFrame sql = sqlContext.sql("select age,count(1) from jtable group by age");
 DataFrame sql2 = sqlContext.sql("select * from jtable");
		
 sc.stop();

2.2、通過json格式的RDD創建DataFrame

SparkConf conf = new SparkConf();
conf.setMaster("local").setAppName("jsonRDD");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
JavaRDD<String> nameRDD = sc.parallelize(Arrays.asList(
	"{\"name\":\"zhangsan\",\"age\":\"18\"}",
	"{\"name\":\"lisi\",\"age\":\"19\"}",
	"{\"name\":\"wangwu\",\"age\":\"20\"}"
));
JavaRDD<String> scoreRDD = sc.parallelize(Arrays.asList(
"{\"name\":\"zhangsan\",\"score\":\"100\"}",
"{\"name\":\"lisi\",\"score\":\"200\"}",
"{\"name\":\"wangwu\",\"score\":\"300\"}"
));

DataFrame namedf = sqlContext.read().json(nameRDD);
DataFrame scoredf = sqlContext.read().json(scoreRDD);
namedf.registerTempTable("name");
scoredf.registerTempTable("score");

DataFrame result = sqlContext.sql("select name.name,name.age,score.score from name,score where name.name = score.name");
result.show();

sc.stop();

2.3、非json格式的RDD創建DataFrame

動態創建Schema將非json格式的RDD轉換成DataFrame：

SparkConf conf = new SparkConf();
conf.setMaster("local").setAppName("rddStruct");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
JavaRDD<String> lineRDD = sc.textFile("./sparksql/person.txt");
/**
 * 轉換成Row類型的RDD
 */
JavaRDD<Row> rowRDD = lineRDD.map(new Function<String, Row>() {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	@Override
	public Row call(String s) throws Exception {
          return RowFactory.create(
                String.valueOf(s.split(",")[0]),
                String.valueOf(s.split(",")[1]),
                Integer.valueOf(s.split(",")[2])
	);
	}
});
/**
 * 動態構建DataFrame中的元數據，一般來說這裏的字段可以來源自字符串，也可以來源於外部數據庫
 */
List<StructField> asList =Arrays.asList(
	DataTypes.createStructField("id", DataTypes.StringType, true),
	DataTypes.createStructField("name", DataTypes.StringType, true),
	DataTypes.createStructField("age", DataTypes.IntegerType, true)
);

StructType schema = DataTypes.createStructType(asList);
DataFrame df = sqlContext.createDataFrame(rowRDD, schema);

df.show();
sc.stop();

2.4、讀取parquet文件創建DataFrame

注意：

可以將DataFrame存儲成parquet文件。保存成parquet文件的方式有兩種：

df.write().mode(SaveMode.Overwrite)format("parquet")
                                    .save("./sparksql/parquet");
df.write().mode(SaveMode.Overwrite).parquet("./sparksql/parquet");

SaveMode指定文件保存時的模式

Overwrite：覆蓋

Append：追加

ErrorIfExists：如果存在就報錯

Ignore：如果存在就忽略

SparkConf conf = new SparkConf();
conf.setMaster("local").setAppName("parquet");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
JavaRDD<String> jsonRDD = sc.textFile("sparksql/json");
DataFrame df = sqlContext.read().json(jsonRDD);
/**
 * 將DataFrame保存成parquet文件，SaveMode指定存儲文件時的保存模式
 * 保存成parquet文件有以下兩種方式：
 */
df.write().mode(SaveMode.Overwrite).format("parquet").save("./sparksql/parquet");
df.write().mode(SaveMode.Overwrite).parquet("./sparksql/parquet");
df.show();
/**
 * 加載parquet文件成DataFrame	
 * 加載parquet文件有以下兩種方式：	
 */

DataFrame load = sqlContext.read().format("parquet").load("./sparksql/parquet");
load = sqlContext.read().parquet("./sparksql/parquet");
load.show();

sc.stop();

2.5、讀取JDBC中的數據創建DataFrame(MySql爲例)

SparkConf conf = new SparkConf();
conf.setMaster("local").setAppName("mysql");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
/**
 * 第一種方式讀取MySql數據庫表，加載爲DataFrame
 */
Map<String, String> options = new HashMap<String,String>();
options.put("url", "jdbc:mysql://192.168.179.4:3306/spark");
options.put("driver", "com.mysql.jdbc.Driver");
options.put("user", "root");
options.put("password", "123456");
options.put("dbtable", "person");
DataFrame person = sqlContext.read().format("jdbc").options(options).load();
person.show();
person.registerTempTable("person");
/**
 * 第二種方式讀取MySql數據表加載爲DataFrame
 */
DataFrameReader reader = sqlContext.read().format("jdbc");
reader.option("url", "jdbc:mysql://192.168.179.4:3306/spark");
reader.option("driver", "com.mysql.jdbc.Driver");
reader.option("user", "root");
reader.option("password", "123456");
reader.option("dbtable", "score");
DataFrame score = reader.load();
score.show();
score.registerTempTable("score");

DataFrame result = 
sqlContext.sql("select person.id,person.name,score.score from person,score where person.name = score.name");
result.show();
/**
 * 將DataFrame結果保存到Mysql中
 */
Properties properties = new Properties();
properties.setProperty("user", "root");
properties.setProperty("password", "123456");
result.write().mode(SaveMode.Overwrite).jdbc("jdbc:mysql://192.168.179.4:3306/spark", "result", properties);

sc.stop();

2.6、讀取Hive中的數據加載成DataFrame

HiveContext是SQLContext的子類，連接Hive建議使用HiveContext。
由於本地沒有Hive環境，要提交到集羣運行，提交命令：

./spark-submit 
--master spark://node1:7077,node2:7077 
--executor-cores 1 
--executor-memory 2G 
--total-executor-cores 1
--class com.bjsxt.sparksql.dataframe.CreateDFFromHive 
/root/test/HiveTest.jar

SparkConf conf = new SparkConf();
conf.setAppName("hive");
JavaSparkContext sc = new JavaSparkContext(conf);
//HiveContext是SQLContext的子類。
HiveContext hiveContext = new HiveContext(sc);
hiveContext.sql("USE spark");
hiveContext.sql("DROP TABLE IF EXISTS student_infos");
//在hive中創建student_infos表
hiveContext.sql("CREATE TABLE IF NOT EXISTS student_infos (name STRING,age INT) row format delimited fields terminated by '\t' ");
hiveContext.sql("load data local inpath '/root/test/student_infos' into table student_infos");

hiveContext.sql("DROP TABLE IF EXISTS student_scores"); 
hiveContext.sql("CREATE TABLE IF NOT EXISTS student_scores (name STRING, score INT) row format delimited fields terminated by '\t'");  
hiveContext.sql("LOAD DATA "
+ "LOCAL INPATH '/root/test/student_scores'"
+ "INTO TABLE student_scores");
/**
 * 查詢表生成DataFrame
 */
DataFrame goodStudentsDF = hiveContext.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");

hiveContext.sql("DROP TABLE IF EXISTS good_student_infos");

goodStudentsDF.registerTempTable("goodstudent");
DataFrame result = hiveContext.sql("select * from goodstudent");
result.show();

/**
 * 將結果保存到hive表 good_student_infos
 */
goodStudentsDF.write().mode(SaveMode.Overwrite).saveAsTable("good_student_infos");

Row[] goodStudentRows = hiveContext.table("good_student_infos").collect();  
for(Row goodStudentRow : goodStudentRows) {
	System.out.println(goodStudentRow);  
}
sc.stop();

三、Spark On Hive的配置

1.	在Spark客戶端配置Hive On Spark
在Spark客戶端安裝包下spark-1.6.0/conf中創建文件hive-site.xml：
配置hive的metastore路徑
<configuration>
   <property>
        <name>hive.metastore.uris</name>
        <value>thrift://node1:9083</value>
   </property>
</configuration>
2.	啓動Hive的metastore服務
hive --service metastore 
3.	啓動zookeeper集羣，啓動HDFS集羣。
4.	啓動SparkShell 讀取Hive中的表總數，對比hive中查詢同一表查詢總數測試時間。
./spark-shell 
--master spark://node1:7077,node2:7077 
 --executor-cores 1 
--executor-memory 1g 
--total-executor-cores 1
import org.apache.spark.sql.hive.HiveContext
val hc = new HiveContext(sc)
hc.sql("show databases").show
hc.sql("user default").show
hc.sql("select count(*) from jizhan").show
	注意：
如果使用Spark on Hive  查詢數據時，出現錯誤：
 
找不到HDFS集羣路徑，要在客戶端機器conf/spark-env.sh中設置HDFS的路徑：

四、自定義函數UDF和UDAF

4.1、UDF:用戶自定義函數

可以自定義類實現UDFX接口。

SparkConf conf = new SparkConf();
conf.setMaster("local");
conf.setAppName("udf");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
JavaRDD<String> parallelize = sc.parallelize(Arrays.asList("zhansan","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);
	}
});

List<StructField> fields = new ArrayList<StructField>();
fields.add(DataTypes.createStructField("name", DataTypes.StringType,true));

StructType schema = DataTypes.createStructType(fields);
DataFrame df = sqlContext.createDataFrame(rowRDD,schema);
df.registerTempTable("user");

/**
 * 根據UDF函數參數的個數來決定是實現哪一個UDF  UDF1，UDF2。。。。UDF1xxx
 */
sqlContext.udf().register("StrLen", new UDF1<String,Integer>() {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	@Override
	public Integer call(String t1) throws Exception {
             return t1.length();
	}
}, DataTypes.IntegerType);
sqlContext.sql("select name ,StrLen(name) as length from user").show();

//sqlContext.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 );
//sqlContext.sql("select name ,StrLen(name,10) as length from user").show();

sc.stop();

4.2、UDAF:用戶自定義聚合函數

實現UDAF函數如果要自定義類要繼承UserDefinedAggregateFunction類

SparkConf conf = new SparkConf();
conf.setMaster("local").setAppName("udaf");
JavaSparkContext sc = new JavaSparkContext(conf);
SQLContext sqlContext = new SQLContext(sc);
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);
DataFrame df = sqlContext.createDataFrame(rowRDD, schema);
df.registerTempTable("user");
/**
 * 註冊一個UDAF函數,實現統計相同值得個數
 * 注意：這裏可以自定義一個類繼承UserDefinedAggregateFunction類也是可以的
 */
sqlContext.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)));
   }
   
});

sqlContext.sql("select name ,StringCount(name) from user group by name").show();

sc.stop();

五、開窗函數

注意：

row_number() 開窗函數是按照某個字段分組，然後取另一字段的前幾個的值，相當於分組取topN

如果SQL語句裏面使用到了開窗函數，那麼這個SQL語句必須使用HiveContext來執行，HiveContext默認情況下在本地無法創建。在MySql8之後也增加了開窗函數。

開窗函數格式：row_number() over (partitin by XXX order by XXX)

SparkConf conf = new SparkConf();
   conf.setAppName("windowfun");
   JavaSparkContext sc = new JavaSparkContext(conf);
   HiveContext hiveContext = new HiveContext(sc);
   hiveContext.sql("use spark");
   hiveContext.sql("drop table if exists sales");
   hiveContext.sql("create table if not exists sales (riqi string,leibie string,jine Int) "
      + "row format delimited fields terminated by '\t'");
   hiveContext.sql("load data local inpath '/root/test/sales' into table sales");
   /**
    * 開窗函數格式：
    * 【 rou_number() over (partitin by XXX order by XXX) 】
    */
   DataFrame result = hiveContext.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();
   sc.stop();

Spark學習（6）——SparkSQL(1)