Spark之SQL高级知识分享二(DataSource+Tuling+CustomDataSource)

最新推荐文章于 2022-05-09 14:06:57 发布

skwang_君永夜

最新推荐文章于 2022-05-09 14:06:57 发布

阅读量736

点赞数

分类专栏： Spark 文章标签： DataSource Spark SQL Tuning JSON Parquet ORC

本文链接：https://blog.csdn.net/qq_32641659/article/details/90524432

版权

Spark 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

1.DataSource

1.1传统的ETL数据操作弊端

如上图，传统的方式如MR、Hive、Spark core方式进行数据ETL操作有如下弊端：

弊端一：若涉及数据格式的转换，则代码或sql相关的逻辑就得重写。
弊端二：若数据的来源非常多样化，混杂，则实现起来就更加麻烦了。

基于这种情况，Spark1.2 诞生了External Data Sources,使用它我们可以非常的方便将外部数据源转换成DF或DS以及将相关数据保存到外External Data Sources。

1.2 Build-In DataSource Options

Spark内置了** Parquet、ORC、JSON、Hive Tables、JDBC To Other DataBases 、Avro**等外部数据源读取和保存操作。详情可参考官网：http://spark.apache.org/docs/latest/sql-data-sources.html，Spark默认的数据源是Parquet，parquet格式数据在读取性能上有良好表现。

1.3 DataSource Option

如下，标准的load、save数据的流程：

val peopleDF = spark.read.format("json").load("exampleData/people.json")
peopleDF.write.save.format("parquet").save("namesAndFavColors.parquet")

1.4 Some Notes

(重要)DataSource Parquet:具有分区自动探索能力,会根据路径下的的k=v名称子路径的值将分区数据信息带上，k为列，v为值，列的类型默认时自动推导的，可以设置。
DataSource Parquet:具有Schema自动合并能力。这种非常耗资源，1.5开始默认时关的。建议不要使用
(重要)DataSource Hive Table:想要Spark session能够操作Hive，必须开启支持hive操作.enableHiveSupport()
(重要)DataSource Hive Table:若我们没有设置hive-site.xml 则底层默认启动metastore_db 数据库
（重要）DataSource JDBC:读取还是用它自带的load，生产采坑，注意写最好使用foreachPartition加jdbc方式。

2.（重要）DataSource Tuling

2.1Caching Data In Memory

可通过df.cache()方式缓存数据，默认是MEMORY_AND_DISK级别。

2. 2 Other Configuration Options

一些有用的配置优化：
spark.sql.autoBroadcastJoinThreshold:默认10M，即表数据只有10M时就自动broadcast，这个值太小，具体根据业务进行优化。
spark.sql.shuffle.partitions：默认是200，join操作时ResultStage的parition数量（spark-sql可测试），这个值也是太小了。

2.3 Broadcast Hint for SQL Queries

主动的广播出去小表，注意注意，一定不要写错了，别把大表广播出去了。

import org.apache.spark.sql.functions.broadcast
broadcast(spark.table("src")).join(spark.table("records"), "key").show()

3.（重要）Custom Extral DataSource

3.1 third-party packages简介

官网这里提供了很多Spark第三方的jar、工具、项目,比如自定义的数据源。有需要可来这里逛逛，做一名合格的搬运工。

3.2 JDBC外部数据源实现源码解析

但是在生产上spark内置的以及第三方的外部数据源有时并不能满足我们的需求，这时我们就需要自己Custom Extral DataSource，可参考JDBC数据源的JDBCRelation.scala以及JdbcRelationProvider.scala的实现。

class JdbcRelationProvider extends CreatableRelationProvider
  with RelationProvider with DataSourceRegister {。。。。。}
  
private[sql] case class JDBCRelation(
    override val schema: StructType,
    parts: Array[Partition],
    jdbcOptions: JDBCOptions)(@transient val sparkSession: SparkSession)
  extends BaseRelation
  with PrunedFilteredScan
  with InsertableRelation {。。。。。。。}

如下是列举了一些常见的trait：

abstract class BaseRelation：外部数据源基类，保存了定义好的的Schema
trait TableScan { def buildScan(): RDD[Row]}：读取数据构建RDD[ROW]，类似于：select * from
trait PrunedScan{def buildScan(requiredColumns: Array[String]): RDD[Row]} :同上，但是能够传入一个列名列表参数，类似于：select a,b,c from
trait PrunedFilteredScan { def buildScan(requiredColumns: Array[String], filters: Array[Filter]):RDD[Row]:同上，但是能够传入一个列名列表参数以及过滤条件列表参数，类似于：select a,b,c from where a!=0
trait CatalystScan {def buildScan(requiredColumns: Seq[Attribute], filters: Seq[Expression]):RDD[Row]}:用于实验的，不建议用，效果完全同PrunedFilteredScan
trait InsertableRelation {def insert(data: DataFrame, overwrite: Boolean): Unit}：存储数据。写数据的
trait RelationProvider {def createRelation(sqlContext: SQLContext, parameters: Map[String, String]): BaseRelation}：用于创建relation，parameters即是设置的参数列表，如设置jdbc的链接信息等
trait SchemaRelationProvider { def createRelation(sqlContext: SQLContext,parameters: Map[String, String],schema: StructType): BaseRelation}:同RelationProvider创建Relation，但是它多传了一个Schema
trait DataSourceRegister { def shortName(): String}:注册一个外部数据源字符串名字，如parquet、jdbc等。

3.3 (重要)Custom Extral Text DataSource 编程

之前提到过有两种方式将RDD转成DF，但是这种方式在遇到格式变化时都是比较麻烦的。因此在这里自定义Text外部数据源：

package com.wsk.spark.sql.textdatasource

import org.apache.spark.sql.types.{DataType, LongType, StringType}

/**
  * 转换类型
  */
object Utils {

  def castTo(value:String, dataType:DataType) ={
    dataType match {
      case _:LongType => value.toLong
      case _:StringType => value
    }
  }

}


package com.wsk.spark.sql.textdatasource

import org.apache.spark.internal.Logging
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{Row, SQLContext}
import org.apache.spark.sql.sources._
import org.apache.spark.sql.types.{LongType, StringType, StructField, StructType}

/**
  * 读取外部数据以及保存
  */
class TextDatasourceRelation(override val sqlContext: SQLContext,
                             path:String,
                             userSchema:StructType)
  extends BaseRelation with TableScan
//  with PrunedScan with PrunedFilteredScan
    with Logging{

  override def schema: StructType = {
    if(userSchema != null){
      userSchema
    } else {
      StructType(
        StructField("id",LongType,false) ::
          StructField("name",StringType,false) ::
          StructField("gender",StringType,false) ::
          StructField("salary",LongType,false) ::
          StructField("comm",LongType,false) :: Nil
      )
    }
  }

  // select * from xxx
  override def buildScan(): RDD[Row] = {
    logError("this is ruozedata custom buildScan...")

    var rdd = sqlContext.sparkContext.wholeTextFiles(path).map(x => {
      println(x)
      x._2
    })
    val schemaField = schema.fields

    rdd.foreach(println)
    // rdd + schemaField

    val l = rdd.count()
    // rdd + schemaField
    val rows = rdd.map(fileContent => {
      val lines = fileContent.split("\n")
      val data = lines.map(_.split(",").map(x=>x.trim)).toSeq

      val result = data.map(x => x.zipWithIndex.map{
        case  (value, index) => {

          val columnName = schemaField(index).name

          Utils.castTo(if(columnName.equalsIgnoreCase("gender")) {
            if(value == "0") {
              "男"
            } else if(value == "1"){
              "女"
            } else {
              "未知"
            }
          } else {
            value
          }, schemaField(index).dataType)
        }
        })
      result.map(x => Row.fromSeq(x))
    })

    rows.flatMap(x=>x)
}

//  override def buildScan(requiredColumns: Array[String]): RDD[Row] = ???
//
//  override def buildScan(requiredColumns: Array[String], filters: Array[Filter]): RDD[Row] = ???
}

package com.wsk.spark.sql.textdatasource

import org.apache.spark.sql.SQLContext
import org.apache.spark.sql.sources.{BaseRelation, RelationProvider, SchemaRelationProvider}
import org.apache.spark.sql.types.StructType

/**
  * 注意这类名字必须是DefaultSource，不然会报错
  *
  */
class DefaultSource extends RelationProvider with SchemaRelationProvider {
  override def createRelation(
                               sqlContext: SQLContext,
                               parameters: Map[String, String],
                               schema: StructType): BaseRelation = {
    val path = parameters.get("path")

    path match {
      case Some(p) => new TextDatasourceRelation(sqlContext, p, schema)
      case _ => throw new IllegalArgumentException("path is required...")
    }

  }

  override def createRelation(sqlContext: SQLContext, parameters: Map[String, String]): BaseRelation = {
    createRelation(sqlContext, parameters, null)
  }
}


package com.wsk.spark.sql.textdatasource

import org.apache.spark.sql.SparkSession

/**
  * 测试
  */
object TextApp {

  def main(args: Array[String]): Unit = {

    val spark = SparkSession.builder().appName("TextApp").master("local[2]").getOrCreate()
    val df = spark.read.format("com.wsk.spark.sql.textdatasource").option("path","D://wskspace/workspace1/data/spark-train/data/textdatasource/*").load()
    df.show()

    spark.stop()
  }

}

注意1：我这里测试时wholeTextFiles方法的路径要写全且文件夹后面/*

skwang_君永夜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spark之SQL高级知识分享二(DataSource+Tuling+CustomDataSource)

1.DataSource1.1传统的ETL数据操作弊端如上图，传统的方式如MR、Hive、Spark core方式进行数据ETL操作有如下弊端：弊端一：若涉及数据格式的转换，则代码或sql相关的逻辑就得重写。弊端二：若数据的来源非常多样化，混杂，则实现起来就更加麻烦了。基于这种情况，Spark1.2 诞生了External Data Sources,使用它我们可以非常的方便将外部数...
复制链接

扫一扫

专栏目录