Spark SQL下的Parquet使用最佳实践和代码实战

一、Spark SQL下的Parquet使用最佳实践

1）过去整个业界对大数据的分析的技术栈的Pipeline一般分为以下两种方式：

a）Data Source -> HDFS -> MR/Hive/Spark（相当于ETL）-> HDFS Parquet -> Spark SQL/Impala -> ResultService（可以放在DB中，也有可能被通过JDBC/ODBC来作为数据服务使用）；

b）Data Source -> Real timeupdate data to HBase/DB -> Export to Parquet -> Spark SQL/Impala -> ResultService（可以放在DB中，也有可能被通过JDBC/ODBC来作为数据服务使用）；

上述的第二种方式完全可以通过Kafka+Spark Streaming+Spark SQL（内部也强烈建议采用Parquet的方式来存储数据）的方式取代

2）期待的方式：DataSource -> Kafka -> Spark Streaming -> Parquet -> Spark SQL（ML、GraphX等）-> Parquet -> 其它各种Data Mining等。

二、Parquet的精要介绍

1）Parquet是列式存储格式的一种文件类型，列式存储有以下的核心优势：

a）可以跳过不符合条件的数据，只读取需要的数据，降低IO数据量。

b）压缩编码可以降低磁盘存储空间。由于同一列的数据类型是一样的，可以使用更高效的压缩编码（例如RunLength Encoding和Delta Encoding）进一步节约存储空间。

c）只读取需要的列，支持向量运算，能够获取更好的扫描性能。

三、代码实战

Java版本：

package com.dt.spark.SparkApps.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;public class SparkSQLParquetOps {    public static void main(String[] args) {        SparkConf conf = new SparkConf().setMaster("local").setAppName("SparkSQLParquetOps");        JavaSparkContext sc = new JavaSparkContext(conf);        SQLContext sqlContext = new SQLContext(sc);        DataFrame usersDF = sqlContext.read().parquet("E:\\Spark\\Sparkinstanll_package\\Big_Data_Software\\spark-1.6.0-bin-hadoop2.6\\examples\\src\\main\\resources\\users.parquet");        /**         * 注册成为临时表以供后续的SQL查询操作         */        usersDF.registerTempTable("users");        /**         * 进行数据的多维度分析         */        DataFrame result = sqlContext.sql("select * from users");        JavaRDD<String> resultRDD = result.javaRDD().map(new Function<Row, String>() {            @Override            public String call(Row row) throws Exception {                return "The name is : " + row.getAs("name");            }        });        /**         * 第六步：对结果进行处理，包括由DataFrame转换成为RDD<Row>，以及结构持久化         */        List<String> listRow = resultRDD.collect();        for(String row : listRow){            System.out.println(row);        }    }}

Schema Merging

Java版本：

package com.dt.spark.SparkApps.sql;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.types.DataTypes;import org.apache.spark.sql.types.StructField;import org.apache.spark.sql.types.StructType;import scala.Tuple2;import java.util.ArrayList;import java.util.Arrays;import java.util.List;public class SchemaOps {    public static void main(String[] args) {        SparkConf conf = new SparkConf().setMaster("local").setAppName("RDD2DataFrameByProgramatically");        JavaSparkContext sc = new JavaSparkContext(conf);        SQLContext sqlContext = new SQLContext(sc);                // Create a simple DataFrame, stored into a partition directory        JavaRDD<Integer> lines = sc.parallelize(Arrays.asList(1,2,3,4,5));        PairFunction<Integer,Integer,Integer> df2 = new PairFunction<Integer,Integer,Integer>() {            @Override            public Tuple2 call(Integer x) throws Exception {                return new Tuple2(x,x * 2);            }        };        JavaPairRDD<Integer,Integer> pairs = lines.mapToPair(df2);        /**         * 第一步：在RDD的基础上创建类型为Row的RDD         */        JavaRDD<Row> personsRDD = pairs.map(new Function<Tuple2<Integer, Integer>, Row>() {            @Override            public Row call(Tuple2<Integer, Integer> integerIntegerTuple2) throws Exception {                return RowFactory.create(integerIntegerTuple2._1,integerIntegerTuple2._2);            }        });        /**         * 第二步：动态构造DataFrame的元数据，一般而言，有多少列，以及每列的具体类型可能来自于JSON文件         * 也可能来自于数据库。         * 指定类型         */        List<StructField> structFields = new ArrayList<StructField>();        structFields.add(DataTypes.createStructField("single",DataTypes.IntegerType,true));        structFields.add(DataTypes.createStructField("double",DataTypes.IntegerType,true));        /**         * 构建StructType用于最后DataFrame元数据的描述         */        StructType structType = DataTypes.createStructType(structFields);        /**         * 第三步：基于以后的MetaData以及RDD<Row>来构建DataFrame         */        DataFrame personsDF = sqlContext.createDataFrame(personsRDD,structType);        personsDF.write().parquet("data/test_table/key=1");        // Create a simple DataFrame, stored into a partition directory        JavaRDD<Integer> lines1 = sc.parallelize(Arrays.asList(6,7,8,9,10));        PairFunction<Integer,Integer,Integer> df3 = new PairFunction<Integer,Integer,Integer>() {            @Override            public Tuple2 call(Integer x) throws Exception {                return new Tuple2(x,x * 2);            }        };        JavaPairRDD<Integer,Integer> pairs1 = lines.mapToPair(df2);        /**         * 第一步：在RDD的基础上创建类型为Row的RDD         */        JavaRDD<Row> personsRDD1 = pairs1.map(new Function<Tuple2<Integer, Integer>, Row>() {            @Override            public Row call(Tuple2<Integer, Integer> integerIntegerTuple2) throws Exception {                return RowFactory.create(integerIntegerTuple2._1,integerIntegerTuple2._2);            }        });        /**         * 第二步：动态构造DataFrame的元数据，一般而言，有多少列，以及每列的具体类型可能来自于JSON文件         * 也可能来自于数据库。         * 指定类型         */        List<StructField> structFields1 = new ArrayList<StructField>();        structFields.add(DataTypes.createStructField("single",DataTypes.IntegerType,true));        structFields.add(DataTypes.createStructField("triple",DataTypes.IntegerType,true));        /**         * 构建StructType用于最后DataFrame元数据的描述         */        StructType structType1 = DataTypes.createStructType(structFields);        /**         * 第三步：基于以后的MetaData以及RDD<Row>来构建DataFrame         */        DataFrame personsDF1 = sqlContext.createDataFrame(personsRDD1,structType1);        personsDF1.write().parquet("data/test_table/key=2");        DataFrame df4 = sqlContext.read().option("mergeSchema","true").parquet("data/test_table");        df4.printSchema();    }}

输出结果如下：

root|--single: integer (nullable = true)|--double: integer (nullable = true)|--single2: integer (nullable = true)|--triple: integer (nullable = true)|--key: integer (nullable = true)复制代码

Scala版本：

// sqlContext from the previous example is used in this example.// This is used to implicitly convert an RDD to a DataFrame.import sqlContext.implicits._// Create a simple DataFrame, stored into a partition directoryval df1 = sc.makeRDD(1 to 5).map(i => (i, i * 2)).toDF("single", "double")df1.write.parquet("data/test_table/key=1")// Create another DataFrame in a new partition directory,// adding a new column and dropping an existing columnval df2 = sc.makeRDD(6 to 10).map(i => (i, i * 3)).toDF("single", "triple")df2.write.parquet("data/test_table/key=2")// Read the partitioned tableval df3 = sqlContext.read.option("mergeSchema", "true").parquet("data/test_table")df3.printSchema()// The final schema consists of all 3 columns in the Parquet files together// with the partitioning column appeared in the partition directory paths.// root// |-- single: int (nullable = true)// |-- double: int (nullable = true)// |-- triple: int (nullable = true)// |-- key : int (nullable = true)