Spark SQL操作之-函数汇总篇-上

最新推荐文章于 2024-06-18 08:45:00 发布
置顶 最新推荐文章于 2024-06-18 08:45:00 发布
阅读量2.4k 收藏 19
点赞数 1
分类专栏： Spark 大数据 Spark spark-sql dataset Spark SQL专栏 文章标签： Spark SQL 聚合函数 统计函数 正则
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coding_hello/article/details/90632259
版权

Spark SQL操作之-函数汇总篇-上

开头的胡扯

又懒了好久了，来一发。

环境说明

1. JDK 1.8
2. Spark 2.1

概要

跟所有的传统关系数据库一样，Spark SQL提供了许多内置函数方便处理数据。同时它也知道不可能满足广大吃瓜群众的胃口，毕竟业务千千万，所以也毫无意外的提供了用户自定义函数接口备用。窗口函数（或者叫分析函数）也是有的，看到有些人说会用窗口函数有多牛多牛，真是扯。就是个带范围的函数而已。接下来都会示例说明。

内置函数详情

org.apache.spark.sql.functions

内置函数基本都在这个类里面。包括聚合函数，集合函数，日期时间函数，字符串函数，数学函数，排序函数，窗口函数以及其他一些杂七杂八的函数。看了下官方文档页面，count了一下关键字，大概299个函数。我擦，这么多函数写下来，我…好饿。就每个类别挑一丢丢写吧。

聚合函数

聚合函数里面有很多统计函数，像是皮尔逊系数，峰度，偏度，标准差，均值，求和，去重求和等；然后还有一些计数统计函数，如非去重计数，去重计数，近似去重计数。

scala> spark.range(1,10).registerTempTable("aaa")
　
scala> spark.sql("select * from aaa").show
+---+
| id|
+---+
|  1|
|  2|
|  3|
|  4|
|  5|
|  6|
|  7|
|  8|
|  9|
+---+
　
### variance是var_samp的别名 ###
scala> spark.sql("select id,id*2 as double_id from aaa").select(
     |   avg("id"),variance("id"),skewness("id"),kurtosis("id"),
     |   corr("id","double_id")).show
+-------+------------+------------+------------+-------------------+
|avg(id)|var_samp(id)|skewness(id)|kurtosis(id)|corr(id, double_id)|
+-------+------------+------------+------------+-------------------+
|    5.0|         7.5|         0.0|       -1.23|                1.0|
+-------+------------+------------+------------+-------------------+
　
scala> spark.sql("select id%3 as id from aaa").select(
     |   count("id"),countDistinct("id"),sum("id"),sumDistinct("id")
     | ).show
+---------+------------------+-------+----------------+
|count(id)|count(DISTINCT id)|sum(id)|sum(DISTINCT id)|
+---------+------------------+-------+----------------+
|        9|                 3|      9|               3|
+---------+------------------+-------+----------------+
　
scala> spark.sql("select id%3 as id from aaa").select(
     |   collect_set("id"), collect_list("id"), 
     |   sort_array(collect_list("id"))).show(false)
+---------------+---------------------------+----------------------------------+
|collect_set(id)|collect_list(id)           |sort_array(collect_list(id), true)|
+---------------+---------------------------+----------------------------------+
|[0, 1, 2]      |[1, 2, 0, 1, 2, 0, 1, 2, 0]|[0, 0, 0, 1, 1, 1, 2, 2, 2]       |
+---------------+---------------------------+----------------------------------+

集合函数

集合函数用的多的可能就是一行转多行那点东西了

scala> val df = spark.createDataset(Seq(
     |   ("aaa",List(1,2,3)),("bbb",List(3,4))) 
df: org.apache.spark.sql.DataFrame = [key1: string, key2: array<int>]
　
scala> df.show
+----+---------+
|key1|     key2|
+----+---------+
| aaa|[1, 2, 3]|
| bbb|   [3, 4]|
+----+---------+
　
### 注意，要转多行了噢 ###
scala> df.select($"key1", explode($"key2").as("explode_col")).show
+----+-----------+
|key1|explode_col|
+----+-----------+
| aaa|          1|
| aaa|          2|
| aaa|          3|
| bbb|          3|
| bbb|          4|
+----+-----------+
　
### 这里还有个posexplode函数，可以在拆分列的时候把原来的位置信息列出来
scala> df.select($"key1", posexplode($"key2").as("key2_pos"::"key2_val"::Nil)).show
+----+--------+--------+
|key1|key2_pos|key2_val|
+----+--------+--------+
| aaa|       0|       1|
| aaa|       1|       2|
| aaa|       2|       3|
| bbb|       0|       3|
| bbb|       1|       4|
+----+--------+--------+

另外就是有些处理json数据的函数，也可以了解一下

scala> val df = spark.createDataset(Seq(
     |   ("aaa",1,2),("bbb",3,4),("ccc",3,5),("bbb",4, 6))).toDF("key1","key2","key3")
df: org.apache.spark.sql.DataFrame = [key1: string, key2: int ... 1 more field]
　
scala> df.show
+----+----+----+
|key1|key2|key3|
+----+----+----+
| aaa|   1|   2|
| bbb|   3|   4|
| ccc|   3|   5|
| bbb|   4|   6|
+----+----+----+
　
### 按列名转成json格式记录 ###
scala> val df_json=df.select(to_json(struct($"key1",$"key2",$"key3")).as("json_key")).cache
df_json: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [json_key: string]
　
scala> df_json.show(false)
+--------------------------------+
|json_key                        |
+--------------------------------+
|{"key1":"aaa","key2":1,"key3":2}|
|{"key1":"bbb","key2":3,"key3":4}|
|{"key1":"ccc","key2":3,"key3":5}|
|{"key1":"bbb","key2":4,"key3":6}|
+--------------------------------+
　
### 反过来，如果是json格式数据，如何转回列###
scala> val df_json_2 = df_json.select(from_json($"json_key", new StructType().add("key1",StringType).add("key2",LongType).add("key3",LongType)).as("json_data")).cache
df_json_2: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [json_data: struct<key1: string, key2: bigint ... 1 more field>]
　
### 看起来还不行，还在一列里面 ###
scala> df_json_2.show
+---------+
|json_data|
+---------+
|[aaa,1,2]|
|[bbb,3,4]|
|[ccc,3,5]|
|[bbb,4,6]|
+---------+
　
### 嗯，这下就还原了 ###
scala> df_json_2.select($"json_data.key1".as("key1"), $"json_data.key2".as("key2"), $"json_data.key3".as("key3")).show
+----+----+----+
|key1|key2|key3|
+----+----+----+
| aaa|   1|   2|
| bbb|   3|   4|
| ccc|   3|   5|
| bbb|   4|   6|
+----+----+----+

时间处理函数

时间处理函数比较多，各种加减法，各种格式转换。最有意思的是，许多函数能同时支持date/timestamp/string三种类型，非常方便。

scala> val df = spark.sql("select current_date() as dt, current_timestamp() as ts, '2019-05-16 04:00:00' as tm_str").cache
df: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [dt: date, ts: timestamp ... 1 more field]
　
scala> df.printSchema
root
 |-- dt: date (nullable = false)
 |-- ts: timestamp (nullable = false)
 |-- tm_str: string (nullable = false)
　
scala> df.show(false)
+----------+-----------------------+-------------------+
|dt        |ts                     |tm_str             |
+----------+-----------------------+-------------------+
|2019-05-16|2019-05-16 05:24:01.874|2019-05-16 04:00:00|
+----------+-----------------------+-------------------+
　
scala> df.select(dayofyear($"dt"), dayofyear($"ts"), dayofyear($"tm_str")).show
+-------------+-------------+-----------------+
|dayofyear(dt)|dayofyear(ts)|dayofyear(tm_str)|
+-------------+-------------+-----------------+
|          136|          136|              136|
+-------------+-------------+-----------------+
　
scala> df.select(hour($"dt"), hour($"ts"), hour($"tm_str")).show
+--------+--------+------------+
|hour(dt)|hour(ts)|hour(tm_str)|
+--------+--------+------------+
|       0|       5|           4|
+--------+--------+------------+
　
### dt字段是date类型，ts字段是timestamp类型，都能直接add_months ###
### ts字段是timestamp类型，ts_str是string类型，也都能直接date_format ###
scala> df.select(datediff(add_months($"dt",2), add_months($"ts",1)).as("diff_days"),
     |   date_format($"ts","HH:mm:SS"), date_format($"tm_str","MM/dd/YYYY")).show
+---------+-------------------------+-------------------------------+
|diff_days|date_format(ts, HH:mm:SS)|date_format(tm_str, MM/dd/YYYY)|
+---------+-------------------------+-------------------------------+
|       30|                05:24:874|                     05/16/2019|
+---------+-------------------------+-------------------------------+

字符串处理函数

字符串处理函数功能挺多，这里列出一部分的用法。包括子串查找，正则匹配，文本相似度等。

scala> val df = spark.createDataset(Seq(("aaa"),("abc"),("aabbc"),("ccc"))).toDF("key1")
df: org.apache.spark.sql.DataFrame = [key1: string]
　
### 可以看到instr和locate的功能是一样的。locate多了个指定位置开始定位的版本
scala> df.select(instr($"key1","b"), locate("b", $"key1"), locate("b",$"key1",3)).show
+--------------+------------------+------------------+
|instr(key1, b)|locate(b, key1, 1)|locate(b, key1, 3)|
+--------------+------------------+------------------+
|             0|                 0|                 0|
|             2|                 2|                 0|
|             3|                 3|                 3|
|             0|                 0|                 0|
+--------------+------------------+------------------+
　
### 官方文档在介绍instr时明确说了两个参数有一个为null则返回结果为null，但是locate的说明里没有提
### 实践证明，行为还是一样的。
scala> df.select(instr($"key1",null),locate(null,$"key1")).show
+-----------------+---------------------+
|instr(key1, NULL)|locate(NULL, key1, 1)|
+-----------------+---------------------+
|             null|                 null|
|             null|                 null|
|             null|                 null|
|             null|                 null|
+-----------------+---------------------+
　
### 居然还有format_string这种函数在sql里面出现
scala> df.select(format_string("wahaha, value is [%s]", $"key1")).show(false)
+------------------------------------------+
|format_string(wahaha, value is [%s], key1)|
+------------------------------------------+
|wahaha, value is [aaa]                    |
|wahaha, value is [abc]                    |
|wahaha, value is [aabbc]                  |
|wahaha, value is [ccc]                    |
+------------------------------------------+
　
### 有个translate函数，用来做单个字符的翻译，注意，是单个字符。
### 尽管看起来有些像字符串替换，但本质上是为了提供编码翻译的功能
scala> df.select($"key1", translate($"key1","abc","123")).show
+-----+-------------------------+
| key1|translate(key1, abc, 123)|
+-----+-------------------------+
|  aaa|                      111|
|  abc|                      123|
|aabbc|                    11223|
|  ccc|                      333|
+-----+-------------------------+
　
### 正则也是支持的，看下正则提取和正则替换
### 参数中的正则表达式和提取的group的概念，不明白的就需要自行百度了
scala> df.select($"key1", regexp_extract($"key1", "b(.*?)c",1 )).show
+-----+--------------------------------+
| key1|regexp_extract(key1, b(.*?)c, 1)|
+-----+--------------------------------+
|  aaa|                                |
|  abc|                                |
|aabbc|                               b|
|  ccc|                                |
+-----+--------------------------------+
　
### 把连续的两个a或者三个a替换成"111_"
scala> df.select($"key1", regexp_replace($"key1", "a{2,3}","111_")).show
+-----+----------------------------------+
| key1|regexp_replace(key1, a{2,3}, 111_)|
+-----+----------------------------------+
|  aaa|                              111_|
|  abc|                               abc|
|aabbc|                           111_bbc|
|  ccc|                               ccc|
+-----+----------------------------------+
　
### 还有两个处理相似度的函数，可以了解一下
### 一个是levenshtein函数，就是求编辑距离
scala> df.select(levenshtein(lit("aaa"),lit("aba")), levenshtein(lit("aaa"),lit("bab"))).limit(1).show
+---------------------+---------------------+
|levenshtein(aaa, aba)|levenshtein(aaa, bab)|
+---------------------+---------------------+
|                    1|                    2|
+---------------------+---------------------+
　
### 另一个是soundex函数，这个函数从没用过。说是按字符串的发音来编码.
### 功能是把字符串编码成4个字节，发音相似的词编码会相似，真会玩~~
scala> df.select(soundex(lit("hello")), soundex(lit("hollow")
   |   ), soundex(lit("how"))).limit(1).show
+--------------+---------------+------------+
|soundex(hello)|soundex(hollow)|soundex(how)|
+--------------+---------------+------------+
|          H400|           H400|        H000|
+--------------+---------------+------------+
　
###　另外还有些奇葩函数，不知道老外们要内置这种函数到底是有多常用。。。
### initcap: 把字段的第一个字母变大写
### ascii: 计算字段的第一个字母的ascii码值
### lpad,rpad：在字符串左右两侧补字符，看着想对齐的样子～
scala> df.select($"key1", initcap($"key1"), ascii($"key1"),lpad($"key1", 5,"*")).show
+-----+-------------+-----------+----------------+
| key1|initcap(key1)|ascii(key1)|lpad(key1, 5, *)|
+-----+-------------+-----------+----------------+
|  aaa|          Aaa|         97|           **aaa|
|  abc|          Abc|         97|           **abc|
|aabbc|        Aabbc|         97|           aabbc|
|  ccc|          Ccc|         99|           **ccc|
+-----+-------------+-----------+----------------+

一些不常见的跨列处理的函数

嗯，这一部分是某些奇奇怪怪的用法的函数，不常用，但需要的时候又挺有用哒。比如，要找出给定的几个列中的第一个非空值，是coalesce()函数。

scala> val df_1 = spark.createDataset(Seq((null,"2"),("0",null),(null,null),("4", "5"))).toDF("key1","key2")
df_1: org.apache.spark.sql.DataFrame = [key1: string, key2: string]
　
### 造点NaN的字段
scala> val df = df_1.withColumn("key3",sqrt(rand()-0.4)).cache
df: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [key1: string, key2: string ... 1 more field]
　
scala> df.show
+----+----+------------------+
|key1|key2|              key3|
+----+----+------------------+
|null|   2|               NaN|
|   0|null|               NaN|
|null|null|0.4865678556424092|
|   4|   5|0.7648302408726048|
+----+----+------------------+
　
scala> df.select($"*",coalesce($"key1",$"key2",$"key3")).show
+----+----+------------------+--------------------------+
|key1|key2|              key3|coalesce(key1, key2, key3)|
+----+----+------------------+--------------------------+
|null|   2|               NaN|                         2|
|   0|null|               NaN|                         0|
|null|null|0.4865678556424092|        0.4865678556424092|
|   4|   5|0.7648302408726048|                         4|
+----+----+------------------+--------------------------+

### 注意一下，和上面的示例对比，这里有这里说明了两个问题
### 1. coalesce函数是找给定顺序的字段的第一个非空值，字段顺序变化会导致结果不一样
### 2. 找的是第一个非空值，NaN也是非空的
scala> df.select($"*",coalesce($"key3",$"key1",$"key2")).show
+----+----+------------------+--------------------------+
|key1|key2|              key3|coalesce(key3, key1, key2)|
+----+----+------------------+--------------------------+
|null|   2|               NaN|                       NaN|
|   0|null|               NaN|                       NaN|
|null|null|0.4865678556424092|        0.4865678556424092|
|   4|   5|0.7648302408726048|        0.7648302408726048|
+----+----+------------------+--------------------------+

对应于处理null值的coalesce函数，Spark SQL还提供了nanvl函数来处理NaN值

### coalesce函数是支持多列的，但是nanvl仅支持两列
scala> df.select($"key2",$"key3",nanvl($"key2",$"key3")).show
+----+------------------+-----------------+
|key2|              key3|nanvl(key2, key3)|
+----+------------------+-----------------+
|   2|               NaN|              2.0|
|null|               NaN|             null|
|null|0.4865678556424092|             null|
|   5|0.7648302408726048|              5.0|
+----+------------------+-----------------+

还有类似greatest(),least()函数这种返回给定的多个列中的最大值，最小值的函数。

### greatest()函数，找出给定所有列中的最大值，同样的，NaN有些特别
scala> df.select($"*",greatest($"key1".cast("double"),$"key2".cast("double"),$"key3")).show
+----+----+------------------+----------------------------------------------------------+
|key1|key2|              key3|greatest(CAST(key1 AS DOUBLE), CAST(key2 AS DOUBLE), key3)|
+----+----+------------------+----------------------------------------------------------+
|null|   2|               NaN|                                                       NaN|
|   0|null|               NaN|                                                       NaN|
|null|null|0.4865678556424092|                                        0.4865678556424092|
|   4|   5|0.7648302408726048|                                                       5.0|
+----+----+------------------+----------------------------------------------------------+
　
### 找最小值时，NaN就不见了，可知NaN是被当成一个极大值处理的
scala> df.select($"*",least($"key1".cast("double"),$"key2".cast("double"),$"key3")).show
+----+----+------------------+-------------------------------------------------------+
|key1|key2|              key3|least(CAST(key1 AS DOUBLE), CAST(key2 AS DOUBLE), key3)|
+----+----+------------------+-------------------------------------------------------+
|null|   2|               NaN|                                                    2.0|
|   0|null|               NaN|                                                    0.0|
|null|null|0.4865678556424092|                                     0.4865678556424092|
|   4|   5|0.7648302408726048|                                     0.7648302408726048|
+----+----+------------------+-------------------------------------------------------+

SQL界的if…else

最后再提一个when函数吧，是个条件函数，简单实用

scala> df.select($"key1", when(isnull($"key1"), rand()).when($"key1"<3,5).otherwise(10).as("new_key1")).show
+----+-------------------+
|key1|           new_key1|
+----+-------------------+
|null| 0.8093967624263269|
|   0|                5.0|
|null|0.11877309710543482|
|   4|               10.0|
+----+-------------------+

差不多就这些吧，窗口函数和自定义函数下一篇再写。果断把标题从《函数汇总篇》改为《函数汇总篇-上》，就是这么机智~

走了走了，上班要迟到了~~


喜欢这些内容的话，可以关注下公众号哈~
微信搜索公众号：代码汪
野男孩
关注
  • 1
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spark sql是如何比较复杂数据类型的？该如何利用呢？
xiaoluobutou的专栏
02-15 521
大家对简单数据类型的比较都很清楚，但是针对array、map、struct这些复杂类型，spark sql是否支持比较呢？都是怎么比较的？我们该怎么利用呢？
Spark SQL之内置函数
威少（微笑）
06-19 720
目录 一：DataFrame的内置函数作用 二：DataFram的的内置函数等 三：案例实战 四：混合函数 一：DataFrame的内置函数作用 DataFrame的函数并会执行后立即返回一个结果值，而是返回一个Column对象，用于在并行作业中进行求值 Column可以用在DataFrame的操作之中，比如select，filter，groupBy等。函数的输入值，也可以是C...
Spark SQL limit 函数第二个参数无法解析
T_Y_F_的博客
02-06 859
Spark SQL limit 函数第二个参数无法解析
Spark SQL空值处理函数 coalesce
修破立生
01-21 5159
函数说明 coalesce这个英文单词是联合，合并的意思。 用于字段空值的处理，譬如，希望把空值转为0。 使用方法 coalesce(field1, value)：意思是如果field1不为null, 则返回field1本身的值，否则，返回value； 如： select coalesce(field1, 0), 当field1为null, 则返回0。 coalesce可以从左到右依次判定多个字段的值，如下： coalesce(field1, field2, field3, value): 字段的个
Spark SQL的基本使用和操作
最新发布
qq_66369005的博客
06-18 1449
​ Spark SQL是一个用于结构化数据处理的Spark组件。所谓结构化数据，是指具有Schema信息的数据，例如JSON、Parquet、Avro、CSV格式的数据。与基础的Spark RDD API不同，Spark SQL提供了对结构化数据的查询和计算接口。将SQL查询与Spark应用程序无缝组合​ Spark SQL允许使用SQL或熟悉的API在Spark程序中查询结构化数据。
sparksql常用计算函数
Moonset1995的博客
01-14 5039
常用函数
[Spark-SQL 2.1] create view as select中NVL函数异常
qq_37771475的博客
12-20 1359
环境： Hive client (version 1.2.1) Spark version 2.1.1.2.6.1.0-129 现有一测试表datadev.t_student，字段如下 col_name data_type comment id string score int 此时，我们在Spark-SQL中执行以下命令，会报错。 create view datadev.t_student_view as select NVL(id, ..
spark-sql入门
01-12
数据清洗和预处理也是Spark SQL的重要应用之一。这可能涉及到处理缺失值、转换数据类型、过滤异常值等步骤。DataFrame提供了一系列的函数，如`na.drop()`用于删除含有缺失值的行，`cast()`用于转换列的数据类型。 ...
利用Spark SQL分析传统数据源的通用步骤.pdf
09-19
Spark SQL支持多种数据处理操作，如数据过滤、数据聚合、数据排序等。例如，我们可以使用SELECT语句对数据进行过滤： ```sql SELECT * FROM mytable WHERE age > 18; ``` 这样，我们就可以获得年龄大于18岁的用户...
编程资料-汇总_编程资料汇总_
10-01
编程资料的汇总是一个重要的资源集合，它通常包含了各种编程语言、框架、工具和技术的教程、指南、手册和示例代码，旨在帮助初学者和经验丰富的程序员提升技能、解决问题和了解最新趋势。在这个压缩包中，我们看到有...
Python大数据处理库 PySpark实战-源代码.rar
04-15
在大数据处理领域，PySpark是Python编程语言与Apache Spark相结合的重要工具，它为开发者提供了便捷的方式来操作和分析大规模数据。PySpark是Spark的Python API，它允许Python开发者利用Spark的强大功能，而无需深入...
7.spark任务设计1
08-08
本项目涉及的是一个基于Spark的数仓任务设计，主要目的是从原始数据中...综上所述，这个Spark任务设计涵盖了数据仓库、大数据处理、Spark SQL、任务调度、数据迁移和分析等多个关键领域，体现了大数据分析的完整流程。
spark sql多维分析优化——提高读取文件的并行度
xiaoluobutou的专栏
02-23 1068
知识技术不能留盲点，尤其是正在用的关键技术。盲点、死穴，不花时间去研究，总会绊你一脚。主动学习，保持激情，不断提高～
Spark：coalesce()方法和repartition()方法
不花的花和尚的博客
05-23 1315
https://blog.csdn.net/olizxq/article/details/82808412
Spark SQL 内置函数
梁辰兴的博客
06-16 2637
Spark SQL内置了大量的函数，位于API org.apache.spark.sql.functions中。这些函数主要分为10类：UDF函数、聚合函数、日期函数、排序函数、非聚合函数、数学函数、混杂函数、窗口函数、字符串函数、集合函数，大部分函数与Hive中相同。当Spark SQL提供的内置函数不能满足查询需求时，用户可以根据自己的业务编写自定义函数（User Defined Functions，UDF），然后在Spark SQL中调用。
udf,udaf,udtf之间的区别
热门推荐
流的博客
04-27 1万+
1、UDF：用户定义（普通）函数，只对单行数值产生作用； 继承UDF类，添加方法 evaluate() /** * @function 自定义UDF统计最小值 * @author John * */ public class Min extends UDF { public Double evaluate(Double a, Do...
Spark Sql 函数
TPH_BETTER.的博客
11-29 7499
Spark Sql 函数 字符串函数 字符串截取 字符串截取之substring_index函数 substring_index(str,delim,count) 其中：str:要处理的字符串；delim:分隔符；count:计数 ①count为正数的情况下，从左往右数，第count个分隔符的左边的全部内容 例子：str=www.baidu.com substring_index(str,’.’,1) 结果是：www substring_index(str,’.’,2) 结果是：www.ba
Spark SQL 函数全集
weixin_43946446的博客
06-29 1380
org.apache.spark.sql.functions是一个Object，提供了约两百多个函数。 大部分函数与Hive的差不多。 除UDF函数，均可在spark-sql中直接使用。 经过import org.apache.spark.sql.functions._ ，也可以用于Dataframe，Dataset。 version 2.3.0 大部分支持Column的函数也支持String类型的列名。这些函数的返回类型基本都是Column。 函数很多，都在下面了。 聚合函数 approx_c...
spark sql操作之-函数汇总篇-中
03-16
本篇文章主要介绍了Spark SQL中的函数汇总，包括数学函数、字符串函数、日期函数、聚合函数等。其中，数学函数包括常见的加减乘除、取余、绝对值、平方根、指数等；字符串函数包括字符串连接、截取、替换、转换大小写等；日期函数包括日期格式化、日期加减、日期比较等；聚合函数包括求和、平均值、最大值、最小值、计数等。这些函数可以帮助我们更方便地处理数据，提高数据处理效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值