通过Spark操作Hudi(增、删、改、查、增量查)

最新推荐文章于 2024-05-14 11:17:27 发布

嘣嘣嚓

最新推荐文章于 2024-05-14 11:17:27 发布

阅读量2.8k

点赞数

本文链接：https://blog.csdn.net/qq_38304392/article/details/125303147

版权

一、概览

Hudi数据湖框架，基于spark计算引擎，对数据进行CRUD操作，使用官方模拟生成出租车出行数据
任务一：模拟数据，插入Hudi表，采用COW模式
任务二：快照方式查询(Snapshot Query)，采用DSL方式
任务三：更新(update)数据
任务四：增量查询数据(Incremental Query)，采用SQL方式
任务五：删除(Delete)数据

二、cow类型表的操作

1.写入

　　写入数据时，如果该rowkey已经存在，则复制原字段，会保留历史版本

2.查询

2.1快照查询Snapshot[默认]

默认加载最近一个版本的数据，通过参数 hoodie.datasource.query.type可以进行设置

val QUERY_TYPE_OPT_KEY = "hoodie.datasource.query.type"
val QUERY_TYPE_SNAPSHOT_OPT_VAL = "snapshot"
val QUERY_TYPE_READ_OPTIMIZED_OPT_VAL = "read_optimized"
val QUERY_TYPE_INCREMENTAL_OPT_VAL = "incremental"
val DEFAULT_QUERY_TYPE_OPT_VAL: String = QUERY_TYPE_SNAPSHOT_OPT_VAL

2.2增量查询Incremental

指定一个时间戳，查询时间戳之后的增量数据，如果是incremental增量查询，需要指定时间戳，当hudi表中数据满足：instant_time > beginTime时，数据将会被读取；此外，可设置某个时间范围：endTime > instant_time > beginTime

val BEGIN_INSTANTTIME_OPT_KEY = "hoodie.datasource.read.begin.instanttime"
val END_INSTANTTIME_OPT_KEY = "hoodie.datasource.read.end.instanttime"

3.删除数据

需要设置属性参数：hoodie.datasource.write.operation : delete

val OPERATION_OPT_KEY = "hoodie.datasource.write.operation"
val BULK_INSERT_OPERATION_OPT_VAL = WriteOperationType.BULK_INSERT.value
val INSERT_OPERATION_OPT_VAL = WriteOperationType.INSERT.value
val UPSERT_OPERATION_OPT_VAL = WriteOperationType.UPSERT.value
val DELETE_OPERATION_OPT_VAL = WriteOperationType.DELETE.value
val BOOTSTRAP_OPERATION_OPT_VAL = WriteOperationType.BOOTSTRAP.value
val INSERT_OVERWRITE_OPERATION_OPT_VAL = WriteOperationType.INSERT_OVERWRITE.value
val INSERT_OVERWRITE_TABLE_OPERATION_OPT_VAL = WriteOperationType.INSERT_OVERWRITE_TABLE.value
val DEFAULT_OPERATION_OPT_VAL = UPSERT_OPERATION_OPT_VAL

三、参考代码

package com.zhen.hudi.spark

import org.apache.hudi.QuickstartUtils.DataGenerator
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}


/**
  * @Author FengZhen
  * @Date 2/17/22 9:09 PM 
  * @Description
  *  Hudi数据湖框架，基于spark计算引擎，对数据进行CRUD操作，使用官方模拟生成出租车出行数据
  *  任务一：模拟数据，插入Hudi表，采用COW模式
  *  任务二：快照方式查询(Snapshot Query)，采用DSL方式
  *  任务三：更新(update)数据
  *  任务四：增量查询数据(Incremental Query)，采用SQL方式
  *  任务五：删除(Delete)数据
  *
  *  cow类型表
  *   写入数据时，如果该rowkey已经存在，则复制原字段
  *   查询
  *     快照查询Snapshot[默认]：
  *       默认加载最近一个版本的数据
  *       通过参数 hoodie.datasource.query.type可以进行设置
  *       val QUERY_TYPE_OPT_KEY = "hoodie.datasource.query.type"
  *       val QUERY_TYPE_SNAPSHOT_OPT_VAL = "snapshot"
  *       val QUERY_TYPE_READ_OPTIMIZED_OPT_VAL = "read_optimized"
  *       val QUERY_TYPE_INCREMENTAL_OPT_VAL = "incremental"
  *       val DEFAULT_QUERY_TYPE_OPT_VAL: String = QUERY_TYPE_SNAPSHOT_OPT_VAL
  *     增量查询Incremental：
  *       指定一个时间戳，查询时间戳之后的增量数据
  *       如果是incremental增量查询，需要指定时间戳，
  *       当hudi表中数据满足：instant_time > beginTime时，数据将会被夹在读取
  *       此外，可设置某个时间范围：endTime > instant_time > beginTime
  *       val BEGIN_INSTANTTIME_OPT_KEY = "hoodie.datasource.read.begin.instanttime"
  *       val END_INSTANTTIME_OPT_KEY = "hoodie.datasource.read.end.instanttime"
  *
  *   删除数据
  *     需要设置属性参数：hoodie.datasource.write.operation : delete
  *     val OPERATION_OPT_KEY = "hoodie.datasource.write.operation"
  *     val BULK_INSERT_OPERATION_OPT_VAL = WriteOperationType.BULK_INSERT.value
  *     val INSERT_OPERATION_OPT_VAL = WriteOperationType.INSERT.value
  *     val UPSERT_OPERATION_OPT_VAL = WriteOperationType.UPSERT.value
  *     val DELETE_OPERATION_OPT_VAL = WriteOperationType.DELETE.value
  *     val BOOTSTRAP_OPERATION_OPT_VAL = WriteOperationType.BOOTSTRAP.value
  *     val INSERT_OVERWRITE_OPERATION_OPT_VAL = WriteOperationType.INSERT_OVERWRITE.value
  *     val INSERT_OVERWRITE_TABLE_OPERATION_OPT_VAL = WriteOperationType.INSERT_OVERWRITE_TABLE.value
  *     val DEFAULT_OPERATION_OPT_VAL = UPSERT_OPERATION_OPT_VAL
  *
  *
  */
object HudiSparkDemo {


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

    //创建SparkSession实例对象，设置属性
    val spark: SparkSession = {
      SparkSession.builder()
        .appName(this.getClass.getSimpleName.stripSuffix("$"))
        .master("local[2]")
        //设置序列化方式：Kryo
        .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
        .getOrCreate()
    }
    
    //定义变量，表名称、保存路径
    val tableName = "tbl_trips_cow"
    val tablePath = "/hudi-warehouse/tbl_trips_cow"
    

    //任务一：模拟数据，插入Hudi表，采用COW模式
//    insertData(spark, tableName, tablePath)

    //任务二：快照方式查询(Snapshot Query)数据，采用DSL方式
    queryData(spark, tablePath)
    //根据时间查询数据
//    queryDataByTime(spark, tablePath)

    /**
      * 任务三：更新数据update。
      *   第一步：模拟产生数据；
      *   第二步：模拟产生数据，针对第一步数据字段值更新；
      *   第三步：将数据更新到hudi表
      * hudi数据湖框架最大优势就是支持对数据的Upsert操作(插入或更新)
      */
//    val dataGen : DataGenerator = new DataGenerator()
//    insertData(spark, tableName, tablePath, dataGen)
//    updateData(spark, tableName, tablePath, dataGen)

    //任务四：增量查询数据(Incremental Query)，采用SQL方式
//    incrementalQueryData(spark, tablePath)

    //任务五：删除(Delete)数据
    deleteData(spark, tableName, tablePath)


    //应用结束，关闭资源
    spark.stop()
  }

  /**
    * 官方案例：模拟产生数据，插入Hudi表，采用COW模式
    * @param spark
    * @param table
    * @param path
    */
  def insertData(spark: SparkSession, table: String, path: String): Unit = {
    import spark.implicits._
    //1.模拟乘车数据
    //构建数据生成器，模拟产生业务数据
    import org.apache.hudi.QuickstartUtils._
    val dataGen : DataGenerator = new DataGenerator()
    //模拟生成100条，并转成String类型
    val inserts = convertToStringList(dataGen.generateInserts(100))

    import scala.collection.JavaConverters._
    val insertDF =spark.read.json(
      spark.sparkContext.parallelize(inserts.asScala, 2).toDS()
    )

    insertDF.printSchema()
    insertDF.show(10, false)

    //2.插入数据到Hudi表
    import org.apache.hudi.DataSourceWriteOptions._
    import org.apache.hudi.config.HoodieWriteConfig._
    insertDF.write
      .mode(SaveMode.Append)
      .format("hudi")
      .option("hoodie.insert.shuffle.parallelism", "2")
      .option("hoodie.upsert.shuffle.parallelism", "2")
      //hudi表的属性值的设置
      //预合并
      .option(PRECOMBINE_FIELD.key(), "ts")
      //主键
      .option(RECORDKEY_FIELD.key(), "uuid")
      //分区
      .option(PARTITIONPATH_FIELD.key(), "partitionpath")
      //表名
      .option(TBL_NAME.key(), table)
      .save(path)

  }

  /**
    * 采用Snapshot Query快照方式查询表的数据
    * @param spark
    * @param path
    * @return
    */
  def queryData(spark: SparkSession, path: String): Unit= {
    import spark.implicits._
    val tripsDF = spark.read.format("hudi").load(path)
//    tripsDF.printSchema()
//    tripsDF.show(10, false)

    //查询费用大于20，小于50的乘车数据
    tripsDF
      .filter($"fare" >= 20 && $"fare" <= 50)
      .select($"driver", $"rider", $"fare", $"begin_lat", $"begin_lon", $"partitionpath", $"_hoodie_commit_time")
      .orderBy($"fare".desc, $"_hoodie_commit_time".desc)
      .show(20, false)
  }

  /**
    * 根据时间点查询数据
    * @param spark
    * @param path
    */
  def queryDataByTime(spark: SparkSession, path: String): Unit = {
    import org.apache.spark.sql.functions._

    //方式一：指定字符串，按照日期时间过滤获取数据
    val df1 = spark.read
      .format("hudi")
      .option("as.of.instant", "20220222214552250")
      .load(path)
      .sort(col("_hoodie_commit_time").desc)

    df1.printSchema()
    df1.show(5, false)

    //方式二：指定字符串，按照日期时间过滤获取数据
    val df2 = spark.read
      .format("hudi")
      .option("as.of.instant", "2022-02-22 21:45:52.250")
      .load(path)
      .sort(col("_hoodie_commit_time").desc)
    df2.printSchema()
    df2.show(5, false)
  }


  /**
    * 官方案例：模拟产生数据，插入Hudi表，采用COW模式
    * @param spark
    * @param table
    * @param path
    * @param dataGen
    */
  def insertData(spark: SparkSession, table: String, path: String, dataGen: DataGenerator): Unit = {
    import spark.implicits._
    //1.模拟乘车数据
    //构建数据生成器，模拟产生业务数据
    import org.apache.hudi.QuickstartUtils._
    //模拟生成100条，并转成String类型
    val inserts = convertToStringList(dataGen.generateInserts(100))

    import scala.collection.JavaConverters._
    val insertDF =spark.read.json(
      spark.sparkContext.parallelize(inserts.asScala, 2).toDS()
    )

    //    insertDF.printSchema()
    //    insertDF.show(10, false)

    //2.插入数据到Hudi表
    import org.apache.hudi.DataSourceWriteOptions._
    import org.apache.hudi.config.HoodieWriteConfig._
    insertDF.write
      .mode(SaveMode.Overwrite)
      .format("hudi")
      .option("hoodie.insert.shuffle.parallelism", "2")
      .option("hoodie.upsert.shuffle.parallelism", "2")
      //hudi表的属性值的设置
      //预合并
      .option(PRECOMBINE_FIELD.key(), "ts")
      //主键
      .option(RECORDKEY_FIELD.key(), "uuid")
      //分区
      .option(PARTITIONPATH_FIELD.key(), "partitionpath")
      //表名
      .option(TBL_NAME.key(), table)
      .save(path)

  }


  /**
    * 模拟产生hudi表中更新数据，将其更新到Hudi表中
    * @param spark
    * @param table
    * @param path
    * @param dataGen
    * @return
    */
  def updateData(spark: SparkSession, table: String, path: String, dataGen: DataGenerator): Unit = {

    import spark.implicits._
    //1.模拟乘车数据
    //构建数据生成器，模拟产生业务数据
    import org.apache.hudi.QuickstartUtils._
    //模拟产生100条更新数据，并转成String类型
    val updates = convertToStringList(dataGen.generateUpdates(100))

    import scala.collection.JavaConverters._
    val updateDF =spark.read.json(
      spark.sparkContext.parallelize(updates.asScala, 2).toDS()
    )

//    updateDF.printSchema()
//    updateDF.show(10, false)

    //2.插入数据到Hudi表
    import org.apache.hudi.DataSourceWriteOptions._
    import org.apache.hudi.config.HoodieWriteConfig._
    updateDF.write
      .mode(SaveMode.Append)
      .format("hudi")
      .option("hoodie.insert.shuffle.parallelism", "2")
      .option("hoodie.upsert.shuffle.parallelism", "2")
      //hudi表的属性值的设置
      //预合并
      .option(PRECOMBINE_FIELD.key(), "ts")
      //主键
      .option(RECORDKEY_FIELD.key(), "uuid")
      //分区
      .option(PARTITIONPATH_FIELD.key(), "partitionpath")
      //表名
      .option(TBL_NAME.key(), table)
      .save(path)


  }

  /**
    * 采用incremental query增量方式查询数据，需要指定时间戳
    * @param spark
    * @param path
    */
  def incrementalQueryData(spark: SparkSession, path: String): Unit = {

    import spark.implicits._

    val QUERY_TYPE_OPT_KEY = "hoodie.datasource.query.type"
    val QUERY_TYPE_SNAPSHOT_OPT_VAL = "snapshot"
    val QUERY_TYPE_READ_OPTIMIZED_OPT_VAL = "read_optimized"
    val QUERY_TYPE_INCREMENTAL_OPT_VAL = "incremental"

    val BEGIN_INSTANTTIME_OPT_KEY = "hoodie.datasource.read.begin.instanttime"
    val END_INSTANTTIME_OPT_KEY = "hoodie.datasource.read.end.instanttime"

    //1.加载hudi表数据，获取commit time时间，作为增量查询数据阈值
    spark.read
      .format("hudi")
      .load(path)
      .createOrReplaceTempView("view_temp_hudi_trips")
    val commits: Array[String] = spark
      .sql(
        """
          |SELECT
          | DISTINCT(_hoodie_commit_time) AS commitTime
          |FROM
          | view_temp_hudi_trips
          |ORDER BY
          | commitTime DESC
          |""".stripMargin
      )
      .map(row => row.getString(0))
      .take(50)
    val beginTime = commits(commits.length - 1)
    println(s"beginTime = ${beginTime}")

    //2.设置hudi数据commit time时间阈值，进行增量数据查询
    val tripsIncrementalDF = spark.read
      .format("hudi")
      //设置查询数据模式为：incremental，增量读取
      .option(QUERY_TYPE_OPT_KEY, QUERY_TYPE_INCREMENTAL_OPT_VAL)
      //设置增量读取数据时开始时间
      .option(BEGIN_INSTANTTIME_OPT_KEY, beginTime)
      .load(path)

    //3.将增量查询数据注册为临时视图，查询费用大于20的数据
    tripsIncrementalDF.createOrReplaceTempView("hudi_trips_incremental")
    spark
      .sql(
        """
          |SELECT
          | `_hoodie_commit_time`, fare, begin_lon, begin_lat, ts
          |FROM
          | hudi_trips_incremental
          |WHERE
          | fare > 20.0
          |""".stripMargin
      )
      .show(10, false)

  }

  /**
    * 删除hudi表数据，依据主键UUID进行删除，如果是分区表，需要指定分区路径
    * @param spark
    * @param table
    * @param path
    */
  def deleteData(spark: SparkSession, table: String, path: String):Unit = {
    import spark.implicits._

    //1.加载hudi表数据，获取条目数
    val tripsDF: DataFrame = spark.read
      .format("hudi")
      .load(path)
    println(s"Raw Count = ${tripsDF.count()}")

    //2.模拟要删除的数据，从hudi表中加载数据，获取几条数据，转换为要删除的数据集合
    val dataFrame = tripsDF.limit(2).select($"uuid", $"partitionpath")
    import org.apache.hudi.QuickstartUtils._

    val dataGenerator = new DataGenerator()
    val deletes = dataGenerator.generateDeletes(dataFrame.collectAsList())

    import scala.collection.JavaConverters._
    val deleteDF = spark.read.json(spark.sparkContext.parallelize(deletes.asScala, 2))

    //3.保存数据到hudi表中，设置操作类型为DELETE
    import org.apache.hudi.DataSourceWriteOptions._
    import org.apache.hudi.config.HoodieWriteConfig._
    deleteDF.write
      .mode(SaveMode.Append)
      .format("hudi")
      .option("hoodie.insert.shuffle.parallelism", 2)
      .option("hoodie.upsert.shuffle.parallelism", 2)
      //设置数据操作类型为delete，默认值为upsert
      .option(OPERATION.key(), "delete")
      .option(PRECOMBINE_FIELD.key(), "ts")
      .option(RECORDKEY_FIELD.key(), "uuid")
      .option(PARTITIONPATH_FIELD.key(), "partitionpath")
      .option(TBL_NAME.key(), table)
      .save(path)

    //4.再次加载hudi表数据，统计条目数，查看是否减少2条数据
    val verifyDF: DataFrame = spark.read
      .format("hudi")
      .load(path)
    println(s"After Delete Raw Count = ${verifyDF.count()}")

  }
}

今天俄罗斯进攻了乌克兰。

嘣嘣嚓

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
通过Spark操作Hudi(增、删、改、查、增量查)

一、概览Hudi数据湖框架，基于spark计算引擎，对数据进行CRUD操作，使用官方模拟生成出租车出行数据任务一：模拟数据，插入Hudi表，采用COW模式任务二：快照方式查询(Snapshot Query)，采用DSL方式任务三：更新(update)数据任务四：增量查询数据(Incremental Query)，采用SQL方式任务五：删除(Delete)数据二、cow类型表的操作...
复制链接

扫一扫