一篇文章教会你如何自定义SparkSQL函数和开窗函数

最新推荐文章于 2022-04-18 22:39:46 发布
最新推荐文章于 2022-04-18 22:39:46 发布
阅读量615 收藏 1
点赞数
分类专栏： 大数据 spark 文章标签： spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mr_yang888/article/details/105847522
版权

前言
大家好，我是DJ丶小哪吒，我又来跟你们分享知识了。对软件开发有着浓厚的兴趣。喜欢与人分享知识。做博客的目的就是为了能与 他 人知识共享。由于水平有限。博客中难免会有一些错误。如有 纰 漏之处，欢迎大家在留言区指正。小编也会及时改正。

DJ丶小哪吒又来与各位分享知识了。今天小编分享的是spark SQL自定义函数和开窗函数。本篇文章带你更熟悉的掌握SparkSQL的使用。下面我们直奔主题了。各位，看好了。操作时间到了，SHOWTIME…

在这里插入图片描述

文章目录

第一章：Spark SQL自定义函数

1.1、自定义函数分类

类似于hive当中的自定义函数， spark同样可以使用自定义函数来实现新的功能。
spark中的自定义函数有如下3类

1.UDF(User-Defined-Function)
输入一行，输出一行

2.UDAF(User-Defined Aggregation Funcation)
输入多行，输出一行

3.UDTF(User-Defined Table-Generating Functions)
输入一行，输出多行

1.2、自定义UDF

●需求
有udf.txt数据格式如下：

Hello
abc
study
small

通过自定义UDF函数将每一行数据转换成大写
select value,smallToBig(value) from t_word

●代码演示

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.sql.{Dataset, SparkSession}


object UDFDemo {
  def main(args: Array[String]): Unit = {
    //1.创建SparkSession
    val spark: SparkSession = SparkSession.builder().master("local[*]").appName("SparkSQL").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val fileDS: Dataset[String] = spark.read.textFile("D:\\data\\udf.txt")
    fileDS.show()
    /*
    +----------+
    |     value|
    +----------+
    |helloworld|
    |       abc|
    |     study|
    | smallWORD|
    +----------+
     */
   /*
    将每一行数据转换成大写
    select value,smallToBig(value) from t_word
    */
    //注册一个函数名称为smallToBig,功能是传入一个String,返回一个大写的String
    spark.udf.register("smallToBig",(str:String) => str.toUpperCase())
    fileDS.createOrReplaceTempView("t_word")
    //使用我们自己定义的函数
    spark.sql("select value,smallToBig(value) from t_word").show()
    /*
    +----------+---------------------+
    |     value|UDF:smallToBig(value)|
    +----------+---------------------+
    |helloworld|           HELLOWORLD|
    |       abc|                  ABC|
    |     study|                STUDY|
    | smallWORD|            SMALLWORD|
    +----------+---------------------+
     */
    sc.stop()
    spark.stop()
  }
}
1.3、自定义UDAF[了解]

虽然小编说UDAF只做了解，但也只需要掌握的。在企业中，这也是你和别人拉开差距的地方

●需求

有udaf.json数据内容如下

{"name":"Michael","salary":3000}
{"name":"Andy","salary":4500}
{"name":"Justin","salary":3500}
{"name":"Berta","salary":4000}

求取平均工资

●继承UserDefinedAggregateFunction方法重写说明

inputSchema：输入数据的类型

bufferSchema：产生中间结果的数据类型

dataType：最终返回的结果类型

deterministic：确保一致性，一般用true

initialize：指定初始值

update：每有一条数据参与运算就更新一下中间结果(update相当于在每一个分区中的运算)

merge：全局聚合(将每个分区的结果进行聚合)

evaluate：计算最终的结果

●代码演示

package cn.itcast.sql

import org.apache.spark.SparkContext
import org.apache.spark.sql.expressions.{MutableAggregationBuffer, UserDefinedAggregateFunction}
import org.apache.spark.sql.types._
import org.apache.spark.sql.{DataFrame, Row, SparkSession}


object UDAFDemo {
  def main(args: Array[String]): Unit = {
    //1.获取sparkSession
    val spark: SparkSession = SparkSession.builder().appName("SparkSQL").master("local[*]").getOrCreate()
    val sc: SparkContext = spark.sparkContext
    sc.setLogLevel("WARN")
    //2.读取文件
    val employeeDF: DataFrame = spark.read.json("D:\\data\\udaf.json")
    //3.创建临时表
    employeeDF.createOrReplaceTempView("t_employee")
    //4.注册UDAF函数
    spark.udf.register("myavg",new MyUDAF)
    //5.使用自定义UDAF函数
    spark.sql("select myavg(salary) from t_employee").show()
    //6.使用内置的avg函数
    spark.sql("select avg(salary) from t_employee").show()
  }
}
class MyUDAF extends UserDefinedAggregateFunction{
  //输入的数据类型的schema
  override def inputSchema: StructType = {
     StructType(StructField("input",LongType)::Nil)
  }
  //缓冲区数据类型schema，就是转换之后的数据的schema
  override def bufferSchema: StructType = {
    StructType(StructField("sum",LongType)::StructField("total",LongType)::Nil)
  }
  //返回值的数据类型
  override def dataType: DataType = {
    DoubleType
  }
  //确定是否相同的输入会有相同的输出
  override def deterministic: Boolean = {
    true
  }
  //初始化内部数据结构
  override def initialize(buffer: MutableAggregationBuffer): Unit = {
    buffer(0) = 0L
    buffer(1) = 0L
  }
  //更新数据内部结构,区内计算
  override def update(buffer: MutableAggregationBuffer, input: Row): Unit = {
    //所有的金额相加
    buffer(0) = buffer.getLong(0) + input.getLong(0)
    //一共有多少条数据
    buffer(1) = buffer.getLong(1) + 1
  }
  //来自不同分区的数据进行合并,全局合并
  override def merge(buffer1: MutableAggregationBuffer, buffer2: Row): Unit = {
    buffer1(0) =buffer1.getLong(0) + buffer2.getLong(0)
    buffer1(1) = buffer1.getLong(1) + buffer2.getLong(1)
  }
  //计算输出数据值
  override def evaluate(buffer: Row): Any = {
    buffer.getLong(0).toDouble / buffer.getLong(1)
  }
}

第二章、开窗函数

2.1、概述

●介绍
开窗函数的引入是为了既显示聚集前的数据，又显示聚集后的数据。即在每一行的最后一列添加聚合函数的结果。

开窗用于为行定义一个窗口(这里的窗口是指运算将要操作的行的集合)，它对一组值进行操作，不需要使用 GROUP BY 子句对数据进行分组，能够在同一行中同时返回基础行的列和聚合列。

●聚合函数和开窗函数
聚合函数是将多行变成一行，count,avg…
开窗函数是将一行变成多行；
聚合函数如果要显示其他的列必须将列加入到group by中
开窗函数可以不使用group by，直接将所有信息显示出来

●开窗函数分类
1.聚合开窗函数
聚合函数(列) OVER(选项)，这里的选项可以是PARTITION BY 子句，但不可以是 ORDER BY 子句。
==2.排序开窗函数 ==
排序函数(列) OVER(选项)，这里的选项可以是ORDER BY 子句，也可以是 OVER(PARTITION BY 子句 ORDER BY 子句)，但不可以是 PARTITION BY 子句。

2.2.准备工作

/export/servers/spark/bin/spark-shell

case class Score(name: String, clazz: Int, score: Int)
val scoreDF = spark.sparkContext.makeRDD(Array(
Score("a1", 1, 80),
Score("a2", 1, 78),
Score("a3", 1, 95),
Score("a4", 2, 74),
Score("a5", 2, 92),
Score("a6", 3, 99),
Score("a7", 3, 99),
Score("a8", 3, 45),
Score("a9", 3, 55),
Score("a10", 3, 78),
Score("a11", 3, 100))
).toDF("name", "class", "score")
scoreDF.createOrReplaceTempView("scores")
scoreDF.show()

查看数据结果：

+----+-----+-----+
|name|class|score|
+----+-----+-----+
|  a1|    1|   80|
|  a2|    1|   78|
|  a3|    1|   95|
|  a4|    2|   74|
|  a5|    2|   92|
|  a6|    3|   99|
|  a7|    3|   99|
|  a8|    3|   45|
|  a9|    3|   55|
| a10|    3|   78|
| a11|    3|  100|
+----+-----+-----+
2.3. 聚合开窗函数

●示例1
OVER 关键字表示把聚合函数当成聚合开窗函数而不是聚合函数。
SQL标准允许将所有聚合函数用做聚合开窗函数。

spark.sql("select  count(name)  from scores").show
spark.sql("select name, class, score, count(name) over() name_count from scores").show

结果如下所示：

+----+-----+-----+----------+                                                   
|name|class|score|name_count|
+----+-----+-----+----------+
|  a1|    1|   80|        11|
|  a2|    1|   78|        11|
|  a3|    1|   95|        11|
|  a4|    2|   74|        11|
|  a5|    2|   92|        11|
|  a6|    3|   99|        11|
|  a7|    3|   99|        11|
|  a8|    3|   45|        11|
|  a9|    3|   55|        11|
| a10|    3|   78|        11|
| a11|    3|  100|        11|
+----+-----+-----+----------+

●示例2
OVER 关键字后的括号中还可以添加选项用以改变进行聚合运算的窗口范围。
如果 OVER 关键字后的括号中的选项为空，则开窗函数会对结果集中的所有行进行聚合运算。

开窗函数的 OVER 关键字后括号中的可以使用 PARTITION BY 子句来定义行的分区来供进行聚合计算。与 GROUP BY 子句不同，PARTITION BY 子句创建的分区是独立于结果集的，创建的分区只是供进行聚合计算的，而且不同的开窗函数所创建的分区也不互相影响。

下面的 SQL 语句用于显示按照班级分组后每组的人数：
OVER(PARTITION BY class)表示对结果集按照 class 进行分区，并且计算当前行所属的组的聚合计算结果。

spark.sql("select name, class, score, count(name) over(partition by class) name_count from scores").show

查询结果如下所示：

+----+-----+-----+----------+                                                   
|name|class|score|name_count|
+----+-----+-----+----------+
|  a1|    1|   80|         3|
|  a2|    1|   78|         3|
|  a3|    1|   95|         3|
|  a6|    3|   99|         6|
|  a7|    3|   99|         6|
|  a8|    3|   45|         6|
|  a9|    3|   55|         6|
| a10|    3|   78|         6|
| a11|    3|  100|         6|
|  a4|    2|   74|         2|
|  a5|    2|   92|         2|
+----+-----+-----+----------+
2.4. 排序开窗函数
2.4.1、ROW_NUMBER顺序排序

row_number() over(order by score) as rownum 表示按score 升序的方式来排序，并得出排序结果的序号

注意：
在排序开窗函数中使用 PARTITION BY 子句需要放置在ORDER BY 子句之前。

●示例1

只做排序，按成绩排序

spark.sql("select name, class, score, row_number() over(order by score) rank from scores").show()

结果如下：

+----+-----+-----+----+
|name|class|score|rank|
+----+-----+-----+----+
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
|  a4|    2|   74|   3|
|  a2|    1|   78|   4|
| a10|    3|   78|   5|
|  a1|    1|   80|   6|
|  a5|    2|   92|   7|
|  a3|    1|   95|   8|
|  a6|    3|   99|   9|
|  a7|    3|   99|  10|
| a11|    3|  100|  11|
+----+-----+-----+----+

分区并排序，按班级分区并按成绩排序

spark.sql("select name, class, score, row_number() over(partition by class order by score) rank from scores").show()

+----+-----+-----+----+                                                         
|name|class|score|rank|
+----+-----+-----+----+
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   5|
| a11|    3|  100|   6|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
+----+-----+-----+----+
2.4.2、RANK跳跃排序

rank() over(order by score) as rank表示按 score升序的方式来排序，并得出排序结果的排名号。

这个函数求出来的排名结果可以并列（并列第一/并列第二），并列排名之后的排名将是并列的排名加上并列数

简单说每个人只有一种排名，然后出现两个并列第一名的情况，这时候排在两个第一名后面的人将是第三名，也就是没有了第二名，但是有两个第一名

●示例2
按成绩跳跃排序

spark.sql("select name, class, score, rank() over(order by score) rank from scores").show()

结果如下所示：

+----+-----+-----+----+
|name|class|score|rank|
+----+-----+-----+----+
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
|  a4|    2|   74|   3|
| a10|    3|   78|   4|
|  a2|    1|   78|   4|
|  a1|    1|   80|   6|
|  a5|    2|   92|   7|
|  a3|    1|   95|   8|
|  a6|    3|   99|   9|
|  a7|    3|   99|   9|
| a11|    3|  100|  11|
+----+-----+-----+----+

按班级分区，并按成绩排序

spark.sql("select name, class, score, rank() over(partition by class order by score) rank from scores").show()

结果如下所示：

+----+-----+-----+----+                                                         
|name|class|score|rank|
+----+-----+-----+----+
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   4|
| a11|    3|  100|   6|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
+----+-----+-----+----+
2.4.3、DENSE_RANK连续排序

dense_rank() over(order by score) as dense_rank 表示按score 升序的方式来排序，并得出排序结果的排名号。

这个函数并列排名之后的排名是并列排名加１

简单说每个人只有一种排名，然后出现两个并列第一名的情况，这时候排在两个第一名后面的人将是第二名，也就是两个第一名，一个第二名

●示例3
按成绩连续排序

spark.sql("select name, class, score, dense_rank() over(order by score) rank from scores").show()

结果如下所示：

+----+-----+-----+----+
|name|class|score|rank|
+----+-----+-----+----+
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
|  a4|    2|   74|   3|
|  a2|    1|   78|   4|
| a10|    3|   78|   4|
|  a1|    1|   80|   5|
|  a5|    2|   92|   6|
|  a3|    1|   95|   7|
|  a6|    3|   99|   8|
|  a7|    3|   99|   8|
| a11|    3|  100|   9|
+----+-----+-----+----+

按班级分区，并按照成绩排序

spark.sql("select name, class, score, dense_rank() over(partition by class order by score) rank from scores").show()

结果如下：

+----+-----+-----+----+                                                         
|name|class|score|rank|
+----+-----+-----+----+
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   4|
| a11|    3|  100|   5|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
+----+-----+-----+----+
2.4.4、NTILE分组排名[了解]

ntile(6) over(order by score)as ntile表示按 score 升序的方式来排序，然后 6 等分成 6 个组，并显示所在组的序号。

●示例4
按成绩连续排序

spark.sql("select name, class, score, ntile(6) over(order by score) rank from scores").show()

结果如下所示：

+----+-----+-----+----+
|name|class|score|rank|
+----+-----+-----+----+
|  a8|    3|   45|   1|
|  a9|    3|   55|   1|
|  a4|    2|   74|   2|
|  a2|    1|   78|   2|
| a10|    3|   78|   3|
|  a1|    1|   80|   3|
|  a5|    2|   92|   4|
|  a3|    1|   95|   4|
|  a6|    3|   99|   5|
|  a7|    3|   99|   5|
| a11|    3|  100|   6|
+----+-----+-----+----+

按班级分区，并按照成绩排序

spark.sql("select name, class, score, ntile(6) over(partition by class order by score) rank from scores").show()

结果如下：

+----+-----+-----+----+                                                         
|name|class|score|rank|
+----+-----+-----+----+
|  a2|    1|   78|   1|
|  a1|    1|   80|   2|
|  a3|    1|   95|   3|
|  a8|    3|   45|   1|
|  a9|    3|   55|   2|
| a10|    3|   78|   3|
|  a6|    3|   99|   4|
|  a7|    3|   99|   5|
| a11|    3|  100|   6|
|  a4|    2|   74|   1|
|  a5|    2|   92|   2|
+----+-----+-----+----+

好了，以上内容就到这里了。看完本篇文章之后，有没有学会自定义函数和开窗函数的使用呢。你学到了吗。 欢迎路过的朋友关注小编哦。各位朋友关注点赞是小编坚持下去的动力。小编会继续为大家分享更多的知识哦~~~。

我是DJ丶小哪吒。是一名互联网行业的工具人，小编的座右铭：“我不生产代码，我只做代码的搬运工”…哈哈哈，我们下期见哦，Bye~

要想青春不留遗憾，小伙必须敢想敢干
小哪吒的BD
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Oracle数据库学习
m0_68493458的博客
06-08 1030
SQL语句,数据库操作
spark、hive中窗口函数实现原理复盘
xiaoluobutou的专栏
02-09 460
这部分就是over里面的内容了里面也有三部分order by前两部分就是把数据分桶然后桶内排序，排好了序才能很好的定位出你需要向前或者向后取哪些数据来参与计算。这第三部分就是确定你需要哪些数据了。spark提供了两种方式一种是ROWS BETWEEN也就是按照距离来取例如ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW就是取从最开始到当前这一条数据，row_number()这个函数就是这样取的。
大数据培训-Flink面试知识分享
weixin_45695430的博客
03-29 923
以下文章来源于大数据左右手 ，作者左右 一. Flink 提交系列 1. Flink怎么提交? Local模式 JobManager 和 TaskManager 共用一个 JVM,只需要jdk支持，单节点运行，主要用来调试。 Standlone模式 Standlone 是Flink自带的一个分布式集群，它不依赖其他的资源调度框架、不依赖yarn 等。充当Master角色的是JobManager。充当Slave/Worker角色是TaskManager Yarn 模式 2. Fl.
linux和shell
weixin_45898374的博客
04-18 717
whatis 加其他命令=查看其他命令用法 pwd 返回当前工作目录 ls列出当前目录内容，有哪些文件 ls -l 显示详细信息 ll ls -l -a 显示隐藏文件（以.开头） ls -l -a -h cd + 目录名 进文件 cd.. 返回上级目录 pwd 显示当前目录 cp复制 文件 cp a.txt b.txt 文件夹(目录）cp -r less 当终端有大量内容输出时可帮助仔细查看 head -n 2 a.txt 查看开头两行 tail -n ...
【干货】你不可不知的 Greenplum实施与运维最佳实践
murkey的专栏
04-18 1344
在近期结束的Pivotal全球数据路演中，我们的大数据架构师为大家介绍了很多Greenplum 的宝贵经验和最佳实践。为了给大家提供更好的参阅信息，我们系统地整理了这篇干货长文与大家分享。 项目经验分享 在为诸多客户做项目实施的过程中，我们会总结了一些好的经验，有时我们也根据多方面需求尝试开发一些通用命令。我们有很多好用的经验总结，这些经验体现了Pivotal专业服务的价值，本次选择了2个命令...
SPARK实现单字段窗口函数
10-28
在SPARK中实现对单字段分区，对单字段排序，进行窗口函数ROWNUMBER以及LIMIT
Spark SQL 自定义函数、开窗函数
最慢的步伐不是跬步，而是徘徊；最快的脚步不是冲刺，而是坚持
04-22 8187
目录 RDD、DF、DS三者之间的转化 Spark SQL自定义函数 开窗函数的作用 开窗函数的分类 聚和开窗函数 排序聚和函数 聚和开窗函数 排序聚和函数 RANK跳跃排序 RDD、DF、DS三者之间的转化 转换成RDD .rdd 转换成DF .toDF() 转换成DS RDD->DS .toDS()...
Spark学习之路 （十九）SparkSQL的自定义函数UDF
weixin_30363509的博客
05-04 114
在Spark中，也支持Hive中的自定义函数。自定义函数大致可以分为三种： UDF(User-Defined-Function)，即最基本的自定义函数，类似to_char,to_date等 UDAF（User- Defined Aggregation Funcation），用户自定义聚合函数，类似在group by之后使用的sum,avg等 UDTF(User-Defined Table...
Spark之自定义UDF和UDAF，开窗函数的应用
lixinkuan的博客
10-13 759
一、概述 二、自定义UDF函数 可以自定义类实现UDFX接口。 package com.bjsxt.sparksql.udf_udaf; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import org.apache.spark.SparkConf; import org.a...
Spark SQL自定义函数UDF、UDAF以及开窗函数
寒暄的博客
08-06 245
UDF com.udf.AppUdf package com.udf import org.apache.spark.SparkConf import org.apache.spark.sql.{Row, SparkSession} import org.apache.spark.sql.types.{DataTypes, StructField} import scala.util.Random object AppUdf { def main(args: Array[String]):
spark-window:Spark 窗口函数的实验
06-05
火花窗 该项目旨在改进 Spark SQL 的窗口函数。 它目前正在进行中。 此实现需要 SPARK 1.4.0 提供的功能。 改进 与当前实现相比的优点是： 本机 Spark-SQL，当前实现仅依赖于 Hive UDAF。 新的实现使用 Spark SQL 聚合。 虽然仍然支持 Hive UDAF。 在运行案例（例如 BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW）和 UNBOUDED FOLLOWING 案例中，性能要好得多（10 倍）。 在单个窗口执行阶段处理所有帧规范的能力。 这一点改善了内存使用和处理。 许多暂存代码已从执行阶段移至“初始化”阶段。 增加优化机会。 AggregateEvaluation 样式优化可用于帧内处理。 钨也可能提供有趣的优化机会。 用法 准备好 SPARK 1.4.0 版本，并确保将 JARS 安装到本
SQL中的开窗函数详解可代替聚合函数使用
09-08
主要介绍了SQL中的开窗函数详解可代替聚合函数使用,本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
一篇文章弄懂Android自定义viewgroup的相关难点
01-05
目的在于教会大家到底如何自定义viewgroup，自定义布局和自定义测量到底如何写。很多网上随便搜搜的概念和流程图 这里不再过多描述了，建议大家看本文之前，先看看基本的自定义viewgroup流程，心中有个大概即可。...
三分钟教会你：如何设计一个功分器
01-20
很多书里都有功分器的介绍，个人十分推崇由清华大学主编的《微带电路》一书，读此书可以感觉到老一辈微波电路的拓荒前辈们严谨的作风，该书理论联系实际，讲解详实但又浅显易懂，对提升微波电路设计的感觉十分有用。...
一篇文章教会你理解Scrapy网络爬虫框架的工作原理和数据采集过程.docx
11-14
一篇文章教会你理解Scrapy网络爬虫框架的工作原理和数据采集过程.docx
一篇教会你写90%的shell脚本.docx
最新发布
03-16
shell脚本
一篇教会你写90%的shell脚本(入门小结)
09-14
主要介绍了一篇教会你写90%的shell脚本，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
数据分析（SQL）常见面试题（一）：开窗函数
weixin_42532898的博客
10-15 2137
一、什么是开窗函数 开窗函数/分析函数：over() 开窗函数也叫分析函数，有两类：一类是聚合开窗函数，一类是排序开窗函数。 开窗函数的调用格式为： 函数名(列名) OVER(partition by 列名 order by列名) 。 如果你没听说过开窗函数，看到上面开窗函数的调用方法，你可能还会有些疑惑。但只要你了解聚合函数，那么理解开窗函数就非常容易了。 我们知道聚合函数对一组值执行计算并返...
我以为我对Mysql索引很了解，直到我遇到了阿里的面试官
weixin_30522095的博客
07-09 3753
GitHub 4.8k Star 的Java工程师成神之路 ，不来了解一下吗? GitHub 4.8k Star 的Java工程师成神之路 ，真的不来了解一下吗? GitHub 4.8k Star 的Java工程师成神之路 ，真的确定不来了解一下吗? 本文来自一位不愿意透露姓名的粉丝投稿 相信很多人对于MySQL的索引都不陌生，索引(Index)是帮助MySQL高效获取数据的数据结构。 因为索引...
一篇教会你写90%的shell脚本
12-06
写一个shell脚本是一种自动化执行命令和任务的好方法。在使用shell脚本时，你可以更快地执行重复性任务，提高工作效率。下面是学习如何写90%的shell脚本的一些步骤： 首先，打开一个文本编辑器，比如说Atom或者Sublime Text。这样你可以开始编写你的脚本。在新建文件中，首先要指定使用哪种shell脚本语言。通常来说，我们使用`#!/bin/bash`来指定使用Bash。 接下来，要开始学习如何定义变量。在shell脚本中，使用变量可以方便地存储和使用数据。比如，你可以定义一个`name="John"`的变量。 然后，学习如何使用条件语句。条件语句允许你根据特定的条件执行不同的命令。比如，`if`语句可以根据一个条件来判断是否执行某个命令。 接着，学习如何使用循环语句。循环语句允许你重复执行一组命令，直到满足特定的条件为止。有`for`和`while`两种循环语句可以选择。 最后，学习如何使用函数。函数可以帮助你将一组命令封装起来，以便在需要时进行重复使用。 通过学习以上这些内容，你就可以掌握写90%的shell脚本所需的基本知识。当然，还有一些高级的内容，比如文件操作、管道和重定向等，这些内容可以让你的脚本更加强大和灵活。希望这些内容对你有所帮助，祝学习顺利！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值