第一片心意
第一片心意

flink-sql自定义函数-1.15

1. 版本说明

本文档内容基于flink-1.15.x，其他版本的整理，请查看本人博客的 flink 专栏其他文章。

2. 简介

2.1. 概述

Flink Table API和SQL允许用户使用函数对数据进行转换处理。

2.2. 函数类型

在Flink中有两个维度可以对函数进行分类。

一个维度是系统(或内置)函数和catalog函数。系统函数没有命名空间，可以直接使用它们的名字来引用。
catalog函数属于指定catalog和数据库，因此它们具有catalog和数据库命名空间，它们可以通过完全/部分限定名（catalog.db.func 或 db.func）或只使用函数名。

另一个维度是临时函数和持久函数。临时函数是不稳定的，只能在会话的生命周期内使用，它们总是由用户创建的。持久函数存在于会话的整个生命周期中，它们要么由系统提供，要么在catalog中持久存在。

这两个维度为Flink用户提供了4种函数：

  • Temporary system functions
  • System functions
  • Temporary catalog functions
  • Catalog functions

2.3. 使用函数

在Flink中，用户可以通过两种方式使用函数：精确使用函数或模糊使用函数。

2.3.1. 精确使用

精确的函数使用户能够跨catalog和跨数据库使用catalog函数，例如select mycatalog.mydb.myfunc(x) from mytable
和 select mydb.myfunc(x) from mytable.。

从Flink 1.10开始支持。

2.3.2. 模糊使用

在模糊函数使用中，用户只需要在SQL查询中指定函数名，例如select myfunc(x) from mytable。

2.4. 函数解析顺序

当有不同类型但名称相同的函数时，需要注意函数的解析顺序。例如，当有三个函数都命名为“myfunc”，但分别是临时catalog、catalog和系统函数。如果没有函数名冲突，函数将被解析为唯一的一个。

2.4.1. 精确函数解析

因为系统函数没有名称空间，所以Flink中的精确函数引用必定指向临时catalog函数或catalog函数。

解析顺序:

  • Temporary catalog function
  • Catalog function

2.4.2. 模糊函数解析

解析顺序：

  • Temporary system function
  • System function
  • Temporary catalog function，在会话的当前catalog和当前数据库中。
  • Catalog function，在会话的当前catalog和当前数据库中。

3. 自定义函数

用户自定义函数(udf)是用于调用经常使用的逻辑或在查询中无法以其他方式实现的自定义逻辑的扩展功能。

用户自定义函数可以用JVM语言(如Java或Scala)或Python实现。实现者可以在UDF中使用任意的第三方库。
本章将重点介绍基于jvm的语言，请参阅PyFlink文档，了解用Python编写通用udf的详细信息。

3.1. 概述

目前，Flink区分了以下几种函数:

  • 标量函数：将标量值映射到一个新的标量值。
  • 表函数：将标量值映射到新行，新行数据可以有多个字段。
  • 聚合函数：将多行标量值映射为新的标量值。
  • 表聚合函数：将多行标量值映射到新行，新行数据可以有多个字段。
  • 异步表值函数：是用于执行查找表源的特殊函数。

下面的示例展示了如何创建一个简单的标量函数，以及如何在Table API和SQL中调用该函数。

对于SQL查询，函数必须使用特定名称注册之后才能使用。对于Table API，函数可以注册或直接内联使用。

java

import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.ScalarFunction;
import static org.apache.flink.table.api.Expressions.*;

// 定义函数逻辑
public static class SubstringFunction extends ScalarFunction {
  public String eval(String s, Integer begin, Integer end) {
    return s.substring(begin, end);
  }
}

TableEnvironment env = TableEnvironment.create(...);

// 在table api中使用不注册的内联方式调用函数
env.from("MyTable").select(call(SubstringFunction.class, $("myField"), 5, 12));

// 注册函数
env.createTemporarySystemFunction("SubstringFunction", SubstringFunction.class);

// 在table api中调用注册过的函数
env.from("MyTable").select(call("SubstringFunction", $("myField"), 5, 12));

// 在SQL中调用注册过的函数
env.sqlQuery("SELECT SubstringFunction(myField, 5, 12) FROM MyTable");

scala

import org.apache.flink.table.api._
import org.apache.flink.table.functions.ScalarFunction

// 定义函数逻辑
class SubstringFunction extends ScalarFunction {
  def eval(s: String, begin: Integer, end: Integer): String = {
    s.substring(begin, end)
  }
}

val env = TableEnvironment.create(...)

// 在table api中使用不注册的内联方式调用函数
env.from("MyTable").select(call(classOf[SubstringFunction], $"myField", 5, 12))

// 注册函数
env.createTemporarySystemFunction("SubstringFunction", classOf[SubstringFunction])

// 在table api中调用注册过的函数
env.from("MyTable").select(call("SubstringFunction", $"myField", 5, 12))

// 在SQL中调用注册过的函数
env.sqlQuery("SELECT SubstringFunction(myField, 5, 12) FROM MyTable")

对于交互式会话，也可以在使用或注册函数之前对它们进行参数化。在这种情况下，可以将函数实例而不是函数类用作临时函数。

它要求参数是可序列化的，以便将函数实例传递到集群。

java

import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.ScalarFunction;
import static org.apache.flink.table.api.Expressions.*;

// 定义可参数化函数逻辑
public static class SubstringFunction extends ScalarFunction {

  private boolean endInclusive;

  public SubstringFunction(boolean endInclusive) {
    this.endInclusive = endInclusive;
  }

  public String eval(String s, Integer begin, Integer end) {
    return s.substring(begin, endInclusive ? end + 1 : end);
  }
}

TableEnvironment env = TableEnvironment.create(...);

//在table api中使用不注册的内联方式调用函数
env.from("MyTable").select(call(new SubstringFunction(true), $("myField"), 5, 12));

//注册函数，直接传递初始化参数，而不是在调用时传递
env.createTemporarySystemFunction("SubstringFunction", new SubstringFunction(true));

scala

import org.apache.flink.table.api._
import org.apache.flink.table.functions.ScalarFunction

// 定义可参数化函数逻辑
class SubstringFunction(val endInclusive) extends ScalarFunction {
  def eval(s: String, begin: Integer, end: Integer): String = {
    s.substring(endInclusive ? end + 1 : end)
  }
}

val env = TableEnvironment.create(...)

//在table api中使用不注册的内联方式调用函数
env.from("MyTable").select(call(new SubstringFunction(true), $"myField", 5, 12))

//注册函数，直接传递初始化参数，而不是在调用时传递
env.createTemporarySystemFunction("SubstringFunction", new SubstringFunction(true))

可以使用星号 * 作为函数调用的参数，在Table API中充当通配符，表示表中的所有列都将被传递给函数对应的位置。

java

import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.ScalarFunction;
import static org.apache.flink.table.api.Expressions.*;

public static class MyConcatFunction extends ScalarFunction {
  public String eval(@DataTypeHint(inputGroup = InputGroup.ANY) Object... fields) {
    return Arrays.stream(fields)
        .map(Object::toString)
        .collect(Collectors.joining(","));
  }
}

TableEnvironment env = TableEnvironment.create(...);

// 使用 $("*") 来调用函数，如果 MyTable 有三个字段 (a, b, c), 则这三个所有的字段都将传递给 MyConcatFunction。
env.from("MyTable").select(call(MyConcatFunction.class, $("*")));

// 上述做法和下面这种显式的指定所有的字段有相同的效果。
env.from("MyTable").select(call(MyConcatFunction.class, $("a"), $("b"), $("c")));

scala

import org.apache.flink.table.api._
import org.apache.flink.table.functions.ScalarFunction

import scala.annotation.varargs

class MyConcatFunction extends ScalarFunction {
  @varargs
  def eval(@DataTypeHint(inputGroup = InputGroup.ANY) row: AnyRef*): String = {
    row.map(f => f.toString).mkString(",")
  }
}

val env = TableEnvironment.create(...)

// 使用 $("*") 来调用函数，如果 MyTable 有三个字段 (a, b, c), 则这三个所有的字段都将传递给 MyConcatFunction。
env.from("MyTable").select(call(classOf[MyConcatFunction], $"*"));

// 上述做法和下面这种显式的指定所有的字段有相同的效果。
env.from("MyTable").select(call(classOf[MyConcatFunction], $"a", $"b", $"c"));

3.2. 实现步骤

不管是实现哪种自定义函数，所有用户自定义的函数都遵循一些基本的实现原则。

3.2.1. 函数类

实现类必须继承于可用的基类(例如org.apache.flink.table.functions.ScalarFunction)。

类必须声明为公有的，而不是抽象的，并且是全局可访问的。因此，不允许使用非静态的内部类或匿名类。

为了在持久catalog中存储用户自定义函数，类必须具有默认构造函数，并且在运行时必须是可实例化的。

3.2.2. evaluation方法

基类提供了一组可以被重写的方法，如open()、close()或isDeterministic()。

但是，除了那些声明的方法外，对于每条传入数据的主要处理逻辑必须通过专门的方法去实现。

根据函数类型的不同，代码生成的操作符会在运行时调用eval()、**accumulate()或retract()**等求值方法。

这些方法必须声明为公有，并接受一组定义好的参数。

常规JVM方法定义在这儿也适用。因此可以：

  • 实现重载方法，如eval(Integer)和eval(LocalDateTime)，
  • 使用可变参数，如eval(Integer...)，
  • 使用对象继承，如eval(object)，同时接受LocalDateTime和Integer，
  • 可变参数加对象继承eval(Object...)，接受各种参数。

如果想在Scala中实现函数，请添加Scala.annotation.varargs注释来处理变量参数。此外，建议使用包装类(例如java.lang.Integer而不是Int)来支持NULL。

下面的代码片段显示了重载函数的示例：

java

import org.apache.flink.table.functions.ScalarFunction;

//重载eval这个方法
public class SumFunction extends ScalarFunction {
    public Integer eval(Integer a, Integer b) {
        return a + b;
    }

    public Integer eval(String a, String b) {
        return Integer.parseInt(a) + Integer.parseInt(b);
    }

    public Integer eval(Double... d) {
        double result = 0;
        for (double value : d)
            result += value;
        return (int) result;
    }

}

scala

import org.apache.flink.table.functions.ScalarFunction
import java.lang.Integer
import java.lang.Double
import scala.annotation.varargs

//重载eval这个方法
class SumFunction extends ScalarFunction {

  def eval(a: Integer, b: Integer): Integer = {
    a + b
  }

  def eval(a: String, b: String): Integer = {
    Integer.valueOf(a) + Integer.valueOf(b)
  }

  @varargs // 类似 java 的可变参数
  def eval(d: Double*): Integer = {
    d.sum.toInt
  }
}

3.2.3. 类型推断

表生态系统(类似于SQL标准)是一个强类型API。因此，函数参数和返回类型都必须映射到之前章节中提到的数据类型。

从逻辑的角度来看，开发人员需要关于预期类型、精度和规模信息。从JVM的角度来看，规划器需要关于调用用户定义函数时如何将内部数据结构表示为JVM对象的信息。

验证输入参数以及为参数和函数结果派生数据类型的逻辑在类型推断中实现。

Flink的用户自定义函数实现了一个自动类型推断提取，通过反射从函数的类及其估值方法派生数据类型。
如果这种隐式反射提取方法没有成功，可以通过使用@DataTypeHint和@FunctionHint注解来改变的参数、类或方法来支持提取过程。下面展示了更多关于如何适用注解的示例。
如果需要更高级的类型推断逻辑，实现者可以在每个用户自定义函数中显式覆盖getTypeInference()方法。推荐使用注解方式，因为它会将自定义类型推断逻辑保持在受影响的位置附近，然后回退到默认行为，并不会影响其余的实现。

自动类型推断

自动类型推断会检查函数的类和计算方法，以派生函数的参数和结果的数据类型。@DataTypeHint和@FunctionHint注释支持自动提取。

有关可以隐式映射到数据类型的完整类列表，请参阅数据类型提取部分。

@DataTypeHint

在许多场景中，需要支持函数的参数和返回值类型的自动内联提取。

下面的示例演示如何使用数据类型提示。更多信息可以在注解类的文档中找到。

java

import org.apache.flink.table.annotation.DataTypeHint;
import org.apache.flink.table.annotation.InputGroup;
import org.apache.flink.table.functions.ScalarFunction;
import org.apache.flink.types.Row;

//重载eval这个方法
public class OverloadedFunction extends ScalarFunction {
    // 没有类型提示
    public Long eval(long a, long b) {
        return a + b;
    }

    // 指定小数的长度和精度
    public @DataTypeHint("DECIMAL(12, 3)")
    BigDecimal eval(double a, double b) {
        return BigDecimal.valueOf(a + b);
    }

    // 定义一个嵌套数据类型
    @DataTypeHint("ROW")
    public Row eval(int i) {
        return Row.of(String.valueOf(i), Instant.ofEpochSecond(i));
    }

    // 允许任何输入和自定义的序列化输出
    @DataTypeHint(value = "RAW", bridgedTo = ByteBuffer.class)
    public ByteBuffer eval(@DataTypeHint(inputGroup = InputGroup.ANY) Object o) {
        return MyUtils.serializeToByteBuffer(o);
    }

}

scala

import org.apache.flink.table.annotation.DataTypeHint
import org.apache.flink.table.annotation.InputGroup
import org.apache.flink.table.functions.ScalarFunction
import org.apache.flink.types.Row
import scala.annotation.varargs

//重载eval这个方法
class OverloadedFunction extends ScalarFunction {

  // 没有类型提示
  def eval(a: Long, b: Long): Long = {
    a + b
  }

  // 指定小数的长度和精度
  @DataTypeHint("DECIMAL(12, 3)")
  def eval(double a, double b): BigDecimal = {
    java.lang.BigDecimal.valueOf(a + b)
  }

  // 定义一个嵌套数据类型
  @DataTypeHint("ROW")
  def eval(Int i): Row = {
    Row.of(java.lang.String.valueOf(i), java.time.Instant.ofEpochSecond(i))
  }

  // 允许任何输入和自定义的序列化输出
  @DataTypeHint(value = "RAW", bridgedTo = classOf[java.nio.ByteBuffer])
  def eval(@DataTypeHint(inputGroup = InputGroup.ANY) Object o): java.nio.ByteBuffer = {
    MyUtils.serializeToByteBuffer(o)
  }
}

@FunctionHint

在某些场景中，一个求值方法可以同时处理多个不同的数据类型。而且，在某些情况下，如果重载的求值方法有一个公共的结果类型，则应该只声明一次。

@FunctionHint注解可以提供从参数数据类型到结果数据类型的映射。它支持为输入、累加器和结果数据类型注解整个函数类或求值方法（相当于这些类型的公共注解）。
可以在类上声明一个或多个注解，也可以为重载函数签名的每个求值方法单独声明一个或多个注解。所有提示参数都是可选的。如果未定义参数，则使用默认的基于反射的提取。所有计算方法都继承于在函数类上定义的提示参数。

下面的示例演示如何使用函数提示。更多信息可以在注解类的文档中找到。

java

import org.apache.flink.table.annotation.DataTypeHint;
import org.apache.flink.table.annotation.FunctionHint;
import org.apache.flink.table.functions.TableFunction;
import org.apache.flink.types.Row;

// 重载eval方法，使用全局定义的输出类型
@FunctionHint(output = @DataTypeHint("ROW"))
public class OverloadedFunction extends TableFunction<Row> {
    public void eval(int a, int b) {
        collect(Row.of("Sum", a + b));
    }

    public void eval() {
        collect(Row.of("Empty args", -1));
    }
}

// 将类型推断和求值方法解耦，将类型推断交给函数提示
@FunctionHint(input = {@DataTypeHint("INT"), @DataTypeHint("INT")}, output = @DataTypeHint("INT"))
@FunctionHint(input = {@DataTypeHint("BIGINT"), @DataTypeHint("BIGINT")}, output = @DataTypeHint("BIGINT"))
@FunctionHint(input = {}, output = @DataTypeHint("BOOLEAN"))
@FunctionHint(output = @DataTypeHint("ROW"))
public class OverloadedFunction extends TableFunction<Object> {
    // 实现只需要确定方法可以被JVM调用即可
    public void eval(Object... o) {
        if (o.length == 0) {
            collect(false);
        }
        collect(o[0]);
    }
}

scala

import org.apache.flink.table.annotation.DataTypeHint
import org.apache.flink.table.annotation.FunctionHint
import org.apache.flink.table.functions.TableFunction
import org.apache.flink.types.Row

// 重载eval方法，使用全局定义的输出类型
@FunctionHint(output = new DataTypeHint("ROW"))
class OverloadedFunction extends TableFunction[Row] {

  def eval(a: Int, b: Int): Unit = {
    collect(Row.of("Sum", Int.box(a + b)))
  }

  // overloading of arguments is still possible
  def eval(): Unit = {
    collect(Row.of("Empty args", Int.box(-1)))
  }
}

/// 将类型推断和求值方法解耦，将类型推断交给函数提示
@FunctionHint(
  input = Array(new DataTypeHint("INT"), new DataTypeHint("INT")),
  output = new DataTypeHint("INT")
)
@FunctionHint(
  input = Array(new DataTypeHint("BIGINT"), new DataTypeHint("BIGINT")),
  output = new DataTypeHint("BIGINT")
)
@FunctionHint(
  input = Array(),
  output = new DataTypeHint("BOOLEAN")
)
class OverloadedFunction extends TableFunction[AnyRef] {

  // 实现只需要确定方法可以被JVM调用即可
  @varargs
  def eval(o: AnyRef*) = {
    if (o.length == 0) {
      collect(Boolean.box(false))
    }
    collect(o(0))
  }
}

3.2.4. 自定义类型推断

对于大多数场景，@DataTypeHint和@FunctionHint应该足以满足用户自定义的函数建模。然而，通过重写getTypeInference()中定义的自动类型推断，实现者可以创建类似内置系统函数的任意函数。

下面用Java实现的示例说明自定义类型推理逻辑的潜力。它使用字符串字面值参数来确定函数的结果类型。该函数接收两个字符串参数:第一个参数表示要解析的字符串，第二个参数表示目标类型。

import org.apache.flink.table.api.DataTypes;
import org.apache.flink.table.catalog.DataTypeFactory;
import org.apache.flink.table.functions.ScalarFunction;
import org.apache.flink.table.types.inference.TypeInference;
import org.apache.flink.types.Row;

public class LiteralFunction extends ScalarFunction {
    public Object eval(String s, String type) {
        return switch (type) {
            case "INT" -> Integer.valueOf(s);
            case "DOUBLE" -> Double.valueOf(s);
            case "STRING", default -> s;
        };
    }

    // 通过下面的逻辑代替自动基于反射的类型推断
    @Override
    public TypeInference getTypeInference(DataTypeFactory typeFactory) {
        return TypeInference.newBuilder()
                // 指定类型参数
                //如果需要的haunt，参数将会被隐式转化为这些类型
                .typedArguments(DataTypes.STRING(), DataTypes.STRING())
                // 指定函数的结果类型策略
                .outputTypeStrategy(callContext -> {
                    if (!callContext.isArgumentLiteral(1) || callContext.isArgumentNull(1)) {
                        throw callContext.newValidationError("Literal expected for second argument.");
                    }
                    // 返回基于字面量的数据类型
                    final String literal = callContext.getArgumentValue(1, String.class).orElse("STRING");
                    return switch (literal) {
                        case "INT" -> Optional.of(DataTypes.INT().notNull());
                        case "DOUBLE" -> Optional.of(DataTypes.DOUBLE().notNull());
                        case "STRING", default -> Optional.of(DataTypes.STRING());
                    };
                })
                .build();
    }

}

有关自定义类型推断的更多示例，请参见带有高级函数实现的flink-examples-table模块。

3.2.5. 确定性结果

每个用户自定义的函数类都可以通过重写isDeterministic()方法声明它是否产生确定性结果。如果函数不是纯函数(如random()、date()或now())，则该方法必须返回false。
默认情况下，isDeterministic()返回true。

确定性结果解释：像random()等函数，由于在SQL中调用函数时，每行数据都会调用一次函数，如果isDeterministic()方法返回false，则每次调用这类函数，都会产生一个新的结果，
也就是说，函数内部逻辑必走一次；如果isDeterministic()方法返回true，该函数则会预先执行一次，然后集群运行SQL时会直接使用预先执行后的结果，而不是每行数据都调用一次这个函数。
如果函数将数据列作为参数，每行数据都会执行一次函数，因为数据列的值对函数来说是不确定的。上述讨论的是无数据行列参数的函数。

此外，isDeterministic()方法还可能影响运行时行为。函数可能会在两个不同的阶段被调用：

  1. 在规划期间(即预运行阶段)：如果一个函数通过常量表达式调用，或者可以从给定的语句派生出常量表达式，则该函数将被预先执行求出结果值以减少常量表达式的运行次数，并且可能不再在集群上执行该函数。
    除非使用isDeterministic()来禁用常量表达式的这种缩减特性。
    例如，在规划时对ABS的调用如下：SELECT ABS(-1) FROM t 和 SELECT ABS(field) FROM t WHERE field = -1;而SELECT ABS(field) FROM t
    则不是常量表达式。
  2. 在运行时(即集群执行)：如果一个函数被非常量表达式调用或isDeterministic()返回false。

3.2.6. 运行时集成方法

有时候，用户自定义的函数可能需要在实际工作之前获取全局运行时信息或做一些设置/清理工作。

用户自定义函数提供了可以被重写的 open() 和 close() 方法，并提供了与DataStream API的RichFunction中的方法类似的方法。

open() 方法在求值方法之前调用一次，最后一次调用求值方法之后调用 close() 方法。

open() 方法提供了一个FunctionContext，它包含了有关用户定义函数执行的上下文的信息，例如度量组（MetricGroup）数据、分布式缓存文件或全局作业参数。

通过调用FunctionContext的相应方法可以获得以下信息：

方法 描述
getMetricGroup() 子任务的度量组信息
getCachedFile(name) 本地临时文件拷贝到分布式的缓存文件
getJobParameter(name, defaultValue) 对应key的全局作业参数值
getExternalResourceInfos(resourceName) 返回对应key的外部资源信息集合

取决于函数执行的上下文，并非所有上述方法都可用。例如，在减少常量表达式期间，添加指标是一个无需执行的操作。

下面的示例片段展示了如何在标量函数中使用FunctionContext来访问全局作业参数：

java

import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.FunctionContext;
import org.apache.flink.table.functions.ScalarFunction;

public class HashCodeFunction extends ScalarFunction {
    private int factor = 0;

    @Override
    public void open(FunctionContext context) {
        // 访问全局参数“hashcode_factor”的值，如果参数不存在，则“12”为其默认值
        factor = Integer.parseInt(context.getJobParameter("hashcode_factor", "12"));
    }

    public int eval(String s) {
        return s.hashCode() * factor;
    }
}

class UseFun {
    public static void main(String[] args) {
        EnvironmentSettings settings = EnvironmentSettings.newInstance().inStreamingMode().build();
        TableEnvironment env = TableEnvironment.create(settings);
        // 添加作业参数
        env.getConfig().addJobParameter("hashcode_factor", "31");
        // 注册函数
        env.createTemporarySystemFunction("hashCode", HashCodeFunction.class);
        // 调用自定义函数
        env.sqlQuery("SELECT myField, hashCode(myField) FROM MyTable");
    }
}

scala

import org.apache.flink.table.api._
import org.apache.flink.table.functions.FunctionContext
import org.apache.flink.table.functions.ScalarFunction

class HashCodeFunction extends ScalarFunction {

  private var factor: Int = 0

  override def open(context: FunctionContext): Unit = {
    // 访问全局参数“hashcode_factor”的值，如果参数不存在，则“12”为其默认值
    factor = context.getJobParameter("hashcode_factor", "12").toInt
  }

  def eval(s: String): Int = {
    s.hashCode * factor
  }
}

val env = TableEnvironment.create(...)

// 添加作业参数
env.getConfig.addJobParameter("hashcode_factor", "31")

// 注册函数
env.createTemporarySystemFunction("hashCode", classOf[HashCodeFunction])

// 调用自定义函数
env.sqlQuery("SELECT myField, hashCode(myField) FROM MyTable")

3.3. 标量函数

用户自定义的标量函数会将零、一个或多个标量值映射到一个新的标量值。数据类型部分中列出的任何数据类型都可以用作求值方法的参数或返回类型。

为了自定义一个标量函数，必须扩展org.apache. fleck .table.functions中的基类ScalarFunction，并实现一个或多个名为eval(...)的求值方法。

下面的示例演示如何定义自己的哈希码函数并在查询中调用它。

java

import org.apache.flink.table.annotation.InputGroup;
import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.ScalarFunction;

import static org.apache.flink.table.api.Expressions.*;

public class HashFunction extends ScalarFunction {
    // 允许输入任何类型数据，然后返回INT类型
    public int eval(@DataTypeHint(inputGroup = InputGroup.ANY) Object o) {
        return o.hashCode();
    }
}

class UseFun {
    public static void main(String[] args) {
        EnvironmentSettings settings = EnvironmentSettings.newInstance().inStreamingMode().build();
        TableEnvironment env = TableEnvironment.create(settings);
        // 在Table API中通过内联方式调用未注册的函数
        env.from("MyTable").select(call(HashFunction.class, $("myField")));
        // 注册函数
        env.createTemporarySystemFunction("HashFunction", HashFunction.class);
        // 在Table API中调用注册的函数
        env.from("MyTable").select(call("HashFunction", $("myField")));
        // 在SQL中调用注册的函数
        env.sqlQuery("SELECT HashFunction(myField) FROM MyTable");
    }
}

scala

import org.apache.flink.table.annotation.InputGroup
import org.apache.flink.table.api._
import org.apache.flink.table.functions.ScalarFunction

class HashFunction extends ScalarFunction {

  // 允许输入任何类型数据，然后返回INT类型
  def eval(@DataTypeHint(inputGroup = InputGroup.ANY) o: AnyRef): Int = {
    o.hashCode()
  }
}

val env = TableEnvironment.create(...)

// 在Table API中通过内联方式调用未注册的函数
env.from("MyTable").select(call(classOf[HashFunction], $"myField"))

// 注册函数
env.createTemporarySystemFunction("HashFunction", classOf[HashFunction])

// 在Table API中调用注册的函数
env.from("MyTable").select(call("HashFunction", $"myField"))

// 在SQL中调用注册的函数
env.sqlQuery("SELECT HashFunction(myField) FROM MyTable")

3.4. 表函数

与用户自定义的标量函数类似，用户自定义的表函数(UDTF)接受零个、一个或多个标量值作为输入参数。但是，它可以返回任意数量的行(或结构化类型)作为输出，而不是单个值。
返回的记录可以由一个或多个字段组成。如果输出记录只包含一个字段，则可以省略结构化数据，并且可以发出一个标量值，该标量值将由运行时隐式包装到row中。

为了定义表函数，必须扩展org.apache.flink.table.functions中的基类TableFunction，并实现一个或多个名为eval(...)的求值方法。

与其他函数类似，使用反射自动提取输入和输出数据类型，包括用于确定输出数据类型的泛型参数T。与标量函数不同，求值方法本身不能有返回类型，
相反，表函数提供了一个collect(T)方法，可以在每个求值方法中调用该方法，以发出零条、一条或多条记录。

在Table API中，通过.joinLateral(…) 或 .leftOuterJoinLateral(…)使用表函数。
joinLateral操作符(cross)将外部表(操作符左侧的表)中的每一行与表函数(操作符右侧的表函数)产生的所有行连接起来。
leftOuterJoinLateral操作符将来自外部表(操作符左边的表)的每一行与表值函数(操作符右边的表值函数)产生的所有行连接起来，并保留表函数返回空表的外部行。

在SQL中，使用带有JOIN的LATERAL TABLE()或带有ON TRUE连接条件的LEFT JOIN。

下面的示例演示如何定义自己的split函数并在查询中调用它。

java

import org.apache.flink.table.annotation.DataTypeHint;
import org.apache.flink.table.annotation.FunctionHint;
import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.TableFunction;
import org.apache.flink.types.Row;

import static org.apache.flink.table.api.Expressions.*;

@FunctionHint(output = @DataTypeHint("ROW"))
public class SplitFunction extends TableFunction<Row> {
    public void eval(String str) {
        for (String s : str.split(" ")) {
            // 使用collect(...)方法发出row类型数据
            collect(Row.of(s, s.length()));
        }
    }
}

class UseFun {
    public static void main(String[] args) {
        EnvironmentSettings settings = EnvironmentSettings.newInstance().inStreamingMode().build();
        TableEnvironment env = TableEnvironment.create(settings);
        // 在Table API中通过内联方式调用未注册的函数
        env
                .from("MyTable")
                .joinLateral(call(SplitFunction.class, $("myField")))
                .select($("myField"), $("word"), $("length"));
        env
                .from("MyTable")
                .leftOuterJoinLateral(call(SplitFunction.class, $("myField")))
                .select($("myField"), $("word"), $("length"));
        // 在Table API中重命名函数的属性名
        env
                .from("MyTable")
                .leftOuterJoinLateral(call(SplitFunction.class, $("myField")).as("newWord", "newLength"))
                .select($("myField"), $("newWord"), $("newLength"));

        //注册函数
        env.createTemporarySystemFunction("SplitFunction", SplitFunction.class);
        // 在Table API中调用注册的函数
        env
                .from("MyTable")
                .joinLateral(call("SplitFunction", $("myField")))
                .select($("myField"), $("word"), $("length"));
        env
                .from("MyTable")
                .leftOuterJoinLateral(call("SplitFunction", $("myField")))
                .select($("myField"), $("word"), $("length"));
        // 在SQL中调用注册的函数
        env.sqlQuery(
                "SELECT myField, word, length " +
                        "FROM MyTable, LATERAL TABLE(SplitFunction(myField))");
        env.sqlQuery(
                "SELECT myField, word, length " +
                        "FROM MyTable " +
                        "LEFT JOIN LATERAL TABLE(SplitFunction(myField)) ON TRUE");
        // 在SQL中重命名属性值
        env.sqlQuery(
                "SELECT myField, newWord, newLength " +
                        "FROM MyTable " +
                        "LEFT JOIN LATERAL TABLE(SplitFunction(myField)) AS T(newWord, newLength) ON TRUE");
    }
}

scala

import org.apache.flink.table.annotation.DataTypeHint
import org.apache.flink.table.annotation.FunctionHint
import org.apache.flink.table.api._
import org.apache.flink.table.functions.TableFunction
import org.apache.flink.types.Row

@FunctionHint(output = new DataTypeHint("ROW"))
class SplitFunction extends TableFunction[Row] {

  def eval(str: String): Unit = {
    // 使用collect(...)方法发出row类型数据
    str.split(" ").foreach(s => collect(Row.of(s, Int.box(s.length))))
  }
}

val env = TableEnvironment.create(...)

// 在 Table API 使用内联方式中调用未注册的函数
env
  .from("MyTable")
  .joinLateral(call(classOf[SplitFunction], $"myField")
  .select($"myField", $"word", $"length")
env
  .from("MyTable")
  .leftOuterJoinLateral(call(classOf[SplitFunction], $"myField"))
  .select($"myField", $"word", $"length")

// 在Table API中重命名函数的属性名
env
  .from("MyTable")
  .leftOuterJoinLateral(call(classOf[SplitFunction], $"myField").as("newWord", "newLength"))
  .select($"myField", $"newWord", $"newLength")

// 注册函数
env.createTemporarySystemFunction("SplitFunction", classOf[SplitFunction])

// 在 Table API 中调用注册的函数
env
  .from("MyTable")
  .joinLateral(call("SplitFunction", $"myField"))
  .select($"myField", $"word", $"length")
env
  .from("MyTable")
  .leftOuterJoinLateral(call("SplitFunction", $"myField"))
  .select($"myField", $"word", $"length")

// 在 SQL 中调用注册的函数
env.sqlQuery(
  "SELECT myField, word, length " +
  "FROM MyTable, LATERAL TABLE(SplitFunction(myField))")
env.sqlQuery(
  "SELECT myField, word, length " +
  "FROM MyTable " +
  "LEFT JOIN LATERAL TABLE(SplitFunction(myField)) ON TRUE")

// 在 SQL 中重命名函数的属性
env.sqlQuery(
  "SELECT myField, newWord, newLength " +
  "FROM MyTable " +
  "LEFT JOIN LATERAL TABLE(SplitFunction(myField)) AS T(newWord, newLength) ON TRUE")

如果想在Scala中实现函数，不要将表函数实现为Scala Object。Scala Object是单例的，会导致并发问题。

3.5. 聚合函数

用户自定义的聚合函数(UDAGG)可以将多行标量值映射到一个新的标量值。

聚合函数会使用到累加器。累加器是一种中间数据结构，用于存储聚合值，直到计算出最终聚合结果。

对于每一组需要聚合的行，运行时将通过调用createAccumulator()方法创建一个空的累加器。随后，对每个输入行调用accumulate(...)方法来更新累加器。
处理完所有行后，调用getValue(...)方法来计算并返回最终结果。

下图演示了聚合过程：

在这里插入图片描述

在本例中，我们假设有一个包含饮料数据的表。该表由三列(id、name、price)和5行数据组成。我们想找出表中所有饮料的最高价格，即执行max()聚合。我们需要计算这5行中的每一行。结果是一个标量数值。

为了定义聚合函数，必须扩展org.apache.flink.table.functions中的基类AggregateFunction，并实现一个或多个名为accumulate(...)的求值方法。
accumulate方法必须public，而不是静态的。accumulate方法可以重载。

默认使用反射自动提取输入、累加器和输出数据类型，包括累加器泛型ACC和返回结果泛型T。输入参数来自一个或多个accumulate(...)方法。

下面的示例演示如何定义自己的聚合函数并在查询中调用它。

java

import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.AggregateFunction;

import static org.apache.flink.table.api.Expressions.*;

// 自定义聚合函数的可变累加器
public class WeightedAvgAccumulator {
    public long sum = 0;
    public int count = 0;
}

// 第一个泛型表示聚合结果类型，也就是返回值类型，第二个泛型表示累加器类型
public class WeightedAvg extends AggregateFunction<Long, WeightedAvgAccumulator> {
    /**
     * 创建并初始化累加器
     * 累加器是计算中间结果的数据结构体，存储聚合数据值，直到计算最终聚合结果。
     *
     * @return 具有初始化值的累加器
     */
    @Override
    public WeightedAvgAccumulator createAccumulator() {
        return new WeightedAvgAccumulator();
    }

    /**
     * 计算并返回最终结果
     */
    @Override
    public Long getValue(WeightedAvgAccumulator acc) {
        if (acc.count == 0) {
            return null;
        } else {
            return acc.sum / acc.count;
        }
    }

    /**
     * 处理输入参数值，并且更新提供的累加器实例。
     * 这个方法可以被重载。
     * 自定义聚合函数必须有至少一个accumulate()方法。
     *
     * @param acc 包含当前聚合结果的累加器
     * @param iValue 用户输入参数
     * @param iWeight 用户输入参数
     */
    public void accumulate(WeightedAvgAccumulator acc, Long iValue, Integer iWeight) {
        acc.sum += iValue * iWeight;
        acc.count += iWeight;
    }

    /**
     * 从累加器实例撤回输入值。
     * 当前设计假定该输入值是以前累加过的值。
     * 该方法可以被重载。
     * 在无界表上使用有界OVER聚合数据时，必须实现该方法。
     *
     * @param acc 包含当前聚合结果的累加器
     * @param iValue 用户输入参数
     * @param iWeight 用户输入参数
     */
    public void retract(WeightedAvgAccumulator acc, Long iValue, Integer iWeight) {
        acc.sum -= iValue * iWeight;
        acc.count -= iWeight;
    }

    /**
     * 将一组累加器实例聚合到一个累加器实例。
     * 在无界会话窗口、滑动窗口进行分组聚合，以及在有界分区聚合时必须实现该方法。
     * 除此之外，实现该方法对优化器是有帮助的。
     * 比如，两阶段聚合优化要求所有聚合函数支持“merge”方法
     *
     * @param acc 保存聚合结果的累加器。注意，它应该包含之前聚合的结果，因此，我们不能在聚合方法中替换或清理这个实例。
     * @param it 一组将被合并的累加器对应的迭代器
     */
    public void merge(WeightedAvgAccumulator acc, Iterable<WeightedAvgAccumulator> it) {
        for (WeightedAvgAccumulator a : it) {
            acc.count += a.count;
            acc.sum += a.sum;
        }
    }

    /**
     * 重置累加器
     */
    public void resetAccumulator(WeightedAvgAccumulator acc) {
        acc.count = 0;
        acc.sum = 0L;
    }
}

class useFun {
    public static void main(String[] args) {
        EnvironmentSettings settings = EnvironmentSettings.newInstance().inStreamingMode().build();
        TableEnvironment env = TableEnvironment.create(settings);
        // 在Table API中调用未被注册的函数
        env
                .from("MyTable")
                .groupBy($("myField"))
                .select($("myField"), call(WeightedAvg.class, $("value"), $("weight")));
        // 注册函数
        env.createTemporarySystemFunction("WeightedAvg", WeightedAvg.class);
        // 在Table API中调用注册的函数
        env
                .from("MyTable")
                .groupBy($("myField"))
                .select($("myField"), call("WeightedAvg", $("value"), $("weight")));
        // 在SQL中调用注册的函数
        env.sqlQuery(
                "SELECT myField, WeightedAvg(`value`, weight) FROM MyTable GROUP BY myField"
        );
    }
}

scala

import org.apache.flink.table.api._
import org.apache.flink.table.functions.AggregateFunction

// 自定义聚合函数的可变累加器
case class WeightedAvgAccumulator(
  var sum: Long = 0,
  var count: Int = 0
)

// 第一个泛型表示聚合结果类型，也就是返回值类型，第二个泛型表示累加器类型
class WeightedAvg extends AggregateFunction[java.lang.Long, WeightedAvgAccumulator] {

  /**
    * 创建并初始化累加器
    * 累加器是计算中间结果的数据结构体，存储聚合数据值，直到计算最终聚合结果。
    *
    * @return 具有初始化值的累加器
  */
  override def createAccumulator(): WeightedAvgAccumulator = {
    WeightedAvgAccumulator()
  }

  /**
   * 计算并返回最终结果
   */
  override def getValue(acc: WeightedAvgAccumulator): java.lang.Long = {
    if (acc.count == 0) {
      null
    } else {
      acc.sum / acc.count
    }
  }

  /**
   * 处理输入参数值，并且更新提供的累加器实例。
   * 这个方法可以被重载。
   * 自定义聚合函数必须有至少一个accumulate()方法。
   *
   * @param acc 包含当前聚合结果的累加器
   * @param iValue 用户输入参数
   * @param iWeight 用户输入参数
   */
  def accumulate(acc: WeightedAvgAccumulator, iValue: java.lang.Long, iWeight: java.lang.Integer): Unit = {
    acc.sum += iValue * iWeight
    acc.count += iWeight
  }

  /**
    * 从累加器实例撤回输入值。
    * 当前设计假定该输入值是以前累加过的值。
    * 该方法可以被重载。
    * 在无界表上使用有界OVER聚合数据时，必须实现该方法。
    *
    * @param acc 包含当前聚合结果的累加器
    * @param iValue 用户输入参数
    * @param iWeight 用户输入参数
   */
  def retract(acc: WeightedAvgAccumulator, iValue: java.lang.Long, iWeight: java.lang.Integer): Unit = {
    acc.sum -= iValue * iWeight
    acc.count -= iWeight
  }

  /**
   * 将一组累加器实例聚合到一个累加器实例。
   * 在无界会话窗口、滑动窗口进行分组聚合，以及在有界分区聚合时必须实现该方法。
   * 除此之外，实现该方法对优化器是有帮助的。
   * 比如，两阶段聚合优化要求所有聚合函数支持“merge”方法
   *
   * @param acc 保存聚合结果的累加器。注意，它应该包含之前聚合的结果，因此，我们不能在聚合方法中替换或清理这个实例。
   * @param it 一组将被合并的累加器对应的迭代器
  */
  def merge(acc: WeightedAvgAccumulator, it: java.lang.Iterable[WeightedAvgAccumulator]): Unit = {
    val iter = it.iterator()
    while (iter.hasNext) {
      val a = iter.next()
      acc.count += a.count
      acc.sum += a.sum
    }
  }

 /**
  * 重置累加器
  */
  def resetAccumulator(acc: WeightedAvgAccumulator): Unit = {
    acc.count = 0
    acc.sum = 0L
  }
}

val env = TableEnvironment.create(...)

// 在Table API中调用未被注册的函数
env
  .from("MyTable")
  .groupBy($"myField")
  .select($"myField", call(classOf[WeightedAvg], $"value", $"weight"))

// 注册函数
env.createTemporarySystemFunction("WeightedAvg", classOf[WeightedAvg])

// 在Table API中调用注册的函数
env
  .from("MyTable")
  .groupBy($"myField")
  .select($"myField", call("WeightedAvg", $"value", $"weight"))

// 在SQL中调用注册的函数
env.sqlQuery(
  "SELECT myField, WeightedAvg(`value`, weight) FROM MyTable GROUP BY myField"
)

WeightedAvg类的accumulate(...)方法接受三个输入参数。第一个是累加器，另外两个是用户自定义的输入。为了计算加权平均值，累加器需要存储已累积的所有数据的加权和计数。
在我们的示例中，我们定义了一个类WeightedAvgAccumulator作为累加器。累加器由Flink的checkpoint机制自动管理，并在出现错误时恢复，以确保恰好一次语义。

3.5.1. 必选和可选方法

对于每个自定义AggregateFunction函数，以下方法是必须实现的：

  • createAccumulator()
  • accumulate(…)
  • getValue(…)

此外，还有一些可选的方法可以实现。虽然其中一些方法只是为了让系统更有效地执行查询，但在某些情况下则必需实现的。
例如，如果在会话分组窗口（session group window）上调用聚合函数，则**merge(…)**方法是强制性的(当“连接”两个会话窗口的数据行时，需要连接两个会话窗口的累加器)。

AggregateFunction的以下方法实现取决于使用情境：

  • retract(…)：在OVER窗口上进行聚合时需要使用。
  • merge(…)：对于许多有界聚合、会话窗口和滑动窗口聚合都是必需的。此外，该方法也有助于查询优化。例如，两阶段聚合优化要求所有AggregateFunction支持merge方法。
    两阶段聚合：类似于MR中的combiner，先在map端进行小的聚合，最后在reduce端再次聚合。

如果聚合函数只能在OVER窗口中使用，则可以通过返回FunctionRequirement来声明。在getRequirements()中返回FunctionRequirement.OVER_WINDOW_ONLY。
如果累加器需要存储大量的数据，则使用org.apache.flink.table.api.dataview.ListView和org.apache.flink.table.api.dataview.MapView
提供的高级特性，在无界数据场景中利用Flink的状态后端。有关这个高级特性的更多信息，请参阅相应类的文档。

由于有些方法是可选的，或者是可以重载，所以运行时是通过生成的代码来调用聚合函数方法的。这意味着基类并不总是提供具体方法实现需要覆盖的签名。然而，所有提到的方法都必须公开的，而且不是静态的，并且完全按照上面提到的方法的名字命名。

下面给出未在AggregateFunction中声明并由生成的代码调用的所有方法的详细文档。

accumulate(…)

java

/**
 * 处理输入参数值，并且更新提供的累加器实例。
 * 这个方法可以被重载。
 * 自定义聚合函数必须有至少一个accumulate()方法。
 *
 * @param acc 包含当前聚合结果的累加器
 * @param: [user defined inputs] 输入值（通常是新到达数据行字段）
 **/
public void accumulate(ACC accumulator,[user defined inputs])

scala

/**
 * 处理输入参数值，并且更新提供的累加器实例。
 * 这个方法可以被重载。
 * 自定义聚合函数必须有至少一个accumulate()方法。
 *
 * @param acc 包含当前聚合结果的累加器
 * @param: [user defined inputs] 输入值（通常是新到达数据行字段）
 **/
def accumulate(accumulator: ACC, [user defined inputs]): Unit

retract(…)

java

/**
 * 从累加器实例撤回输入值。
 * 当前设计假定该输入值是以前累加过的值。
 * 该方法可以被重载。
 * 在无界表上使用有界OVER聚合数据时，必须实现该方法。
 * @param accumulator 包含当前聚合结果的累加器
 * @param [user defined inputs] 输入值（通常是新到达数据行字段）
 */
public void retract(ACC accumulator,[user defined inputs])

scala

/**
 * 从累加器实例撤回输入值。
 * 当前设计假定该输入值是以前累加过的值。
 * 该方法可以被重载。
 * 在无界表上使用有界OVER聚合数据时，必须实现该方法。
 * @param accumulator 包含当前聚合结果的累加器
 * @param [user defined inputs] 输入值（通常是新到达数据行字段）
 */
def retract(accumulator: ACC, [user defined inputs]): Unit

merge(…)

java

/**
 * 将一组累加器实例聚合到一个累加器实例。
 * 在无界会话窗口、滑动窗口进行分组聚合，以及在有界分区聚合时必须实现该方法。
 * 除此之外，实现该方法对优化器是有帮助的。
 * 比如，两阶段聚合优化要求所有聚合函数支持“merge”方法
 *
 * @param accumulator 保存聚合结果的累加器。注意，它应该包含之前聚合的结果，因此，我们不能在聚合方法中替换或清理这个实例。
 * @param iterable 一组将被合并的累加器对应的迭代器
 */
public void merge(ACC accumulator,java.lang.Iterable<ACC> iterable)

scala

/**
 * 将一组累加器实例聚合到一个累加器实例。
 * 在无界会话窗口、滑动窗口进行分组聚合，以及在有界分区聚合时必须实现该方法。
 * 除此之外，实现该方法对优化器是有帮助的。
 * 比如，两阶段聚合优化要求所有聚合函数支持“merge”方法
 *
 * @param accumulator 保存聚合结果的累加器。注意，它应该包含之前聚合的结果，因此，我们不能在聚合方法中替换或清理这个实例。
 * @param iterable 一组将被合并的累加器对应的迭代器
 */
def merge(accumulator: ACC, iterable: java.lang.Iterable[ACC]): Unit

3.6. 表聚合函数

用户定义的表聚合函数(UDTAGG)可以将多行标量值映射为0、1或多行(或结构化类型)标量值。返回的记录可以由一个或多个字段组成。如果输出记录只包含一个字段，则可以省略结构化，并且发出一个标量值，该标量值将由运行时隐式包装到row中。

与聚合函数类似，表聚合的行为以累加器的概念为中心。累加器是中间数据结构，用于存储聚合值，直到计算出最终聚合结果。

对于每一组需要聚合的行，运行时将通过调用createAccumulator()创建一个空的累加器。随后，对每个输入行调用函数的accumulate(...)方法来更新累加器。
处理完所有行后，调用函数的emitValue(...)或emitUpdateWithRetract(...)方法来计算并返回最终结果。

下图演示了聚合过程：

在这里插入图片描述

在本例中，我们假设一个包含饮料数据的表。该表由三列(id、name、price)和5行数据组成。我们想在表格中找出所有饮料最高的2个价格，即执行TOP2()表格汇总。我们需要计算这5行中的每一行。结果是一个包含前2个值的表。

为了定义表聚合函数，必须扩展org.apache.flink.table.functions中的基类TableAggregateFunction，并实现一个或多个名为accumulate(...)的求值方法。
accumulate方法必须public，而且是非静态的。累加方法也可以通过实现多个名为accumulate的方法来重载。

默认情况下，使用反射自动提取输入、累加器和输出数据类型。这包括确定累加器泛型参数ACC和累加器结果泛型参数T。输入参数来自一个或多个accumulate(...)方法。

如果打算在Python中实现或调用函数，请参阅Python函数文档了解更多细节。

下面的示例演示如何定义自己的表聚合函数并在查询中调用它。

java

import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.table.api.*;
import org.apache.flink.table.functions.TableAggregateFunction;
import org.apache.flink.util.Collector;

import static org.apache.flink.table.api.Expressions.*;

// 自定义表聚合函数的可变累加器
public class Top2Accumulator {
    public Integer first;
    public Integer second;
}

// 函数包含用户输入值（INT），保存中间结果到Top2Accumulator对象，最后返回Tuple2类型的结果，第一个表示结果值，第二个表示级别。
// 函数第一个泛型表示聚合结果类型，第二个泛型表示累加器类型
public class Top2 extends TableAggregateFunction<Tuple2<Integer, Integer>, Top2Accumulator> {
    /**
     * 创建一个初始化的累加器
     *
     * @return 初始化的累加器
     */
    @Override
    public Top2Accumulator createAccumulator() {
        Top2Accumulator acc = new Top2Accumulator();
        acc.first = Integer.MIN_VALUE;
        acc.second = Integer.MIN_VALUE;
        return acc;
    }

    /**
     * 处理输入值，并且更新之前的累加器实例。这个方法可以被重载。表聚合函数要求至少一个accumulate()方法。
     *
     * @param acc 包含当前聚合结果的累加器
     * @param value 输入值（通常是用户输入的数据）
     */
    public void accumulate(Top2Accumulator acc, Integer value) {
        if (value > acc.first) {
            acc.second = acc.first;
            acc.first = value;
        } else if (value > acc.second) {
            acc.second = value;
        }
    }

    /**
     * 合并一组累加器实例到一个累加器实例。这个方法必须在无界会话、滑动窗口分组聚合、有界分组聚合中实现。
     *
     * @param acc 将要保存聚合结果的累加器。这个累加器可能包含之前聚合的结果，因此用户不能替换，或者是清理这个实例。
     * @param it 将要被合并的一组累加器对应的迭代器
     */
    public void merge(Top2Accumulator acc, Iterable<Top2Accumulator> it) {
        for (Top2Accumulator otherAcc : it) {
            accumulate(acc, otherAcc.first);
            accumulate(acc, otherAcc.second);
        }
    }

    /**
     * 每次聚合结果应该被物化时调用。返回值可以是早期未完成的结果（当数据到达时定期发出），或者是最终的聚合结果。
     *
     * @param acc 包含当前聚合结果的累加器。
     * @param out 输出数据的收集器。
     */
    public void emitValue(Top2Accumulator acc, Collector<Tuple2<Integer, Integer>> out) {
        // emit the value and rank
        if (acc.first != Integer.MIN_VALUE) {
            out.collect(Tuple2.of(acc.first, 1));
        }
        if (acc.second != Integer.MIN_VALUE) {
            out.collect(Tuple2.of(acc.second, 2));
        }
    }
}

class UseFun {
    public static void main(String[] args) {


        EnvironmentSettings settings = EnvironmentSettings.newInstance().inStreamingMode().build();
        TableEnvironment env = TableEnvironment.create(settings);
        // 在Table API中通过内联方式调用未被注册的函数
        env
                .from("MyTable")
                .groupBy($("myField"))
                .flatAggregate(call(Top2.class, $("value")))
                .select($("myField"), $("f0"), $("f1"));
        // 在Table API中通过内联方式调用未被注册的函数，并且使用别名来更好的标识返回值二元组的属性
        env
                .from("MyTable")
                .groupBy($("myField"))
                .flatAggregate(call(Top2.class, $("value")).as("value", "rank"))
                .select($("myField"), $("value"), $("rank"));
        // 注册函数
        env.createTemporarySystemFunction("Top2", Top2.class);
        //在Table API中调用注册的函数
        env
                .from("MyTable")
                .groupBy($("myField"))
                .flatAggregate(call("Top2", $("value")).as("value", "rank"))
                .select($("myField"), $("value"), $("rank"));
    }
}

scala

import java.lang.Integer
import org.apache.flink.api.java.tuple.Tuple2
import org.apache.flink.table.api._
import org.apache.flink.table.functions.TableAggregateFunction
import org.apache.flink.util.Collector

// 自定义表聚合函数的可变累加器
case class Top2Accumulator(
  var first: Integer,
  var second: Integer
)

// 函数包含用户输入值（INT），保存中间结果到Top2Accumulator对象，最后返回Tuple2类型的结果，第一个表示结果值，第二个表示级别。
// 函数第一个泛型表示聚合结果类型，第二个泛型表示累加器类型
class Top2 extends TableAggregateFunction[Tuple2[Integer, Integer], Top2Accumulator] {

  /**
   * 创建一个初始化的累加器
   *
   * @return 初始化的累加器
   */
  override def createAccumulator(): Top2Accumulator = {
    Top2Accumulator(
      Integer.MIN_VALUE,
      Integer.MIN_VALUE
    )
  }

  /**
   * 处理输入值，并且更新之前的累加器实例。这个方法可以被重载。表聚合函数要求至少一个accumulate()方法。
   *
   * @param acc 包含当前聚合结果的累加器
   * @param value 输入值（通常是用户输入的数据）
   */
  def accumulate(acc: Top2Accumulator, value: Integer): Unit = {
    if (value > acc.first) {
      acc.second = acc.first
      acc.first = value
    } else if (value > acc.second) {
      acc.second = value
    }
  }

  /**
   * 合并一组累加器实例到一个累加器实例。这个方法必须在无界会话、滑动窗口分组聚合、有界分组聚合中实现。
   *
   * @param acc 将要保存聚合结果的累加器。这个累加器可能包含之前聚合的结果，因此用户不能替换，或者是清理这个实例。
   * @param it 将要被合并的一组累加器对应的迭代器
   */
  def merge(acc: Top2Accumulator, it: java.lang.Iterable[Top2Accumulator]) {
    val iter = it.iterator()
    while (iter.hasNext) {
      val otherAcc = iter.next()
      accumulate(acc, otherAcc.first)
      accumulate(acc, otherAcc.second)
    }
  }

  /**
   * 每次聚合结果应该被物化时调用。返回值可以是早期未完成的结果（当数据到达时定期发出），或者是最终的聚合结果。
   *
   * @param acc 包含当前聚合结果的累加器。
   * @param out 输出数据的收集器。
   */
  def emitValue(acc: Top2Accumulator, out: Collector[Tuple2[Integer, Integer]]): Unit = {
    // emit the value and rank
    if (acc.first != Integer.MIN_VALUE) {
      out.collect(Tuple2.of(acc.first, 1))
    }
    if (acc.second != Integer.MIN_VALUE) {
      out.collect(Tuple2.of(acc.second, 2))
    }
  }
}

val env = TableEnvironment.create(...)

// 在Table API中通过内联方式调用未被注册的函数
env
  .from("MyTable")
  .groupBy($"myField")
  .flatAggregate(call(classOf[Top2], $"value"))
  .select($"myField", $"f0", $"f1")

// 在Table API中通过内联方式调用未被注册的函数，并且使用别名来更好的标识返回值二元组的属性
env
  .from("MyTable")
  .groupBy($"myField")
  .flatAggregate(call(classOf[Top2], $"value").as("value", "rank"))
  .select($"myField", $"value", $"rank")

// 注册函数
env.createTemporarySystemFunction("Top2", classOf[Top2])

//在Table API中调用注册的函数
env
  .from("MyTable")
  .groupBy($"myField")
  .flatAggregate(call("Top2", $"value").as("value", "rank"))
  .select($"myField", $"value", $"rank")

Top2类的accumulate(...)方法接受两个输入。第一个是累加器，第二个是用户定义的输入。
为了计算结果，累加器需要存储已累积的所有数据的2个最高值。累加器由Flink的checkpoint机制自动管理，并在出现错误时恢复，以确保精确一次的语义。结果值与排名索引作为结果一起发出。

3.6.1. 必选和可选方法

对于每个自定义TableAggregateFunction，以下方法是必须的：

  • createAccumulator()
  • accumulate(…)
  • emitValue(…) or emitUpdateWithRetract(…)

此外，还有一些可选的方法可以实现。其中一些方法可以让系统更有效地执行查询，但在某些情境下，有些方法是必需的。

例如，如果在会话分组窗口（session group window）上使用表聚合函数，则merge(...)方法是强制性的(当需要“连接”两个会话窗口的数据行时，需要连接两个会话窗口的累加器)。

TableAggregateFunction的以下方法取决于用例:

  • retract(…)：在OVER窗口上进行聚合时需要使用。
  • merge(…)：对于许多有界聚合、无界会话、滑动窗口聚合都是必需的。
  • emitValue(…)：对于有界、窗口聚合是必需的。

TableAggregateFunction的以下方法可以提高流作业的性能：

  • emitUpdateWithRetract(…)：用于发出在回撤模式下更新的值。

emitValue(...)方法总是通过累加器发出完整的数据。在无界流场景中可能会带来性能问题。
以Top N函数为例，每次emitValue(...)都会发出所有N个值。为了提高性能，可以实现emitUpdateWithRetract(...)，在retract模式下增量输出数据。
换句话说，一旦有了更新，该方法可以在发送新的、更新的记录之前撤销旧记录。该方法将优先于emitValue(...)方法调用。

如果表聚合函数只能在OVER窗口中应用，则可以通过getRequirements()方法返回FunctionRequirement.OVER_WINDOW_ONLY来说明。

如果一个累加器需要存储大量的数据，可以使用org.apache.flink.table.api.dataview.ListView和org.apache.flink.table.api.dataview.MapView
提供的高级特性，在无界流数据场景中利用Flink的状态后端。有关这个高级特性的更多信息，请参阅相应类的文档。

由于有些方法是可选或可以重载的，因此flink会根据生成的代码来调用这些方法。基类并不总是提供所有需要实现的方法的签名。然而，所有提到的方法都必须是public，非静态的，并且完全按照上面提到的名字命名。

下面给出了未在TableAggregateFunction中声明并由生成的代码调用的所有方法的详细文档。

accumulate(…)

java

/**
 * 处理输入参数值，并且更新提供的累加器实例。
 * 这个方法可以被重载。
 * 自定义聚合函数必须有至少一个accumulate()方法。
 *
 * @param acc 包含当前聚合结果的累加器
 * @param: [user defined inputs] 输入值（通常是新到达数据行字段）
 **/
public void accumulate(ACC accumulator,[user defined inputs])

scala

/**
 * 处理输入参数值，并且更新提供的累加器实例。
 * 这个方法可以被重载。
 * 自定义聚合函数必须有至少一个accumulate()方法。
 *
 * @param acc 包含当前聚合结果的累加器
 * @param: [user defined inputs] 输入值（通常是新到达数据行字段）
 **/
def accumulate(accumulator: ACC, [user defined inputs]): Unit

retract(…)

java

/**
 * 从累加器实例撤回输入值。
 * 当前设计假定该输入值是以前累加过的值。
 * 该方法可以被重载。
 * 在无界表上使用有界OVER聚合数据时，必须实现该方法。
 * @param accumulator 包含当前聚合结果的累加器
 * @param [user defined inputs] 输入值（通常是新到达数据行字段）
 */
public void retract(ACC accumulator,[user defined inputs])

scala

/**
 * 从累加器实例撤回输入值。
 * 当前设计假定该输入值是以前累加过的值。
 * 该方法可以被重载。
 * 在无界表上使用有界OVER聚合数据时，必须实现该方法。
 * @param accumulator 包含当前聚合结果的累加器
 * @param [user defined inputs] 输入值（通常是新到达数据行字段）
 */
def retract(accumulator: ACC, [user defined inputs]): Unit

merge(…)

java

/**
 * 将一组累加器实例聚合到一个累加器实例。
 * 在无界会话窗口、滑动窗口进行分组聚合，以及在有界分区聚合时必须实现该方法。
 * 除此之外，实现该方法对优化器是有帮助的。
 * 比如，两阶段聚合优化要求所有聚合函数支持“merge”方法
 *
 * @param accumulator 保存聚合结果的累加器。注意，它应该包含之前聚合的结果，因此，我们不能在聚合方法中替换或清理这个实例。
 * @param iterable 一组将被合并的累加器对应的迭代器
 */
public void merge(ACC accumulator,java.lang.Iterable<ACC> iterable)

scala

/**
 * 将一组累加器实例聚合到一个累加器实例。
 * 在无界会话窗口、滑动窗口进行分组聚合，以及在有界分区聚合时必须实现该方法。
 * 除此之外，实现该方法对优化器是有帮助的。
 * 比如，两阶段聚合优化要求所有聚合函数支持“merge”方法
 *
 * @param accumulator 保存聚合结果的累加器。注意，它应该包含之前聚合的结果，因此，我们不能在聚合方法中替换或清理这个实例。
 * @param iterable 一组将被合并的累加器对应的迭代器
 */
def merge(accumulator: ACC, iterable: java.lang.Iterable[ACC]): Unit

emitValue(…)

java

/**
 * 每次聚合结果应该被物化时调用。返回值可以是早期未完成的结果（当数据到达时定期发出），或者是最终的聚合结果。
 *
 * param: accumulator 包含当前聚合结果的累加器。
 * param: out 输出数据的收集器。
 */
public void emitValue(ACC accumulator,org.apache.flink.util.Collector<T> out)

scala

/**
 * 每次聚合结果应该被物化时调用。返回值可以是早期未完成的结果（当数据到达时定期发出），或者是最终的聚合结果。
 *
 * param: accumulator 包含当前聚合结果的累加器。
 * param: out 输出数据的收集器。
 */
def emitValue(accumulator: ACC, out: org.apache.flink.util.Collector[T]): Unit

emitUpdateWithRetract(…)

java

/*
 * 每次聚合结果应该被物化时调用。返回值可以是早期未完成的结果（当数据到达时定期发出），或者是最终的聚合结果。
 * 与emitValue()相比，emitUpdateWithRetract() 用来发出被更新的结果值。
 * 这个方法在回撤模式（也叫做"update before" 和 "update after"）下会立即输出数据。
 * 一旦遇到一个更新，我们必须在发送新的更新数据之前撤回旧的记录。
 * 如果在表聚合函数中同时实现了emitUpdateWithRetract()和emitValue()，则会优先使用emitUpdateWithRetract()，
 * 因为这个方法可以以增长的方式输出数据，比emitValue更有效。
 *
 * param: accumulator 包含当前聚合结果的累加器。
 * param: out 回撤收集器被用于输出数据。使用collect()方法输出增加的数据，使用retract()方法删除数据。
 */
public void emitUpdateWithRetract(ACC accumulator,RetractableCollector<T> out)

scala

/*
 * 每次聚合结果应该被物化时调用。返回值可以是早期未完成的结果（当数据到达时定期发出），或者是最终的聚合结果。
 * 与emitValue()相比，emitUpdateWithRetract() 用来发出被更新的结果值。
 * 这个方法在回撤模式（也叫做"update before" 和 "update after"）下会立即输出数据。
 * 一旦遇到一个更新，我们必须在发送新的更新数据之前撤回旧的记录。
 * 如果在表聚合函数中同时实现了emitUpdateWithRetract()和emitValue()，则会优先使用emitUpdateWithRetract()，
 * 因为这个方法可以以增长的方式输出数据，比emitValue更有效。
 *
 * param: accumulator 包含当前聚合结果的累加器。
 * param: out 回撤收集器被用于输出数据。使用collect()方法输出增加的数据，使用retract()方法删除数据。
 */
def emitUpdateWithRetract(accumulator: ACC, out: RetractableCollector[T]): Unit

3.6.2. Retraction案例

下面的案例展示如何使用 emitUpdateWithRetract(...) 方法发射只递增的更新。为了实现该目的，累加器需要同时保存 top2 的旧值和新值。

如果 TopN 的 N 是一个很大的数字，同时保存旧值和新值可能会影响性能。解决该问题的一个方式为在 accumulate 方法中只保存输入数据，然后在 emitUpdateWithRetract 方法中执行计算。

java

import org.apache.flink.api.java.tuple.Tuple2;
import org.apache.flink.table.functions.TableAggregateFunction;

// 前两个属性表示最新的top2，后两个属性表示上一次top2
public class Top2WithRetractAccumulator {
    public Integer first;
    public Integer second;
    public Integer oldFirst;
    public Integer oldSecond;
}

public class Top2WithRetract extends TableAggregateFunction<Tuple2<Integer, Integer>, Top2WithRetractAccumulator> {
    @Override
    public Top2WithRetractAccumulator createAccumulator() {
        Top2WithRetractAccumulator acc = new Top2WithRetractAccumulator();
        acc.first = Integer.MIN_VALUE;
        acc.second = Integer.MIN_VALUE;
        acc.oldFirst = Integer.MIN_VALUE;
        acc.oldSecond = Integer.MIN_VALUE;
        return acc;
    }

    public void accumulate(Top2WithRetractAccumulator acc, Integer v) {
        // 更新最新top2数据
        if (v > acc.first) {
            acc.second = acc.first;
            acc.first = v;
        } else if (v > acc.second) {
            acc.second = v;
        }
    }

    public void emitUpdateWithRetract(Top2WithRetractAccumulator acc, RetractableCollector<Tuple2<Integer, Integer>> out) {
        if (!acc.first.equals(acc.oldFirst)) {
            // 如果发现有更新数据，则先删除之前的旧值，然后发出新值
            if (acc.oldFirst != Integer.MIN_VALUE) {
                out.retract(Tuple2.of(acc.oldFirst, 1));
            }
            out.collect(Tuple2.of(acc.first, 1));
            acc.oldFirst = acc.first;
        }
        if (!acc.second.equals(acc.oldSecond)) {
            // 如果发现有更新数据，则先删除之前的旧值，然后发出新值
            if (acc.oldSecond != Integer.MIN_VALUE) {
                out.retract(Tuple2.of(acc.oldSecond, 2));
            }
            out.collect(Tuple2.of(acc.second, 2));
            acc.oldSecond = acc.second;
        }
    }

scala

import org.apache.flink.api.java.tuple.Tuple2
import org.apache.flink.table.functions.TableAggregateFunction
import org.apache.flink.table.functions.TableAggregateFunction.RetractableCollector

// 前两个属性表示最新的top2，后两个属性表示上一次top2
case class Top2WithRetractAccumulator(
  var first: Integer,
  var second: Integer,
  var oldFirst: Integer,
  var oldSecond: Integer
)

class Top2WithRetract
    extends TableAggregateFunction[Tuple2[Integer, Integer], Top2WithRetractAccumulator] {

  override def createAccumulator(): Top2WithRetractAccumulator = {
    Top2WithRetractAccumulator(
      Integer.MIN_VALUE,
      Integer.MIN_VALUE,
      Integer.MIN_VALUE,
      Integer.MIN_VALUE
    )
  }

  def accumulate(acc: Top2WithRetractAccumulator, value: Integer): Unit = {
    // 更新最新top2数据
    if (value > acc.first) {
      acc.second = acc.first
      acc.first = value
    } else if (value > acc.second) {
      acc.second = value
    }
  }

  def emitUpdateWithRetract(
      acc: Top2WithRetractAccumulator,
      out: RetractableCollector[Tuple2[Integer, Integer]])
    : Unit = {
    if (!acc.first.equals(acc.oldFirst)) {
      // 如果发现有更新数据，则先删除之前的旧值，然后发出新值
      if (acc.oldFirst != Integer.MIN_VALUE) {
          out.retract(Tuple2.of(acc.oldFirst, 1))
      }
      out.collect(Tuple2.of(acc.first, 1))
      acc.oldFirst = acc.first
    }
    if (!acc.second.equals(acc.oldSecond)) {
      // 如果发现有更新数据，则先删除之前的旧值，然后发出新值
      if (acc.oldSecond != Integer.MIN_VALUE) {
          out.retract(Tuple2.of(acc.oldSecond, 2))
      }
      out.collect(Tuple2.of(acc.second, 2))
      acc.oldSecond = acc.second
    }
  }
}

4. 实际案例

4.1. 模拟hive函数collect_list

package cn.com.function.udaf;

import org.apache.flink.table.functions.AggregateFunction;

import java.util.ArrayList;
import java.util.List;

/**
 * 将字段所有值拼接到一起，保留重复值。

 * 默认拼接符号为英文逗号。

 * 必须将字段强转为字符串。

 * 第一个泛型表示聚合结果类型，也就是返回值类型，第二个泛型表示累加器类型
 *
 */
public class CollectList extends AggregateFunction<String, List<String>> {

    /**
     * 最终结果拼接符号
     */
    private final String separator = ",";

    /**
     * 创建并初始化累加器
     * 累加器是计算中间结果的数据结构体，存储聚合数据值，直到计算最终聚合结果。
     *
     * @return 具有初始化值的累加器
     */
    @Override
    public List<String> createAccumulator() {
        return new ArrayList<>();
    }


    /**
     * 计算并返回最终结果
     */
    @Override
    public String getValue(List<String> accumulator) {
        if (!accumulator.isEmpty()) {
            StringBuilder builder = new StringBuilder();
            accumulator.forEach(s -> builder.append(s).append(separator));
            return builder.deleteCharAt(builder.length() - 1).toString();
        } else {
            return "";
        }
    }


    /**
     * 处理输入参数值，并且更新提供的累加器实例。
     * 这个方法可以被重载。
     * 自定义聚合函数必须有至少一个accumulate()方法。
     *
     * @param acc   包含当前聚合结果的累加器
     * @param value 用户输入参数
     */
    public void accumulate(List<String> acc, String value) {
        if (value != null) {
            acc.add(value);
        }
    }


    /**
     * 从累加器实例撤回输入值。
     * 当前设计假定该输入值是以前累加过的值。
     * 该方法可以被重载。
     * 在无界表上使用有界OVER聚合数据时，必须实现该方法。
     *
     * @param acc   包含当前聚合结果的累加器
     * @param value 用户输入参数
     */
    public void retract(List<String> acc, String value) {
        if (value != null) {
            acc.remove(value);
        }
    }

    /**
     * 将一组累加器实例聚合到一个累加器实例。
     * 在无界会话窗口、滑动窗口进行分组聚合，以及在有界分区聚合时必须实现该方法。
     * 除此之外，实现该方法对优化器是有帮助的。
     * 比如，两阶段聚合优化要求所有聚合函数支持“merge”方法
     *
     * @param acc 保存聚合结果的累加器。注意，它应该包含之前聚合的结果，因此，我们不能在聚合方法中替换或清理这个实例。
     * @param it  一组将被合并的累加器对应的迭代器
     */
    public void merge(List<String> acc, Iterable<List<String>> it) {
        for (List<String> list : it) {
            acc.addAll(list);
        }
    }

    /**
     * 重置累加器
     */
    public void resetAccumulator(List<String> acc) {
        acc.clear();
    }

}

你可能感兴趣的:(flink,flink,sql,flink,flink,sql自定义函数)

  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • MYSQL面试系列-04 king01299 面试mysql面试
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
  • MongoDB知识概括 GeorgeLin98 持久层mongodb
    MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • 入门MySQL——查询语法练习 K_un
    前言：前面几篇文章为大家介绍了DML以及DDL语句的使用方法，本篇文章将主要讲述常用的查询语法。其实MySQL官网给出了多个示例数据库供大家实用查询，下面我们以最常用的员工示例数据库为准，详细介绍各自常用的查询语法。1.员工示例数据库导入官方文档员工示例数据库介绍及下载链接：https://dev.mysql.com/doc/employee/en/employees-installation.h
  • 博客网站制作教程 2401_85194651 javamaven
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
  • ubuntu安装wordpress lissettecarlr
    1安装nginx网上安装方式很多，这就就直接用apt-get了apt-getinstallnginx不用启动啥，然后直接在浏览器里面输入IP:80就能看到nginx的主页了。如果修改了一些配置可以使用下列命令重启一下systemctlrestartnginx.service2安装mysql输入安装前也可以更新一下软件源，在安装过程中将会让你输入数据库的密码。sudoapt-getinstallmy
  • 计算机毕业设计PHP仓储综合管理系统（源码+程序+VUE+lw+部署） java毕设程序源码王哥 php课程设计vue.js
    该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流项目运行环境配置：phpStudy+Vscode+Mysql5.7+HBuilderX+Navicat11+Vue+Express。项目技术：原生PHP++Vue等等组成，B/S模式+Vscode管理+前后端分离等等。环境需要1.运行环境：最好是小皮phpstudy最新版，我们在这个版本上开发的。其他版本理论上也可以。2.开发
  • MyBatis 详解 阿贾克斯的黎明 javamybatis
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
  • You have an error in your SQL syntax； check the manual that corresponds to your MySQL server version 努力的菜鸟~ sql数据库
    YouhaveanerrorinyourSQLsyntax;checkthemanualthatcorrespondstoyourMySQLserverversionfortherightsyntaxtousenear‘IDENTIFIEDBY‘123456’WITHGRANTOPTION’atline1在mysql5.7之前GRANTALLPRIVILEGESON*.*TO'root'@'%'I
  • mysql学习教程，从入门到精通，TOP 和MySQL LIMIT 子句（15） 知识分享小能手 大数据数据库MySQLmysql学习oracle数据库开发语言adb大数据
    1、TOP和MySQLLIMIT子句内容在SQL中，不同的数据库系统对于限制查询结果的数量有不同的实现方式。TOP关键字主要用于SQLServer和Access数据库中，而LIMIT子句则主要用于MySQL、PostgreSQL（通过LIMIT/OFFSET语法）、SQLite等数据库中。下面将分别详细介绍这两个功能的语法、语句以及案例。1.1、TOP子句（SQLServer和Access）1.1
  • ERROR 1064 (42000): You have an error in your SQL syntax; check the manual that corresponds to your †徐先森® Oracle数据库Web相关错误集
    createtablestudents(idintunsignedprimarykeyauto_increment,namevarchar(50)notnull,ageintunsigned,highdecimal(3,2),genderenum('男','女','中性','保密','妖')default'保密',cls_idintunsigned);在对数据库插入如上带有中文带有默认值的字段的时
  • 鲲鹏 ARM 架构 麒麟 Lylin v10 安装 Nginx (离线) 焚木灵 arm开发架构nginx服务器
    最近做一个银行的项目，银行的服务器是鲲鹏ARM架构的服务器，并且是麒麟v10的系统，这里记录一下在无法访问外网安装Nginx的方法。其他文章：鲲鹏ARM架构麒麟Lylinv10安装Mysql8.3(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装Node和NVM(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装Pm2(离线)-CSDN博客鲲鹏ARM架构麒麟Lylinv10安装P
  • 【Golang】 Golang 的 GORM 库中的 Rows 函数 不爱洗脚的小滕 golang开发语言后端
    文章目录前言一、Rows函数解释二、代码实现三、总结前言在使用Go语言进行数据库操作时，GORM（GoObject-RelationalMapping）库是一个常用的工具。它提供了一种简洁和强大的方式来处理数据库操作。本文将介绍GORM库中的Rows函数，这是一个用于执行原生SQL查询并返回结果的函数。一、Rows函数解释在GORM库中，Rows函数用于执行原生SQL查询并返回*sql.Rows结
  • Kubernetes部署MySQL数据持久化 沫殇-MS KubernetesMySQL数据库kubernetesmysql容器
    一、安装配置NFS服务端1、安装nfs-kernel-server：sudoapt-yinstallnfs-kernel-server2、服务端创建共享目录#列出所有可用块设备的信息lsblk#格式化磁盘sudomkfs-text4/dev/sdb#创建一个目录：sudomkdir-p/data/nfs/mysql#更改目录权限：sudochown-Rnobody:nogroup/data/nfs
  • MySQL事务隔离级别和MVCC 简书徐小耳
    MySQL事务隔离级别和MVCC参考：https://mp.weixin.qq.com/s/Jeg8656gGtkPteYWrG5_Nw1.MVCC只对读已提交和可重复的读有效果，而未提交读和串行则无意义。2.每条记录都会有trx_id(事务修改记录的id）和roll_pointer是一个指针指向旧版本的undo日志链表（row_id不是必必要的，如果有主键存在就不需要了）3.版本链的头结点就是记
  • 【Death Note】网吧战神之7天爆肝渗透测试死亡笔记_sqlmap在默认情况下除了使用 char() 函数防止出现单引号 2401_84561374 程序员笔记
    网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！特殊服务端口2181zookeeper服务未授权访问
  • CentOS7 安装MySQL5.7.44 不要Null了 javacentosmysql
    1.下载mysql安装包，我放在百度网盘里(下方链接)链接：https://pan.baidu.com/s/1_Mn1XW_1mWdTV4mhnLG66A提取码：s31n2.首先看看以前是否安装过mysqlrpm-qa|grep-imysql如果已经安装过mysql会提示卸载mysqlrpm-emysql-…3.使用FinallShell或者Xftp进行上传放到/usr/local/mysql，没
  • 非关系型数据库 天秤-white nosql
    一、为什么要用Nosql1.单机MySQL的时代。一个基本的网站访问量一般不会太大，单个数据库完全足够。那时候更多使用的静态网页html，服务器根本没有太大压力。这时候网站的瓶颈是什么？-数据量如果太大，一个机器放不下。-数据量太大需要建立数据的索引（B+Tree），一个服务器内存放不下。-访问量读写混合，一个服务器承受不了。2.memcached缓存+MySQL+垂直拆分（读写分离）。网站80%
  • 六、全局锁和表锁：给表加个字段怎么有这么多阻碍 nieniemin
    数据库锁设计的初衷是处理并发问题。作为多用户共享的资源，当出现并发访问的时候，数据库需要合理地控制资源的访问规则。而锁就是用来实现这些访问规则的重要数据结构。根据加锁的范围，MySQL里面的锁大致可以分成全局锁、表级锁和行锁三类。6.1全局锁全局锁就是对整个数据库实例加锁。MySQL提供了一个加全局读锁的方法，命令是Flushtableswithreadlock(FTWRL)。当你需要让整个库处于
  • [转载] NoSQL简介 weixin_30325793 大数据数据库运维
    摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
  • Kubernetes 自定义控制器开发 IT回忆录 Kubeneteskubernetes
    目录前言一、CRD二、创建数据库表（Mysql）二、控制器开发1.使用kubernetes的examplecontroller模板2.在controller.go中新增数据表监听方法3.修改tools工具生成资源对象结构体定义这里记录开发k8s控制器的一般方式，controller开发主要使用k8s提供的client-go库进行。前言Controller监听集群内部资源对象的变化，编辑资源对象(增
  • 详解mybatis的一二级缓存以及缓存失效原因 仰望天花板 缓存数据库mybatisjavamysql
    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
  • 【K8s】专题十一：Kubernetes 集群证书过期处理方法 行者Sun1989 Kuberneteskubernetes云原生容器
    本文内容均来自个人笔记并重新梳理，如有错误欢迎指正！如果对您有帮助，烦请点赞、关注、转发、订阅专栏！专栏订阅入口Linux专栏|Docker专栏|Kubernetes专栏往期精彩文章【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法【Docker】（全网首发）KylinV10下MySQL容器内存占用异常的解决方法（续）【Docker】MySQL源码构建Docker镜
  • Web安全:Web体系架构存在的安全问题和解决方室 程序员-张师傅 前端安全web安全前端
    Web体系架构在提供丰富功能和高效服务的同时，也面临着诸多安全问题。这些问题可能涉及数据泄露、服务中断、系统被控制等多个方面，对企业和个人造成不可估量的损失。以下是对Web体系架构中存在的安全问题及解决方案的详细分析：Web体系架构存在的安全问题注入攻击SQL注入：攻击者通过在输入字段中插入恶意SQL代码，操控后台数据库，窃取、篡改或删除数据。OS命令注入：攻击者通过输入字段插入恶意代码，执行系统
  • MySQl篇（SQL - 基本介绍）（持续更新迭代） wclass-zhengge mysqlsql数据库
    目录一、简介二、SQL方言（分页查询为例）1.简介2.SQL方言大比拼2.1.Oracle2.1.1.使用ROWNUM实现分页查询2.1.2.使用ROW_NUMBER()实现分页查询2.2.MySQL2.3.PostgreSQL三、语法规范四、注释五、MySQL脚本中的标点符号一、简介1、SQL是结构化查询语言（StructureQueryLanguage），专门用来操作/访问关系型数据库的通用语
  • Maven Array_06 eclipsejdkmaven
    Maven Maven是基于项目对象模型(POM)， 信息来管理项目的构建，报告和文档的软件项目管理工具。 Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目发文时使用 Maven，而且公司
  • ibatis的queyrForList和queryForMap区别 bijian1013 javaibatis
    一.说明         iBatis的返回值参数类型也有种：resultMap与resultClass，这两种类型的选择可以用两句话说明之：         1.当结果集列名和类的属性名完全相对应的时候，则可直接用resultClass直接指定查询结果类
  • LeetCode[位运算] - #191 计算汉明权重 Cwind java位运算LeetCodeAlgorithm题解
    原题链接：#191 Number of 1 Bits 要求： 写一个函数，以一个无符号整数为参数，返回其汉明权重。例如，‘11’的二进制表示为'00000000000000000000000000001011', 故函数应当返回3。 汉明权重：指一个字符串中非零字符的个数；对于二进制串，即其中‘1’的个数。 难度：简单 分析： 将十进制参数转换为二进制，然后计算其中1的个数即可。 “
  • 浅谈java类与对象 15700786134 java
          java是一门面向对象的编程语言，类与对象是其最基本的概念。所谓对象，就是一个个具体的物体，一个人，一台电脑，都是对象。而类，就是对象的一种抽象，是多个对象具有的共性的一种集合，其中包含了属性与方法，就是属于该类的对象所具有的共性。当一个类创建了对象，这个对象就拥有了该类全部的属性，方法。相比于结构化的编程思路，面向对象更适用于人的思维
  • linux下双网卡同一个IP 被触发 linux
    转自： http://q2482696735.blog.163.com/blog/static/250606077201569029441/ 由于需要一台机器有两个网卡，开始时设置在同一个网段的IP，发现数据总是从一个网卡发出，而另一个网卡上没有数据流动。网上找了下，发现相同的问题不少： 一、 关于双网卡设置同一网段IP然后连接交换机的时候出现的奇怪现象。当时没有怎么思考、以为是生成树
  • 安卓按主页键隐藏程序之后无法再次打开 肆无忌惮_ 安卓
    遇到一个奇怪的问题，当SplashActivity跳转到MainActivity之后，按主页键，再去打开程序，程序没法再打开（闪一下），结束任务再开也是这样，只能卸载了再重装。而且每次在Log里都打印了这句话"进入主程序"。后来发现是必须跳转之后再finish掉SplashActivity   本来代码：   // 销毁这个Activity fin
  • 通过cookie保存并读取用户登录信息实例 知了ing JavaScripthtml
    通过cookie的getCookies()方法可获取所有cookie对象的集合；通过getName()方法可以获取指定的名称的cookie；通过getValue()方法获取到cookie对象的值。另外，将一个cookie对象发送到客户端，使用response对象的addCookie()方法。 下面通过cookie保存并读取用户登录信息的例子加深一下理解。 （1）创建index.jsp文件。在改
  • JAVA 对象池 矮蛋蛋 javaObjectPool
    原文地址： http://www.blogjava.net/baoyaer/articles/218460.html Jakarta对象池       ☆为什么使用对象池   恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化
  • ArrayList根据条件+for循环批量删除的方法 alleni123 java
    场景如下： ArrayList<Obj> list Obj-> createTime, sid. 现在要根据obj的createTime来进行定期清理。（释放内存） ------------------------- 首先想到的方法就是 for(Obj o:list){ if(o.createTime-currentT>xxx){
  • 阿里巴巴“耕地宝”大战各种宝 百合不是茶 平台战略
    “耕地保”平台是阿里巴巴和安徽农民共同推出的一个 “首个互联网定制私人农场”，“耕地宝”由阿里巴巴投入一亿 ，主要是用来进行农业方面，将农民手中的散地集中起来 不仅加大农民集体在土地上面的话语权，还增加了土地的流通与 利用率，提高了土地的产量，有利于大规模的产业化的高科技农业的 发展，阿里在农业上的探索将会引起新一轮的产业调整，但是集体化之后农民的个体的话语权 将更少，国家应出台相应的法律法规保护
  • Spring注入有继承关系的类（1） bijian1013 javaspring
    一个类一个类的注入 1.AClass类 package com.bijian.spring.test2; public class AClass { String a; String b; public String getA() { return a; } public void setA(Strin
  • 30岁转型期你能否成为成功人士 bijian1013 成功
            很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
  • [Velocity三]基于Servlet+Velocity的web应用 bit1129 velocity
    什么是VelocityViewServlet 使用org.apache.velocity.tools.view.VelocityViewServlet可以将Velocity集成到基于Servlet的web应用中，以Servlet+Velocity的方式实现web应用   Servlet + Velocity的一般步骤 1.自定义Servlet，实现VelocityViewServl
  • 【Kafka十二】关于Kafka是一个Commit Log Service bit1129 service
    Kafka is a distributed, partitioned, replicated commit log service.这里的commit log如何理解？   A message is considered "committed" when all in sync replicas for that partition have applied i
  • NGINX + LUA实现复杂的控制 ronin47 lua nginx 控制
    安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。 这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
  • java-14.输入一个已经按升序排序过的数组和一个数字， 在数组中查找两个数，使得它们的和正好是输入的那个数字 bylijinnan java
    public class TwoElementEqualSum { /** * 第 14 题： 题目：输入一个已经按升序排序过的数组和一个数字， 在数组中查找两个数，使得它们的和正好是输入的那个数字。 要求时间复杂度是 O(n) 。如果有多对数字的和等于输入的数字，输出任意一对即可。 例如输入数组 1 、 2 、 4 、 7 、 11 、 15 和数字 15 。由于
  • Netty源码学习-HttpChunkAggregator-HttpRequestEncoder-HttpResponseDecoder bylijinnan javanetty
    今天看Netty如何实现一个Http Server org.jboss.netty.example.http.file.HttpStaticFileServerPipelineFactory： pipeline.addLast("decoder", new HttpRequestDecoder()); pipeline.addLast(&quo
  • java敏感词过虑-基于多叉树原理 cngolon 违禁词过虑替换违禁词敏感词过虑多叉树
    基于多叉树的敏感词、关键词过滤的工具包，用于java中的敏感词过滤 1、工具包自带敏感词词库，第一次调用时读入词库，故第一次调用时间可能较长，在类加载后普通pc机上html过滤5000字在80毫秒左右，纯文本35毫秒左右。   2、如需自定义词库，将jar包考入WEB-INF工程的lib目录，在WEB-INF/classes目录下建一个 utf-8的words.dict文本文件，
  • 多线程知识 cuishikuan 多线程
    T1，T2，T3三个线程工作顺序，按照T1，T2，T3依次进行 public class T1 implements Runnable{           @Override      
  • spring整合activemq dalan_123 java spring jms
    整合spring和activemq需要搞清楚如下的东东1、ConnectionFactory分：     a、spring管理连接到activemq服务器的管理ConnectionFactory也即是所谓产生到jms服务器的链接      b、真正产生到JMS服务器链接的ConnectionFactory还得
  • MySQL时间字段究竟使用INT还是DateTime？ dcj3sjt126com mysql
      环境：Windows XPPHP Version 5.2.9MySQL Server 5.1 第一步、创建一个表date_test（非定长、int时间） CREATE TABLE `test`.`date_test` (`id` INT NOT NULL AUTO_INCREMENT ,`start_time` INT NOT NULL ,`some_content`
  • Parcel: unable to marshal value dcj3sjt126com marshal
    在两个activity直接传递List<xxInfo>时，出现Parcel: unable to marshal value异常。   在MainActivity页面（MainActivity页面向NextActivity页面传递一个List<xxInfo>）：   Intent intent = new Intent(this, Next
  • linux进程的查看上（ps） eksliang linux pslinux ps -llinux ps aux
    ps:将某个时间点的进程运行情况选取下来 转载请出自出处：http://eksliang.iteye.com/admin/blogs/2119469 http://eksliang.iteye.com         ps 这个命令的man page 不是很好查阅，因为很多不同的Unix都使用这儿ps来查阅进程的状态，为了要符合不同版本的需求，所以这个
  • 为什么第三方应用能早于System的app启动 gqdy365 System
    Android应用的启动顺序网上有一大堆资料可以查阅了，这里就不细述了，这里不阐述ROM启动还有bootloader，软件启动的大致流程应该是启动kernel -> 运行servicemanager 把一些native的服务用命令启动起来（包括wifi, power, rild, surfaceflinger, mediaserver等等）-> 启动Dalivk中的第一个进程Zygot
  • App Framework发送JSONP请求(3) hw1287789687 jsonp跨域请求发送jsonpajax请求越狱请求
    App Framework 中如何发送JSONP请求呢? 使用jsonp,详情请参考:http://json-p.org/ 如何发送Ajax请求呢? (1)登录 /*** * 会员登录 * @param username * @param password */ var user_login=function(username,password){ // aler
  • 发福利，整理了一份关于“资源汇总”的汇总 justjavac 资源
    觉得有用的话，可以去github关注：https://github.com/justjavac/awesome-awesomeness-zh_CN 通用 free-programming-books-zh_CN 免费的计算机编程类中文书籍 精彩博客集合 hacke2/hacke2.github.io#2 ResumeSample 程序员简历
  • 用 Java 技术创建 RESTful Web 服务 macroli java编程WebREST
    转载：http://www.ibm.com/developerworks/cn/web/wa-jaxrs/   JAX-RS (JSR-311) 【 Java API for RESTful Web Services 】是一种 Java™ API，可使 Java Restful 服务的开发变得迅速而轻松。这个 API 提供了一种基于注释的模型来描述分布式资源。注释被用来提供资源的位
  • CentOS6.5-x86_64位下oracle11g的安装详细步骤及注意事项 超声波 oraclelinux
    前言： 这两天项目要上线了，由我负责往服务器部署整个项目，因此首先要往服务器安装oracle，服务器本身是CentOS6.5的64位系统，安装的数据库版本是11g，在整个的安装过程中碰到很多的坑，不过最后还是通过各种途径解决并成功装上了。转别写篇博客来记录完整的安装过程以及在整个过程中的注意事项。希望对以后那些刚刚接触的菜鸟们能起到一定的帮助作用。   安装过程中可能遇到的问题（注
  • HttpClient 4.3 设置keeplive 和 timeout 的方法 supben httpclient
    ConnectionKeepAliveStrategy kaStrategy = new DefaultConnectionKeepAliveStrategy() { @Override public long getKeepAliveDuration(HttpResponse response, HttpContext context) { long keepAlive
  • Spring 4.2新特性-@Import注解的升级 wiselyman spring 4
    3.1 @Import @Import注解在4.2之前只支持导入配置类 在4.2,@Import注解支持导入普通的java类,并将其声明成一个bean 3.2 示例 演示java类 package com.wisely.spring4_2.imp; public class DemoService { public void doSomethin