spark 常用类，常用函数，spark DataFrame函数，funcation库

Spark-DataFrame常用函数

Column类

• cast(to:String):Column

  对指定的列进行数据类型转换，例如 :将一个字符串的 money列进行转换

  col("money").cast(DoubleType)
  

• otherwise(value:Any):Column

  该函数通常跟在when()函数后面，通常用来用作条件判断，跟when函数进行结合，when相当于if，otherwise相当于else，例：我需要判断两个值那个大，如果第一个值更大就返回大，如果小就返回小，如果相等就返回相等

  ds.withColumn("compare",when(col("a") > col("b"),"大").when(col("a") < col("b"),"小").otherwise("相同"))
  

• as(alias:String):Column

  为列指定别名

  ds.select(col("a").as("b")) 
  

• over

  定义一个窗口列，用于开启窗口函数,例：根据id进行分组，求每个组中的最大值，并进行返回

  ds.withColumn("max_time",max("max_time").over(Window.partitionBy("id")))
  

• isNotNull

  判断列是是否不为空，不为空返回true，为空返回false,例：过滤出a列中不为空的数据

  ds.where(col("a").isNotNull)
  

• isNull

  如果当前列为空，则为True，否则为false 例：查询出a列为空的数据

  ds.where(col("a").isNull)
  

• between

  判断该值是否在指定的区间中，包括两边的值，例：我需要查找a列的值在1到3之间的,包括1和3，其他的不要

  ds.where(col("a").between(1,3))
  

• isin

  判断该值是否在指定列表中，在则为True,列：筛选出a列中的值含1，4，5的数据

  ds.where(col("a").isin(1,4,5))
  

• isNaN

  如果当前两列为NaN，则为True

• or

  布尔运算符 or,条件满足一个就返回true，都不满足则为false ,例：查询出a列等于b列的值，或a列等于c列的值的数据

  ds.where(col("a") === col("b") or col("a") === col("c"))
  

• and

  布尔运算 和,，条件都满足返回true，否则返回false,例，查询a列中大于5的小于10的数据

  ds.where(col("a") > 5 and  col("a") < 10)
  

• +

  表示这个列和另外一个列的和

  ds.select(col("a") + col("b"))
  

• -

  从这个表达式中减去另一个表达式

  ds.select(col("a") - col("b"))
  

• =!=

  表示不等于 例：a列中不为0的

  ds.where(col("a") =!= 0)
  

• ===

  表示等于 例：a列中等于0的

  ds.where(col("a") === 0)
  

• desc

  返回排序使用降序排序

• asc

  返回排序使用升序排序

• last

  返回最后一个非空值

• max

  返回表达式的最大值

• min

  返回表达式的最小子

• mean

  返回表达式的平均值

• sum

  返回表达式中所有值得和

functions类

• date_format( dateExpr:Column，format:String):Column

  将参数1时间，转换为参数2格式的时间类型

• currente_date ()：Column

  获取当前时间 格式为：2023-02-16

• asc (columnName):Column

  根据列的升序返回排序表达式，跟排序函数进行搭配使用比如orderBy(asc(“colName”))

• desc(columnName):Column

  根据列的降序升序返回排序表达式，跟排序函数进行搭配使用比如orderBy(asc(“colName”))

• lit ( literal: Any): Column

  创建一个具有literal(文字值)的列

• col(colName:String):Column

  根据指定的列名返回一个列

• isnull(e:Column):Column

  如果列为空，则返回true

• when(condition:Column,valueAny):Column

  计算条件列表并返回多个可能的结果之一，如果末尾为定义else，则对不匹配的条件返回null

• year(e:Column):Column

  从给定日期/时间戳提取年份为整数

• month(e:Column)：Column

  从给定日期/时间戳提取月份为整数

• dayofmonth(e:Column):Column

  从给定的日期/时间戳/字符串中以整数形式提取月份中的天。

• hour(e:Column):Column

  从给定日期/时间戳/字符串中以整数形式提取小时

• sum(columnName:String):Column

  聚合函数，对组中元素进行求和

• date_sub(start:Column,days:int)

  返回指定start日期的前days天

• date_add(str:col,n:int)

  返回指定日期的后n天

• max(col)

  聚合函数：根据分组获取组中最大的元素

• min(col)

  聚合函数:根据分组获取组中最小的元素

• round

  round(col,n)给col中的小数四舍五入保留到n为 ，这里需要特别注意是如果是Double类型的话想去除小数部分，建议使用round后转换成整形，不然是无法去除小数点后面的0的

• countDistinct

  countDistinct(col:String ,colString*) 聚合函数返回组内不同项的数量。

• sumDistinct

  聚合函数返回表达式中不同值的和

• first

  first(col) 返回组中第一个值

• avg(col)

  聚合函数返回组中值得平均数

• collect_list(col)

  聚合函数：返回具有重复对象的列表，注意：该函数是不确定的，因为收集结果的顺序取决于行顺序，而行顺序在shuffle后可能是不确定的。

• collect_set(e:column)

  聚合函数：返回一组消除重复元素的对象。注意：该函数是不确定的，因为收集结果的顺序取决于行顺序，而行顺序在shuffle后可能是不确定的。

• count(e:column)

  聚合函数：返回组中元素的个数

• lag

  lag(col,n，def) 窗口函数：返回当前行前行前n行数的值，如果当前行前n行数小于当前行前面的行数则返回def值

• lead

  lead(col, n, def)窗口函数：返回当前行后n行函数的值，如果当前行前n行数小于当前行前面的行数则返回def值.

• first_value

  取分组内排序后，截止到当前行，第一个值

• last_valu

  取分组内排序后，截止当前行，最后一个值

• rank

  在每个分组中，为每行分配一个从1开始的序列号，考虑重复，挤占后续位置；

• row_number

  在每个分组中，为每行分配一个从1开始的唯一序列号，递增，不考虑重复；

• dense_rank

  在每个分组中，为每行分配一个从1开始的序列号，考虑重复，不挤占后续位置；

• concat_ws(sep:string, exprs:Column*)

  使用给定的分隔符将多个输入字符串列连接到一个字符长列中。

• coalesce(col *)

  返回第一个非空的列，可以传递多个列为参数

• isnan(col)

  如果列为NoN这返回true

• not(col)

  布尔表达式的反转

• rand(seed:long)

  生成一列的随机数，在0-1之间

• abs(col)

  计算数值的绝对值

• floor(col)

  向下取整

• length(e:col)

  计算字符串列的长度

• lower(e:Column)

  将字符串列转换为小写

• upper(e:Column)

  将字符串列转换为大写

• split(str:Column,pattern:String)

  将给定字符串列一指定字符串进行分割

• substring(str:Column,pos:Int,len:Int)

  将给定字符串列，从开始索引到结束索引，索引从1开始，包头不包维

• trim(e:Column)

  为指定字符串修建两端的空格

时间函数（重点）

• add_months(startDate:Column,numMonths:Int)

  返回startDate 后numMonts个月的日期

• current_date()

  查询当前的日期并返回

• current_timestamp()

  查询当前的时间戳并返回

• date_format()

  将日期/时间戳/字符串转换为由第二个参数给出的指定的格式的字符串值

• dateiff(end:Column,start:Column)

  返回从开始到结束的天数

• year(col)

  返回给定的日期/时间戳/字符串中提取年份为整数进行返回

• quarter(col)

  从给定的日期/时间戳/字符串中提取分钟为整数进行返回

• month(col)

  从给定的日期/时间戳/字符串中提取月份为整数

• dayofweek(col)

  从给定的日期/时间戳/字符串中提取星期几作为整数，周日为1，周六为7

• dayofmonth(col)

  提取月中天数

• dayofyear(col)

  返回年中天

• hour(col)

  从给定的时间做/日期/字符串中提取小时为整数返回

• last_day(col)

  返回给定日期所属月份的最后一天

• minute(e:Column)

  从给定的日期/时间戳/字符串中提取分钟作为整数。

• months_between(end:Column,Start:Column)

  返回日期开始和结束之间的月份

• next_day(date:Column,dayOrWeek:String)

  返回日期列的值之后的第一个dayOrWeek

• second(e:Column)

  从给定日期/时间戳/字符串中提取秒作为整数

• weekofyear(e:Column)

  从给定的日期/时间戳/字符串中提取周数作为整数

• unix_timestamp()

  返回当前unix时间戳

• to_timestamp(s:Column，fmt:String)

  将指定格式的字符串列转换为timestamp时间类型

• to_date(e:Column，fmt:String)

  将列转换为具有指定格式的Date类型

• date_trunc(format:String,timestamp:Column)

  返回被截断为格式指定单位的时间戳

• window(timeColumn:Column,windowDuration:String,slideDuration:String,startTime:String)

  给定一个时间戳指定列，将行存储到一个或多个时间窗口中。窗口开始是包含的，但窗口结束是独占的，例如12:05将在窗口[12:05,12:10)中，但不在[12:00,12:05)中。窗口可以支持微秒精度。不支持以月为单位的窗口。下面的例子取一分钟窗口内的平均股价，每10秒计算一次，每小时5秒计算一次

  val df = ... // schema => timestamp: TimestampType, stockId: StringType, price: DoubleType
  df.groupBy(window($"timestamp", "1 minute", "10 seconds", "5 seconds"), $"stockId")
     .agg(mean("price"))
  
  //   09:00:05-09:01:05
  //   09:00:15-09:01:15
  //   09:00:25-09:01:25
  

• window(timeColumn:Column,windowDuration:String,slideDuration:String)

     val df = ... // schema => timestamp: TimestampType, stockId: StringType, price: DoubleType
     df.groupBy(window($"timestamp", "1 minute", "10 seconds"), $"stockId")
       .agg(mean("price"))
  
  //参数解释
  // timeColumn    作为按时间开窗的时间戳的列或表达式。时间列必须为timestamp类型。
  // windowDuration  指定窗口宽度的字符串，例如 "1 minute"
  // slideDuration  窗口滑动的间隔，必须小于等于windowDruation。
  //   09:00:00-09:01:00
  //   09:00:10-09:01:10
  //   09:00:20-09:01:20
  

• window(timeColumn:Column,windowDuration:String)

     val df = ... // schema => timestamp: TimestampType, stockId: StringType, price: DoubleType
     df.groupBy(window($"timestamp", "1 minute"), $"stockId")
       .agg(mean("price"))
  /*
     09:00:00-09:01:00
     09:01:00-09:02:00
     09:02:00-09:03:00
  */
  

• udaf(agg:Aggregator[IN,BUF,OUT])

  // 获取一个UserDefinedFunction,该函数包装给定的聚合器，以便可以用于非类型化Dataframes
  val agg = Aggregator[In,BUF,OUT]
  // 基于rdd声明一个udf
  val aggUDF = udaf(agg)
  val aggData = df.agg(aggUDF(col("colname")))
  
  // 声明一个基于agg的udf
  spark.udf.register("myAggName",udaf(agg))
  
  
  

Dataset类

• toDF()

  将指定强类型的数据集转换为DataFrame数据集，toDF(colNames:String*) 可以将列名称

• as[T]

  将Dataset中的泛型转换为指定类型，如：Dataset[Person] => .as[String] => Dataset[String]

• schema

  返回指定数据集的schema信息

  ds.schema
  // 返回StructType(StructField(id,LongType,true), StructField(name,StringType,true)
  

• printSchema()

  打印指定数据集的schema信息（列名和数据类型）

• columns :Array[String]

  以数组形式返回所有列名

• isEmpty:Boolean

  如果数据集为空则返回true

• withColumn (colName:String,col:Column) :DataFrame

  添加一个列，或替换一个具有相同名称的列，参数1：列名，参数2：一列数据

• withColumnRenamed(existingName:String,newName:String)

  对列重命名的函数

• dropDuplicates(col1：String,cols:Stirng*)

  对指定列进行联合去重

• where（条件：String）：Dataset

  根据指定字符串类型的条件进行过滤

• drop (colName:String) :DataFram

  返回一个删除指定列名的后的新的DataFram

• CreateTempView (viewName:String):Unit

  使用给定的名称创建一个本地临时视图。此临时视图的的生存期于创建此数据的SparkSession绑定,该表不能被相同表名的临时表替换

• createOrReplaceTempView(viewName:String)

  使用给定的名称创建一个本地临时视图。此临时视图的的生存期于创建此数据的SparkSession绑定，该表可以被相同表名的临时表替换

• groupBy(col1:String,cols:String*):RelationalGroupedDataset

  使用指定的列对数据集进行分组，以方便我们可以对它们运行聚合

• join(right:Dataset[_],usingColumn:String):DataFrame

  内连接right:右边的表，usingColumn要连接的列的名称，这一列必须存在两边

• join(right:Dataset[_],usingColumn:Seq[String]，joinType:String):DataFrame

  内连接right:右边的表，usingColumn要连接的列的名称，这一列必须存在两边,joinType参数添加join类型可以是left 也可以是right

• crossJoin(dataset)

  交叉连接，笛卡尔积

• cache()

  使用默认存储级别持久化此数据集

• printSchema()

  打印此数据集的字段结构信息

• show(num:Int,truncate:Boolean)

  以表格的形式显示数据集 num为展示的数据条数，truncate为是否截断多余的字符

• na

  返回一个处理缺失数据的dataframe的函数，删除包含空值得行。

• sort(sortCol:String,sortCols:String*)

  返回一个按指定列排序的新数据集，全部按升序排列。

• orderBy(sortCol:Stirng*)

  返回一个按指定列排序的新数据集，全部按升序排列。

• col(colName:String)

  根据列名选择列，并将其作为Column返回，还有apply(col:String) 和column(col:String)的作用和col都是一样的

• as(alias:String)

  返回一个带有别名的新的数据集

• select(cols:Column*)

  选择一组基于列的表达式，cols可以是列对象也可以是聚合函数

• filter(condition:Column)

  使用给定条件筛选行 peopleDs.filter("age > 15")

• where(condition:Column)

  使用给定条件筛选行 peopleDs.where("age > 15")

• groupBy(cols:Column*)

  使用指定的列对数据进行分组，以便我们可以使用agg函数对它们运行聚合

• rollup(cols:Column*)

  使用指定的列为当前数据集创建多维汇总，以便对其运行聚合。

• cube(cols:Column*)

  使用指定的列为当前数据集创建多维数据集，这样我们就

• limit(n:Int)

  通过取前n行返回一个型的数据集

• union(other:Dataset)

  将两个数据集进行联合,该函数通过位置进行解析,该函数没有去重效果，需要手动指定词有distinct的作用

• unionByName(other:Dataset)

  将两个数据集进行联合,该函数通过字段名进行解析，并联合，该函数没有去重效果，需要手动指定词有distinct的作用，列以第一个数据集中的为主

• intersect(other:Dataset)

  交集，返回两个数据都包含的行，返回一个新的数据集

• except(other:Dataset)

  差集，返回有这个数据没有另外一个数据集的一个型的数据集

• sampley(fraction:Double,seedLong)

  通过使用用户提供的种子对部分行进行采样（不进行替换），返回一个新的数据集。参数fraction要生成数据的百分比，这并不保证提供给定数据集的精确计数的部分。

• randomSplit(weight)

  使用提供的权重随机分割此数据集。weights表示分割的权重，如果他们的和不等于1,将被规范化。

• explode(input:Column*)

  将输入数组或集合由列转换成行

• first()

  返回第一行数据集

• tail(n:Int)

  返回此数据集中最后n行

• write

  将非流数据集保存到外部存储的接口

• collect()

  返回包含此数据集中所有行的数组

• count()

  返回数据集的行数

• repartition(numPartitions:Int)

  返回分区数量是numPartitions的一个数据集

• distinct()

  根据所有列进行去重

• persist()

  持久化此数据集，参数可以设置存储级别，内存，磁盘

• cache()

  持久化此数据集

• checkpoint()

  检查点可以斩断RDD的血缘性（依赖性）

• coalesce(numPartitions :Int)

  指定分区数返回一个新的Dataset，通常可以用来优化写入时的小文件（写入时候产生多少小文件根据分区指定），在写入时候调整该分区不会影响shuffle的执行。

• repartition(numPartition:Int)

  和coalesce函数有类似的作用

DataFrameWriter类

• partitionBy(colName:String) :DataFrame

  根据文件系统上的给定列对输出进行分区，如果指定了，输出将指定在该文件系统上的分区中，比如hive中的分区

• bucketBy(numBuckets:Int,colName:String,colName:String*)

  按照指定字段进行分桶，numbuckets为分桶数

• saveAsTable(tableName:String):Unit

  保存DataFrame的内容为指定的表，如果表不存在，则会根据mode函数指定的保存模式默认抛出异常，当表不存在的时候创建表

• mode(saveMode):DataFrameWriter

  指定当数据或表已经存在时候的行为。

  选项包括：

  overwrite:覆盖已有数据

  append:追加数据

  ignore：忽略操作

  error：默认选项，在运行时抛出异常

• jdbc(url:String,table:String,connectionProperties: Properties)

  通过jdbc将DataFrame的内容保存到外部数据库表中。在表已经存在于外部数据库的情况下，次函数的行为取决于mode函数指定的保存模式（默认抛出异常）

• option(key:String,value:String)

  添加配置选项，不区分大小写

• save(path:String)

  将DataFrame的数据内容保存到指定路径

• insertInto(tableName:String)

  将DataFrame的内容插入到指定的表。它要求DataFrame的schema于表的schema相同

• json(path:String)

  将指定格式以json的格式保存到指定路径

SparkSession类

• sql(sqlTest)

  使用spark执行sql查询，将结果作为DataFrame返回。

• read

  用于读取非流数据作为一个DataFrame

• implicits

  用于导入spark的隐式转换，方便rdd和dataframe的转换

• table(tableName:String)

  返回指定表的DataFrame

• createDateFrame(rowRDD:RDD[Row],schema:StructType)D

  从包含Rows的RDD中使用给定模式创建一个DataFrame

• udf()

  用于注册用户自定义的udf函数

• stop()

  关闭sparkContext

• appName(name:String)

  设置应用程序的名称，不设置的话将随机生成

• config(key:String,value:String)

  设置配置选项

• master(master:String)

  设置要连接的Spark主URL,例如“local”为本地运行，local[4]为本地4核运行，或“Spark://master:7077”在Spark独立集群上运行，

  或”yarn“在yarn模式下运行。

• enableHiveSupport()

  启用Hive支持，包括连接到持久的HIve metastore，支持Hive serdes和Hive用户定义函数，如果不启用hive支持，spark是找不到hive中的表的。

• getOrCreate()

  获取一个现有的SparkSession,如果没有，这根据此构建器中设置的选项创建一个新的SparkSession.

• builder()

  创建SparkSession构建器

Window类

• partitionBy

  创建带有已经定义分区的窗口空间

• order by

  在Window中定义排序列

• rowsBetween.

  // 创建一个定义了框架边界的WindowSpec，从开始(包括)到结束(包括)。起始和结束都是相对于当前行的位置。例如，“O”表示“当前
  // 行”，“l”而“-1”表示当前行的前一行，“5”表示当前行的后第五行。我们建议用户使用Window。unboundedPreceding,窗口。
  // unboundedFollowing和Window。currentRow用于指定特殊的边界值，而不是直接使用整数值。基于行的边界基于分区中的行位置。偏
  // 移量表示当前行的上方或下方的行数，当前行的帧开始或结束。例如，给定一个基于行的滑动框架，其下界偏移量为-1，上界偏移量为+2。
  // 索引为5的行所在的坐标系范围从索引4到索引7。
  import org.apache.spark.sql.expressions.Window
     val df = Seq((1, "a"), (1, "a"), (2, "a"), (1, "b"), (2, "b"), (3, "b"))
       .toDF("id", "category")
     val byCategoryOrderedById =
       Window.partitionBy('category).orderBy('id).rowsBetween(Window.currentRow, 1)
     df.withColumn("sum", sum('id) over byCategoryOrderedById).show()
  
     +---+--------+---+
     | id|category|sum|
     +---+--------+---+
     |  1|       b|  3|
     |  2|       b|  5|
     |  3|       b|  3|
     |  1|       a|  2|
     |  1|       a|  3|
     |  2|       a|  2|
     +---+--------+---+
  

  rowBetween(start :Long,end :Long) start表示起始位置，end表示结束位置

  start 为0 表示当前行开始，为-1表示从前一行开始，为4表示从后5行开始

  end为0 表示当前行结束，为-1表示从前一行结束，为4表示从后5行结束

• unboundePreceding

  值表示分区中的第一行，这可以指定rowsBetween函数的边界

  val spec = Window.rowsBetween(Window.unboundedPreceding, Window.unboundedFollowing)
  

• unboundedFollowing

  值表示分区中的最红一行，可以指定rowsBetween的函数边界

  Window.rowsBetween(Window.unboundedPreceding, Window.currentRow)
  

• currentRow

  值表示当前行，这可以用来指定rowsBetween的边界

• rangeBetween(start:Long,end:Long)

  和rowsBetween类似，但是区别在于它是根据orderBy() 函数指定的列进行划分边界的，如果有相同排名的他是按照一行来处理的

RelationalGroupedDataset类

• agg

  通过指定一系列聚合函数来计算聚合，默认情况下，该函数在输出中保留分组列。如果不想保留需要设置spark.sql.retainGroupColumns 设为false

  df.groupBy("department").agg(max("age"), sum("expense")) 按照department进行分组，使用聚合函数max来和sum来计算两个列的聚合值

Row类

• getInt(i:Int)

  返回i位置出的int类型的值，其他数据类型以get+数据类型以此类推

• getAs[T](field:String)

  返回指定字段名称的值，如果是基本类型null返回为0

• getAs[T](i:Int)

  返回指定位置的值，如果是基本数据类型null返回为0

• mkString(sep:String)

  使用指定分隔符，返回此队列中的所有元素

Aggregator类

继承Aggregator自定义udaf函数需要重写的方法：

• zero

• reduce

• merge

• finish

• bufferEncoder

• outputEncoder