2024年最全[新星计划]通过扩展 Spark SQL ，打造自己的大数据分析引擎(3)，2024年最新面试加分项

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

( “First Value”,4, java.sql.Date.valueOf(“2010-01-01”)),

(“Second Value”,2,  java.sql.Date.valueOf(“2010-02-01”)),

(“Second Value”,9,  java.sql.Date.valueOf(“2010-02-01”))

).toDF(“name”, “score”, “date_column”)

df.createTempView(“p”)

​

//   val df = spark.read.json(“examples/src/main/resources/people.json”)

//   df.toDF().write.saveAsTable(“person”)

//,javg(score)

​

// custom parser

//   spark.sql("select * from p ").show

​

spark.sql(“select * from p”).show()

}

}

​

下面是执行结果，符合我们的预期。

扩展优化器

=====

接下来，我们来扩展优化器，砖厂提供了很多默认的RBO，这里可以方便的构建我们自己的优化规则，本例中我们构建一套比较奇怪的规则，而且是完全不等价的，这里只是为了说明。

针对字段+0的操作，规则如下：

1. 如果0出现在+左边，则直接将字段变成右表达式，即 0+nr 等效为 nr

2. 如果0出现在+右边，则将0变成3，即 nr+0 变成 nr+3

3. 如果没出现0，则表达式不变

下面是代码：

package wang.datahub.optimizer

​

import org.apache.spark.sql.SparkSession

import org.apache.spark.sql.catalyst.expressions.{Add, Expression, Literal}

import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan

import org.apache.spark.sql.catalyst.rules.Rule

​

object MyOptimizer extends Rule[LogicalPlan] {

​

def apply(logicalPlan: LogicalPlan): LogicalPlan = {

logicalPlan.transformAllExpressions {

case Add(left, right) => {

println(“this this my add optimizer”)

if (isStaticAdd(left)) {

right

} else if (isStaticAdd(right)) {

Add(left, Literal(3L))

} else {

Add(left, right)

}

}

}

}

​

private def isStaticAdd(expression: Expression): Boolean = {

expression.isInstanceOf[Literal] && expression.asInstanceOf[Literal].toString == “0”

}

​

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

System.setProperty(“hadoop.home.dir”,“E:\devlop\envs\hadoop-common-2.2.0-bin-master”);

val testSparkSession: SparkSession = SparkSession.builder().appName(“Extra optimization rules”)

.master(“local[*]”)

.withExtensions(extensions => {

extensions.injectOptimizerRule(session => MyOptimizer)

})

.getOrCreate()

​

testSparkSession.sparkContext.setLogLevel(“ERROR”)

​

import testSparkSession.implicits._

testSparkSession.experimental.extraOptimizations = Seq()

Seq(-1, -2, -3).toDF(“nr”).write.mode(“overwrite”).json(“./test_nrs”)

//   val optimizedResult = testSparkSession.read.json(“./test_nrs”).selectExpr(“nr + 0”)

testSparkSession.read.json(“./test_nrs”).createTempView(“p”)

​

var sql = “select nr+0 from p”;

var t = testSparkSession.sql(sql)

println(t.queryExecution.optimizedPlan)

println(sql)

t.show()

​

sql = “select 0+nr from p”;

var  u = testSparkSession.sql(sql)

println(u.queryExecution.optimizedPlan)

println(sql)

u.show()

​

sql = “select nr+8 from p”;

var  v = testSparkSession.sql(sql)

println(v.queryExecution.optimizedPlan)

println(sql)

v.show()

//   println(optimizedResult.queryExecution.optimizedPlan.toString() )

//   optimizedResult.collect().map(row => row.getAs[Long](“(nr + 0)”))

Thread.sleep(1000000)

}

​

}

执行如下

this this my add optimizer

this this my add optimizer

this this my add optimizer

Project [(nr#12L + 3) AS (nr + CAST(0 AS BIGINT))#14L]

± Relation[nr#12L] json

​

select nr+0 from p

this this my add optimizer

this this my add optimizer

this this my add optimizer

±-----------------------+

|(nr + CAST(0 AS BIGINT))|

±-----------------------+

|                       2|

|                       1|

|                       0|

±-----------------------+

​

this this my add optimizer

Project [nr#12L AS (CAST(0 AS BIGINT) + nr)#21L]

± Relation[nr#12L] json

​

select 0+nr from p

this this my add optimizer

±-----------------------+

|(CAST(0 AS BIGINT) + nr)|

±-----------------------+

|                     -1|

|                     -2|

|                     -3|

±-----------------------+

​

this this my add optimizer

this this my add optimizer

this this my add optimizer

Project [(nr#12L + 8) AS (nr + CAST(8 AS BIGINT))#28L]

± Relation[nr#12L] json

​

select nr+8 from p

this this my add optimizer

this this my add optimizer

this this my add optimizer

±-----------------------+

|(nr + CAST(8 AS BIGINT))|

±-----------------------+

|                       7|

|                       6|

|                       5|

±-----------------------+

​

​

扩展策略

====

SparkStrategies包含了一系列特定的Strategies，这些Strategies是继承自QueryPlanner中定义的Strategy，它定义接受一个Logical Plan，生成一系列的Physical Plan

通过Strategies把逻辑计划转换成可以具体执行的物理计划，代码如下

package wang.datahub.strategy

​

import org.apache.spark.sql.{SparkSession, Strategy}

import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan

import org.apache.spark.sql.execution.SparkPlan

​

object MyStrategy extends Strategy {

def apply(plan: LogicalPlan): Seq[SparkPlan] = {

println(“Hello world!”)

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

ntln(“Hello world!”)

[外链图片转存中…(img-ZpY81gMc-1715282459381)]
[外链图片转存中…(img-rQd6d0C1-1715282459382)]
[外链图片转存中…(img-N1l7aLhp-1715282459382)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取